PSO refactoring for ray tracing

8 files changed, 448 insertions, 127 deletions

diff --git a/Graphics/ShaderTools/include/GLSLUtils.hpp b/Graphics/ShaderTools/include/GLSLUtils.hpp
index 4c8b92c8..53fbeab7 100644
--- a/Graphics/ShaderTools/include/GLSLUtils.hpp
+++ b/Graphics/ShaderTools/include/GLSLUtils.hpp
@@ -34,7 +34,7 @@
 namespace Diligent
 {
 
-enum TargetGLSLCompiler
+enum class TargetGLSLCompiler
 {
     glslang,
     driver
diff --git a/Graphics/ShaderTools/include/GLSLangUtils.hpp b/Graphics/ShaderTools/include/GLSLangUtils.hpp
index b61bb5e6..6a459911 100644
--- a/Graphics/ShaderTools/include/GLSLangUtils.hpp
+++ b/Graphics/ShaderTools/include/GLSLangUtils.hpp
@@ -37,6 +37,14 @@ namespace Diligent
 namespace GLSLangUtils
 {
 
+enum class SpirvVersion
+{
+    Vk100,         // SPIRV 1.0
+    Vk110,         // SPIRV 1.3
+    Vk110_Spirv14, // SPIRV 1.4 (extension)
+    Vk120,         // SPIRV 1.4
+};
+
 void InitializeGlslang();
 void FinalizeGlslang();
 
@@ -45,6 +53,7 @@ std::vector<unsigned int> GLSLtoSPIRV(SHADER_TYPE                      ShaderTyp
                                       int                              SourceCodeLen,
                                       const ShaderMacro*               Macros,
                                       IShaderSourceInputStreamFactory* pShaderSourceStreamFactory,
+                                      SpirvVersion                     Version,
                                       IDataBlob**                      ppCompilerOutput);
 
 std::vector<unsigned int> HLSLtoSPIRV(const ShaderCreateInfo& ShaderCI,
diff --git a/Graphics/ShaderTools/include/SPIRVShaderResources.hpp b/Graphics/ShaderTools/include/SPIRVShaderResources.hpp
index 091e2343..338bf602 100644
--- a/Graphics/ShaderTools/include/SPIRVShaderResources.hpp
+++ b/Graphics/ShaderTools/include/SPIRVShaderResources.hpp
@@ -71,6 +71,7 @@ struct SPIRVShaderResourceAttribs
         SeparateImage,
         SeparateSampler,
         InputAttachment,
+        AccelerationStructure,
         NumResourceTypes
     };
 
@@ -137,19 +138,6 @@ public:
         SepSmplrOrImgInd = SepImageInd;
     }
 
-    String GetPrintName(Uint32 ArrayInd) const
-    {
-        VERIFY_EXPR(ArrayInd < ArraySize);
-        if (ArraySize > 1)
-        {
-            std::stringstream ss;
-            ss << Name << '[' << ArrayInd << ']';
-            return ss.str();
-        }
-        else
-            return Name;
-    }
-
     bool IsCompatibleWith(const SPIRVShaderResourceAttribs& Attribs) const
     {
         // clang-format off
@@ -211,26 +199,28 @@ public:
 
     // clang-format off
 
-    Uint32 GetNumUBs      ()const noexcept{ return (m_StorageBufferOffset   - 0);                      }
-    Uint32 GetNumSBs      ()const noexcept{ return (m_StorageImageOffset    - m_StorageBufferOffset);  }
-    Uint32 GetNumImgs     ()const noexcept{ return (m_SampledImageOffset    - m_StorageImageOffset);   }
-    Uint32 GetNumSmpldImgs()const noexcept{ return (m_AtomicCounterOffset   - m_SampledImageOffset);   }
-    Uint32 GetNumACs      ()const noexcept{ return (m_SeparateSamplerOffset - m_AtomicCounterOffset);  }
-    Uint32 GetNumSepSmplrs()const noexcept{ return (m_SeparateImageOffset   - m_SeparateSamplerOffset);}
-    Uint32 GetNumSepImgs  ()const noexcept{ return (m_InputAttachmentOffset - m_SeparateImageOffset);  }
-    Uint32 GetNumInptAtts ()const noexcept{ return (m_TotalResources        - m_InputAttachmentOffset);}
-    Uint32 GetTotalResources()      const noexcept { return m_TotalResources; }
+    Uint32 GetNumUBs         ()const noexcept{ return (m_StorageBufferOffset   - 0);                      }
+    Uint32 GetNumSBs         ()const noexcept{ return (m_StorageImageOffset    - m_StorageBufferOffset);  }
+    Uint32 GetNumImgs        ()const noexcept{ return (m_SampledImageOffset    - m_StorageImageOffset);   }
+    Uint32 GetNumSmpldImgs   ()const noexcept{ return (m_AtomicCounterOffset   - m_SampledImageOffset);   }
+    Uint32 GetNumACs         ()const noexcept{ return (m_SeparateSamplerOffset - m_AtomicCounterOffset);  }
+    Uint32 GetNumSepSmplrs   ()const noexcept{ return (m_SeparateImageOffset   - m_SeparateSamplerOffset);}
+    Uint32 GetNumSepImgs     ()const noexcept{ return (m_InputAttachmentOffset - m_SeparateImageOffset);  }
+    Uint32 GetNumInptAtts    ()const noexcept{ return (m_AccelStructOffset     - m_InputAttachmentOffset);}
+    Uint32 GetNumAccelStructs()const noexcept{ return (m_TotalResources        - m_AccelStructOffset);    }
+    Uint32 GetTotalResources ()    const noexcept { return m_TotalResources; }
     Uint32 GetNumShaderStageInputs()const noexcept { return m_NumShaderStageInputs; }
 
-    const SPIRVShaderResourceAttribs& GetUB      (Uint32 n)const noexcept{ return GetResAttribs(n, GetNumUBs(),         0                      ); }
-    const SPIRVShaderResourceAttribs& GetSB      (Uint32 n)const noexcept{ return GetResAttribs(n, GetNumSBs(),         m_StorageBufferOffset  ); }
-    const SPIRVShaderResourceAttribs& GetImg     (Uint32 n)const noexcept{ return GetResAttribs(n, GetNumImgs(),        m_StorageImageOffset   ); }
-    const SPIRVShaderResourceAttribs& GetSmpldImg(Uint32 n)const noexcept{ return GetResAttribs(n, GetNumSmpldImgs(),   m_SampledImageOffset   ); }
-    const SPIRVShaderResourceAttribs& GetAC      (Uint32 n)const noexcept{ return GetResAttribs(n, GetNumACs(),         m_AtomicCounterOffset  ); }
-    const SPIRVShaderResourceAttribs& GetSepSmplr(Uint32 n)const noexcept{ return GetResAttribs(n, GetNumSepSmplrs(),   m_SeparateSamplerOffset); }
-    const SPIRVShaderResourceAttribs& GetSepImg  (Uint32 n)const noexcept{ return GetResAttribs(n, GetNumSepImgs(),     m_SeparateImageOffset  ); }
-    const SPIRVShaderResourceAttribs& GetInptAtt (Uint32 n)const noexcept{ return GetResAttribs(n, GetNumInptAtts(),    m_InputAttachmentOffset); }
-    const SPIRVShaderResourceAttribs& GetResource(Uint32 n)const noexcept{ return GetResAttribs(n, GetTotalResources(), 0                      ); }
+    const SPIRVShaderResourceAttribs& GetUB         (Uint32 n)const noexcept{ return GetResAttribs(n, GetNumUBs(),          0                      ); }
+    const SPIRVShaderResourceAttribs& GetSB         (Uint32 n)const noexcept{ return GetResAttribs(n, GetNumSBs(),          m_StorageBufferOffset  ); }
+    const SPIRVShaderResourceAttribs& GetImg        (Uint32 n)const noexcept{ return GetResAttribs(n, GetNumImgs(),         m_StorageImageOffset   ); }
+    const SPIRVShaderResourceAttribs& GetSmpldImg   (Uint32 n)const noexcept{ return GetResAttribs(n, GetNumSmpldImgs(),    m_SampledImageOffset   ); }
+    const SPIRVShaderResourceAttribs& GetAC         (Uint32 n)const noexcept{ return GetResAttribs(n, GetNumACs(),          m_AtomicCounterOffset  ); }
+    const SPIRVShaderResourceAttribs& GetSepSmplr   (Uint32 n)const noexcept{ return GetResAttribs(n, GetNumSepSmplrs(),    m_SeparateSamplerOffset); }
+    const SPIRVShaderResourceAttribs& GetSepImg     (Uint32 n)const noexcept{ return GetResAttribs(n, GetNumSepImgs(),      m_SeparateImageOffset  ); }
+    const SPIRVShaderResourceAttribs& GetInptAtt    (Uint32 n)const noexcept{ return GetResAttribs(n, GetNumInptAtts(),     m_InputAttachmentOffset); }
+    const SPIRVShaderResourceAttribs& GetAccelStruct(Uint32 n)const noexcept{ return GetResAttribs(n, GetNumAccelStructs(), m_AccelStructOffset    ); }
+    const SPIRVShaderResourceAttribs& GetResource   (Uint32 n)const noexcept{ return GetResAttribs(n, GetTotalResources(),  0                      ); }
 
     // clang-format on
 
@@ -250,14 +240,15 @@ public:
 
     struct ResourceCounters
     {
-        Uint32 NumUBs       = 0;
-        Uint32 NumSBs       = 0;
-        Uint32 NumImgs      = 0;
-        Uint32 NumSmpldImgs = 0;
-        Uint32 NumACs       = 0;
-        Uint32 NumSepSmplrs = 0;
-        Uint32 NumSepImgs   = 0;
-        Uint32 NumInptAtts  = 0;
+        Uint32 NumUBs          = 0;
+        Uint32 NumSBs          = 0;
+        Uint32 NumImgs         = 0;
+        Uint32 NumSmpldImgs    = 0;
+        Uint32 NumACs          = 0;
+        Uint32 NumSepSmplrs    = 0;
+        Uint32 NumSepImgs      = 0;
+        Uint32 NumInptAtts     = 0;
+        Uint32 NumAccelStructs = 0;
     };
 
     SHADER_TYPE GetShaderType() const noexcept { return m_ShaderType; }
@@ -270,15 +261,17 @@ public:
               typename THandleAC,
               typename THandleSepSmpl,
               typename THandleSepImg,
-              typename THandleInptAtt>
-    void ProcessResources(THandleUB      HandleUB,
-                          THandleSB      HandleSB,
-                          THandleImg     HandleImg,
-                          THandleSmplImg HandleSmplImg,
-                          THandleAC      HandleAC,
-                          THandleSepSmpl HandleSepSmpl,
-                          THandleSepImg  HandleSepImg,
-                          THandleInptAtt HandleInptAtt) const
+              typename THandleInptAtt,
+              typename THandleAccelStruct>
+    void ProcessResources(THandleUB          HandleUB,
+                          THandleSB          HandleSB,
+                          THandleImg         HandleImg,
+                          THandleSmplImg     HandleSmplImg,
+                          THandleAC          HandleAC,
+                          THandleSepSmpl     HandleSepSmpl,
+                          THandleSepImg      HandleSepImg,
+                          THandleInptAtt     HandleInptAtt,
+                          THandleAccelStruct HandleAccelStruct) const
     {
         for (Uint32 n = 0; n < GetNumUBs(); ++n)
         {
@@ -328,7 +321,13 @@ public:
             HandleInptAtt(InptAtt, n);
         }
 
-        static_assert(SPIRVShaderResourceAttribs::ResourceType::NumResourceTypes == 11, "Please handle the new resource type here, if needed");
+        for (Uint32 n = 0; n < GetNumAccelStructs(); ++n)
+        {
+            const auto& AccelStruct = GetAccelStruct(n);
+            HandleAccelStruct(AccelStruct, n);
+        }
+
+        static_assert(SPIRVShaderResourceAttribs::ResourceType::NumResourceTypes == 12, "Please handle the new resource type here, if needed");
     }
 
     template <typename THandler>
@@ -378,15 +377,16 @@ private:
 
     // clang-format off
 
-    SPIRVShaderResourceAttribs& GetUB      (Uint32 n)noexcept{ return GetResAttribs(n, GetNumUBs(),         0                      ); }
-    SPIRVShaderResourceAttribs& GetSB      (Uint32 n)noexcept{ return GetResAttribs(n, GetNumSBs(),         m_StorageBufferOffset  ); }
-    SPIRVShaderResourceAttribs& GetImg     (Uint32 n)noexcept{ return GetResAttribs(n, GetNumImgs(),        m_StorageImageOffset   ); }
-    SPIRVShaderResourceAttribs& GetSmpldImg(Uint32 n)noexcept{ return GetResAttribs(n, GetNumSmpldImgs(),   m_SampledImageOffset   ); }
-    SPIRVShaderResourceAttribs& GetAC      (Uint32 n)noexcept{ return GetResAttribs(n, GetNumACs(),         m_AtomicCounterOffset  ); }
-    SPIRVShaderResourceAttribs& GetSepSmplr(Uint32 n)noexcept{ return GetResAttribs(n, GetNumSepSmplrs(),   m_SeparateSamplerOffset); }
-    SPIRVShaderResourceAttribs& GetSepImg  (Uint32 n)noexcept{ return GetResAttribs(n, GetNumSepImgs(),     m_SeparateImageOffset  ); }
-    SPIRVShaderResourceAttribs& GetInptAtt (Uint32 n)noexcept{ return GetResAttribs(n, GetNumInptAtts(),    m_InputAttachmentOffset); }
-    SPIRVShaderResourceAttribs& GetResource(Uint32 n)noexcept{ return GetResAttribs(n, GetTotalResources(), 0                      ); }
+    SPIRVShaderResourceAttribs& GetUB         (Uint32 n)noexcept{ return GetResAttribs(n, GetNumUBs(),          0                      ); }
+    SPIRVShaderResourceAttribs& GetSB         (Uint32 n)noexcept{ return GetResAttribs(n, GetNumSBs(),          m_StorageBufferOffset  ); }
+    SPIRVShaderResourceAttribs& GetImg        (Uint32 n)noexcept{ return GetResAttribs(n, GetNumImgs(),         m_StorageImageOffset   ); }
+    SPIRVShaderResourceAttribs& GetSmpldImg   (Uint32 n)noexcept{ return GetResAttribs(n, GetNumSmpldImgs(),    m_SampledImageOffset   ); }
+    SPIRVShaderResourceAttribs& GetAC         (Uint32 n)noexcept{ return GetResAttribs(n, GetNumACs(),          m_AtomicCounterOffset  ); }
+    SPIRVShaderResourceAttribs& GetSepSmplr   (Uint32 n)noexcept{ return GetResAttribs(n, GetNumSepSmplrs(),    m_SeparateSamplerOffset); }
+    SPIRVShaderResourceAttribs& GetSepImg     (Uint32 n)noexcept{ return GetResAttribs(n, GetNumSepImgs(),      m_SeparateImageOffset  ); }
+    SPIRVShaderResourceAttribs& GetInptAtt    (Uint32 n)noexcept{ return GetResAttribs(n, GetNumInptAtts(),     m_InputAttachmentOffset); }
+    SPIRVShaderResourceAttribs& GetAccelStruct(Uint32 n)noexcept{ return GetResAttribs(n, GetNumAccelStructs(), m_AccelStructOffset    ); }
+    SPIRVShaderResourceAttribs& GetResource   (Uint32 n)noexcept{ return GetResAttribs(n, GetTotalResources(),  0                      ); }
 
     // clang-format on
 
@@ -410,6 +410,7 @@ private:
     OffsetType m_SeparateSamplerOffset = 0;
     OffsetType m_SeparateImageOffset   = 0;
     OffsetType m_InputAttachmentOffset = 0;
+    OffsetType m_AccelStructOffset     = 0;
     OffsetType m_TotalResources        = 0;
     OffsetType m_NumShaderStageInputs  = 0;
 
diff --git a/Graphics/ShaderTools/src/DXCompiler.cpp b/Graphics/ShaderTools/src/DXCompiler.cpp
index 1f818af7..75782aaa 100644
--- a/Graphics/ShaderTools/src/DXCompiler.cpp
+++ b/Graphics/ShaderTools/src/DXCompiler.cpp
@@ -376,6 +376,199 @@ bool DXCompilerImpl::Compile(const CompileAttribs& Attribs)
     return true;
 }
 
+
+#if D3D12_SUPPORTED
+class ShaderReflectionViaLibraryReflection final : public ID3D12ShaderReflection
+{
+public:
+    ShaderReflectionViaLibraryReflection(CComPtr<ID3D12LibraryReflection> pLib, ID3D12FunctionReflection* pFunc) :
+        m_pLib{std::move(pLib)},
+        m_pFunc{pFunc},
+        m_RefCount{0}
+    {}
+
+    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, LPVOID* ppv) override
+    {
+        return E_FAIL;
+    }
+
+    ULONG STDMETHODCALLTYPE AddRef() override
+    {
+        return Atomics::AtomicIncrement(m_RefCount);
+    }
+
+    ULONG STDMETHODCALLTYPE Release() override
+    {
+        auto RefCount = Atomics::AtomicDecrement(m_RefCount);
+        VERIFY(RefCount >= 0, "Inconsistent call to ReleaseStrongRef()");
+        if (RefCount == 0)
+        {
+            delete this;
+        }
+        return RefCount;
+    }
+
+    HRESULT STDMETHODCALLTYPE GetDesc(D3D12_SHADER_DESC* pDesc) override
+    {
+        D3D12_FUNCTION_DESC FnDesc = {};
+        HRESULT             hr     = m_pFunc->GetDesc(&FnDesc);
+        if (FAILED(hr))
+            return hr;
+
+        pDesc->Version                     = FnDesc.Version;
+        pDesc->Creator                     = FnDesc.Creator;
+        pDesc->Flags                       = FnDesc.Flags;
+        pDesc->ConstantBuffers             = FnDesc.ConstantBuffers;
+        pDesc->BoundResources              = FnDesc.BoundResources;
+        pDesc->InputParameters             = 0;
+        pDesc->OutputParameters            = 0;
+        pDesc->InstructionCount            = FnDesc.InstructionCount;
+        pDesc->TempRegisterCount           = FnDesc.TempRegisterCount;
+        pDesc->TempArrayCount              = FnDesc.TempArrayCount;
+        pDesc->DefCount                    = FnDesc.DefCount;
+        pDesc->DclCount                    = FnDesc.DclCount;
+        pDesc->TextureNormalInstructions   = FnDesc.TextureNormalInstructions;
+        pDesc->TextureLoadInstructions     = FnDesc.TextureLoadInstructions;
+        pDesc->TextureCompInstructions     = FnDesc.TextureCompInstructions;
+        pDesc->TextureBiasInstructions     = FnDesc.TextureBiasInstructions;
+        pDesc->TextureGradientInstructions = FnDesc.TextureGradientInstructions;
+        pDesc->FloatInstructionCount       = FnDesc.FloatInstructionCount;
+        pDesc->IntInstructionCount         = FnDesc.IntInstructionCount;
+        pDesc->UintInstructionCount        = FnDesc.UintInstructionCount;
+        pDesc->StaticFlowControlCount      = FnDesc.StaticFlowControlCount;
+        pDesc->DynamicFlowControlCount     = FnDesc.DynamicFlowControlCount;
+        pDesc->MacroInstructionCount       = FnDesc.MacroInstructionCount;
+        pDesc->ArrayInstructionCount       = FnDesc.ArrayInstructionCount;
+        pDesc->CutInstructionCount         = 0;
+        pDesc->EmitInstructionCount        = 0;
+        pDesc->GSOutputTopology            = D3D_PRIMITIVE_TOPOLOGY_UNDEFINED;
+        pDesc->GSMaxOutputVertexCount      = 0;
+        pDesc->InputPrimitive              = D3D_PRIMITIVE_UNDEFINED;
+        pDesc->PatchConstantParameters     = 0;
+        pDesc->cGSInstanceCount            = 0;
+        pDesc->cControlPoints              = 0;
+        pDesc->HSOutputPrimitive           = D3D_TESSELLATOR_OUTPUT_UNDEFINED;
+        pDesc->HSPartitioning              = D3D_TESSELLATOR_PARTITIONING_UNDEFINED;
+        pDesc->TessellatorDomain           = D3D_TESSELLATOR_DOMAIN_UNDEFINED;
+        pDesc->cBarrierInstructions        = 0;
+        pDesc->cInterlockedInstructions    = 0;
+        pDesc->cTextureStoreInstructions   = 0;
+
+        return S_OK;
+    }
+
+    ID3D12ShaderReflectionConstantBuffer* STDMETHODCALLTYPE GetConstantBufferByIndex(UINT Index) override
+    {
+        return m_pFunc->GetConstantBufferByIndex(Index);
+    }
+
+    ID3D12ShaderReflectionConstantBuffer* STDMETHODCALLTYPE GetConstantBufferByName(LPCSTR Name) override
+    {
+        return m_pFunc->GetConstantBufferByName(Name);
+    }
+
+    HRESULT STDMETHODCALLTYPE GetResourceBindingDesc(UINT ResourceIndex, D3D12_SHADER_INPUT_BIND_DESC* pDesc) override
+    {
+        return m_pFunc->GetResourceBindingDesc(ResourceIndex, pDesc);
+    }
+
+    HRESULT STDMETHODCALLTYPE GetInputParameterDesc(UINT ParameterIndex, D3D12_SIGNATURE_PARAMETER_DESC* pDesc) override
+    {
+        UNEXPECTED("not supported");
+        return E_FAIL;
+    }
+
+    HRESULT STDMETHODCALLTYPE GetOutputParameterDesc(UINT ParameterIndex, D3D12_SIGNATURE_PARAMETER_DESC* pDesc) override
+    {
+        UNEXPECTED("not supported");
+        return E_FAIL;
+    }
+
+    HRESULT STDMETHODCALLTYPE GetPatchConstantParameterDesc(UINT ParameterIndex, D3D12_SIGNATURE_PARAMETER_DESC* pDesc) override
+    {
+        UNEXPECTED("not supported");
+        return E_FAIL;
+    }
+
+    ID3D12ShaderReflectionVariable* STDMETHODCALLTYPE GetVariableByName(LPCSTR Name) override
+    {
+        return m_pFunc->GetVariableByName(Name);
+    }
+
+    HRESULT STDMETHODCALLTYPE GetResourceBindingDescByName(LPCSTR Name, D3D12_SHADER_INPUT_BIND_DESC* pDesc) override
+    {
+        return m_pFunc->GetResourceBindingDescByName(Name, pDesc);
+    }
+
+    UINT STDMETHODCALLTYPE GetMovInstructionCount() override
+    {
+        UNEXPECTED("not supported");
+        return 0;
+    }
+
+    UINT STDMETHODCALLTYPE GetMovcInstructionCount() override
+    {
+        UNEXPECTED("not supported");
+        return 0;
+    }
+
+    UINT STDMETHODCALLTYPE GetConversionInstructionCount() override
+    {
+        UNEXPECTED("not supported");
+        return 0;
+    }
+
+    UINT STDMETHODCALLTYPE GetBitwiseInstructionCount() override
+    {
+        UNEXPECTED("not supported");
+        return 0;
+    }
+
+    D3D_PRIMITIVE STDMETHODCALLTYPE GetGSInputPrimitive() override
+    {
+        UNEXPECTED("not supported");
+        return D3D_PRIMITIVE_UNDEFINED;
+    }
+
+    BOOL STDMETHODCALLTYPE IsSampleFrequencyShader() override
+    {
+        UNEXPECTED("not supported");
+        return FALSE;
+    }
+
+    UINT STDMETHODCALLTYPE GetNumInterfaceSlots() override
+    {
+        UNEXPECTED("not supported");
+        return 0;
+    }
+
+    HRESULT STDMETHODCALLTYPE GetMinFeatureLevel(D3D_FEATURE_LEVEL* pLevel) override
+    {
+        UNEXPECTED("not supported");
+        return E_FAIL;
+    }
+
+    UINT STDMETHODCALLTYPE GetThreadGroupSize(UINT* pSizeX, UINT* pSizeY, UINT* pSizeZ) override
+    {
+        UNEXPECTED("not supported");
+        *pSizeX = *pSizeY = *pSizeZ = 0;
+        return 0;
+    }
+
+    UINT64 STDMETHODCALLTYPE GetRequiresFlags() override
+    {
+        UNEXPECTED("not supported");
+        return 0;
+    }
+
+private:
+    CComPtr<ID3D12LibraryReflection> m_pLib;
+    ID3D12FunctionReflection*        m_pFunc = nullptr;
+    Atomics::AtomicLong              m_RefCount;
+};
+#endif // D3D12_SUPPORTED
+
+
 void DXCompilerImpl::GetD3D12ShaderReflection(IDxcBlob*                pShaderBytecode,
                                               ID3D12ShaderReflection** ppShaderReflection)
 {
@@ -386,9 +579,6 @@ void DXCompilerImpl::GetD3D12ShaderReflection(IDxcBlob*                pShaderBy
         if (CreateInstance == nullptr)
             return;
 
-#    define FOURCC(a, b, c, d) (uint32_t{((d) << 24) | ((c) << 16) | ((b) << 8) | (a)})
-        const uint32_t DFCC_DXIL = FOURCC('D', 'X', 'I', 'L');
-
         CComPtr<IDxcContainerReflection> pReflection;
 
         auto hr = CreateInstance(CLSID_DxcContainerReflection, IID_PPV_ARGS(&pReflection));
@@ -401,18 +591,39 @@ void DXCompilerImpl::GetD3D12ShaderReflection(IDxcBlob*                pShaderBy
 
         UINT32 shaderIdx;
 
-        hr = pReflection->FindFirstPartKind(DFCC_DXIL, &shaderIdx);
+        hr = pReflection->FindFirstPartKind(DXC_PART_DXIL, &shaderIdx);
         if (SUCCEEDED(hr))
         {
-            hr = pReflection->GetPartReflection(shaderIdx, __uuidof(*ppShaderReflection), reinterpret_cast<void**>(ppShaderReflection));
-            if (FAILED(hr))
-                LOG_ERROR_AND_THROW("Failed to get the shader reflection");
+            hr = pReflection->GetPartReflection(shaderIdx, IID_PPV_ARGS(ppShaderReflection));
+            if (SUCCEEDED(hr))
+                return;
+
+            // for ray tracing shaders
+            CComPtr<ID3D12LibraryReflection> pLib;
+
+            hr = pReflection->GetPartReflection(shaderIdx, IID_PPV_ARGS(&pLib));
+            if (SUCCEEDED(hr))
+            {
+                D3D12_LIBRARY_DESC Desc = {};
+                pLib->GetDesc(&Desc);
+                VERIFY_EXPR(Desc.FunctionCount == 1);
+
+                ID3D12FunctionReflection* pFunc = pLib->GetFunctionByIndex(0);
+                if (pFunc != nullptr)
+                {
+                    *ppShaderReflection = new ShaderReflectionViaLibraryReflection{std::move(pLib), pFunc};
+                    (*ppShaderReflection)->AddRef();
+                    return;
+                }
+            }
         }
+
+        LOG_ERROR_AND_THROW("Failed to get the shader reflection");
     }
     catch (...)
     {
     }
-#endif
+#endif // D3D12_SUPPORTED
 }
 
 
@@ -470,19 +681,28 @@ void DXCompilerImpl::Compile(const ShaderCreateInfo& ShaderCI,
             DxilArgs.push_back(L"-Qembed_debug");
         }
 #else
-        DxilArgs.push_back(L"-Od"); // TODO: something goes wrong if optimization is enabled
+        if (m_MajorVer > 1 || m_MajorVer == 1 && m_MinorVer >= 5)
+            DxilArgs.push_back(L"-O3"); // Optimization level 3
+        else
+            DxilArgs.push_back(L"-Od"); // TODO: something goes wrong if optimization is enabled
 #endif
     }
     else if (m_Target == DXCompilerTarget::Vulkan)
     {
+        const Uint32 RayTracingStages =
+            SHADER_TYPE_RAY_GEN | SHADER_TYPE_RAY_MISS | SHADER_TYPE_RAY_CLOSEST_HIT |
+            SHADER_TYPE_RAY_ANY_HIT | SHADER_TYPE_RAY_INTERSECTION | SHADER_TYPE_CALLABLE;
+
         DxilArgs.assign(
             {
                 L"-spirv",
                 L"-fspv-reflect",
-                L"-fspv-target-env=vulkan1.0",
                 //L"-WX", // Warnings as errors
                 L"-O3", // Optimization level 3
             });
+
+        if (ShaderCI.Desc.ShaderType & RayTracingStages)
+            DxilArgs.push_back(L"-fspv-target-env=vulkan1.2");
     }
     else
     {
diff --git a/Graphics/ShaderTools/src/GLSLangUtils.cpp b/Graphics/ShaderTools/src/GLSLangUtils.cpp
index f23a46a3..75d97528 100644
--- a/Graphics/ShaderTools/src/GLSLangUtils.cpp
+++ b/Graphics/ShaderTools/src/GLSLangUtils.cpp
@@ -455,6 +455,11 @@ 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");
+    VERIFY(ShLang != EShLangTaskNV && ShLang != EShLangMeshNV,
+           "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);
     Shader.setEnvTarget(::glslang::EShTargetSpv, ::glslang::EShTargetSpv_1_0);
@@ -513,12 +518,41 @@ std::vector<unsigned int> GLSLtoSPIRV(SHADER_TYPE                      ShaderTyp
                                       int                              SourceCodeLen,
                                       const ShaderMacro*               Macros,
                                       IShaderSourceInputStreamFactory* pShaderSourceStreamFactory,
+                                      SpirvVersion                     Version,
                                       IDataBlob**                      ppCompilerOutput)
 {
     VERIFY_EXPR(ShaderSource != nullptr && SourceCodeLen > 0);
 
     EShLanguage        ShLang = ShaderTypeToShLanguage(ShaderType);
     ::glslang::TShader Shader(ShLang);
+    spv_target_env     spvTarget = SPV_ENV_VULKAN_1_0;
+
+    switch (Version)
+    {
+        case SpirvVersion::Vk100:
+            // keep default
+            break;
+        case SpirvVersion::Vk110:
+            Shader.setEnvInput(::glslang::EShSourceGlsl, ShLang, ::glslang::EShClientVulkan, 110);
+            Shader.setEnvClient(::glslang::EShClientVulkan, ::glslang::EShTargetVulkan_1_1);
+            Shader.setEnvTarget(::glslang::EShTargetSpv, ::glslang::EShTargetSpv_1_3);
+            spvTarget = SPV_ENV_VULKAN_1_1;
+            break;
+        case SpirvVersion::Vk110_Spirv14:
+            Shader.setEnvInput(::glslang::EShSourceGlsl, ShLang, ::glslang::EShClientVulkan, 110);
+            Shader.setEnvClient(::glslang::EShClientVulkan, ::glslang::EShTargetVulkan_1_1);
+            Shader.setEnvTarget(::glslang::EShTargetSpv, ::glslang::EShTargetSpv_1_4);
+            spvTarget = SPV_ENV_VULKAN_1_1_SPIRV_1_4;
+            break;
+        case SpirvVersion::Vk120:
+            Shader.setEnvInput(::glslang::EShSourceGlsl, ShLang, ::glslang::EShClientVulkan, 120);
+            Shader.setEnvClient(::glslang::EShClientVulkan, ::glslang::EShTargetVulkan_1_2);
+            Shader.setEnvTarget(::glslang::EShTargetSpv, ::glslang::EShTargetSpv_1_4);
+            spvTarget = SPV_ENV_VULKAN_1_2;
+            break;
+        default:
+            UNEXPECTED("Unknown SPIRV version");
+    }
 
     EShMessages messages = (EShMessages)(EShMsgSpvRules | EShMsgVulkanRules);
 
@@ -539,7 +573,7 @@ std::vector<unsigned int> GLSLtoSPIRV(SHADER_TYPE                      ShaderTyp
     if (SPIRV.empty())
         return SPIRV;
 
-    spvtools::Optimizer SpirvOptimizer(SPV_ENV_VULKAN_1_0);
+    spvtools::Optimizer SpirvOptimizer(spvTarget);
     SpirvOptimizer.RegisterPerformancePasses();
     std::vector<uint32_t> OptimizedSPIRV;
     if (SpirvOptimizer.Run(SPIRV.data(), SPIRV.size(), &OptimizedSPIRV))
diff --git a/Graphics/ShaderTools/src/HLSLUtils.cpp b/Graphics/ShaderTools/src/HLSLUtils.cpp
index 613eea25..72f201b7 100644
--- a/Graphics/ShaderTools/src/HLSLUtils.cpp
+++ b/Graphics/ShaderTools/src/HLSLUtils.cpp
@@ -68,17 +68,25 @@ String BuildHLSLSourceString(const ShaderCreateInfo& ShaderCI,
 String GetHLSLProfileString(SHADER_TYPE ShaderType, ShaderVersion ShaderModel)
 {
     String strShaderProfile;
+
+    static_assert(SHADER_TYPE_LAST == SHADER_TYPE_CALLABLE, "Please update the switch below to handle the new shader type");
     switch (ShaderType)
     {
         // clang-format off
-        case SHADER_TYPE_VERTEX:        strShaderProfile = "vs"; break;
-        case SHADER_TYPE_PIXEL:         strShaderProfile = "ps"; break;
-        case SHADER_TYPE_GEOMETRY:      strShaderProfile = "gs"; break;
-        case SHADER_TYPE_HULL:          strShaderProfile = "hs"; break;
-        case SHADER_TYPE_DOMAIN:        strShaderProfile = "ds"; break;
-        case SHADER_TYPE_COMPUTE:       strShaderProfile = "cs"; break;
-        case SHADER_TYPE_AMPLIFICATION: strShaderProfile = "as"; break;
-        case SHADER_TYPE_MESH:          strShaderProfile = "ms"; break;
+        case SHADER_TYPE_VERTEX:           strShaderProfile = "vs"; break;
+        case SHADER_TYPE_PIXEL:            strShaderProfile = "ps"; break;
+        case SHADER_TYPE_GEOMETRY:         strShaderProfile = "gs"; break;
+        case SHADER_TYPE_HULL:             strShaderProfile = "hs"; break;
+        case SHADER_TYPE_DOMAIN:           strShaderProfile = "ds"; break;
+        case SHADER_TYPE_COMPUTE:          strShaderProfile = "cs"; break;
+        case SHADER_TYPE_AMPLIFICATION:    strShaderProfile = "as"; break;
+        case SHADER_TYPE_MESH:             strShaderProfile = "ms"; break;
+        case SHADER_TYPE_RAY_GEN:
+        case SHADER_TYPE_RAY_MISS:
+        case SHADER_TYPE_RAY_CLOSEST_HIT:
+        case SHADER_TYPE_RAY_ANY_HIT:
+        case SHADER_TYPE_RAY_INTERSECTION:
+        case SHADER_TYPE_CALLABLE:         strShaderProfile = "lib"; break;
         // clang-format on
         default: UNEXPECTED("Unknown shader type");
     }
diff --git a/Graphics/ShaderTools/src/SPIRVShaderResources.cpp b/Graphics/ShaderTools/src/SPIRVShaderResources.cpp
index cda18772..7f1d78d5 100644
--- a/Graphics/ShaderTools/src/SPIRVShaderResources.cpp
+++ b/Graphics/ShaderTools/src/SPIRVShaderResources.cpp
@@ -133,7 +133,7 @@ ShaderResourceDesc SPIRVShaderResourceAttribs::GetResourceDesc() const
     ResourceDesc.Name      = Name;
     ResourceDesc.ArraySize = ArraySize;
 
-    static_assert(SPIRVShaderResourceAttribs::ResourceType::NumResourceTypes == 11, "Please handle the new resource type below");
+    static_assert(SPIRVShaderResourceAttribs::ResourceType::NumResourceTypes == 12, "Please handle the new resource type below");
     switch (Type)
     {
         case SPIRVShaderResourceAttribs::ResourceType::UniformBuffer:
@@ -183,6 +183,10 @@ ShaderResourceDesc SPIRVShaderResourceAttribs::GetResourceDesc() const
             ResourceDesc.Type = SHADER_RESOURCE_TYPE_INPUT_ATTACHMENT;
             break;
 
+        case SPIRVShaderResourceAttribs::ResourceType::AccelerationStructure:
+            ResourceDesc.Type = SHADER_RESOURCE_TYPE_ACCEL_STRUCT;
+            break;
+
         default:
             UNEXPECTED("Unknown SPIRV resource type");
     }
@@ -299,7 +303,7 @@ SPIRVShaderResources::SPIRVShaderResources(IMemoryAllocator&     Allocator,
     size_t ResourceNamesPoolSize = 0;
     for (const auto& ub : resources.uniform_buffers)
         ResourceNamesPoolSize += GetUBName(Compiler, ub, ParsedIRSource).length() + 1;
-    static_assert(SPIRVShaderResourceAttribs::ResourceType::NumResourceTypes == 11, "Please account for the new resource type below");
+    static_assert(SPIRVShaderResourceAttribs::ResourceType::NumResourceTypes == 12, "Please account for the new resource type below");
     for (auto* pResType :
          {
              &resources.storage_buffers,
@@ -308,7 +312,8 @@ SPIRVShaderResources::SPIRVShaderResources(IMemoryAllocator&     Allocator,
              &resources.atomic_counters,
              &resources.separate_images,
              &resources.separate_samplers,
-             &resources.subpass_inputs
+             &resources.subpass_inputs,
+             &resources.acceleration_structures
              // clang-format off
          })
     // clang-format on
@@ -371,15 +376,16 @@ SPIRVShaderResources::SPIRVShaderResources(IMemoryAllocator&     Allocator,
     }
 
     ResourceCounters ResCounters;
-    ResCounters.NumUBs       = static_cast<Uint32>(resources.uniform_buffers.size());
-    ResCounters.NumSBs       = static_cast<Uint32>(resources.storage_buffers.size());
-    ResCounters.NumImgs      = static_cast<Uint32>(resources.storage_images.size());
-    ResCounters.NumSmpldImgs = static_cast<Uint32>(resources.sampled_images.size());
-    ResCounters.NumACs       = static_cast<Uint32>(resources.atomic_counters.size());
-    ResCounters.NumSepSmplrs = static_cast<Uint32>(resources.separate_samplers.size());
-    ResCounters.NumSepImgs   = static_cast<Uint32>(resources.separate_images.size());
-    ResCounters.NumInptAtts  = static_cast<Uint32>(resources.subpass_inputs.size());
-    static_assert(SPIRVShaderResourceAttribs::ResourceType::NumResourceTypes == 11, "Please set the new resource type counter here");
+    ResCounters.NumUBs          = static_cast<Uint32>(resources.uniform_buffers.size());
+    ResCounters.NumSBs          = static_cast<Uint32>(resources.storage_buffers.size());
+    ResCounters.NumImgs         = static_cast<Uint32>(resources.storage_images.size());
+    ResCounters.NumSmpldImgs    = static_cast<Uint32>(resources.sampled_images.size());
+    ResCounters.NumACs          = static_cast<Uint32>(resources.atomic_counters.size());
+    ResCounters.NumSepSmplrs    = static_cast<Uint32>(resources.separate_samplers.size());
+    ResCounters.NumSepImgs      = static_cast<Uint32>(resources.separate_images.size());
+    ResCounters.NumInptAtts     = static_cast<Uint32>(resources.subpass_inputs.size());
+    ResCounters.NumAccelStructs = static_cast<Uint32>(resources.acceleration_structures.size());
+    static_assert(SPIRVShaderResourceAttribs::ResourceType::NumResourceTypes == 12, "Please set the new resource type counter here");
 
     // Resource names pool is only needed to facilitate string allocation.
     StringPool ResourceNamesPool;
@@ -543,7 +549,20 @@ SPIRVShaderResources::SPIRVShaderResources(IMemoryAllocator&     Allocator,
         VERIFY_EXPR(CurrSubpassInput == GetNumInptAtts());
     }
 
-    static_assert(SPIRVShaderResourceAttribs::ResourceType::NumResourceTypes == 11, "Please initialize SPIRVShaderResourceAttribs for the new resource type here");
+    {
+        Uint32 CurrAccelStruct = 0;
+        for (const auto& AccelStruct : resources.acceleration_structures)
+        {
+            new (&GetAccelStruct(CurrAccelStruct++))
+                SPIRVShaderResourceAttribs(Compiler,
+                                           AccelStruct,
+                                           ResourceNamesPool.CopyString(AccelStruct.name),
+                                           SPIRVShaderResourceAttribs::ResourceType::AccelerationStructure);
+        }
+        VERIFY_EXPR(CurrAccelStruct == GetNumAccelStructs());
+    }
+
+    static_assert(SPIRVShaderResourceAttribs::ResourceType::NumResourceTypes == 12, "Please initialize SPIRVShaderResourceAttribs for the new resource type here");
 
     if (CombinedSamplerSuffix != nullptr)
     {
@@ -609,8 +628,9 @@ void SPIRVShaderResources::Initialize(IMemoryAllocator&       Allocator,
     m_SeparateSamplerOffset = AdvanceOffset(Counters.NumSepSmplrs);
     m_SeparateImageOffset   = AdvanceOffset(Counters.NumSepImgs);
     m_InputAttachmentOffset = AdvanceOffset(Counters.NumInptAtts);
+    m_AccelStructOffset     = AdvanceOffset(Counters.NumAccelStructs);
     m_TotalResources        = AdvanceOffset(0);
-    static_assert(SPIRVShaderResourceAttribs::ResourceType::NumResourceTypes == 11, "Please update the new resource type offset");
+    static_assert(SPIRVShaderResourceAttribs::ResourceType::NumResourceTypes == 12, "Please update the new resource type offset");
 
     VERIFY(NumShaderStageInputs <= MaxOffset, "Max offset exceeded");
     m_NumShaderStageInputs = static_cast<OffsetType>(NumShaderStageInputs);
@@ -623,14 +643,16 @@ void SPIRVShaderResources::Initialize(IMemoryAllocator&       Allocator,
                       m_NumShaderStageInputs        * sizeof(SPIRVShaderStageInputAttribs) +
                       AlignedResourceNamesPoolSize  * sizeof(char);
 
-    VERIFY_EXPR(GetNumUBs()       == Counters.NumUBs);
-    VERIFY_EXPR(GetNumSBs()       == Counters.NumSBs);
-    VERIFY_EXPR(GetNumImgs()      == Counters.NumImgs);
-    VERIFY_EXPR(GetNumSmpldImgs() == Counters.NumSmpldImgs);
-    VERIFY_EXPR(GetNumACs()       == Counters.NumACs);
-    VERIFY_EXPR(GetNumSepSmplrs() == Counters.NumSepSmplrs);
-    VERIFY_EXPR(GetNumSepImgs()   == Counters.NumSepImgs);
-    VERIFY_EXPR(GetNumInptAtts()  == Counters.NumInptAtts);
+    VERIFY_EXPR(GetNumUBs()          == Counters.NumUBs);
+    VERIFY_EXPR(GetNumSBs()          == Counters.NumSBs);
+    VERIFY_EXPR(GetNumImgs()         == Counters.NumImgs);
+    VERIFY_EXPR(GetNumSmpldImgs()    == Counters.NumSmpldImgs);
+    VERIFY_EXPR(GetNumACs()          == Counters.NumACs);
+    VERIFY_EXPR(GetNumSepSmplrs()    == Counters.NumSepSmplrs);
+    VERIFY_EXPR(GetNumSepImgs()      == Counters.NumSepImgs);
+    VERIFY_EXPR(GetNumInptAtts()     == Counters.NumInptAtts);
+    VERIFY_EXPR(GetNumAccelStructs() == Counters.NumAccelStructs);
+    static_assert(SPIRVShaderResourceAttribs::ResourceType::NumResourceTypes == 12, "Please update the new resource count verification");
     // clang-format on
 
     if (MemorySize)
@@ -670,8 +692,13 @@ 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();
+
+    static_assert(SPIRVShaderResourceAttribs::ResourceType::NumResourceTypes == 12, "Please add destructor for the new resource");
 }
 
 
@@ -710,7 +737,7 @@ std::string SPIRVShaderResources::DumpResources()
         {
             VERIFY(UB.Type == SPIRVShaderResourceAttribs::ResourceType::UniformBuffer, "Unexpected resource type");
             ss << std::endl
-               << std::setw(3) << ResNum << " Uniform Buffer   ";
+               << std::setw(3) << ResNum << " Uniform Buffer     ";
             DumpResource(UB);
         },
         [&](const SPIRVShaderResourceAttribs& SB, Uint32) //
@@ -720,7 +747,7 @@ std::string SPIRVShaderResources::DumpResources()
                    "Unexpected resource type");
             ss << std::endl
                << std::setw(3) << ResNum
-               << (SB.Type == SPIRVShaderResourceAttribs::ResourceType::ROStorageBuffer ? " RO Storage Buffer" : " RW Storage Buffer");
+               << (SB.Type == SPIRVShaderResourceAttribs::ResourceType::ROStorageBuffer ? " RO Storage Buffer  " : " RW Storage Buffer  ");
             DumpResource(SB);
         },
         [&](const SPIRVShaderResourceAttribs& Img, Uint32) //
@@ -728,12 +755,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");
@@ -744,12 +771,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");
@@ -759,29 +786,36 @@ 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";
+            DumpResource(AccelStruct);
         } //
     );
     VERIFY_EXPR(ResNum == GetTotalResources());
@@ -801,10 +835,12 @@ bool SPIRVShaderResources::IsCompatibleWith(const SPIRVShaderResources& Resource
         GetNumACs()               != Resources.GetNumACs()        ||
         GetNumSepImgs()           != Resources.GetNumSepImgs()    ||
         GetNumSepSmplrs()         != Resources.GetNumSepSmplrs()  ||
-        GetNumInptAtts()          != Resources.GetNumInptAtts())
+        GetNumInptAtts()          != Resources.GetNumInptAtts()   ||
+        GetNumAccelStructs()      != Resources.GetNumAccelStructs())
         return false;
     // clang-format on
     VERIFY_EXPR(GetTotalResources() == Resources.GetTotalResources());
+    static_assert(SPIRVShaderResourceAttribs::ResourceType::NumResourceTypes == 12, "Please update comparison with the new resource");
 
     bool IsCompatible = true;
     ProcessResources(
diff --git a/Graphics/ShaderTools/src/ShaderToolsCommon.cpp b/Graphics/ShaderTools/src/ShaderToolsCommon.cpp
index dfb12bec..41d73b4a 100644
--- a/Graphics/ShaderTools/src/ShaderToolsCommon.cpp
+++ b/Graphics/ShaderTools/src/ShaderToolsCommon.cpp
@@ -35,30 +35,43 @@ namespace Diligent
 namespace
 {
 
-const ShaderMacro VSMacros[] = {{"VERTEX_SHADER", "1"}, {}};
-const ShaderMacro PSMacros[] = {{"FRAGMENT_SHADER", "1"}, {"PIXEL_SHADER", "1"}, {}};
-const ShaderMacro GSMacros[] = {{"GEOMETRY_SHADER", "1"}, {}};
-const ShaderMacro HSMacros[] = {{"TESS_CONTROL_SHADER", "1"}, {"HULL_SHADER", "1"}, {}};
-const ShaderMacro DSMacros[] = {{"TESS_EVALUATION_SHADER", "1"}, {"DOMAIN_SHADER", "1"}, {}};
-const ShaderMacro CSMacros[] = {{"COMPUTE_SHADER", "1"}, {}};
-const ShaderMacro ASMacros[] = {{"TASK_SHADER", "1"}, {"AMPLIFICATION_SHADER", "1"}, {}};
-const ShaderMacro MSMacros[] = {{"MESH_SHADER", "1"}, {}};
+const ShaderMacro VSMacros[]  = {{"VERTEX_SHADER", "1"}, {}};
+const ShaderMacro PSMacros[]  = {{"FRAGMENT_SHADER", "1"}, {"PIXEL_SHADER", "1"}, {}};
+const ShaderMacro GSMacros[]  = {{"GEOMETRY_SHADER", "1"}, {}};
+const ShaderMacro HSMacros[]  = {{"TESS_CONTROL_SHADER", "1"}, {"HULL_SHADER", "1"}, {}};
+const ShaderMacro DSMacros[]  = {{"TESS_EVALUATION_SHADER", "1"}, {"DOMAIN_SHADER", "1"}, {}};
+const ShaderMacro CSMacros[]  = {{"COMPUTE_SHADER", "1"}, {}};
+const ShaderMacro ASMacros[]  = {{"TASK_SHADER", "1"}, {"AMPLIFICATION_SHADER", "1"}, {}};
+const ShaderMacro MSMacros[]  = {{"MESH_SHADER", "1"}, {}};
+const ShaderMacro RGMacros[]  = {{"RAY_GEN_SHADER", "1"}, {}};
+const ShaderMacro RMMacros[]  = {{"RAY_MISS_SHADER", "1"}, {}};
+const ShaderMacro RCHMacros[] = {{"RAY_CLOSEST_HIT_SHADER", "1"}, {}};
+const ShaderMacro RAHMacros[] = {{"RAY_ANY_HIT_SHADER", "1"}, {}};
+const ShaderMacro RIMacros[]  = {{"RAY_INTERSECTION_SHADER", "1"}, {}};
+const ShaderMacro RCMacros[]  = {{"RAY_CALLABLE_SHADER", "1"}, {}};
 
 } // namespace
 
 const ShaderMacro* GetShaderTypeMacros(SHADER_TYPE Type)
 {
+    static_assert(SHADER_TYPE_LAST == SHADER_TYPE_CALLABLE, "Please update the switch below to handle the new shader type");
     switch (Type)
     {
         // clang-format off
-        case SHADER_TYPE_VERTEX:        return VSMacros;
-        case SHADER_TYPE_PIXEL:         return PSMacros;
-        case SHADER_TYPE_GEOMETRY:      return GSMacros;
-        case SHADER_TYPE_HULL:          return HSMacros;
-        case SHADER_TYPE_DOMAIN:        return DSMacros;
-        case SHADER_TYPE_COMPUTE:       return CSMacros;
-        case SHADER_TYPE_AMPLIFICATION: return ASMacros;
-        case SHADER_TYPE_MESH:          return MSMacros;
+        case SHADER_TYPE_VERTEX:           return VSMacros;
+        case SHADER_TYPE_PIXEL:            return PSMacros;
+        case SHADER_TYPE_GEOMETRY:         return GSMacros;
+        case SHADER_TYPE_HULL:             return HSMacros;
+        case SHADER_TYPE_DOMAIN:           return DSMacros;
+        case SHADER_TYPE_COMPUTE:          return CSMacros;
+        case SHADER_TYPE_AMPLIFICATION:    return ASMacros;
+        case SHADER_TYPE_MESH:             return MSMacros;
+        case SHADER_TYPE_RAY_GEN:          return RGMacros;
+        case SHADER_TYPE_RAY_MISS:         return RMMacros;
+        case SHADER_TYPE_RAY_CLOSEST_HIT:  return RCHMacros;
+        case SHADER_TYPE_RAY_ANY_HIT:      return RAHMacros;
+        case SHADER_TYPE_RAY_INTERSECTION: return RIMacros;
+        case SHADER_TYPE_CALLABLE:         return RCMacros;
         // clang-format on
         default:
             UNEXPECTED("Unexpected shader type");