Skip to content

Commit af2c0d2

Browse files
baldurkbaldurk
committed
Add fake expanded root signature into structured data. Closes baldurk#1621 
1 parent 18a85ee commit af2c0d2

11 files changed

+266
-46
lines changed

‎renderdoc/driver/d3d12/d3d12_command_list_wrap.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1604,7 +1604,7 @@ void WrappedID3D12GraphicsCommandList::SetComputeRootDescriptorTable(
16041604
eFrameRef_Read);
16051605

16061606
std::vector<D3D12_DESCRIPTOR_RANGE1> &ranges =
1607-
GetWrapped(m_CurCompRootSig)->sig.params[RootParameterIndex].ranges;
1607+
GetWrapped(m_CurCompRootSig)->sig.Parameters[RootParameterIndex].ranges;
16081608

16091609
D3D12Descriptor *base = GetWrapped(BaseDescriptor);
16101610
UINT HeapNumDescriptors = base->GetHeap()->GetNumDescriptors();
@@ -2168,7 +2168,7 @@ void WrappedID3D12GraphicsCommandList::SetGraphicsRootDescriptorTable(
21682168
eFrameRef_Read);
21692169

21702170
std::vector<D3D12_DESCRIPTOR_RANGE1> &ranges =
2171-
GetWrapped(m_CurGfxRootSig)->sig.params[RootParameterIndex].ranges;
2171+
GetWrapped(m_CurGfxRootSig)->sig.Parameters[RootParameterIndex].ranges;
21722172

21732173
D3D12Descriptor *base = GetWrapped(BaseDescriptor);
21742174
UINT HeapNumDescriptors = base->GetHeap()->GetNumDescriptors();

‎renderdoc/driver/d3d12/d3d12_commands.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1573,12 +1573,12 @@ void D3D12CommandData::AddUsage(const D3D12RenderState &state, D3D12DrawcallTree
15731573
WrappedID3D12RootSignature *sig =
15741574
m_pDevice->GetResourceManager()->GetCurrentAs<WrappedID3D12RootSignature>(rootdata->rootsig);
15751575

1576-
for(size_t rootEl = 0; rootEl < sig->sig.params.size(); rootEl++)
1576+
for(size_t rootEl = 0; rootEl < sig->sig.Parameters.size(); rootEl++)
15771577
{
15781578
if(rootEl >= rootdata->sigelems.size())
15791579
break;
15801580

1581-
const D3D12RootSignatureParameter &p = sig->sig.params[rootEl];
1581+
const D3D12RootSignatureParameter &p = sig->sig.Parameters[rootEl];
15821582
const D3D12RenderState::SignatureElement &el = rootdata->sigelems[rootEl];
15831583

15841584
ResourceUsage cb = ResourceUsage::CS_Constants;

‎renderdoc/driver/d3d12/d3d12_common.h

Lines changed: 18 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -319,16 +319,20 @@ struct D3D12RootSignatureParameter : D3D12_ROOT_PARAMETER1
319319
std::vector<D3D12_DESCRIPTOR_RANGE1> ranges;
320320
};
321321

322+
DECLARE_REFLECTION_STRUCT(D3D12RootSignatureParameter);
323+
322324
struct D3D12RootSignature
323325
{
324326
uint32_t maxSpaceIndex = 0;
325327
uint32_t dwordLength = 0;
326328

327329
D3D12_ROOT_SIGNATURE_FLAGS Flags = D3D12_ROOT_SIGNATURE_FLAG_NONE;
328-
std::vector<D3D12RootSignatureParameter> params;
329-
std::vector<D3D12_STATIC_SAMPLER_DESC> samplers;
330+
std::vector<D3D12RootSignatureParameter> Parameters;
331+
std::vector<D3D12_STATIC_SAMPLER_DESC> StaticSamplers;
330332
};
331333

334+
DECLARE_REFLECTION_STRUCT(D3D12RootSignature);
335+
332336
struct D3D12CommandSignature
333337
{
334338
bool graphics = true;
@@ -622,6 +626,13 @@ DECLARE_REFLECTION_ENUM(D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE);
622626
DECLARE_REFLECTION_ENUM(D3D12_RENDER_PASS_ENDING_ACCESS_TYPE);
623627
DECLARE_REFLECTION_ENUM(D3D12_SHADING_RATE);
624628
DECLARE_REFLECTION_ENUM(D3D12_SHADING_RATE_COMBINER);
629+
DECLARE_REFLECTION_ENUM(D3D12_ROOT_SIGNATURE_FLAGS);
630+
DECLARE_REFLECTION_ENUM(D3D12_ROOT_PARAMETER_TYPE);
631+
DECLARE_REFLECTION_ENUM(D3D12_ROOT_DESCRIPTOR_FLAGS);
632+
DECLARE_REFLECTION_ENUM(D3D12_SHADER_VISIBILITY);
633+
DECLARE_REFLECTION_ENUM(D3D12_STATIC_BORDER_COLOR);
634+
DECLARE_REFLECTION_ENUM(D3D12_DESCRIPTOR_RANGE_TYPE);
635+
DECLARE_REFLECTION_ENUM(D3D12_DESCRIPTOR_RANGE_FLAGS);
625636

626637
DECLARE_REFLECTION_STRUCT(D3D12_RESOURCE_DESC);
627638
DECLARE_REFLECTION_STRUCT(D3D12_COMMAND_QUEUE_DESC);
@@ -717,6 +728,11 @@ DECLARE_REFLECTION_STRUCT(D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS);
717728
DECLARE_REFLECTION_STRUCT(D3D12_RENDER_PASS_ENDING_ACCESS);
718729
DECLARE_REFLECTION_STRUCT(D3D12_RENDER_PASS_RENDER_TARGET_DESC);
719730
DECLARE_REFLECTION_STRUCT(D3D12_RENDER_PASS_DEPTH_STENCIL_DESC);
731+
DECLARE_REFLECTION_STRUCT(D3D12_STATIC_SAMPLER_DESC);
732+
DECLARE_REFLECTION_STRUCT(D3D12_DESCRIPTOR_RANGE1);
733+
DECLARE_REFLECTION_STRUCT(D3D12_ROOT_DESCRIPTOR_TABLE1);
734+
DECLARE_REFLECTION_STRUCT(D3D12_ROOT_CONSTANTS);
735+
DECLARE_REFLECTION_STRUCT(D3D12_ROOT_DESCRIPTOR1);
720736

721737
DECLARE_DESERIALISE_TYPE(D3D12_DISCARD_REGION);
722738
DECLARE_DESERIALISE_TYPE(D3D12_GRAPHICS_PIPELINE_STATE_DESC);

‎renderdoc/driver/d3d12/d3d12_debug.cpp

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -1642,44 +1642,44 @@ void MoveRootSignatureElementsToRegisterSpace(D3D12RootSignature &sig, uint32_t
16421642
// because then then the root signature indices wouldn't match up as expected. Instead move them
16431643
// into the specified register space so that another register space (commonly space0) can be used
16441644
// for other purposes.
1645-
size_t numParams = sig.params.size();
1645+
size_t numParams = sig.Parameters.size();
16461646
for(size_t i = 0; i < numParams; i++)
16471647
{
1648-
if(sig.params[i].ShaderVisibility == visibility ||
1649-
sig.params[i].ShaderVisibility == D3D12_SHADER_VISIBILITY_ALL)
1648+
if(sig.Parameters[i].ShaderVisibility == visibility ||
1649+
sig.Parameters[i].ShaderVisibility == D3D12_SHADER_VISIBILITY_ALL)
16501650
{
1651-
D3D12_ROOT_PARAMETER_TYPE rootType = sig.params[i].ParameterType;
1651+
D3D12_ROOT_PARAMETER_TYPE rootType = sig.Parameters[i].ParameterType;
16521652
if(rootType == D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE)
16531653
{
1654-
size_t numRanges = sig.params[i].ranges.size();
1654+
size_t numRanges = sig.Parameters[i].ranges.size();
16551655
for(size_t r = 0; r < numRanges; r++)
16561656
{
1657-
D3D12_DESCRIPTOR_RANGE_TYPE rangeType = sig.params[i].ranges[r].RangeType;
1657+
D3D12_DESCRIPTOR_RANGE_TYPE rangeType = sig.Parameters[i].ranges[r].RangeType;
16581658
if(rangeType == D3D12_DESCRIPTOR_RANGE_TYPE_CBV && type == D3D12DescriptorType::CBV)
16591659
{
1660-
sig.params[i].ranges[r].RegisterSpace = registerSpace;
1660+
sig.Parameters[i].ranges[r].RegisterSpace = registerSpace;
16611661
}
16621662
else if(rangeType == D3D12_DESCRIPTOR_RANGE_TYPE_SRV && type == D3D12DescriptorType::SRV)
16631663
{
1664-
sig.params[i].ranges[r].RegisterSpace = registerSpace;
1664+
sig.Parameters[i].ranges[r].RegisterSpace = registerSpace;
16651665
}
16661666
else if(rangeType == D3D12_DESCRIPTOR_RANGE_TYPE_UAV && type == D3D12DescriptorType::UAV)
16671667
{
1668-
sig.params[i].ranges[r].RegisterSpace = registerSpace;
1668+
sig.Parameters[i].ranges[r].RegisterSpace = registerSpace;
16691669
}
16701670
}
16711671
}
16721672
else if(rootType == D3D12_ROOT_PARAMETER_TYPE_CBV && type == D3D12DescriptorType::CBV)
16731673
{
1674-
sig.params[i].Descriptor.RegisterSpace = registerSpace;
1674+
sig.Parameters[i].Descriptor.RegisterSpace = registerSpace;
16751675
}
16761676
else if(rootType == D3D12_ROOT_PARAMETER_TYPE_SRV && type == D3D12DescriptorType::SRV)
16771677
{
1678-
sig.params[i].Descriptor.RegisterSpace = registerSpace;
1678+
sig.Parameters[i].Descriptor.RegisterSpace = registerSpace;
16791679
}
16801680
else if(rootType == D3D12_ROOT_PARAMETER_TYPE_UAV && type == D3D12DescriptorType::UAV)
16811681
{
1682-
sig.params[i].Descriptor.RegisterSpace = registerSpace;
1682+
sig.Parameters[i].Descriptor.RegisterSpace = registerSpace;
16831683
}
16841684
}
16851685
}

‎renderdoc/driver/d3d12/d3d12_device_wrap.cpp

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -914,6 +914,13 @@ bool WrappedID3D12Device::Serialise_CreateRootSignature(SerialiserType &ser, UIN
914914
wrapped->sig =
915915
GetShaderCache()->GetRootSig(pBlobWithRootSignature, (size_t)blobLengthInBytes);
916916

917+
{
918+
StructuredSerialiser structuriser(ser.GetStructuredFile().chunks.back(), &GetChunkName);
919+
structuriser.SetUserData(GetResourceManager());
920+
921+
structuriser.Serialise("UnpackedSignature"_lit, wrapped->sig);
922+
}
923+
917924
GetResourceManager()->AddLiveResource(pRootSignature, ret);
918925
}
919926

‎renderdoc/driver/d3d12/d3d12_overlay.cpp

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -93,14 +93,14 @@ struct D3D12QuadOverdrawCallback : public D3D12DrawcallCallback
9393
range.Flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE;
9494
range.OffsetInDescriptorsFromTableStart = 0;
9595

96-
modsig.params.push_back(D3D12RootSignatureParameter());
97-
D3D12RootSignatureParameter &param = modsig.params.back();
96+
modsig.Parameters.push_back(D3D12RootSignatureParameter());
97+
D3D12RootSignatureParameter &param = modsig.Parameters.back();
9898
param.ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
9999
param.ShaderVisibility = D3D12_SHADER_VISIBILITY_PIXEL;
100100
param.DescriptorTable.NumDescriptorRanges = 1;
101101
param.DescriptorTable.pDescriptorRanges = &range;
102102

103-
cache.sigElem = uint32_t(modsig.params.size() - 1);
103+
cache.sigElem = uint32_t(modsig.Parameters.size() - 1);
104104

105105
ID3DBlob *root = m_pDevice->GetShaderCache()->MakeRootSig(modsig);
106106

‎renderdoc/driver/d3d12/d3d12_replay.cpp

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -913,9 +913,9 @@ void D3D12Replay::FillRegisterSpaces(const D3D12RenderState::RootSignature &root
913913
dstSpaces.clear();
914914
dstSpaces.reserve(8);
915915

916-
for(size_t rootEl = 0; rootEl < sig->sig.params.size(); rootEl++)
916+
for(size_t rootEl = 0; rootEl < sig->sig.Parameters.size(); rootEl++)
917917
{
918-
const D3D12RootSignatureParameter &p = sig->sig.params[rootEl];
918+
const D3D12RootSignatureParameter &p = sig->sig.Parameters[rootEl];
919919

920920
if(p.ShaderVisibility != D3D12_SHADER_VISIBILITY_ALL && p.ShaderVisibility != visibility)
921921
continue;
@@ -1209,9 +1209,9 @@ void D3D12Replay::FillRegisterSpaces(const D3D12RenderState::RootSignature &root
12091209
}
12101210
}
12111211

1212-
for(size_t i = 0; i < sig->sig.samplers.size(); i++)
1212+
for(size_t i = 0; i < sig->sig.StaticSamplers.size(); i++)
12131213
{
1214-
D3D12_STATIC_SAMPLER_DESC &sampDesc = sig->sig.samplers[i];
1214+
D3D12_STATIC_SAMPLER_DESC &sampDesc = sig->sig.StaticSamplers[i];
12151215

12161216
if(sampDesc.ShaderVisibility != D3D12_SHADER_VISIBILITY_ALL &&
12171217
sampDesc.ShaderVisibility != visibility)
@@ -2747,15 +2747,15 @@ void D3D12Replay::FillCBufferVariables(ResourceId pipeline, ResourceId shader,
27472747

27482748
bytebuf rootData;
27492749

2750-
for(size_t i = 0; sig && i < sig->sig.params.size(); i++)
2750+
for(size_t i = 0; sig && i < sig->sig.Parameters.size(); i++)
27512751
{
2752-
const D3D12RootSignatureParameter &p = sig->sig.params[i];
2752+
const D3D12RootSignatureParameter &p = sig->sig.Parameters[i];
27532753

27542754
if(p.ParameterType == D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS &&
27552755
p.Constants.RegisterSpace == (UINT)bind.bindset &&
27562756
p.Constants.ShaderRegister == (UINT)bind.bind)
27572757
{
2758-
size_t dstSize = sig->sig.params[i].Constants.Num32BitValues * sizeof(uint32_t);
2758+
size_t dstSize = sig->sig.Parameters[i].Constants.Num32BitValues * sizeof(uint32_t);
27592759
rootData.resize(dstSize);
27602760

27612761
if(i < sigElems->size())

‎renderdoc/driver/d3d12/d3d12_serialise.cpp

Lines changed: 92 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -104,6 +104,97 @@ void DoSerialiseViaResourceId(SerialiserType &ser, Interface *&el)
104104

105105
SERIALISE_D3D_INTERFACES();
106106

107+
template <class SerialiserType>
108+
void DoSerialise(SerialiserType &ser, D3D12_DESCRIPTOR_RANGE1 &el)
109+
{
110+
SERIALISE_MEMBER(RangeType);
111+
SERIALISE_MEMBER(NumDescriptors);
112+
SERIALISE_MEMBER(BaseShaderRegister);
113+
SERIALISE_MEMBER(RegisterSpace);
114+
SERIALISE_MEMBER(Flags);
115+
SERIALISE_MEMBER(OffsetInDescriptorsFromTableStart);
116+
}
117+
118+
template <class SerialiserType>
119+
void DoSerialise(SerialiserType &ser, D3D12_ROOT_DESCRIPTOR_TABLE1 &el)
120+
{
121+
SERIALISE_MEMBER(NumDescriptorRanges);
122+
SERIALISE_MEMBER_ARRAY(pDescriptorRanges, NumDescriptorRanges);
123+
}
124+
125+
template <class SerialiserType>
126+
void DoSerialise(SerialiserType &ser, D3D12_ROOT_CONSTANTS &el)
127+
{
128+
SERIALISE_MEMBER(ShaderRegister);
129+
SERIALISE_MEMBER(RegisterSpace);
130+
SERIALISE_MEMBER(Num32BitValues);
131+
}
132+
133+
template <class SerialiserType>
134+
void DoSerialise(SerialiserType &ser, D3D12_ROOT_DESCRIPTOR1 &el)
135+
{
136+
SERIALISE_MEMBER(ShaderRegister);
137+
SERIALISE_MEMBER(RegisterSpace);
138+
SERIALISE_MEMBER(Flags);
139+
}
140+
141+
template <class SerialiserType>
142+
void DoSerialise(SerialiserType &ser, D3D12_STATIC_SAMPLER_DESC &el)
143+
{
144+
SERIALISE_MEMBER(Filter);
145+
SERIALISE_MEMBER(AddressU);
146+
SERIALISE_MEMBER(AddressV);
147+
SERIALISE_MEMBER(AddressW);
148+
SERIALISE_MEMBER(MipLODBias);
149+
SERIALISE_MEMBER(MaxAnisotropy);
150+
SERIALISE_MEMBER(ComparisonFunc);
151+
SERIALISE_MEMBER(BorderColor);
152+
SERIALISE_MEMBER(MinLOD);
153+
SERIALISE_MEMBER(MaxLOD);
154+
SERIALISE_MEMBER(ShaderRegister);
155+
SERIALISE_MEMBER(RegisterSpace);
156+
SERIALISE_MEMBER(ShaderVisibility);
157+
}
158+
159+
template <class SerialiserType>
160+
void DoSerialise(SerialiserType &ser, D3D12RootSignatureParameter &el)
161+
{
162+
RDCASSERTMSG(
163+
"root signature parameter serialisation is only supported for structured serialisers",
164+
ser.IsDummy());
165+
166+
SERIALISE_MEMBER(ParameterType);
167+
switch(el.ParameterType)
168+
{
169+
case D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE:
170+
{
171+
SERIALISE_MEMBER(DescriptorTable);
172+
break;
173+
}
174+
case D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS:
175+
{
176+
SERIALISE_MEMBER(Constants);
177+
break;
178+
}
179+
case D3D12_ROOT_PARAMETER_TYPE_CBV:
180+
case D3D12_ROOT_PARAMETER_TYPE_SRV:
181+
case D3D12_ROOT_PARAMETER_TYPE_UAV:
182+
{
183+
SERIALISE_MEMBER(Descriptor);
184+
break;
185+
}
186+
}
187+
SERIALISE_MEMBER(ShaderVisibility);
188+
}
189+
190+
template <class SerialiserType>
191+
void DoSerialise(SerialiserType &ser, D3D12RootSignature &el)
192+
{
193+
SERIALISE_MEMBER(Flags);
194+
SERIALISE_MEMBER(Parameters);
195+
SERIALISE_MEMBER(StaticSamplers);
196+
}
197+
107198
// similarly we serialise handles, buffer locations, through Id + indices
108199

109200
template <class SerialiserType>
@@ -1384,6 +1475,7 @@ void DoSerialise(SerialiserType &ser, D3D12_DISPATCH_ARGUMENTS &el)
13841475
SERIALISE_MEMBER(ThreadGroupCountZ);
13851476
}
13861477

1478+
INSTANTIATE_SERIALISE_TYPE(D3D12RootSignature);
13871479
INSTANTIATE_SERIALISE_TYPE(PortableHandle);
13881480
INSTANTIATE_SERIALISE_TYPE(D3D12_CPU_DESCRIPTOR_HANDLE);
13891481
INSTANTIATE_SERIALISE_TYPE(D3D12_GPU_DESCRIPTOR_HANDLE);

‎renderdoc/driver/d3d12/d3d12_shader_cache.cpp

Lines changed: 17 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -249,13 +249,13 @@ D3D12RootSignature D3D12ShaderCache::GetRootSig(const void *data, size_t dataSiz
249249

250250
ret.Flags = desc->Flags;
251251

252-
ret.params.resize(desc->NumParameters);
252+
ret.Parameters.resize(desc->NumParameters);
253253

254254
ret.dwordLength = 0;
255255

256-
for(size_t i = 0; i < ret.params.size(); i++)
256+
for(size_t i = 0; i < ret.Parameters.size(); i++)
257257
{
258-
ret.params[i].MakeFrom(desc->pParameters[i], ret.maxSpaceIndex);
258+
ret.Parameters[i].MakeFrom(desc->pParameters[i], ret.maxSpaceIndex);
259259

260260
// Descriptor tables cost 1 DWORD each.
261261
// 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
270270

271271
if(desc->NumStaticSamplers > 0)
272272
{
273-
ret.samplers.assign(desc->pStaticSamplers, desc->pStaticSamplers + desc->NumStaticSamplers);
273+
ret.StaticSamplers.assign(desc->pStaticSamplers,
274+
desc->pStaticSamplers + desc->NumStaticSamplers);
274275

275-
for(size_t i = 0; i < ret.samplers.size(); i++)
276-
ret.maxSpaceIndex = RDCMAX(ret.maxSpaceIndex, ret.samplers[i].RegisterSpace + 1);
276+
for(size_t i = 0; i < ret.StaticSamplers.size(); i++)
277+
ret.maxSpaceIndex = RDCMAX(ret.maxSpaceIndex, ret.StaticSamplers[i].RegisterSpace + 1);
277278
}
278279

279280
SAFE_RELEASE(deser);
@@ -307,13 +308,13 @@ D3D12RootSignature D3D12ShaderCache::GetRootSig(const void *data, size_t dataSiz
307308

308309
ret.Flags = desc->Flags;
309310

310-
ret.params.resize(desc->NumParameters);
311+
ret.Parameters.resize(desc->NumParameters);
311312

312313
ret.dwordLength = 0;
313314

314-
for(size_t i = 0; i < ret.params.size(); i++)
315+
for(size_t i = 0; i < ret.Parameters.size(); i++)
315316
{
316-
ret.params[i].MakeFrom(desc->pParameters[i], ret.maxSpaceIndex);
317+
ret.Parameters[i].MakeFrom(desc->pParameters[i], ret.maxSpaceIndex);
317318

318319
// Descriptor tables cost 1 DWORD each.
319320
// 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
328329

329330
if(desc->NumStaticSamplers > 0)
330331
{
331-
ret.samplers.assign(desc->pStaticSamplers, desc->pStaticSamplers + desc->NumStaticSamplers);
332+
ret.StaticSamplers.assign(desc->pStaticSamplers, desc->pStaticSamplers + desc->NumStaticSamplers);
332333

333-
for(size_t i = 0; i < ret.samplers.size(); i++)
334-
ret.maxSpaceIndex = RDCMAX(ret.maxSpaceIndex, ret.samplers[i].RegisterSpace + 1);
334+
for(size_t i = 0; i < ret.StaticSamplers.size(); i++)
335+
ret.maxSpaceIndex = RDCMAX(ret.maxSpaceIndex, ret.StaticSamplers[i].RegisterSpace + 1);
335336
}
336337

337338
SAFE_RELEASE(deser);
@@ -480,12 +481,12 @@ ID3DBlob *D3D12ShaderCache::MakeRootSig(const std::vector<D3D12_ROOT_PARAMETER1>
480481
ID3DBlob *D3D12ShaderCache::MakeRootSig(const D3D12RootSignature &rootsig)
481482
{
482483
std::vector<D3D12_ROOT_PARAMETER1> params;
483-
params.resize(rootsig.params.size());
484+
params.resize(rootsig.Parameters.size());
484485
for(size_t i = 0; i < params.size(); i++)
485-
params[i] = rootsig.params[i];
486+
params[i] = rootsig.Parameters[i];
486487

487-
return MakeRootSig(params, rootsig.Flags, (UINT)rootsig.samplers.size(),
488-
rootsig.samplers.empty() ? NULL : &rootsig.samplers[0]);
488+
return MakeRootSig(params, rootsig.Flags, (UINT)rootsig.StaticSamplers.size(),
489+
rootsig.StaticSamplers.empty() ? NULL : &rootsig.StaticSamplers[0]);
489490
}
490491

491492
ID3DBlob *D3D12ShaderCache::MakeFixedColShader(float overlayConsts[4])

0 commit comments

Comments
 (0)