lee/renderdoc
1
0
Fork 0
mirror of https://github.com/baldurk/renderdoc.git synced 2026-09-04 12:55:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add fake expanded root signature into structured data. Closes #1621

Browse Source
This commit is contained in:
baldurk
2019-11-29 13:53:45 +00:00
parent 18a85eed3d
commit af2c0d2012
11 changed files with 266 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files
renderdoc/driver/d3d12/d3d12_command_list_wrap.cpp
+2 -2
View File
@@ -1604,7 +1604,7 @@ void WrappedID3D12GraphicsCommandList::SetComputeRootDescriptorTable(
eFrameRef_Read);
std::vector<D3D12_DESCRIPTOR_RANGE1> &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<D3D12_DESCRIPTOR_RANGE1> &ranges =
GetWrapped(m_CurGfxRootSig)->sig.params[RootParameterIndex].ranges;
GetWrapped(m_CurGfxRootSig)->sig.Parameters[RootParameterIndex].ranges;
D3D12Descriptor *base = GetWrapped(BaseDescriptor);
UINT HeapNumDescriptors = base->GetHeap()->GetNumDescriptors();
renderdoc/driver/d3d12/d3d12_commands.cpp
+2 -2
View File
@@ -1573,12 +1573,12 @@ void D3D12CommandData::AddUsage(const D3D12RenderState &state, D3D12DrawcallTree
WrappedID3D12RootSignature *sig =
m_pDevice->GetResourceManager()->GetCurrentAs<WrappedID3D12RootSignature>(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;
renderdoc/driver/d3d12/d3d12_common.h
+18 -2
View File
@@ -319,16 +319,20 @@ struct D3D12RootSignatureParameter : D3D12_ROOT_PARAMETER1
std::vector<D3D12_DESCRIPTOR_RANGE1> 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<D3D12RootSignatureParameter> params;
std::vector<D3D12_STATIC_SAMPLER_DESC> samplers;
std::vector<D3D12RootSignatureParameter> Parameters;
std::vector<D3D12_STATIC_SAMPLER_DESC> 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);
renderdoc/driver/d3d12/d3d12_debug.cpp
+12 -12
View File
@@ -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;
}
}
}
renderdoc/driver/d3d12/d3d12_device_wrap.cpp
+7
View File
@@ -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);
}
renderdoc/driver/d3d12/d3d12_overlay.cpp
+3 -3
View File
@@ -93,14 +93,14 @@ struct D3D12QuadOverdrawCallback : public D3D12DrawcallCallback
range.Flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE;
range.OffsetInDescriptorsFromTableStart = 0;
modsig.params.push_back(D3D12RootSignatureParameter());
D3D12RootSignatureParameter &param = modsig.params.back();
modsig.Parameters.push_back(D3D12RootSignatureParameter());
D3D12RootSignatureParameter &param = modsig.Parameters.back();
param.ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
param.ShaderVisibility = D3D12_SHADER_VISIBILITY_PIXEL;
param.DescriptorTable.NumDescriptorRanges = 1;
param.DescriptorTable.pDescriptorRanges = &range;
cache.sigElem = uint32_t(modsig.params.size() - 1);
cache.sigElem = uint32_t(modsig.Parameters.size() - 1);
ID3DBlob *root = m_pDevice->GetShaderCache()->MakeRootSig(modsig);
renderdoc/driver/d3d12/d3d12_replay.cpp
+7 -7
View File
@@ -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())
renderdoc/driver/d3d12/d3d12_serialise.cpp
+92
View File
@@ -104,6 +104,97 @@ void DoSerialiseViaResourceId(SerialiserType &ser, Interface *&el)
SERIALISE_D3D_INTERFACES();
template <class SerialiserType>
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 <class SerialiserType>
void DoSerialise(SerialiserType &ser, D3D12_ROOT_DESCRIPTOR_TABLE1 &el)
{
SERIALISE_MEMBER(NumDescriptorRanges);
SERIALISE_MEMBER_ARRAY(pDescriptorRanges, NumDescriptorRanges);
}
template <class SerialiserType>
void DoSerialise(SerialiserType &ser, D3D12_ROOT_CONSTANTS &el)
{
SERIALISE_MEMBER(ShaderRegister);
SERIALISE_MEMBER(RegisterSpace);
SERIALISE_MEMBER(Num32BitValues);
}
template <class SerialiserType>
void DoSerialise(SerialiserType &ser, D3D12_ROOT_DESCRIPTOR1 &el)
{
SERIALISE_MEMBER(ShaderRegister);
SERIALISE_MEMBER(RegisterSpace);
SERIALISE_MEMBER(Flags);
}
template <class SerialiserType>
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 <class SerialiserType>
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 <class SerialiserType>
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 <class SerialiserType>
@@ -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);
renderdoc/driver/d3d12/d3d12_shader_cache.cpp
+17 -16
View File
@@ -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<D3D12_ROOT_PARAMETER1>
ID3DBlob *D3D12ShaderCache::MakeRootSig(const D3D12RootSignature &rootsig)
{
std::vector<D3D12_ROOT_PARAMETER1> 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])
renderdoc/driver/d3d12/d3d12_shaderdebug.cpp
+2 -2
View File
@@ -157,10 +157,10 @@ void D3D12DebugManager::CreateShaderGlobalState(ShaderDebug::GlobalState &global
WrappedID3D12RootSignature *pD3D12RootSig =
rm->GetCurrentAs<WrappedID3D12RootSignature>(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 &param = pD3D12RootSig->sig.params[i];
const D3D12RootSignatureParameter &param = pD3D12RootSig->sig.Parameters[i];
const D3D12RenderState::SignatureElement &element = pRootSignature->sigelems[i];
if(IsShaderParameterVisible(dxbc->m_Type, param.ShaderVisibility))
{
renderdoc/driver/d3d12/d3d12_stringise.cpp
+104
View File
@@ -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();
}