From 7f26e40e0898391a32e6a05d91ef1a217d885668 Mon Sep 17 00:00:00 2001 From: azhirnov Date: Sun, 25 Oct 2020 15:53:05 +0300 Subject: PSO refactoring for ray tracing --- Graphics/ShaderTools/include/GLSLUtils.hpp | 2 +- Graphics/ShaderTools/include/GLSLangUtils.hpp | 9 + .../ShaderTools/include/SPIRVShaderResources.hpp | 117 +++++----- Graphics/ShaderTools/src/DXCompiler.cpp | 240 ++++++++++++++++++++- Graphics/ShaderTools/src/GLSLangUtils.cpp | 36 +++- Graphics/ShaderTools/src/HLSLUtils.cpp | 24 ++- Graphics/ShaderTools/src/SPIRVShaderResources.cpp | 102 ++++++--- Graphics/ShaderTools/src/ShaderToolsCommon.cpp | 45 ++-- 8 files changed, 448 insertions(+), 127 deletions(-) (limited to 'Graphics/ShaderTools') 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 GLSLtoSPIRV(SHADER_TYPE ShaderTyp int SourceCodeLen, const ShaderMacro* Macros, IShaderSourceInputStreamFactory* pShaderSourceStreamFactory, + SpirvVersion Version, IDataBlob** ppCompilerOutput); std::vector 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 @@ -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 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 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 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(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 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 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 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 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 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(resources.uniform_buffers.size()); - ResCounters.NumSBs = static_cast(resources.storage_buffers.size()); - ResCounters.NumImgs = static_cast(resources.storage_images.size()); - ResCounters.NumSmpldImgs = static_cast(resources.sampled_images.size()); - ResCounters.NumACs = static_cast(resources.atomic_counters.size()); - ResCounters.NumSepSmplrs = static_cast(resources.separate_samplers.size()); - ResCounters.NumSepImgs = static_cast(resources.separate_images.size()); - ResCounters.NumInptAtts = static_cast(resources.subpass_inputs.size()); - static_assert(SPIRVShaderResourceAttribs::ResourceType::NumResourceTypes == 11, "Please set the new resource type counter here"); + ResCounters.NumUBs = static_cast(resources.uniform_buffers.size()); + ResCounters.NumSBs = static_cast(resources.storage_buffers.size()); + ResCounters.NumImgs = static_cast(resources.storage_images.size()); + ResCounters.NumSmpldImgs = static_cast(resources.sampled_images.size()); + ResCounters.NumACs = static_cast(resources.atomic_counters.size()); + ResCounters.NumSepSmplrs = static_cast(resources.separate_samplers.size()); + ResCounters.NumSepImgs = static_cast(resources.separate_images.size()); + ResCounters.NumInptAtts = static_cast(resources.subpass_inputs.size()); + ResCounters.NumAccelStructs = static_cast(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(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"); -- cgit v1.2.3