From c0087704ea69eec2d52d4db891309b362a2c2812 Mon Sep 17 00:00:00 2001 From: Egor Yusov Date: Thu, 17 May 2018 21:36:46 -0700 Subject: Reworked SPIRVShaderResources: reduced sizeof(SPIRVShaderResourceAttribs) to 32; packing resource names into the string pool --- Graphics/GLSLTools/include/SPIRVShaderResources.h | 66 +++++--- Graphics/GLSLTools/src/SPIRVShaderResources.cpp | 174 ++++++++++++++++++---- 2 files changed, 185 insertions(+), 55 deletions(-) (limited to 'Graphics/GLSLTools') diff --git a/Graphics/GLSLTools/include/SPIRVShaderResources.h b/Graphics/GLSLTools/include/SPIRVShaderResources.h index 6290d55c..a7b610b5 100644 --- a/Graphics/GLSLTools/include/SPIRVShaderResources.h +++ b/Graphics/GLSLTools/include/SPIRVShaderResources.h @@ -30,10 +30,11 @@ // // m_MemoryBuffer m_TotalResources // | | -// | Uniform Buffers | Storage Buffers | Storage Images | Sampled Images | Atomic Counters | Separate Images | Separate Samplers | Static Samplers | +// | Uniform Buffers | Storage Buffers | Storage Images | Sampled Images | Atomic Counters | Separate Images | Separate Samplers | Static Samplers | Resource Names | #include #include +#include #include "Shader.h" #include "Sampler.h" @@ -41,6 +42,7 @@ #include "STDAllocator.h" #include "HashUtils.h" #include "RefCntAutoPtr.h" +#include "StringPool.h" namespace spirv_cross { @@ -84,19 +86,19 @@ struct SPIRVShaderResourceAttribs NumResourceTypes }; - const String Name; - + const char *Name; const Uint16 ArraySize; const ResourceType Type : 4; const SHADER_VARIABLE_TYPE VarType : 4; const Int8 StaticSamplerInd; - // offset in SPIRV words (uint32_t) for a decoration which was originally declared in the SPIRV binary + // Offset in SPIRV words (uint32_t) of binding & descriptor set decorations in SPIRV binary const uint32_t BindingDecorationOffset; const uint32_t DescriptorSetDecorationOffset; SPIRVShaderResourceAttribs(const spirv_cross::Compiler& Compiler, const spirv_cross::Resource& Res, + const char* _Name, ResourceType _Type, SHADER_VARIABLE_TYPE _VarType, Int32 _StaticSamplerInd); @@ -105,7 +107,11 @@ struct SPIRVShaderResourceAttribs { VERIFY_EXPR(ArrayInd < ArraySize); if (ArraySize > 1) - return Name+ '[' + std::to_string(ArrayInd) + ']'; + { + std::stringstream ss; + ss << Name << '[' << ArrayInd << ']'; + return ss.str(); + } else return Name; } @@ -122,10 +128,10 @@ static_assert(sizeof(SPIRVShaderResourceAttribs) % sizeof(void*) == 0, "Size of class SPIRVShaderResources { public: - SPIRVShaderResources(IMemoryAllocator& Allocator, - IRenderDevice* pRenderDevice, - std::vector spirv_binary, - const ShaderDesc& shaderDesc); + SPIRVShaderResources(IMemoryAllocator& Allocator, + IRenderDevice* pRenderDevice, + std::vector spirv_binary, + const ShaderDesc& shaderDesc); SPIRVShaderResources (const SPIRVShaderResources&) = delete; SPIRVShaderResources (SPIRVShaderResources&&) = delete; @@ -134,6 +140,8 @@ public: ~SPIRVShaderResources(); + using SamplerPtrType = RefCntAutoPtr; + 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); } @@ -159,7 +167,7 @@ public: VERIFY(ResAttribs.StaticSamplerInd < m_NumStaticSamplers, "Static sampler index (", ResAttribs.StaticSamplerInd, ") is out of range. Array size: ", m_NumStaticSamplers); auto *ResourceMemoryEnd = reinterpret_cast(m_MemoryBuffer.get()) + m_TotalResources; - return reinterpret_cast*>(ResourceMemoryEnd)[ResAttribs.StaticSamplerInd]; + return reinterpret_cast(ResourceMemoryEnd)[ResAttribs.StaticSamplerInd]; } void CountResources(const SHADER_VARIABLE_TYPE *AllowedVarTypes, @@ -182,15 +190,15 @@ public: typename THandleAC, typename THandleSepImg, typename THandleSepSmpl> - void ProcessResources(const SHADER_VARIABLE_TYPE *AllowedVarTypes, - Uint32 NumAllowedTypes, - THandleUB HandleUB, - THandleSB HandleSB, - THandleImg HandleImg, - THandleSmplImg HandleSmplImg, - THandleAC HandleAC, - THandleSepImg HandleSepImg, - THandleSepSmpl HandleSepSmpl)const + void ProcessResources(const SHADER_VARIABLE_TYPE* AllowedVarTypes, + Uint32 NumAllowedTypes, + THandleUB HandleUB, + THandleSB HandleSB, + THandleImg HandleImg, + THandleSmplImg HandleSmplImg, + THandleAC HandleAC, + THandleSepImg HandleSepImg, + THandleSepSmpl HandleSepSmpl)const { Uint32 AllowedTypeBits = GetAllowedTypeBits(AllowedVarTypes, NumAllowedTypes); @@ -259,12 +267,23 @@ public: } } + std::string DumpResources(); + //bool IsCompatibleWith(const ShaderResources &Resources)const; //size_t GetHash()const; protected: - void Initialize(IMemoryAllocator &Allocator, Uint32 NumUBs, Uint32 NumSBs, Uint32 NumImgs, Uint32 NumSmplImgs, Uint32 NumACs, Uint32 NumSepImgs, Uint32 NumSepSmpls, Uint32 NumStaticSamplers); + void Initialize(IMemoryAllocator& Allocator, + Uint32 NumUBs, + Uint32 NumSBs, + Uint32 NumImgs, + Uint32 NumSmplImgs, + Uint32 NumACs, + Uint32 NumSepImgs, + Uint32 NumSepSmpls, + Uint32 NumStaticSamplers, + size_t ResourceNamesPoolSize); __forceinline SPIRVShaderResourceAttribs& GetResAttribs(Uint32 n, Uint32 NumResources, Uint32 Offset)noexcept { @@ -288,17 +307,18 @@ protected: SPIRVShaderResourceAttribs& GetSepImg (Uint32 n)noexcept{ return GetResAttribs(n, GetNumSepImgs(), m_SeparateImageOffset ); } SPIRVShaderResourceAttribs& GetSepSmpl (Uint32 n)noexcept{ return GetResAttribs(n, GetNumSepSmpls(), m_SeparateSamplerOffset); } SPIRVShaderResourceAttribs& GetResource(Uint32 n)noexcept{ return GetResAttribs(n, GetTotalResources(), 0); } - RefCntAutoPtr& GetStaticSampler(Uint32 n)noexcept + SamplerPtrType& GetStaticSampler(Uint32 n)noexcept { VERIFY(n < m_NumStaticSamplers, "Static sampler index (", n, ") is out of range. Array size: ", m_NumStaticSamplers); auto *ResourceMemoryEnd = reinterpret_cast(m_MemoryBuffer.get()) + m_TotalResources; - return reinterpret_cast*>(ResourceMemoryEnd)[n]; + return reinterpret_cast(ResourceMemoryEnd)[n]; } private: // Memory buffer that holds all resources as continuous chunk of memory: - // | UBs | SBs | StrgImgs | SmplImgs | ACs | SepImgs | SepSamplers | Static Samplers | + // | UBs | SBs | StrgImgs | SmplImgs | ACs | SepImgs | SepSamplers | Static Samplers | Resource Names | std::unique_ptr< void, STDDeleterRawMem > m_MemoryBuffer; + StringPool m_ResourceNames; using OffsetType = Uint16; OffsetType m_StorageBufferOffset = 0; diff --git a/Graphics/GLSLTools/src/SPIRVShaderResources.cpp b/Graphics/GLSLTools/src/SPIRVShaderResources.cpp index a1cd5639..41d21946 100644 --- a/Graphics/GLSLTools/src/SPIRVShaderResources.cpp +++ b/Graphics/GLSLTools/src/SPIRVShaderResources.cpp @@ -21,6 +21,7 @@ * of the possibility of such damages. */ +#include #include "SPIRVShaderResources.h" #include "spirv_cross.hpp" #include "ShaderBase.h" @@ -58,27 +59,28 @@ static uint32_t GetDecorationOffset(const spirv_cross::Compiler &Compiler, SPIRVShaderResourceAttribs::SPIRVShaderResourceAttribs(const spirv_cross::Compiler& Compiler, const spirv_cross::Resource& Res, + const char* _Name, ResourceType _Type, SHADER_VARIABLE_TYPE _VarType, Int32 _StaticSamplerInd) : - Name(Res.name), + Name(_Name), ArraySize(GetResourceArraySize(Compiler, Res)), - BindingDecorationOffset(GetDecorationOffset(Compiler, Res, spv::Decoration::DecorationBinding)), - DescriptorSetDecorationOffset(GetDecorationOffset(Compiler, Res, spv::Decoration::DecorationDescriptorSet)), Type(_Type), VarType(_VarType), - StaticSamplerInd(static_cast(_StaticSamplerInd)) + StaticSamplerInd(static_cast(_StaticSamplerInd)), + BindingDecorationOffset(GetDecorationOffset(Compiler, Res, spv::Decoration::DecorationBinding)), + DescriptorSetDecorationOffset(GetDecorationOffset(Compiler, Res, spv::Decoration::DecorationDescriptorSet)) { VERIFY(_StaticSamplerInd >= std::numeric_limits::min() && _StaticSamplerInd <= std::numeric_limits::max(), "Static sampler index is out of representable range" ); } -Int32 FindStaticSampler(const ShaderDesc& shaderDesc, const char* SamplerName) +Int32 FindStaticSampler(const ShaderDesc& shaderDesc, const std::string& SamplerName) { for(Uint32 s=0; s < shaderDesc.NumStaticSamplers; ++s) { const auto& StSam = shaderDesc.StaticSamplers[s]; - if(strcmp(SamplerName, StSam.TextureName) == 0) + if(SamplerName.compare(StSam.TextureName) == 0) return s; } @@ -98,6 +100,23 @@ SPIRVShaderResources::SPIRVShaderResources(IMemoryAllocator& Allocator, // The SPIR-V is now parsed, and we can perform reflection on it. spirv_cross::ShaderResources resources = Compiler.get_shader_resources(); + size_t ResourceNamesPoolSize = 0; + for(auto *pResType : + { + &resources.uniform_buffers, + &resources.storage_buffers, + &resources.storage_images, + &resources.sampled_images, + &resources.atomic_counters, + &resources.push_constant_buffers, + &resources.separate_images, + &resources.separate_samplers + }) + { + for(const auto &res : *pResType) + ResourceNamesPoolSize += res.name.length() + 1; + } + Initialize(Allocator, static_cast(resources.uniform_buffers.size()), static_cast(resources.storage_buffers.size()), @@ -106,14 +125,20 @@ SPIRVShaderResources::SPIRVShaderResources(IMemoryAllocator& Allocator, static_cast(resources.atomic_counters.size()), static_cast(resources.separate_images.size()), static_cast(resources.separate_samplers.size()), - shaderDesc.NumStaticSamplers); + shaderDesc.NumStaticSamplers, + ResourceNamesPoolSize); { Uint32 CurrUB = 0; for (const auto &UB : resources.uniform_buffers) { - auto VarType = GetShaderVariableType(UB.name.c_str(), shaderDesc.DefaultVariableType, shaderDesc.VariableDesc, shaderDesc.NumVariables); - new (&GetUB(CurrUB++)) SPIRVShaderResourceAttribs(Compiler, UB, SPIRVShaderResourceAttribs::ResourceType::UniformBuffer, VarType, false); + new (&GetUB(CurrUB++)) + SPIRVShaderResourceAttribs(Compiler, + UB, + m_ResourceNames.CopyString(UB.name), + SPIRVShaderResourceAttribs::ResourceType::UniformBuffer, + GetShaderVariableType(UB.name, shaderDesc), + -1); } VERIFY_EXPR(CurrUB == GetNumUBs()); } @@ -122,8 +147,13 @@ SPIRVShaderResources::SPIRVShaderResources(IMemoryAllocator& Allocator, Uint32 CurrSB = 0; for (const auto &SB : resources.storage_buffers) { - auto VarType = GetShaderVariableType(SB.name.c_str(), shaderDesc.DefaultVariableType, shaderDesc.VariableDesc, shaderDesc.NumVariables); - new (&GetSB(CurrSB++)) SPIRVShaderResourceAttribs(Compiler, SB, SPIRVShaderResourceAttribs::ResourceType::StorageBuffer, VarType, false); + new (&GetSB(CurrSB++)) + SPIRVShaderResourceAttribs(Compiler, + SB, + m_ResourceNames.CopyString(SB.name), + SPIRVShaderResourceAttribs::ResourceType::StorageBuffer, + GetShaderVariableType(SB.name, shaderDesc), + -1); } VERIFY_EXPR(CurrSB == GetNumSBs()); } @@ -132,13 +162,18 @@ SPIRVShaderResources::SPIRVShaderResources(IMemoryAllocator& Allocator, Uint32 CurrSmplImg = 0; for (const auto &SmplImg : resources.sampled_images) { - auto VarType = GetShaderVariableType(SmplImg.name.c_str(), shaderDesc.DefaultVariableType, shaderDesc.VariableDesc, shaderDesc.NumVariables); - auto StaticSamplerInd = FindStaticSampler(shaderDesc, SmplImg.name.c_str()); + auto StaticSamplerInd = FindStaticSampler(shaderDesc, SmplImg.name); const auto& type = Compiler.get_type(SmplImg.type_id); auto ResType = type.image.dim == spv::DimBuffer ? SPIRVShaderResourceAttribs::ResourceType::UniformTexelBuffer : SPIRVShaderResourceAttribs::ResourceType::SampledImage; - new (&GetSmplImg(CurrSmplImg++)) SPIRVShaderResourceAttribs(Compiler, SmplImg, ResType, VarType, StaticSamplerInd); + new (&GetSmplImg(CurrSmplImg++)) + SPIRVShaderResourceAttribs(Compiler, + SmplImg, + m_ResourceNames.CopyString(SmplImg.name), + ResType, + GetShaderVariableType(SmplImg.name, shaderDesc), + StaticSamplerInd); } VERIFY_EXPR(CurrSmplImg == GetNumSmplImgs()); } @@ -147,12 +182,17 @@ SPIRVShaderResources::SPIRVShaderResources(IMemoryAllocator& Allocator, Uint32 CurrImg = 0; for (const auto &Img : resources.storage_images) { - auto VarType = GetShaderVariableType(Img.name.c_str(), shaderDesc.DefaultVariableType, shaderDesc.VariableDesc, shaderDesc.NumVariables); const auto& type = Compiler.get_type(Img.type_id); auto ResType = type.image.dim == spv::DimBuffer ? SPIRVShaderResourceAttribs::ResourceType::StorageTexelBuffer : SPIRVShaderResourceAttribs::ResourceType::StorageImage; - new (&GetImg(CurrImg++)) SPIRVShaderResourceAttribs(Compiler, Img, ResType, VarType, false); + new (&GetImg(CurrImg++)) + SPIRVShaderResourceAttribs(Compiler, + Img, + m_ResourceNames.CopyString(Img.name), + ResType, + GetShaderVariableType(Img.name, shaderDesc), + -1); } VERIFY_EXPR(CurrImg == GetNumImgs()); } @@ -161,8 +201,13 @@ SPIRVShaderResources::SPIRVShaderResources(IMemoryAllocator& Allocator, Uint32 CurrAC = 0; for (const auto &AC : resources.atomic_counters) { - auto VarType = GetShaderVariableType(AC.name.c_str(), shaderDesc.DefaultVariableType, shaderDesc.VariableDesc, shaderDesc.NumVariables); - new (&GetAC(CurrAC++)) SPIRVShaderResourceAttribs(Compiler, AC, SPIRVShaderResourceAttribs::ResourceType::AtomicCounter, VarType, false); + new (&GetAC(CurrAC++)) + SPIRVShaderResourceAttribs(Compiler, + AC, + m_ResourceNames.CopyString(AC.name), + SPIRVShaderResourceAttribs::ResourceType::AtomicCounter, + GetShaderVariableType(AC.name, shaderDesc), + -1); } VERIFY_EXPR(CurrAC == GetNumACs()); } @@ -171,8 +216,13 @@ SPIRVShaderResources::SPIRVShaderResources(IMemoryAllocator& Allocator, Uint32 CurrSepImg = 0; for (const auto &SepImg : resources.separate_images) { - auto VarType = GetShaderVariableType(SepImg.name.c_str(), shaderDesc.DefaultVariableType, shaderDesc.VariableDesc, shaderDesc.NumVariables); - new (&GetSepImg(CurrSepImg++)) SPIRVShaderResourceAttribs(Compiler, SepImg, SPIRVShaderResourceAttribs::ResourceType::SeparateImage, VarType, false); + new (&GetSepImg(CurrSepImg++)) + SPIRVShaderResourceAttribs(Compiler, + SepImg, + m_ResourceNames.CopyString(SepImg.name), + SPIRVShaderResourceAttribs::ResourceType::SeparateImage, + GetShaderVariableType(SepImg.name, shaderDesc), + -1); } VERIFY_EXPR(CurrSepImg == GetNumSepImgs()); } @@ -181,21 +231,29 @@ SPIRVShaderResources::SPIRVShaderResources(IMemoryAllocator& Allocator, Uint32 CurrSepSmpl = 0; for (const auto &SepSam : resources.separate_samplers) { - auto VarType = GetShaderVariableType(SepSam.name.c_str(), shaderDesc.DefaultVariableType, shaderDesc.VariableDesc, shaderDesc.NumVariables); - auto StaticSamplerInd = FindStaticSampler(shaderDesc, SepSam.name.c_str()); - new (&GetSepSmpl(CurrSepSmpl++)) SPIRVShaderResourceAttribs(Compiler, SepSam, SPIRVShaderResourceAttribs::ResourceType::SeparateSampler, VarType, StaticSamplerInd); + auto StaticSamplerInd = FindStaticSampler(shaderDesc, SepSam.name); + new (&GetSepSmpl(CurrSepSmpl++)) + SPIRVShaderResourceAttribs(Compiler, + SepSam, + m_ResourceNames.CopyString(SepSam.name), + SPIRVShaderResourceAttribs::ResourceType::SeparateSampler, + GetShaderVariableType(SepSam.name, shaderDesc), + StaticSamplerInd); } VERIFY_EXPR(CurrSepSmpl == GetNumSepSmpls()); } + VERIFY(m_ResourceNames.GetRemainingSize() == 0, "Names pool must be empty"); for (Uint32 s = 0; s < m_NumStaticSamplers; ++s) { - RefCntAutoPtr &pStaticSampler = GetStaticSampler(s); - new (std::addressof(pStaticSampler)) RefCntAutoPtr(); + SamplerPtrType &pStaticSampler = GetStaticSampler(s); + new (std::addressof(pStaticSampler)) SamplerPtrType(); pRenderDevice->CreateSampler(shaderDesc.StaticSamplers[s].Desc, &pStaticSampler); } + //LOG_INFO_MESSAGE(DumpResources()); + #ifdef _DEBUG if (shaderDesc.NumVariables != 0) { @@ -208,7 +266,7 @@ SPIRVShaderResources::SPIRVShaderResources(IMemoryAllocator& Allocator, for (Uint32 res = 0; res < GetTotalResources(); ++res) { const auto &ResAttribs = GetResource(res); - if (ResAttribs.Name.compare(VarName) == 0) + if (strcmp(ResAttribs.Name, VarName) == 0) { VariableFound = true; break; @@ -230,7 +288,7 @@ SPIRVShaderResources::SPIRVShaderResources(IMemoryAllocator& Allocator, for (Uint32 i = 0; i < GetNumSmplImgs(); ++i) { const auto &SmplImg = GetSmplImg(i); - if (SmplImg.Name.compare(SamName) == 0) + if (strcmp(SmplImg.Name, SamName) == 0) { SamplerFound = true; break; @@ -243,7 +301,7 @@ SPIRVShaderResources::SPIRVShaderResources(IMemoryAllocator& Allocator, for (Uint32 i = 0; i < GetNumSepSmpls(); ++i) { const auto &SepSmpl = GetSepSmpl(i); - if (SepSmpl.Name.compare(SamName) == 0) + if (strcmp(SepSmpl.Name, SamName) == 0) { SamplerFound = true; break; @@ -267,11 +325,12 @@ void SPIRVShaderResources::Initialize(IMemoryAllocator& Allocator, Uint32 NumACs, Uint32 NumSepImgs, Uint32 NumSepSmpls, - Uint32 NumStaticSamplers) + Uint32 NumStaticSamplers, + size_t ResourceNamesPoolSize) { VERIFY(&m_MemoryBuffer.get_deleter().m_Allocator == &Allocator, "Incosistent allocators provided"); - static constexpr Uint16 UniformBufferOffset = 0; + static constexpr OffsetType UniformBufferOffset = 0; const auto MaxOffset = static_cast(std::numeric_limits::max()); VERIFY(UniformBufferOffset + NumUBs <= MaxOffset, "Max offset exceeded"); @@ -298,7 +357,11 @@ void SPIRVShaderResources::Initialize(IMemoryAllocator& Allocator, VERIFY(m_NumStaticSamplers <= MaxOffset, "Max offset exceeded"); m_NumStaticSamplers = static_cast(NumStaticSamplers); - auto MemorySize = m_TotalResources * sizeof(SPIRVShaderResourceAttribs) + m_NumStaticSamplers * sizeof(RefCntAutoPtr); + static_assert(sizeof(SPIRVShaderResourceAttribs) % sizeof(void*) == 0, "Size of SPIRVShaderResourceAttribs struct must be multiple of sizeof(void*)"); + static_assert(sizeof(SamplerPtrType) % sizeof(void*) == 0, "Size of SamplerPtrType must be multiple of sizeof(void*)"); + auto MemorySize = m_TotalResources * sizeof(SPIRVShaderResourceAttribs) + + m_NumStaticSamplers * sizeof(SamplerPtrType) + + ResourceNamesPoolSize * sizeof(char); VERIFY_EXPR(GetNumUBs() == NumUBs); VERIFY_EXPR(GetNumSBs() == NumSBs); @@ -312,6 +375,10 @@ void SPIRVShaderResources::Initialize(IMemoryAllocator& Allocator, { auto *pRawMem = Allocator.Allocate(MemorySize, "Memory for shader resources", __FILE__, __LINE__); m_MemoryBuffer.reset(pRawMem); + char* NamesPool = reinterpret_cast(m_MemoryBuffer.get()) + + m_TotalResources * sizeof(SPIRVShaderResourceAttribs) + + m_NumStaticSamplers * sizeof(SamplerPtrType); + m_ResourceNames.AssignMemory(NamesPool, ResourceNamesPoolSize); } } @@ -339,7 +406,7 @@ SPIRVShaderResources::~SPIRVShaderResources() GetSepSmpl(n).~SPIRVShaderResourceAttribs(); for (Uint32 n = 0; n < GetNumStaticSamplers(); ++n) - GetStaticSampler(n).~RefCntAutoPtr(); + GetStaticSampler(n).~SamplerPtrType(); } void SPIRVShaderResources::CountResources(const SHADER_VARIABLE_TYPE *AllowedVarTypes, @@ -402,4 +469,47 @@ void SPIRVShaderResources::CountResources(const SHADER_VARIABLE_TYPE *AllowedVar ); } +std::string SPIRVShaderResources::DumpResources() +{ + std::stringstream ss; + ss << "Resource counters:" << std::endl << "UBs: " << GetNumUBs() << "; SBs: " << GetNumSBs() << "; Imgs: " << GetNumImgs() + << "; Smpl Imgs: " << GetNumSmplImgs() << "; ACs: " << GetNumACs() << "; Sep Imgs: " << GetNumSepImgs() + << "; Sep Smpls: " << GetNumSepSmpls() << "; Static Samplers: " << GetNumStaticSamplers() << std::endl << "Resources:"; + + ProcessResources(nullptr, 0, + [&](const SPIRVShaderResourceAttribs& Res, Uint32) + { + ss << std::endl; + switch(Res.Type) + { + case SPIRVShaderResourceAttribs::ResourceType::UniformBuffer: ss << "Uniform Buffer "; break; + case SPIRVShaderResourceAttribs::ResourceType::StorageBuffer: ss << "Storage Buffer "; break; + case SPIRVShaderResourceAttribs::ResourceType::UniformTexelBuffer: ss << "Uniform Txl Buff"; break; + case SPIRVShaderResourceAttribs::ResourceType::StorageTexelBuffer: ss << "Storage Txl Buff"; break; + case SPIRVShaderResourceAttribs::ResourceType::StorageImage: ss << "Storage Image "; break; + case SPIRVShaderResourceAttribs::ResourceType::SampledImage: ss << "Sampled Image "; break; + case SPIRVShaderResourceAttribs::ResourceType::AtomicCounter: ss << "Atomic Cntr "; break; + case SPIRVShaderResourceAttribs::ResourceType::SeparateImage: ss << "Separate Img "; break; + case SPIRVShaderResourceAttribs::ResourceType::SeparateSampler: ss << "Separate Smpl "; break; + default: UNEXPECTED("Unknown resource type"); + } + + std::stringstream FullResNameSS; + FullResNameSS << '\'' << Res.Name; + if(Res.ArraySize > 1) + FullResNameSS << '[' << Res.ArraySize << ']'; + FullResNameSS << '\''; + ss << std::setw(32) << FullResNameSS.str(); + ss << " (" << GetShaderVariableTypeLiteralName(Res.VarType) << ")"; + + if(Res.StaticSamplerInd >= 0) + { + ss << " Static sampler: " << Int32{Res.StaticSamplerInd}; + } + } + ); + + return ss.str(); +} + } -- cgit v1.2.3