From af2c0d2012ce1873766af547c6fc3a8020187735 Mon Sep 17 00:00:00 2001 From: baldurk Date: Thu, 28 Nov 2019 10:51:25 +0000 Subject: [PATCH] Add fake expanded root signature into structured data. Closes #1621 --- .../driver/d3d12/d3d12_command_list_wrap.cpp | 4 +- renderdoc/driver/d3d12/d3d12_commands.cpp | 4 +- renderdoc/driver/d3d12/d3d12_common.h | 20 +++- renderdoc/driver/d3d12/d3d12_debug.cpp | 24 ++-- renderdoc/driver/d3d12/d3d12_device_wrap.cpp | 7 ++ renderdoc/driver/d3d12/d3d12_overlay.cpp | 6 +- renderdoc/driver/d3d12/d3d12_replay.cpp | 14 +-- renderdoc/driver/d3d12/d3d12_serialise.cpp | 92 ++++++++++++++++ renderdoc/driver/d3d12/d3d12_shader_cache.cpp | 33 +++--- renderdoc/driver/d3d12/d3d12_shaderdebug.cpp | 4 +- renderdoc/driver/d3d12/d3d12_stringise.cpp | 104 ++++++++++++++++++ 11 files changed, 266 insertions(+), 46 deletions(-) diff --git a/renderdoc/driver/d3d12/d3d12_command_list_wrap.cpp b/renderdoc/driver/d3d12/d3d12_command_list_wrap.cpp index 569f977e7..48aacc4d3 100644 --- a/renderdoc/driver/d3d12/d3d12_command_list_wrap.cpp +++ b/renderdoc/driver/d3d12/d3d12_command_list_wrap.cpp @@ -1604,7 +1604,7 @@ void WrappedID3D12GraphicsCommandList::SetComputeRootDescriptorTable( eFrameRef_Read); std::vector &ranges = - GetWrapped(m_CurCompRootSig)->sig.params[RootParameterIndex].ranges; + GetWrapped(m_CurCompRootSig)->sig.Parameters[RootParameterIndex].ranges; D3D12Descriptor *base = GetWrapped(BaseDescriptor); UINT HeapNumDescriptors = base->GetHeap()->GetNumDescriptors(); @@ -2168,7 +2168,7 @@ void WrappedID3D12GraphicsCommandList::SetGraphicsRootDescriptorTable( eFrameRef_Read); std::vector &ranges = - GetWrapped(m_CurGfxRootSig)->sig.params[RootParameterIndex].ranges; + GetWrapped(m_CurGfxRootSig)->sig.Parameters[RootParameterIndex].ranges; D3D12Descriptor *base = GetWrapped(BaseDescriptor); UINT HeapNumDescriptors = base->GetHeap()->GetNumDescriptors(); diff --git a/renderdoc/driver/d3d12/d3d12_commands.cpp b/renderdoc/driver/d3d12/d3d12_commands.cpp index 808598231..f792cf418 100644 --- a/renderdoc/driver/d3d12/d3d12_commands.cpp +++ b/renderdoc/driver/d3d12/d3d12_commands.cpp @@ -1573,12 +1573,12 @@ void D3D12CommandData::AddUsage(const D3D12RenderState &state, D3D12DrawcallTree WrappedID3D12RootSignature *sig = m_pDevice->GetResourceManager()->GetCurrentAs(rootdata->rootsig); - for(size_t rootEl = 0; rootEl < sig->sig.params.size(); rootEl++) + for(size_t rootEl = 0; rootEl < sig->sig.Parameters.size(); rootEl++) { if(rootEl >= rootdata->sigelems.size()) break; - const D3D12RootSignatureParameter &p = sig->sig.params[rootEl]; + const D3D12RootSignatureParameter &p = sig->sig.Parameters[rootEl]; const D3D12RenderState::SignatureElement &el = rootdata->sigelems[rootEl]; ResourceUsage cb = ResourceUsage::CS_Constants; diff --git a/renderdoc/driver/d3d12/d3d12_common.h b/renderdoc/driver/d3d12/d3d12_common.h index af137edbf..340bb7ff9 100644 --- a/renderdoc/driver/d3d12/d3d12_common.h +++ b/renderdoc/driver/d3d12/d3d12_common.h @@ -319,16 +319,20 @@ struct D3D12RootSignatureParameter : D3D12_ROOT_PARAMETER1 std::vector ranges; }; +DECLARE_REFLECTION_STRUCT(D3D12RootSignatureParameter); + struct D3D12RootSignature { uint32_t maxSpaceIndex = 0; uint32_t dwordLength = 0; D3D12_ROOT_SIGNATURE_FLAGS Flags = D3D12_ROOT_SIGNATURE_FLAG_NONE; - std::vector params; - std::vector samplers; + std::vector Parameters; + std::vector StaticSamplers; }; +DECLARE_REFLECTION_STRUCT(D3D12RootSignature); + struct D3D12CommandSignature { bool graphics = true; @@ -622,6 +626,13 @@ DECLARE_REFLECTION_ENUM(D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE); DECLARE_REFLECTION_ENUM(D3D12_RENDER_PASS_ENDING_ACCESS_TYPE); DECLARE_REFLECTION_ENUM(D3D12_SHADING_RATE); DECLARE_REFLECTION_ENUM(D3D12_SHADING_RATE_COMBINER); +DECLARE_REFLECTION_ENUM(D3D12_ROOT_SIGNATURE_FLAGS); +DECLARE_REFLECTION_ENUM(D3D12_ROOT_PARAMETER_TYPE); +DECLARE_REFLECTION_ENUM(D3D12_ROOT_DESCRIPTOR_FLAGS); +DECLARE_REFLECTION_ENUM(D3D12_SHADER_VISIBILITY); +DECLARE_REFLECTION_ENUM(D3D12_STATIC_BORDER_COLOR); +DECLARE_REFLECTION_ENUM(D3D12_DESCRIPTOR_RANGE_TYPE); +DECLARE_REFLECTION_ENUM(D3D12_DESCRIPTOR_RANGE_FLAGS); DECLARE_REFLECTION_STRUCT(D3D12_RESOURCE_DESC); DECLARE_REFLECTION_STRUCT(D3D12_COMMAND_QUEUE_DESC); @@ -717,6 +728,11 @@ DECLARE_REFLECTION_STRUCT(D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS); DECLARE_REFLECTION_STRUCT(D3D12_RENDER_PASS_ENDING_ACCESS); DECLARE_REFLECTION_STRUCT(D3D12_RENDER_PASS_RENDER_TARGET_DESC); DECLARE_REFLECTION_STRUCT(D3D12_RENDER_PASS_DEPTH_STENCIL_DESC); +DECLARE_REFLECTION_STRUCT(D3D12_STATIC_SAMPLER_DESC); +DECLARE_REFLECTION_STRUCT(D3D12_DESCRIPTOR_RANGE1); +DECLARE_REFLECTION_STRUCT(D3D12_ROOT_DESCRIPTOR_TABLE1); +DECLARE_REFLECTION_STRUCT(D3D12_ROOT_CONSTANTS); +DECLARE_REFLECTION_STRUCT(D3D12_ROOT_DESCRIPTOR1); DECLARE_DESERIALISE_TYPE(D3D12_DISCARD_REGION); DECLARE_DESERIALISE_TYPE(D3D12_GRAPHICS_PIPELINE_STATE_DESC); diff --git a/renderdoc/driver/d3d12/d3d12_debug.cpp b/renderdoc/driver/d3d12/d3d12_debug.cpp index c0d9e68f1..d297d91b1 100644 --- a/renderdoc/driver/d3d12/d3d12_debug.cpp +++ b/renderdoc/driver/d3d12/d3d12_debug.cpp @@ -1642,44 +1642,44 @@ void MoveRootSignatureElementsToRegisterSpace(D3D12RootSignature &sig, uint32_t // because then then the root signature indices wouldn't match up as expected. Instead move them // into the specified register space so that another register space (commonly space0) can be used // for other purposes. - size_t numParams = sig.params.size(); + size_t numParams = sig.Parameters.size(); for(size_t i = 0; i < numParams; i++) { - if(sig.params[i].ShaderVisibility == visibility || - sig.params[i].ShaderVisibility == D3D12_SHADER_VISIBILITY_ALL) + if(sig.Parameters[i].ShaderVisibility == visibility || + sig.Parameters[i].ShaderVisibility == D3D12_SHADER_VISIBILITY_ALL) { - D3D12_ROOT_PARAMETER_TYPE rootType = sig.params[i].ParameterType; + D3D12_ROOT_PARAMETER_TYPE rootType = sig.Parameters[i].ParameterType; if(rootType == D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE) { - size_t numRanges = sig.params[i].ranges.size(); + size_t numRanges = sig.Parameters[i].ranges.size(); for(size_t r = 0; r < numRanges; r++) { - D3D12_DESCRIPTOR_RANGE_TYPE rangeType = sig.params[i].ranges[r].RangeType; + D3D12_DESCRIPTOR_RANGE_TYPE rangeType = sig.Parameters[i].ranges[r].RangeType; if(rangeType == D3D12_DESCRIPTOR_RANGE_TYPE_CBV && type == D3D12DescriptorType::CBV) { - sig.params[i].ranges[r].RegisterSpace = registerSpace; + sig.Parameters[i].ranges[r].RegisterSpace = registerSpace; } else if(rangeType == D3D12_DESCRIPTOR_RANGE_TYPE_SRV && type == D3D12DescriptorType::SRV) { - sig.params[i].ranges[r].RegisterSpace = registerSpace; + sig.Parameters[i].ranges[r].RegisterSpace = registerSpace; } else if(rangeType == D3D12_DESCRIPTOR_RANGE_TYPE_UAV && type == D3D12DescriptorType::UAV) { - sig.params[i].ranges[r].RegisterSpace = registerSpace; + sig.Parameters[i].ranges[r].RegisterSpace = registerSpace; } } } else if(rootType == D3D12_ROOT_PARAMETER_TYPE_CBV && type == D3D12DescriptorType::CBV) { - sig.params[i].Descriptor.RegisterSpace = registerSpace; + sig.Parameters[i].Descriptor.RegisterSpace = registerSpace; } else if(rootType == D3D12_ROOT_PARAMETER_TYPE_SRV && type == D3D12DescriptorType::SRV) { - sig.params[i].Descriptor.RegisterSpace = registerSpace; + sig.Parameters[i].Descriptor.RegisterSpace = registerSpace; } else if(rootType == D3D12_ROOT_PARAMETER_TYPE_UAV && type == D3D12DescriptorType::UAV) { - sig.params[i].Descriptor.RegisterSpace = registerSpace; + sig.Parameters[i].Descriptor.RegisterSpace = registerSpace; } } } diff --git a/renderdoc/driver/d3d12/d3d12_device_wrap.cpp b/renderdoc/driver/d3d12/d3d12_device_wrap.cpp index 8af9cefdb..bcd4d773e 100644 --- a/renderdoc/driver/d3d12/d3d12_device_wrap.cpp +++ b/renderdoc/driver/d3d12/d3d12_device_wrap.cpp @@ -914,6 +914,13 @@ bool WrappedID3D12Device::Serialise_CreateRootSignature(SerialiserType &ser, UIN wrapped->sig = GetShaderCache()->GetRootSig(pBlobWithRootSignature, (size_t)blobLengthInBytes); + { + StructuredSerialiser structuriser(ser.GetStructuredFile().chunks.back(), &GetChunkName); + structuriser.SetUserData(GetResourceManager()); + + structuriser.Serialise("UnpackedSignature"_lit, wrapped->sig); + } + GetResourceManager()->AddLiveResource(pRootSignature, ret); } diff --git a/renderdoc/driver/d3d12/d3d12_overlay.cpp b/renderdoc/driver/d3d12/d3d12_overlay.cpp index d554171d3..46e32b670 100644 --- a/renderdoc/driver/d3d12/d3d12_overlay.cpp +++ b/renderdoc/driver/d3d12/d3d12_overlay.cpp @@ -93,14 +93,14 @@ struct D3D12QuadOverdrawCallback : public D3D12DrawcallCallback range.Flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE; range.OffsetInDescriptorsFromTableStart = 0; - modsig.params.push_back(D3D12RootSignatureParameter()); - D3D12RootSignatureParameter ¶m = modsig.params.back(); + modsig.Parameters.push_back(D3D12RootSignatureParameter()); + D3D12RootSignatureParameter ¶m = modsig.Parameters.back(); param.ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE; param.ShaderVisibility = D3D12_SHADER_VISIBILITY_PIXEL; param.DescriptorTable.NumDescriptorRanges = 1; param.DescriptorTable.pDescriptorRanges = ⦥ - cache.sigElem = uint32_t(modsig.params.size() - 1); + cache.sigElem = uint32_t(modsig.Parameters.size() - 1); ID3DBlob *root = m_pDevice->GetShaderCache()->MakeRootSig(modsig); diff --git a/renderdoc/driver/d3d12/d3d12_replay.cpp b/renderdoc/driver/d3d12/d3d12_replay.cpp index 9a9f7428c..0d24df849 100644 --- a/renderdoc/driver/d3d12/d3d12_replay.cpp +++ b/renderdoc/driver/d3d12/d3d12_replay.cpp @@ -913,9 +913,9 @@ void D3D12Replay::FillRegisterSpaces(const D3D12RenderState::RootSignature &root dstSpaces.clear(); dstSpaces.reserve(8); - for(size_t rootEl = 0; rootEl < sig->sig.params.size(); rootEl++) + for(size_t rootEl = 0; rootEl < sig->sig.Parameters.size(); rootEl++) { - const D3D12RootSignatureParameter &p = sig->sig.params[rootEl]; + const D3D12RootSignatureParameter &p = sig->sig.Parameters[rootEl]; if(p.ShaderVisibility != D3D12_SHADER_VISIBILITY_ALL && p.ShaderVisibility != visibility) continue; @@ -1209,9 +1209,9 @@ void D3D12Replay::FillRegisterSpaces(const D3D12RenderState::RootSignature &root } } - for(size_t i = 0; i < sig->sig.samplers.size(); i++) + for(size_t i = 0; i < sig->sig.StaticSamplers.size(); i++) { - D3D12_STATIC_SAMPLER_DESC &sampDesc = sig->sig.samplers[i]; + D3D12_STATIC_SAMPLER_DESC &sampDesc = sig->sig.StaticSamplers[i]; if(sampDesc.ShaderVisibility != D3D12_SHADER_VISIBILITY_ALL && sampDesc.ShaderVisibility != visibility) @@ -2747,15 +2747,15 @@ void D3D12Replay::FillCBufferVariables(ResourceId pipeline, ResourceId shader, bytebuf rootData; - for(size_t i = 0; sig && i < sig->sig.params.size(); i++) + for(size_t i = 0; sig && i < sig->sig.Parameters.size(); i++) { - const D3D12RootSignatureParameter &p = sig->sig.params[i]; + const D3D12RootSignatureParameter &p = sig->sig.Parameters[i]; if(p.ParameterType == D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS && p.Constants.RegisterSpace == (UINT)bind.bindset && p.Constants.ShaderRegister == (UINT)bind.bind) { - size_t dstSize = sig->sig.params[i].Constants.Num32BitValues * sizeof(uint32_t); + size_t dstSize = sig->sig.Parameters[i].Constants.Num32BitValues * sizeof(uint32_t); rootData.resize(dstSize); if(i < sigElems->size()) diff --git a/renderdoc/driver/d3d12/d3d12_serialise.cpp b/renderdoc/driver/d3d12/d3d12_serialise.cpp index d399e4259..5b093735d 100644 --- a/renderdoc/driver/d3d12/d3d12_serialise.cpp +++ b/renderdoc/driver/d3d12/d3d12_serialise.cpp @@ -104,6 +104,97 @@ void DoSerialiseViaResourceId(SerialiserType &ser, Interface *&el) SERIALISE_D3D_INTERFACES(); +template +void DoSerialise(SerialiserType &ser, D3D12_DESCRIPTOR_RANGE1 &el) +{ + SERIALISE_MEMBER(RangeType); + SERIALISE_MEMBER(NumDescriptors); + SERIALISE_MEMBER(BaseShaderRegister); + SERIALISE_MEMBER(RegisterSpace); + SERIALISE_MEMBER(Flags); + SERIALISE_MEMBER(OffsetInDescriptorsFromTableStart); +} + +template +void DoSerialise(SerialiserType &ser, D3D12_ROOT_DESCRIPTOR_TABLE1 &el) +{ + SERIALISE_MEMBER(NumDescriptorRanges); + SERIALISE_MEMBER_ARRAY(pDescriptorRanges, NumDescriptorRanges); +} + +template +void DoSerialise(SerialiserType &ser, D3D12_ROOT_CONSTANTS &el) +{ + SERIALISE_MEMBER(ShaderRegister); + SERIALISE_MEMBER(RegisterSpace); + SERIALISE_MEMBER(Num32BitValues); +} + +template +void DoSerialise(SerialiserType &ser, D3D12_ROOT_DESCRIPTOR1 &el) +{ + SERIALISE_MEMBER(ShaderRegister); + SERIALISE_MEMBER(RegisterSpace); + SERIALISE_MEMBER(Flags); +} + +template +void DoSerialise(SerialiserType &ser, D3D12_STATIC_SAMPLER_DESC &el) +{ + SERIALISE_MEMBER(Filter); + SERIALISE_MEMBER(AddressU); + SERIALISE_MEMBER(AddressV); + SERIALISE_MEMBER(AddressW); + SERIALISE_MEMBER(MipLODBias); + SERIALISE_MEMBER(MaxAnisotropy); + SERIALISE_MEMBER(ComparisonFunc); + SERIALISE_MEMBER(BorderColor); + SERIALISE_MEMBER(MinLOD); + SERIALISE_MEMBER(MaxLOD); + SERIALISE_MEMBER(ShaderRegister); + SERIALISE_MEMBER(RegisterSpace); + SERIALISE_MEMBER(ShaderVisibility); +} + +template +void DoSerialise(SerialiserType &ser, D3D12RootSignatureParameter &el) +{ + RDCASSERTMSG( + "root signature parameter serialisation is only supported for structured serialisers", + ser.IsDummy()); + + SERIALISE_MEMBER(ParameterType); + switch(el.ParameterType) + { + case D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE: + { + SERIALISE_MEMBER(DescriptorTable); + break; + } + case D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS: + { + SERIALISE_MEMBER(Constants); + break; + } + case D3D12_ROOT_PARAMETER_TYPE_CBV: + case D3D12_ROOT_PARAMETER_TYPE_SRV: + case D3D12_ROOT_PARAMETER_TYPE_UAV: + { + SERIALISE_MEMBER(Descriptor); + break; + } + } + SERIALISE_MEMBER(ShaderVisibility); +} + +template +void DoSerialise(SerialiserType &ser, D3D12RootSignature &el) +{ + SERIALISE_MEMBER(Flags); + SERIALISE_MEMBER(Parameters); + SERIALISE_MEMBER(StaticSamplers); +} + // similarly we serialise handles, buffer locations, through Id + indices template @@ -1384,6 +1475,7 @@ void DoSerialise(SerialiserType &ser, D3D12_DISPATCH_ARGUMENTS &el) SERIALISE_MEMBER(ThreadGroupCountZ); } +INSTANTIATE_SERIALISE_TYPE(D3D12RootSignature); INSTANTIATE_SERIALISE_TYPE(PortableHandle); INSTANTIATE_SERIALISE_TYPE(D3D12_CPU_DESCRIPTOR_HANDLE); INSTANTIATE_SERIALISE_TYPE(D3D12_GPU_DESCRIPTOR_HANDLE); diff --git a/renderdoc/driver/d3d12/d3d12_shader_cache.cpp b/renderdoc/driver/d3d12/d3d12_shader_cache.cpp index c5082d55e..6740f7315 100644 --- a/renderdoc/driver/d3d12/d3d12_shader_cache.cpp +++ b/renderdoc/driver/d3d12/d3d12_shader_cache.cpp @@ -249,13 +249,13 @@ D3D12RootSignature D3D12ShaderCache::GetRootSig(const void *data, size_t dataSiz ret.Flags = desc->Flags; - ret.params.resize(desc->NumParameters); + ret.Parameters.resize(desc->NumParameters); ret.dwordLength = 0; - for(size_t i = 0; i < ret.params.size(); i++) + for(size_t i = 0; i < ret.Parameters.size(); i++) { - ret.params[i].MakeFrom(desc->pParameters[i], ret.maxSpaceIndex); + ret.Parameters[i].MakeFrom(desc->pParameters[i], ret.maxSpaceIndex); // Descriptor tables cost 1 DWORD each. // Root constants cost 1 DWORD each, since they are 32-bit values. @@ -270,10 +270,11 @@ D3D12RootSignature D3D12ShaderCache::GetRootSig(const void *data, size_t dataSiz if(desc->NumStaticSamplers > 0) { - ret.samplers.assign(desc->pStaticSamplers, desc->pStaticSamplers + desc->NumStaticSamplers); + ret.StaticSamplers.assign(desc->pStaticSamplers, + desc->pStaticSamplers + desc->NumStaticSamplers); - for(size_t i = 0; i < ret.samplers.size(); i++) - ret.maxSpaceIndex = RDCMAX(ret.maxSpaceIndex, ret.samplers[i].RegisterSpace + 1); + for(size_t i = 0; i < ret.StaticSamplers.size(); i++) + ret.maxSpaceIndex = RDCMAX(ret.maxSpaceIndex, ret.StaticSamplers[i].RegisterSpace + 1); } SAFE_RELEASE(deser); @@ -307,13 +308,13 @@ D3D12RootSignature D3D12ShaderCache::GetRootSig(const void *data, size_t dataSiz ret.Flags = desc->Flags; - ret.params.resize(desc->NumParameters); + ret.Parameters.resize(desc->NumParameters); ret.dwordLength = 0; - for(size_t i = 0; i < ret.params.size(); i++) + for(size_t i = 0; i < ret.Parameters.size(); i++) { - ret.params[i].MakeFrom(desc->pParameters[i], ret.maxSpaceIndex); + ret.Parameters[i].MakeFrom(desc->pParameters[i], ret.maxSpaceIndex); // Descriptor tables cost 1 DWORD each. // Root constants cost 1 DWORD each, since they are 32-bit values. @@ -328,10 +329,10 @@ D3D12RootSignature D3D12ShaderCache::GetRootSig(const void *data, size_t dataSiz if(desc->NumStaticSamplers > 0) { - ret.samplers.assign(desc->pStaticSamplers, desc->pStaticSamplers + desc->NumStaticSamplers); + ret.StaticSamplers.assign(desc->pStaticSamplers, desc->pStaticSamplers + desc->NumStaticSamplers); - for(size_t i = 0; i < ret.samplers.size(); i++) - ret.maxSpaceIndex = RDCMAX(ret.maxSpaceIndex, ret.samplers[i].RegisterSpace + 1); + for(size_t i = 0; i < ret.StaticSamplers.size(); i++) + ret.maxSpaceIndex = RDCMAX(ret.maxSpaceIndex, ret.StaticSamplers[i].RegisterSpace + 1); } SAFE_RELEASE(deser); @@ -480,12 +481,12 @@ ID3DBlob *D3D12ShaderCache::MakeRootSig(const std::vector ID3DBlob *D3D12ShaderCache::MakeRootSig(const D3D12RootSignature &rootsig) { std::vector params; - params.resize(rootsig.params.size()); + params.resize(rootsig.Parameters.size()); for(size_t i = 0; i < params.size(); i++) - params[i] = rootsig.params[i]; + params[i] = rootsig.Parameters[i]; - return MakeRootSig(params, rootsig.Flags, (UINT)rootsig.samplers.size(), - rootsig.samplers.empty() ? NULL : &rootsig.samplers[0]); + return MakeRootSig(params, rootsig.Flags, (UINT)rootsig.StaticSamplers.size(), + rootsig.StaticSamplers.empty() ? NULL : &rootsig.StaticSamplers[0]); } ID3DBlob *D3D12ShaderCache::MakeFixedColShader(float overlayConsts[4]) diff --git a/renderdoc/driver/d3d12/d3d12_shaderdebug.cpp b/renderdoc/driver/d3d12/d3d12_shaderdebug.cpp index 294cf4090..01ce6308c 100644 --- a/renderdoc/driver/d3d12/d3d12_shaderdebug.cpp +++ b/renderdoc/driver/d3d12/d3d12_shaderdebug.cpp @@ -157,10 +157,10 @@ void D3D12DebugManager::CreateShaderGlobalState(ShaderDebug::GlobalState &global WrappedID3D12RootSignature *pD3D12RootSig = rm->GetCurrentAs(pRootSignature->rootsig); - size_t numParams = RDCMIN(pD3D12RootSig->sig.params.size(), pRootSignature->sigelems.size()); + size_t numParams = RDCMIN(pD3D12RootSig->sig.Parameters.size(), pRootSignature->sigelems.size()); for(size_t i = 0; i < numParams; ++i) { - const D3D12RootSignatureParameter ¶m = pD3D12RootSig->sig.params[i]; + const D3D12RootSignatureParameter ¶m = pD3D12RootSig->sig.Parameters[i]; const D3D12RenderState::SignatureElement &element = pRootSignature->sigelems[i]; if(IsShaderParameterVisible(dxbc->m_Type, param.ShaderVisibility)) { diff --git a/renderdoc/driver/d3d12/d3d12_stringise.cpp b/renderdoc/driver/d3d12/d3d12_stringise.cpp index 43f02ba5d..942190124 100644 --- a/renderdoc/driver/d3d12/d3d12_stringise.cpp +++ b/renderdoc/driver/d3d12/d3d12_stringise.cpp @@ -843,6 +843,60 @@ rdcstr DoStringise(const D3D12_SHADING_RATE_COMBINER &el) END_ENUM_STRINGISE(); } +template <> +rdcstr DoStringise(const D3D12_ROOT_PARAMETER_TYPE &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_ROOT_PARAMETER_TYPE); + { + STRINGISE_ENUM(D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE) + STRINGISE_ENUM(D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS) + STRINGISE_ENUM(D3D12_ROOT_PARAMETER_TYPE_CBV) + STRINGISE_ENUM(D3D12_ROOT_PARAMETER_TYPE_SRV) + STRINGISE_ENUM(D3D12_ROOT_PARAMETER_TYPE_UAV) + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const D3D12_SHADER_VISIBILITY &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_SHADER_VISIBILITY); + { + STRINGISE_ENUM(D3D12_SHADER_VISIBILITY_ALL) + STRINGISE_ENUM(D3D12_SHADER_VISIBILITY_VERTEX) + STRINGISE_ENUM(D3D12_SHADER_VISIBILITY_HULL) + STRINGISE_ENUM(D3D12_SHADER_VISIBILITY_DOMAIN) + STRINGISE_ENUM(D3D12_SHADER_VISIBILITY_GEOMETRY) + STRINGISE_ENUM(D3D12_SHADER_VISIBILITY_PIXEL) + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const D3D12_STATIC_BORDER_COLOR &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_STATIC_BORDER_COLOR); + { + STRINGISE_ENUM(D3D12_STATIC_BORDER_COLOR_TRANSPARENT_BLACK) + STRINGISE_ENUM(D3D12_STATIC_BORDER_COLOR_OPAQUE_BLACK) + STRINGISE_ENUM(D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE) + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const D3D12_DESCRIPTOR_RANGE_TYPE &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_DESCRIPTOR_RANGE_TYPE); + { + STRINGISE_ENUM(D3D12_DESCRIPTOR_RANGE_TYPE_SRV) + STRINGISE_ENUM(D3D12_DESCRIPTOR_RANGE_TYPE_UAV) + STRINGISE_ENUM(D3D12_DESCRIPTOR_RANGE_TYPE_CBV) + STRINGISE_ENUM(D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER) + } + END_ENUM_STRINGISE(); +} + template <> rdcstr DoStringise(const D3D12_CLEAR_FLAGS &el) { @@ -1108,3 +1162,53 @@ rdcstr DoStringise(const D3D12_RENDER_PASS_FLAGS &el) } END_BITFIELD_STRINGISE(); } + +template <> +rdcstr DoStringise(const D3D12_ROOT_SIGNATURE_FLAGS &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D12_ROOT_SIGNATURE_FLAGS); + { + STRINGISE_BITFIELD_VALUE(D3D12_ROOT_SIGNATURE_FLAG_NONE); + + STRINGISE_BITFIELD_BIT(D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT); + STRINGISE_BITFIELD_BIT(D3D12_ROOT_SIGNATURE_FLAG_DENY_VERTEX_SHADER_ROOT_ACCESS); + STRINGISE_BITFIELD_BIT(D3D12_ROOT_SIGNATURE_FLAG_DENY_HULL_SHADER_ROOT_ACCESS); + STRINGISE_BITFIELD_BIT(D3D12_ROOT_SIGNATURE_FLAG_DENY_DOMAIN_SHADER_ROOT_ACCESS); + STRINGISE_BITFIELD_BIT(D3D12_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS); + STRINGISE_BITFIELD_BIT(D3D12_ROOT_SIGNATURE_FLAG_DENY_PIXEL_SHADER_ROOT_ACCESS); + STRINGISE_BITFIELD_BIT(D3D12_ROOT_SIGNATURE_FLAG_ALLOW_STREAM_OUTPUT); + STRINGISE_BITFIELD_BIT(D3D12_ROOT_SIGNATURE_FLAG_LOCAL_ROOT_SIGNATURE); + } + END_BITFIELD_STRINGISE(); +} + +template <> +rdcstr DoStringise(const D3D12_ROOT_DESCRIPTOR_FLAGS &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D12_ROOT_DESCRIPTOR_FLAGS); + { + STRINGISE_BITFIELD_VALUE(D3D12_ROOT_DESCRIPTOR_FLAG_NONE); + + STRINGISE_BITFIELD_BIT(D3D12_ROOT_DESCRIPTOR_FLAG_DATA_VOLATILE); + STRINGISE_BITFIELD_BIT(D3D12_ROOT_DESCRIPTOR_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE); + STRINGISE_BITFIELD_BIT(D3D12_ROOT_DESCRIPTOR_FLAG_DATA_STATIC); + } + END_BITFIELD_STRINGISE(); +} + +template <> +rdcstr DoStringise(const D3D12_DESCRIPTOR_RANGE_FLAGS &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D12_DESCRIPTOR_RANGE_FLAGS); + { + STRINGISE_BITFIELD_VALUE(D3D12_DESCRIPTOR_RANGE_FLAG_NONE); + + STRINGISE_BITFIELD_BIT(D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_VOLATILE); + STRINGISE_BITFIELD_BIT(D3D12_DESCRIPTOR_RANGE_FLAG_DATA_VOLATILE); + STRINGISE_BITFIELD_BIT(D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE); + STRINGISE_BITFIELD_BIT(D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC); + STRINGISE_BITFIELD_BIT( + D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS); + } + END_BITFIELD_STRINGISE(); +}