aboutsummaryrefslogtreecommitdiff
path: root/contrib/DirectX-Headers-1.618.2/include/directx/d3dx12_state_object.h
diff options
context:
space:
mode:
Diffstat (limited to 'contrib/DirectX-Headers-1.618.2/include/directx/d3dx12_state_object.h')
-rw-r--r--contrib/DirectX-Headers-1.618.2/include/directx/d3dx12_state_object.h2570
1 files changed, 2570 insertions, 0 deletions
diff --git a/contrib/DirectX-Headers-1.618.2/include/directx/d3dx12_state_object.h b/contrib/DirectX-Headers-1.618.2/include/directx/d3dx12_state_object.h
new file mode 100644
index 0000000..579ecc8
--- /dev/null
+++ b/contrib/DirectX-Headers-1.618.2/include/directx/d3dx12_state_object.h
@@ -0,0 +1,2570 @@
1//*********************************************************
2//
3// Copyright (c) Microsoft Corporation.
4// Licensed under the MIT License (MIT).
5//
6//*********************************************************
7
8#pragma once
9
10#ifndef __cplusplus
11#error D3DX12 requires C++
12#endif
13
14#include "d3dx12_default.h"
15#include "d3d12.h"
16#include "d3dx12_core.h"
17
18//================================================================================================
19// D3DX12 State Object Creation Helpers
20//
21// Helper classes for creating new style state objects out of an arbitrary set of subobjects.
22// Uses STL
23//
24// Start by instantiating CD3DX12_STATE_OBJECT_DESC (see its public methods).
25// One of its methods is CreateSubobject(), which has a comment showing a couple of options for
26// defining subobjects using the helper classes for each subobject (CD3DX12_DXIL_LIBRARY_SUBOBJECT
27// etc.). The subobject helpers each have methods specific to the subobject for configuring its
28// contents.
29//
30//================================================================================================
31#include <list>
32#include <forward_list>
33#include <vector>
34#include <memory>
35#include <string>
36#include <vector>
37#ifndef D3DX12_USE_ATL
38#include <wrl/client.h>
39#define D3DX12_COM_PTR Microsoft::WRL::ComPtr
40#define D3DX12_COM_PTR_GET(x) x.Get()
41#define D3DX12_COM_PTR_ADDRESSOF(x) x.GetAddressOf()
42#else
43#include <atlbase.h>
44#define D3DX12_COM_PTR ATL::CComPtr
45#define D3DX12_COM_PTR_GET(x) x.p
46#define D3DX12_COM_PTR_ADDRESSOF(x) &x.p
47#endif
48
49//------------------------------------------------------------------------------------------------
50class CD3DX12_STATE_OBJECT_DESC
51{
52public:
53 CD3DX12_STATE_OBJECT_DESC() noexcept
54 {
55 Init(D3D12_STATE_OBJECT_TYPE_COLLECTION);
56 }
57 CD3DX12_STATE_OBJECT_DESC(D3D12_STATE_OBJECT_TYPE Type) noexcept
58 {
59 Init(Type);
60 }
61 void SetStateObjectType(D3D12_STATE_OBJECT_TYPE Type) noexcept { m_Desc.Type = Type; }
62 CD3DX12_STATE_OBJECT_DESC(const CD3DX12_STATE_OBJECT_DESC& other) = delete;
63 CD3DX12_STATE_OBJECT_DESC& operator=(const CD3DX12_STATE_OBJECT_DESC& other) = delete;
64 CD3DX12_STATE_OBJECT_DESC(CD3DX12_STATE_OBJECT_DESC&& other) = default;
65 CD3DX12_STATE_OBJECT_DESC& operator=(CD3DX12_STATE_OBJECT_DESC&& other) = default;
66 operator const D3D12_STATE_OBJECT_DESC& ()
67 {
68#if defined(D3D12_SDK_VERSION) && (D3D12_SDK_VERSION >= 612)
69 m_RepointedSubobjectVectors.clear();
70 m_RepointedPrograms.clear();
71#endif
72 m_RepointedAssociations.clear();
73 m_SubobjectArray.clear();
74 m_SubobjectArray.reserve(m_Desc.NumSubobjects);
75 // Flatten subobjects into an array (each flattened subobject still has a
76 // member that's a pointer to its desc that's not flattened)
77 for (auto Iter = m_SubobjectList.begin();
78 Iter != m_SubobjectList.end(); Iter++)
79 {
80 m_SubobjectArray.push_back(*Iter);
81 // Store new location in array so we can redirect pointers contained in subobjects
82 Iter->pSubobjectArrayLocation = &m_SubobjectArray.back();
83 }
84 // For subobjects with pointer fields, create a new copy of those subobject definitions
85 // with fixed pointers
86 for (UINT i = 0; i < m_Desc.NumSubobjects; i++)
87 {
88 if (m_SubobjectArray[i].Type == D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION)
89 {
90 auto pOriginalSubobjectAssociation =
91 static_cast<const D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION*>(m_SubobjectArray[i].pDesc);
92 D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION Repointed = *pOriginalSubobjectAssociation;
93 auto pWrapper =
94 static_cast<const SUBOBJECT_WRAPPER*>(pOriginalSubobjectAssociation->pSubobjectToAssociate);
95 Repointed.pSubobjectToAssociate = pWrapper->pSubobjectArrayLocation;
96 m_RepointedAssociations.push_back(Repointed);
97 m_SubobjectArray[i].pDesc = &m_RepointedAssociations.back();
98 }
99#if defined(D3D12_SDK_VERSION) && (D3D12_SDK_VERSION >= 612)
100 else if (m_SubobjectArray[i].Type == D3D12_STATE_SUBOBJECT_TYPE_GENERIC_PROGRAM)
101 {
102 auto originalGenericProgramDesc =
103 static_cast<const D3D12_GENERIC_PROGRAM_DESC*>(m_SubobjectArray[i].pDesc);
104 D3D12_GENERIC_PROGRAM_DESC Repointed = *originalGenericProgramDesc;
105 if (originalGenericProgramDesc->NumSubobjects > 0)
106 {
107 m_RepointedSubobjectVectors.emplace_back(std::vector<const D3D12_STATE_SUBOBJECT*>());
108 std::vector<D3D12_STATE_SUBOBJECT const*>& repointedGenericProgramSubobjects = m_RepointedSubobjectVectors.back();
109 repointedGenericProgramSubobjects.resize(originalGenericProgramDesc->NumSubobjects);
110 for (UINT s = 0; s < originalGenericProgramDesc->NumSubobjects; s++)
111 {
112 auto pWrapper =
113 static_cast<const SUBOBJECT_WRAPPER*>(originalGenericProgramDesc->ppSubobjects[s]);
114 repointedGenericProgramSubobjects[s] = pWrapper->pSubobjectArrayLocation;
115 }
116 // Below: using ugly way to get pointer in case .data() is not defined
117 Repointed.ppSubobjects = &repointedGenericProgramSubobjects[0];
118 }
119 m_RepointedPrograms.push_back(Repointed);
120 m_SubobjectArray[i].pDesc = &m_RepointedPrograms.back();
121 }
122#endif
123 }
124 // Below: using ugly way to get pointer in case .data() is not defined
125 m_Desc.pSubobjects = m_Desc.NumSubobjects ? &m_SubobjectArray[0] : nullptr;
126 return m_Desc;
127 }
128 operator const D3D12_STATE_OBJECT_DESC* ()
129 {
130 // Cast calls the above final preparation work
131 return &static_cast<const D3D12_STATE_OBJECT_DESC&>(*this);
132 }
133
134 // CreateSubobject creates a sububject helper (e.g. CD3DX12_HIT_GROUP_SUBOBJECT)
135 // whose lifetime is owned by this class.
136 // e.g.
137 //
138 // CD3DX12_STATE_OBJECT_DESC Collection1(D3D12_STATE_OBJECT_TYPE_COLLECTION);
139 // auto Lib0 = Collection1.CreateSubobject<CD3DX12_DXIL_LIBRARY_SUBOBJECT>();
140 // Lib0->SetDXILLibrary(&pMyAppDxilLibs[0]);
141 // Lib0->DefineExport(L"rayGenShader0"); // in practice these export listings might be
142 // // data/engine driven
143 // etc.
144 //
145 // Alternatively, users can instantiate sububject helpers explicitly, such as via local
146 // variables instead, passing the state object desc that should point to it into the helper
147 // constructor (or call mySubobjectHelper.AddToStateObject(Collection1)).
148 // In this alternative scenario, the user must keep the subobject alive as long as the state
149 // object it is associated with is alive, else its pointer references will be stale.
150 // e.g.
151 //
152 // CD3DX12_STATE_OBJECT_DESC RaytracingState2(D3D12_STATE_OBJECT_TYPE_RAYTRACING_PIPELINE);
153 // CD3DX12_DXIL_LIBRARY_SUBOBJECT LibA(RaytracingState2);
154 // LibA.SetDXILLibrary(&pMyAppDxilLibs[4]); // not manually specifying exports
155 // // - meaning all exports in the libraries
156 // // are exported
157 // etc.
158
159 template<typename T>
160 T* CreateSubobject()
161 {
162 T* pSubobject = new T(*this);
163 m_OwnedSubobjectHelpers.emplace_back(pSubobject);
164 return pSubobject;
165 }
166
167 template<typename T, typename U>
168 T* CreateSubobject(U&& arg)
169 {
170 T* pSubobject = new T(std::forward<U>(arg), *this);
171 m_OwnedSubobjectHelpers.emplace_back(pSubobject);
172 return pSubobject;
173 }
174
175private:
176 D3D12_STATE_SUBOBJECT* TrackSubobject(D3D12_STATE_SUBOBJECT_TYPE Type, void* pDesc)
177 {
178 SUBOBJECT_WRAPPER Subobject;
179 Subobject.pSubobjectArrayLocation = nullptr;
180 Subobject.Type = Type;
181 Subobject.pDesc = pDesc;
182 m_SubobjectList.push_back(Subobject);
183 m_Desc.NumSubobjects++;
184 return &m_SubobjectList.back();
185 }
186 void Init(D3D12_STATE_OBJECT_TYPE Type) noexcept
187 {
188 SetStateObjectType(Type);
189 m_Desc.pSubobjects = nullptr;
190 m_Desc.NumSubobjects = 0;
191 m_SubobjectList.clear();
192 m_SubobjectArray.clear();
193 m_RepointedAssociations.clear();
194#if defined(D3D12_SDK_VERSION) && (D3D12_SDK_VERSION >= 612)
195 m_RepointedSubobjectVectors.clear();
196 m_RepointedPrograms.clear();
197#endif
198 }
199 typedef struct SUBOBJECT_WRAPPER : public D3D12_STATE_SUBOBJECT
200 {
201 D3D12_STATE_SUBOBJECT* pSubobjectArrayLocation; // new location when flattened into array
202 // for repointing pointers in subobjects
203 } SUBOBJECT_WRAPPER;
204 D3D12_STATE_OBJECT_DESC m_Desc;
205 std::list<SUBOBJECT_WRAPPER> m_SubobjectList; // Pointers to list nodes handed out so
206 // these can be edited live
207 std::vector<D3D12_STATE_SUBOBJECT> m_SubobjectArray; // Built at the end, copying list contents
208
209 std::list<D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION>
210 m_RepointedAssociations; // subobject type that contains pointers to other subobjects,
211 // repointed to flattened array
212
213#if defined(D3D12_SDK_VERSION) && (D3D12_SDK_VERSION >= 612)
214 std::list<std::vector<D3D12_STATE_SUBOBJECT const*>>
215 m_RepointedSubobjectVectors;
216 std::list<D3D12_GENERIC_PROGRAM_DESC>
217 m_RepointedPrograms;
218#endif
219
220 template<typename CStr, typename StdStr>
221 class StringContainer
222 {
223 public:
224 CStr LocalCopy(CStr string, bool bSingleString = false)
225 {
226 if (string)
227 {
228 if (bSingleString)
229 {
230 m_Strings.clear();
231 m_Strings.push_back(string);
232 }
233 else
234 {
235 m_Strings.push_back(string);
236 }
237 return m_Strings.back().c_str();
238 }
239 else
240 {
241 return nullptr;
242 }
243 }
244 void clear() noexcept { m_Strings.clear(); }
245 private:
246 std::list<StdStr> m_Strings;
247 };
248
249public:
250 class SUBOBJECT_HELPER_BASE
251 {
252 public:
253 SUBOBJECT_HELPER_BASE() noexcept { Init(); }
254 virtual ~SUBOBJECT_HELPER_BASE() = default;
255 virtual D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept = 0;
256 SUBOBJECT_HELPER_BASE(const SUBOBJECT_HELPER_BASE& other) = delete;
257 SUBOBJECT_HELPER_BASE& operator=(const SUBOBJECT_HELPER_BASE& other) = delete;
258 SUBOBJECT_HELPER_BASE(SUBOBJECT_HELPER_BASE&& other) = default;
259 SUBOBJECT_HELPER_BASE& operator=(SUBOBJECT_HELPER_BASE&& other) = default;
260 void AddToStateObject(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
261 {
262 m_pSubobject = ContainingStateObject.TrackSubobject(Type(), Data());
263 }
264 operator const D3D12_STATE_SUBOBJECT& () const noexcept { return *m_pSubobject; }
265 protected:
266 virtual void* Data() noexcept = 0;
267 void Init() noexcept { m_pSubobject = nullptr; }
268 D3D12_STATE_SUBOBJECT* m_pSubobject;
269 };
270
271private:
272 std::list<std::unique_ptr<SUBOBJECT_HELPER_BASE>> m_OwnedSubobjectHelpers;
273
274 friend class CD3DX12_DXIL_LIBRARY_SUBOBJECT;
275 friend class CD3DX12_EXISTING_COLLECTION_SUBOBJECT;
276 friend class CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT;
277 friend class CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
278 friend class CD3DX12_HIT_GROUP_SUBOBJECT;
279 friend class CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT;
280 friend class CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT;
281 friend class CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT;
282 friend class CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT;
283 friend class CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT;
284 friend class CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT;
285 friend class CD3DX12_NODE_MASK_SUBOBJECT;
286 //TODO: SDK Version check should include all the newly added subobject type for the public release.
287 // The SDK version check will be changed based on when we release state objects.
288#if defined(D3D12_SDK_VERSION) && (D3D12_SDK_VERSION >= 612)
289 friend class CD3DX12_GENERIC_PROGRAM_SUBOBJECT;
290 friend class CD3DX12_WORK_GRAPH_SUBOBJECT;
291 friend class CD3DX12_STREAM_OUTPUT_SUBOBJECT;
292 friend class CD3DX12_BLEND_SUBOBJECT;
293 friend class CD3DX12_RASTERIZER_SUBOBJECT;
294 friend class CD3DX12_DEPTH_STENCIL2_SUBOBJECT;
295 friend class CD3DX12_INPUT_LAYOUT_SUBOBJECT;
296 friend class CD3DX12_IB_STRIP_CUT_VALUE_SUBOBJECT;
297 friend class CD3DX12_PRIMITIVE_TOPOLOGY_SUBOBJECT;
298 friend class CD3DX12_RENDER_TARGET_FORMATS_SUBOBJECT;
299 friend class CD3DX12_DEPTH_STENCIL_FORMAT_SUBOBJECT;
300 friend class CD3DX12_SAMPLE_DESC_SUBOBJECT;
301 friend class CD3DX12_FLAGS_SUBOBJECT;
302 friend class CD3DX12_VIEW_INSTANCING_SUBOBJECT;
303 friend class CD3DX12_DEPTH_STENCIL_SUBOBJECT;
304 friend class CD3DX12_DEPTH_STENCIL1_SUBOBJECT;
305 friend class CD3DX12_SAMPLE_MASK_SUBOBJECT;
306 friend class CD3DX12_NODE_OUTPUT_OVERRIDES;
307 friend class CD3DX12_NODE_HELPER_BASE;
308 friend class CD3DX12_SHADER_NODE;
309 friend class CD3DX12_BROADCASTING_LAUNCH_NODE_OVERRIDES;
310 friend class CD3DX12_COALESCING_LAUNCH_NODE_OVERRIDES;
311 friend class CD3DX12_THREAD_LAUNCH_NODE_OVERRIDES;
312 friend class CD3DX12_COMMON_COMPUTE_NODE_OVERRIDES;
313#endif // D3D12_SDK_VERSION >= 612
314#if defined(D3D12_SDK_VERSION) && (D3D12_SDK_VERSION >= 618)
315 friend class CD3DX12_GLOBAL_SERIALIZED_ROOT_SIGNATURE_SUBOBJECT;
316 friend class CD3DX12_LOCAL_SERIALIZED_ROOT_SIGNATURE_SUBOBJECT;
317 friend class CD3DX12_COMPILER_EXISTING_COLLECTION_SUBOBJECT;
318 friend class CD3DX12_EXISTING_COLLECTION_BY_KEY_SUBOBJECT;
319#endif
320};
321
322//------------------------------------------------------------------------------------------------
323class CD3DX12_DXIL_LIBRARY_SUBOBJECT
324 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
325{
326public:
327 CD3DX12_DXIL_LIBRARY_SUBOBJECT() noexcept
328 {
329 Init();
330 }
331 CD3DX12_DXIL_LIBRARY_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
332 {
333 Init();
334 AddToStateObject(ContainingStateObject);
335 }
336 CD3DX12_DXIL_LIBRARY_SUBOBJECT(const CD3DX12_DXIL_LIBRARY_SUBOBJECT& other) = delete;
337 CD3DX12_DXIL_LIBRARY_SUBOBJECT& operator=(const CD3DX12_DXIL_LIBRARY_SUBOBJECT& other) = delete;
338 CD3DX12_DXIL_LIBRARY_SUBOBJECT(CD3DX12_DXIL_LIBRARY_SUBOBJECT&& other) = default;
339 CD3DX12_DXIL_LIBRARY_SUBOBJECT& operator=(CD3DX12_DXIL_LIBRARY_SUBOBJECT&& other) = default;
340 void SetDXILLibrary(const D3D12_SHADER_BYTECODE* pCode) noexcept
341 {
342 static const D3D12_SHADER_BYTECODE Default = {};
343 m_Desc.DXILLibrary = pCode ? *pCode : Default;
344 }
345 void DefineExport(
346 LPCWSTR Name,
347 LPCWSTR ExportToRename = nullptr,
348 D3D12_EXPORT_FLAGS Flags = D3D12_EXPORT_FLAG_NONE)
349 {
350 D3D12_EXPORT_DESC Export;
351 Export.Name = m_Strings.LocalCopy(Name);
352 Export.ExportToRename = m_Strings.LocalCopy(ExportToRename);
353 Export.Flags = Flags;
354 m_Exports.push_back(Export);
355 m_Desc.pExports = &m_Exports[0]; // using ugly way to get pointer in case .data() is not defined
356 m_Desc.NumExports = static_cast<UINT>(m_Exports.size());
357 }
358 template<size_t N>
359 void DefineExports(LPCWSTR(&Exports)[N])
360 {
361 for (UINT i = 0; i < N; i++)
362 {
363 DefineExport(Exports[i]);
364 }
365 }
366 void DefineExports(const LPCWSTR* Exports, UINT N)
367 {
368 for (UINT i = 0; i < N; i++)
369 {
370 DefineExport(Exports[i]);
371 }
372 }
373 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
374 {
375 return D3D12_STATE_SUBOBJECT_TYPE_DXIL_LIBRARY;
376 }
377 operator const D3D12_DXIL_LIBRARY_DESC&() const noexcept { return m_Desc; }
378private:
379 void Init() noexcept
380 {
381 SUBOBJECT_HELPER_BASE::Init();
382 m_Desc = {};
383 m_Strings.clear();
384 m_Exports.clear();
385 }
386 void* Data() noexcept override { return &m_Desc; }
387 D3D12_DXIL_LIBRARY_DESC m_Desc;
388 CD3DX12_STATE_OBJECT_DESC::StringContainer<LPCWSTR, std::wstring> m_Strings;
389 std::vector<D3D12_EXPORT_DESC> m_Exports;
390};
391
392//------------------------------------------------------------------------------------------------
393class CD3DX12_EXISTING_COLLECTION_SUBOBJECT
394 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
395{
396public:
397 CD3DX12_EXISTING_COLLECTION_SUBOBJECT() noexcept
398 {
399 Init();
400 }
401 CD3DX12_EXISTING_COLLECTION_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
402 {
403 Init();
404 AddToStateObject(ContainingStateObject);
405 }
406 CD3DX12_EXISTING_COLLECTION_SUBOBJECT(const CD3DX12_EXISTING_COLLECTION_SUBOBJECT& other) = delete;
407 CD3DX12_EXISTING_COLLECTION_SUBOBJECT& operator=(const CD3DX12_EXISTING_COLLECTION_SUBOBJECT& other) = delete;
408 CD3DX12_EXISTING_COLLECTION_SUBOBJECT(CD3DX12_EXISTING_COLLECTION_SUBOBJECT&& other) = default;
409 CD3DX12_EXISTING_COLLECTION_SUBOBJECT& operator=(CD3DX12_EXISTING_COLLECTION_SUBOBJECT&& other) = default;
410 void SetExistingCollection(ID3D12StateObject*pExistingCollection) noexcept
411 {
412 m_Desc.pExistingCollection = pExistingCollection;
413 m_CollectionRef = pExistingCollection;
414 }
415 void DefineExport(
416 LPCWSTR Name,
417 LPCWSTR ExportToRename = nullptr,
418 D3D12_EXPORT_FLAGS Flags = D3D12_EXPORT_FLAG_NONE)
419 {
420 D3D12_EXPORT_DESC Export;
421 Export.Name = m_Strings.LocalCopy(Name);
422 Export.ExportToRename = m_Strings.LocalCopy(ExportToRename);
423 Export.Flags = Flags;
424 m_Exports.push_back(Export);
425 m_Desc.pExports = &m_Exports[0]; // using ugly way to get pointer in case .data() is not defined
426 m_Desc.NumExports = static_cast<UINT>(m_Exports.size());
427 }
428 template<size_t N>
429 void DefineExports(LPCWSTR(&Exports)[N])
430 {
431 for (UINT i = 0; i < N; i++)
432 {
433 DefineExport(Exports[i]);
434 }
435 }
436 void DefineExports(const LPCWSTR* Exports, UINT N)
437 {
438 for (UINT i = 0; i < N; i++)
439 {
440 DefineExport(Exports[i]);
441 }
442 }
443 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
444 {
445 return D3D12_STATE_SUBOBJECT_TYPE_EXISTING_COLLECTION;
446 }
447 operator const D3D12_EXISTING_COLLECTION_DESC&() const noexcept { return m_Desc; }
448private:
449 void Init() noexcept
450 {
451 SUBOBJECT_HELPER_BASE::Init();
452 m_Desc = {};
453 m_CollectionRef = nullptr;
454 m_Strings.clear();
455 m_Exports.clear();
456 }
457 void* Data() noexcept override { return &m_Desc; }
458 D3D12_EXISTING_COLLECTION_DESC m_Desc;
459 D3DX12_COM_PTR<ID3D12StateObject> m_CollectionRef;
460 CD3DX12_STATE_OBJECT_DESC::StringContainer<LPCWSTR, std::wstring> m_Strings;
461 std::vector<D3D12_EXPORT_DESC> m_Exports;
462};
463
464//------------------------------------------------------------------------------------------------
465class CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT
466 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
467{
468public:
469 CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT() noexcept
470 {
471 Init();
472 }
473 CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
474 {
475 Init();
476 AddToStateObject(ContainingStateObject);
477 }
478 CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT(const CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT& other) = delete;
479 CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT& operator=(const CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT& other) = delete;
480 CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT(CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT&& other) = default;
481 CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT& operator=(CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT&& other) = default;
482 void SetSubobjectToAssociate(const D3D12_STATE_SUBOBJECT& SubobjectToAssociate) noexcept
483 {
484 m_Desc.pSubobjectToAssociate = &SubobjectToAssociate;
485 }
486 void AddExport(LPCWSTR Export)
487 {
488 m_Desc.NumExports++;
489 m_Exports.push_back(m_Strings.LocalCopy(Export));
490 m_Desc.pExports = &m_Exports[0]; // using ugly way to get pointer in case .data() is not defined
491 }
492 template<size_t N>
493 void AddExports(LPCWSTR (&Exports)[N])
494 {
495 for (UINT i = 0; i < N; i++)
496 {
497 AddExport(Exports[i]);
498 }
499 }
500 void AddExports(const LPCWSTR* Exports, UINT N)
501 {
502 for (UINT i = 0; i < N; i++)
503 {
504 AddExport(Exports[i]);
505 }
506 }
507 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
508 {
509 return D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
510 }
511 operator const D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION&() const noexcept { return m_Desc; }
512private:
513 void Init() noexcept
514 {
515 SUBOBJECT_HELPER_BASE::Init();
516 m_Desc = {};
517 m_Strings.clear();
518 m_Exports.clear();
519 }
520 void* Data() noexcept override { return &m_Desc; }
521 D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION m_Desc;
522 CD3DX12_STATE_OBJECT_DESC::StringContainer<LPCWSTR, std::wstring> m_Strings;
523 std::vector<LPCWSTR> m_Exports;
524};
525
526//------------------------------------------------------------------------------------------------
527class CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION
528 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
529{
530public:
531 CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION() noexcept
532 {
533 Init();
534 }
535 CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
536 {
537 Init();
538 AddToStateObject(ContainingStateObject);
539 }
540 CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION(const CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION& other) = delete;
541 CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION& operator=(const CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION& other) = delete;
542 CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION(CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION&& other) = default;
543 CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION& operator=(CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION&& other) = default;
544 void SetSubobjectNameToAssociate(LPCWSTR SubobjectToAssociate)
545 {
546 m_Desc.SubobjectToAssociate = m_SubobjectName.LocalCopy(SubobjectToAssociate, true);
547 }
548 void AddExport(LPCWSTR Export)
549 {
550 m_Desc.NumExports++;
551 m_Exports.push_back(m_Strings.LocalCopy(Export));
552 m_Desc.pExports = &m_Exports[0]; // using ugly way to get pointer in case .data() is not defined
553 }
554 template<size_t N>
555 void AddExports(LPCWSTR (&Exports)[N])
556 {
557 for (UINT i = 0; i < N; i++)
558 {
559 AddExport(Exports[i]);
560 }
561 }
562 void AddExports(const LPCWSTR* Exports, UINT N)
563 {
564 for (UINT i = 0; i < N; i++)
565 {
566 AddExport(Exports[i]);
567 }
568 }
569 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
570 {
571 return D3D12_STATE_SUBOBJECT_TYPE_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
572 }
573 operator const D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION&() const noexcept { return m_Desc; }
574private:
575 void Init() noexcept
576 {
577 SUBOBJECT_HELPER_BASE::Init();
578 m_Desc = {};
579 m_Strings.clear();
580 m_SubobjectName.clear();
581 m_Exports.clear();
582 }
583 void* Data() noexcept override { return &m_Desc; }
584 D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION m_Desc;
585 CD3DX12_STATE_OBJECT_DESC::StringContainer<LPCWSTR, std::wstring> m_Strings;
586 CD3DX12_STATE_OBJECT_DESC::StringContainer<LPCWSTR, std::wstring> m_SubobjectName;
587 std::vector<LPCWSTR> m_Exports;
588};
589
590//------------------------------------------------------------------------------------------------
591class CD3DX12_HIT_GROUP_SUBOBJECT
592 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
593{
594public:
595 CD3DX12_HIT_GROUP_SUBOBJECT() noexcept
596 {
597 Init();
598 }
599 CD3DX12_HIT_GROUP_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
600 {
601 Init();
602 AddToStateObject(ContainingStateObject);
603 }
604 CD3DX12_HIT_GROUP_SUBOBJECT(const CD3DX12_HIT_GROUP_SUBOBJECT& other) = delete;
605 CD3DX12_HIT_GROUP_SUBOBJECT& operator=(const CD3DX12_HIT_GROUP_SUBOBJECT& other) = delete;
606 CD3DX12_HIT_GROUP_SUBOBJECT(CD3DX12_HIT_GROUP_SUBOBJECT&& other) = default;
607 CD3DX12_HIT_GROUP_SUBOBJECT& operator=(CD3DX12_HIT_GROUP_SUBOBJECT&& other) = default;
608 void SetHitGroupExport(LPCWSTR exportName)
609 {
610 m_Desc.HitGroupExport = m_Strings[0].LocalCopy(exportName, true);
611 }
612 void SetHitGroupType(D3D12_HIT_GROUP_TYPE Type) noexcept { m_Desc.Type = Type; }
613 void SetAnyHitShaderImport(LPCWSTR importName)
614 {
615 m_Desc.AnyHitShaderImport = m_Strings[1].LocalCopy(importName, true);
616 }
617 void SetClosestHitShaderImport(LPCWSTR importName)
618 {
619 m_Desc.ClosestHitShaderImport = m_Strings[2].LocalCopy(importName, true);
620 }
621 void SetIntersectionShaderImport(LPCWSTR importName)
622 {
623 m_Desc.IntersectionShaderImport = m_Strings[3].LocalCopy(importName, true);
624 }
625 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
626 {
627 return D3D12_STATE_SUBOBJECT_TYPE_HIT_GROUP;
628 }
629 operator const D3D12_HIT_GROUP_DESC&() const noexcept { return m_Desc; }
630private:
631 void Init() noexcept
632 {
633 SUBOBJECT_HELPER_BASE::Init();
634 m_Desc = {};
635 for (UINT i = 0; i < m_NumStrings; i++)
636 {
637 m_Strings[i].clear();
638 }
639 }
640 void* Data() noexcept override { return &m_Desc; }
641 D3D12_HIT_GROUP_DESC m_Desc;
642 static constexpr UINT m_NumStrings = 4;
643 CD3DX12_STATE_OBJECT_DESC::StringContainer<LPCWSTR, std::wstring>
644 m_Strings[m_NumStrings]; // one string for every entrypoint name
645};
646
647//------------------------------------------------------------------------------------------------
648class CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT
649 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
650{
651public:
652 CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT() noexcept
653 : m_Desc({})
654 {
655 Init();
656 }
657 CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
658 : m_Desc({})
659 {
660 Init();
661 AddToStateObject(ContainingStateObject);
662 }
663 CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT(const D3D12_RAYTRACING_SHADER_CONFIG &desc)
664 : m_Desc(desc)
665 {
666 Init();
667 }
668 CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT(const D3D12_RAYTRACING_SHADER_CONFIG &desc, CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
669 : m_Desc(desc)
670 {
671 Init();
672 AddToStateObject(ContainingStateObject);
673 }
674 CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT(const CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT& other) = delete;
675 CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT& operator=(const CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT& other) = delete;
676 CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT(CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT&& other) = default;
677 CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT& operator=(CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT&& other) = default;
678 void Config(UINT MaxPayloadSizeInBytes, UINT MaxAttributeSizeInBytes) noexcept
679 {
680 m_Desc.MaxPayloadSizeInBytes = MaxPayloadSizeInBytes;
681 m_Desc.MaxAttributeSizeInBytes = MaxAttributeSizeInBytes;
682 }
683 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
684 {
685 return D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_SHADER_CONFIG;
686 }
687 operator const D3D12_RAYTRACING_SHADER_CONFIG&() const noexcept { return m_Desc; }
688 operator D3D12_RAYTRACING_SHADER_CONFIG&() noexcept { return m_Desc; }
689private:
690 void Init() noexcept
691 {
692 SUBOBJECT_HELPER_BASE::Init();
693 }
694 void* Data() noexcept override { return &m_Desc; }
695 D3D12_RAYTRACING_SHADER_CONFIG m_Desc;
696};
697
698//------------------------------------------------------------------------------------------------
699class CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT
700 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
701{
702public:
703 CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT() noexcept
704 : m_Desc({})
705 {
706 Init();
707 }
708 CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
709 : m_Desc({})
710 {
711 Init();
712 AddToStateObject(ContainingStateObject);
713 }
714 CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT(const D3D12_RAYTRACING_PIPELINE_CONFIG &desc)
715 : m_Desc(desc)
716 {
717 Init();
718 }
719 CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT(const D3D12_RAYTRACING_PIPELINE_CONFIG &desc, CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
720 : m_Desc(desc)
721 {
722 Init();
723 AddToStateObject(ContainingStateObject);
724 }
725 CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT(const CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT& other) = delete;
726 CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT& operator=(const CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT& other) = delete;
727 CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT(CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT&& other) = default;
728 CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT& operator=(CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT&& other) = default;
729 void Config(UINT MaxTraceRecursionDepth) noexcept
730 {
731 m_Desc.MaxTraceRecursionDepth = MaxTraceRecursionDepth;
732 }
733 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
734 {
735 return D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG;
736 }
737 operator const D3D12_RAYTRACING_PIPELINE_CONFIG&() const noexcept { return m_Desc; }
738 operator D3D12_RAYTRACING_PIPELINE_CONFIG&() noexcept { return m_Desc; }
739private:
740 void Init() noexcept
741 {
742 SUBOBJECT_HELPER_BASE::Init();
743 }
744 void* Data() noexcept override { return &m_Desc; }
745 D3D12_RAYTRACING_PIPELINE_CONFIG m_Desc;
746};
747
748//------------------------------------------------------------------------------------------------
749class CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT
750 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
751{
752public:
753 CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT() noexcept
754 : m_Desc({})
755 {
756 Init();
757 }
758 CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
759 : m_Desc({})
760 {
761 Init();
762 AddToStateObject(ContainingStateObject);
763 }
764 CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT(const D3D12_RAYTRACING_PIPELINE_CONFIG1 &desc)
765 : m_Desc(desc)
766 {
767 Init();
768 }
769 CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT(const D3D12_RAYTRACING_PIPELINE_CONFIG1 &desc, CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
770 : m_Desc(desc)
771 {
772 Init();
773 AddToStateObject(ContainingStateObject);
774 }
775 CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT(const CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT& other) = delete;
776 CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT& operator=(const CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT& other) = delete;
777 CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT(CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT&& other) = default;
778 CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT& operator=(CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT&& other) = default;
779 void Config(UINT MaxTraceRecursionDepth, D3D12_RAYTRACING_PIPELINE_FLAGS Flags) noexcept
780 {
781 m_Desc.MaxTraceRecursionDepth = MaxTraceRecursionDepth;
782 m_Desc.Flags = Flags;
783 }
784 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
785 {
786 return D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG1;
787 }
788 operator const D3D12_RAYTRACING_PIPELINE_CONFIG1&() const noexcept { return m_Desc; }
789 operator D3D12_RAYTRACING_PIPELINE_CONFIG1&() noexcept { return m_Desc; }
790private:
791 void Init() noexcept
792 {
793 SUBOBJECT_HELPER_BASE::Init();
794 }
795 void* Data() noexcept override { return &m_Desc; }
796 D3D12_RAYTRACING_PIPELINE_CONFIG1 m_Desc;
797};
798
799//------------------------------------------------------------------------------------------------
800class CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT
801 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
802{
803public:
804 CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT() noexcept
805 {
806 Init();
807 }
808 CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
809 {
810 Init();
811 AddToStateObject(ContainingStateObject);
812 }
813 CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT(const CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT& other) = delete;
814 CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT& operator=(const CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT& other) = delete;
815 CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT(CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT&& other) = default;
816 CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT& operator=(CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT&& other) = default;
817 void SetRootSignature(ID3D12RootSignature* pRootSig) noexcept
818 {
819 m_pRootSig = pRootSig;
820 }
821 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
822 {
823 return D3D12_STATE_SUBOBJECT_TYPE_GLOBAL_ROOT_SIGNATURE;
824 }
825 operator ID3D12RootSignature*() const noexcept { return D3DX12_COM_PTR_GET(m_pRootSig); }
826private:
827 void Init() noexcept
828 {
829 SUBOBJECT_HELPER_BASE::Init();
830 m_pRootSig = nullptr;
831 }
832 void* Data() noexcept override { return D3DX12_COM_PTR_ADDRESSOF(m_pRootSig); }
833 D3DX12_COM_PTR<ID3D12RootSignature> m_pRootSig;
834};
835
836
837//------------------------------------------------------------------------------------------------
838class CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT
839 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
840{
841public:
842 CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT() noexcept
843 {
844 Init();
845 }
846 CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
847 {
848 Init();
849 AddToStateObject(ContainingStateObject);
850 }
851 CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT(const CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT& other) = delete;
852 CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT& operator=(const CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT& other) = delete;
853 CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT(CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT&& other) = default;
854 CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT& operator=(CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT&& other) = default;
855 void SetRootSignature(ID3D12RootSignature* pRootSig) noexcept
856 {
857 m_pRootSig = pRootSig;
858 }
859 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
860 {
861 return D3D12_STATE_SUBOBJECT_TYPE_LOCAL_ROOT_SIGNATURE;
862 }
863 operator ID3D12RootSignature*() const noexcept { return D3DX12_COM_PTR_GET(m_pRootSig); }
864private:
865 void Init() noexcept
866 {
867 SUBOBJECT_HELPER_BASE::Init();
868 m_pRootSig = nullptr;
869 }
870 void* Data() noexcept override { return D3DX12_COM_PTR_ADDRESSOF(m_pRootSig); }
871 D3DX12_COM_PTR<ID3D12RootSignature> m_pRootSig;
872};
873
874#if defined(D3D12_SDK_VERSION) && (D3D12_SDK_VERSION >= 618)
875//------------------------------------------------------------------------------------------------
876class CD3DX12_GLOBAL_SERIALIZED_ROOT_SIGNATURE_SUBOBJECT
877 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
878{
879public:
880 CD3DX12_GLOBAL_SERIALIZED_ROOT_SIGNATURE_SUBOBJECT() noexcept
881 : m_Desc({})
882 {
883 Init();
884 }
885 CD3DX12_GLOBAL_SERIALIZED_ROOT_SIGNATURE_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
886 : m_Desc({})
887 {
888 Init();
889 AddToStateObject(ContainingStateObject);
890 }
891 CD3DX12_GLOBAL_SERIALIZED_ROOT_SIGNATURE_SUBOBJECT(const CD3DX12_GLOBAL_SERIALIZED_ROOT_SIGNATURE_SUBOBJECT& other) = delete;
892 CD3DX12_GLOBAL_SERIALIZED_ROOT_SIGNATURE_SUBOBJECT& operator=(const CD3DX12_GLOBAL_SERIALIZED_ROOT_SIGNATURE_SUBOBJECT& other) = delete;
893 CD3DX12_GLOBAL_SERIALIZED_ROOT_SIGNATURE_SUBOBJECT(CD3DX12_GLOBAL_SERIALIZED_ROOT_SIGNATURE_SUBOBJECT&& other) = default;
894 CD3DX12_GLOBAL_SERIALIZED_ROOT_SIGNATURE_SUBOBJECT& operator=(CD3DX12_GLOBAL_SERIALIZED_ROOT_SIGNATURE_SUBOBJECT&& other) = default;
895 void SetRootSignature(const D3D12_SERIALIZED_ROOT_SIGNATURE_DESC* pDesc) noexcept
896 {
897 if (pDesc)
898 {
899 m_Desc.Desc = {};
900 m_Desc.Desc.pSerializedBlob = pDesc->pSerializedBlob;
901 m_Desc.Desc.SerializedBlobSizeInBytes = pDesc->SerializedBlobSizeInBytes;
902 }
903 }
904 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
905 {
906 return D3D12_STATE_SUBOBJECT_TYPE_GLOBAL_SERIALIZED_ROOT_SIGNATURE;
907 }
908 operator const D3D12_GLOBAL_SERIALIZED_ROOT_SIGNATURE&() const noexcept { return m_Desc; }
909 operator D3D12_GLOBAL_SERIALIZED_ROOT_SIGNATURE&() noexcept { return m_Desc; }
910private:
911 void Init() noexcept
912 {
913 SUBOBJECT_HELPER_BASE::Init();
914 m_Desc = {};
915 }
916 void* Data() noexcept override { return &m_Desc; }
917 D3D12_GLOBAL_SERIALIZED_ROOT_SIGNATURE m_Desc;
918};
919
920//------------------------------------------------------------------------------------------------
921class CD3DX12_LOCAL_SERIALIZED_ROOT_SIGNATURE_SUBOBJECT
922 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
923{
924public:
925 CD3DX12_LOCAL_SERIALIZED_ROOT_SIGNATURE_SUBOBJECT() noexcept
926 : m_Desc({})
927 {
928 Init();
929 }
930 CD3DX12_LOCAL_SERIALIZED_ROOT_SIGNATURE_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
931 : m_Desc({})
932 {
933 Init();
934 AddToStateObject(ContainingStateObject);
935 }
936 CD3DX12_LOCAL_SERIALIZED_ROOT_SIGNATURE_SUBOBJECT(const CD3DX12_LOCAL_SERIALIZED_ROOT_SIGNATURE_SUBOBJECT& other) = delete;
937 CD3DX12_LOCAL_SERIALIZED_ROOT_SIGNATURE_SUBOBJECT& operator=(const CD3DX12_LOCAL_SERIALIZED_ROOT_SIGNATURE_SUBOBJECT& other) = delete;
938 CD3DX12_LOCAL_SERIALIZED_ROOT_SIGNATURE_SUBOBJECT(CD3DX12_LOCAL_SERIALIZED_ROOT_SIGNATURE_SUBOBJECT&& other) = default;
939 CD3DX12_LOCAL_SERIALIZED_ROOT_SIGNATURE_SUBOBJECT& operator=(CD3DX12_LOCAL_SERIALIZED_ROOT_SIGNATURE_SUBOBJECT&& other) = default;
940 void SetRootSignature(const D3D12_SERIALIZED_ROOT_SIGNATURE_DESC* pDesc) noexcept
941 {
942 if (pDesc)
943 {
944 m_Desc.Desc = {};
945 m_Desc.Desc.pSerializedBlob = pDesc->pSerializedBlob;
946 m_Desc.Desc.SerializedBlobSizeInBytes = pDesc->SerializedBlobSizeInBytes;
947 }
948 }
949 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
950 {
951 return D3D12_STATE_SUBOBJECT_TYPE_LOCAL_SERIALIZED_ROOT_SIGNATURE;
952 }
953 operator const D3D12_LOCAL_SERIALIZED_ROOT_SIGNATURE&() const noexcept { return m_Desc; }
954 operator D3D12_LOCAL_SERIALIZED_ROOT_SIGNATURE&() noexcept { return m_Desc; }
955private:
956 void Init() noexcept
957 {
958 SUBOBJECT_HELPER_BASE::Init();
959 m_Desc = {};
960 }
961 void* Data() noexcept override { return &m_Desc; }
962 D3D12_LOCAL_SERIALIZED_ROOT_SIGNATURE m_Desc;
963};
964
965
966//------------------------------------------------------------------------------------------------
967class CD3DX12_EXISTING_COLLECTION_BY_KEY_SUBOBJECT
968 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
969{
970public:
971 CD3DX12_EXISTING_COLLECTION_BY_KEY_SUBOBJECT() noexcept
972 {
973 Init();
974 }
975 CD3DX12_EXISTING_COLLECTION_BY_KEY_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
976 {
977 Init();
978 AddToStateObject(ContainingStateObject);
979 }
980 CD3DX12_EXISTING_COLLECTION_BY_KEY_SUBOBJECT(const CD3DX12_EXISTING_COLLECTION_BY_KEY_SUBOBJECT& other) = delete;
981 CD3DX12_EXISTING_COLLECTION_BY_KEY_SUBOBJECT& operator=(const CD3DX12_EXISTING_COLLECTION_BY_KEY_SUBOBJECT& other) = delete;
982 CD3DX12_EXISTING_COLLECTION_BY_KEY_SUBOBJECT(CD3DX12_EXISTING_COLLECTION_BY_KEY_SUBOBJECT&& other) = default;
983 CD3DX12_EXISTING_COLLECTION_BY_KEY_SUBOBJECT& operator=(CD3DX12_EXISTING_COLLECTION_BY_KEY_SUBOBJECT&& other) = default;
984 void SetExistingCollection(const void* pKey, UINT KeySize) noexcept
985 {
986 const unsigned char* pKeyBytes = static_cast<const unsigned char *>(pKey);
987 m_Key.clear();
988 m_Key.insert(m_Key.begin(), pKeyBytes, pKeyBytes + KeySize);
989 m_Desc.pKey = m_Key.data();
990 m_Desc.KeySize = KeySize;
991 }
992 void DefineExport(
993 LPCWSTR Name,
994 LPCWSTR ExportToRename = nullptr,
995 D3D12_EXPORT_FLAGS Flags = D3D12_EXPORT_FLAG_NONE)
996 {
997 D3D12_EXPORT_DESC Export;
998 Export.Name = m_Strings.LocalCopy(Name);
999 Export.ExportToRename = m_Strings.LocalCopy(ExportToRename);
1000 Export.Flags = Flags;
1001 m_Exports.push_back(Export);
1002 m_Desc.pExports = &m_Exports[0]; // using ugly way to get pointer in case .data() is not defined
1003 m_Desc.NumExports = static_cast<UINT>(m_Exports.size());
1004 }
1005 template<size_t N>
1006 void DefineExports(LPCWSTR(&Exports)[N])
1007 {
1008 for (UINT i = 0; i < N; i++)
1009 {
1010 DefineExport(Exports[i]);
1011 }
1012 }
1013 void DefineExports(const LPCWSTR* Exports, UINT N)
1014 {
1015 for (UINT i = 0; i < N; i++)
1016 {
1017 DefineExport(Exports[i]);
1018 }
1019 }
1020 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
1021 {
1022 return D3D12_STATE_SUBOBJECT_TYPE_EXISTING_COLLECTION_BY_KEY;
1023 }
1024 operator const D3D12_EXISTING_COLLECTION_BY_KEY_DESC&() const noexcept { return m_Desc; }
1025private:
1026 void Init() noexcept
1027 {
1028 SUBOBJECT_HELPER_BASE::Init();
1029 m_Desc = {};
1030 m_Strings.clear();
1031 m_Exports.clear();
1032 }
1033 void* Data() noexcept override { return &m_Desc; }
1034 D3D12_EXISTING_COLLECTION_BY_KEY_DESC m_Desc;
1035 std::vector<unsigned char> m_Key;
1036 CD3DX12_STATE_OBJECT_DESC::StringContainer<LPCWSTR, std::wstring> m_Strings;
1037 std::vector<D3D12_EXPORT_DESC> m_Exports;
1038};
1039
1040#endif // defined(D3D12_SDK_VERSION) && (D3D12_SDK_VERSION >= 618)
1041
1042//------------------------------------------------------------------------------------------------
1043class CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT
1044 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
1045{
1046public:
1047 CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT() noexcept
1048 : m_Desc({})
1049 {
1050 Init();
1051 }
1052 CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1053 : m_Desc({})
1054 {
1055 Init();
1056 AddToStateObject(ContainingStateObject);
1057 }
1058 CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT(const D3D12_STATE_OBJECT_CONFIG &desc) noexcept
1059 : m_Desc(desc)
1060 {
1061 Init();
1062 }
1063 CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT(const D3D12_STATE_OBJECT_CONFIG &desc, CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1064 : m_Desc(desc)
1065 {
1066 Init();
1067 AddToStateObject(ContainingStateObject);
1068 }
1069 CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT(const CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT& other) = delete;
1070 CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT& operator=(const CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT& other) = delete;
1071 CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT(CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT&& other) = default;
1072 CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT& operator=(CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT&& other) = default;
1073 void SetFlags(D3D12_STATE_OBJECT_FLAGS Flags) noexcept
1074 {
1075 m_Desc.Flags = Flags;
1076 }
1077 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
1078 {
1079 return D3D12_STATE_SUBOBJECT_TYPE_STATE_OBJECT_CONFIG;
1080 }
1081 operator const D3D12_STATE_OBJECT_CONFIG&() const noexcept { return m_Desc; }
1082 operator D3D12_STATE_OBJECT_CONFIG&() noexcept { return m_Desc; }
1083private:
1084 void Init() noexcept
1085 {
1086 SUBOBJECT_HELPER_BASE::Init();
1087 }
1088 void* Data() noexcept override { return &m_Desc; }
1089 D3D12_STATE_OBJECT_CONFIG m_Desc;
1090};
1091
1092//------------------------------------------------------------------------------------------------
1093class CD3DX12_NODE_MASK_SUBOBJECT
1094 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
1095{
1096public:
1097 CD3DX12_NODE_MASK_SUBOBJECT() noexcept
1098 : m_Desc({})
1099 {
1100 Init();
1101 }
1102 CD3DX12_NODE_MASK_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1103 : m_Desc({})
1104 {
1105 Init();
1106 AddToStateObject(ContainingStateObject);
1107 }
1108 CD3DX12_NODE_MASK_SUBOBJECT(const D3D12_NODE_MASK &desc) noexcept
1109 : m_Desc(desc)
1110 {
1111 Init();
1112 }
1113 CD3DX12_NODE_MASK_SUBOBJECT(const D3D12_NODE_MASK &desc, CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1114 : m_Desc(desc)
1115 {
1116 Init();
1117 AddToStateObject(ContainingStateObject);
1118 }
1119 CD3DX12_NODE_MASK_SUBOBJECT(const CD3DX12_NODE_MASK_SUBOBJECT& other) = delete;
1120 CD3DX12_NODE_MASK_SUBOBJECT& operator=(const CD3DX12_NODE_MASK_SUBOBJECT& other) = delete;
1121 CD3DX12_NODE_MASK_SUBOBJECT(CD3DX12_NODE_MASK_SUBOBJECT&& other) = default;
1122 CD3DX12_NODE_MASK_SUBOBJECT& operator=(CD3DX12_NODE_MASK_SUBOBJECT&& other) = default;
1123 void SetNodeMask(UINT NodeMask) noexcept
1124 {
1125 m_Desc.NodeMask = NodeMask;
1126 }
1127 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
1128 {
1129 return D3D12_STATE_SUBOBJECT_TYPE_NODE_MASK;
1130 }
1131 operator const D3D12_NODE_MASK&() const noexcept { return m_Desc; }
1132 operator D3D12_NODE_MASK&() noexcept { return m_Desc; }
1133private:
1134 void Init() noexcept
1135 {
1136 SUBOBJECT_HELPER_BASE::Init();
1137 }
1138 void* Data() noexcept override { return &m_Desc; }
1139 D3D12_NODE_MASK m_Desc;
1140};
1141
1142#if defined(D3D12_SDK_VERSION) && (D3D12_SDK_VERSION >= 612)
1143//------------------------------------------------------------------------------------------------
1144class CD3DX12_STREAM_OUTPUT_SUBOBJECT
1145 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
1146{
1147public:
1148 CD3DX12_STREAM_OUTPUT_SUBOBJECT()
1149 {
1150 Init();
1151 }
1152 CD3DX12_STREAM_OUTPUT_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1153 {
1154 Init();
1155 AddToStateObject(ContainingStateObject);
1156 }
1157 void AddSODeclEntry(const D3D12_SO_DECLARATION_ENTRY &entry)
1158 {
1159 m_soDecalEntries.emplace_back(D3D12_SO_DECLARATION_ENTRY{
1160 entry.Stream,
1161 m_Strings.LocalCopy(entry.SemanticName),
1162 entry.SemanticIndex,
1163 entry.StartComponent,
1164 entry.ComponentCount,
1165 entry.OutputSlot
1166 });
1167 m_Desc.NumEntries++;
1168 // Below: using ugly way to get pointer in case .data() is not defined
1169 m_Desc.pSODeclaration = &m_soDecalEntries[0];
1170 }
1171 void SetSODeclEntries(const D3D12_SO_DECLARATION_ENTRY* soDeclEntries, UINT numEntries)
1172 {
1173 m_soDecalEntries.resize(numEntries);
1174 for (UINT i = 0; i < numEntries; i++)
1175 {
1176 m_soDecalEntries[i] = D3D12_SO_DECLARATION_ENTRY{
1177 soDeclEntries[i].Stream,
1178 m_Strings.LocalCopy(soDeclEntries[i].SemanticName),
1179 soDeclEntries[i].SemanticIndex,
1180 soDeclEntries[i].StartComponent,
1181 soDeclEntries[i].ComponentCount,
1182 soDeclEntries[i].OutputSlot
1183 };
1184 }
1185 m_Desc.NumEntries = numEntries;
1186 // Below: using ugly way to get pointer in case .data() is not defined
1187 if (numEntries > 0)
1188 {
1189 m_Desc.pSODeclaration = &m_soDecalEntries[0];
1190 }
1191 }
1192 void SetBufferStrides(const UINT* bufferStrides, UINT numStrides)
1193 {
1194 for (UINT i = 0; i < numStrides; ++i)
1195 {
1196 m_Strides[i] = bufferStrides[i];
1197 }
1198 m_Desc.pBufferStrides = m_Strides;
1199 m_Desc.NumStrides = numStrides;
1200 }
1201 void SetRasterizedStream(UINT rasterizedStream)
1202 {
1203 m_Desc.RasterizedStream = rasterizedStream;
1204 }
1205 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
1206 {
1207 return D3D12_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT;
1208 }
1209 operator const D3D12_STREAM_OUTPUT_DESC& () const noexcept { return m_Desc; }
1210
1211private:
1212 void Init()
1213 {
1214 SUBOBJECT_HELPER_BASE::Init();
1215 m_Desc = {};
1216 }
1217 void* Data() noexcept override { return &m_Desc; }
1218 D3D12_STREAM_OUTPUT_DESC m_Desc;
1219 CD3DX12_STATE_OBJECT_DESC::StringContainer<LPCSTR, std::string> m_Strings;
1220 std::vector<D3D12_SO_DECLARATION_ENTRY> m_soDecalEntries;
1221 UINT m_Strides[D3D12_SO_STREAM_COUNT];
1222};
1223
1224//------------------------------------------------------------------------------------------------
1225class CD3DX12_BLEND_SUBOBJECT
1226 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
1227{
1228public:
1229 CD3DX12_BLEND_SUBOBJECT()
1230 : m_Desc(CD3DX12_BLEND_DESC(D3D12_DEFAULT))
1231 {
1232 Init();
1233 }
1234 CD3DX12_BLEND_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1235 : m_Desc(CD3DX12_BLEND_DESC(D3D12_DEFAULT))
1236 {
1237 Init();
1238 AddToStateObject(ContainingStateObject);
1239 }
1240 CD3DX12_BLEND_SUBOBJECT(const D3D12_BLEND_DESC &desc)
1241 : m_Desc(desc)
1242 {
1243 Init();
1244 }
1245 CD3DX12_BLEND_SUBOBJECT(const D3D12_BLEND_DESC &desc, CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1246 : m_Desc(desc)
1247 {
1248 Init();
1249 AddToStateObject(ContainingStateObject);
1250 }
1251 void SetAlphaToCoverageEnable(bool alphaToCoverageEnable)
1252 {
1253 m_Desc.AlphaToCoverageEnable = alphaToCoverageEnable;
1254 }
1255 void SetIndependentBlendEnable(bool independentBlendEnable)
1256 {
1257 m_Desc.IndependentBlendEnable = independentBlendEnable;
1258 }
1259 void SetRenderTarget(UINT renderTargetIndex, const D3D12_RENDER_TARGET_BLEND_DESC& renderTargetBlendDesc)
1260 {
1261 m_Desc.RenderTarget[renderTargetIndex].BlendEnable = renderTargetBlendDesc.BlendEnable;
1262 m_Desc.RenderTarget[renderTargetIndex].BlendOp = renderTargetBlendDesc.BlendOp;
1263 m_Desc.RenderTarget[renderTargetIndex].BlendOpAlpha = renderTargetBlendDesc.BlendOpAlpha;
1264 m_Desc.RenderTarget[renderTargetIndex].DestBlend = renderTargetBlendDesc.DestBlend;
1265 m_Desc.RenderTarget[renderTargetIndex].DestBlendAlpha = renderTargetBlendDesc.DestBlendAlpha;
1266 m_Desc.RenderTarget[renderTargetIndex].LogicOp = renderTargetBlendDesc.LogicOp;
1267 m_Desc.RenderTarget[renderTargetIndex].LogicOpEnable = renderTargetBlendDesc.LogicOpEnable;
1268 m_Desc.RenderTarget[renderTargetIndex].RenderTargetWriteMask = renderTargetBlendDesc.RenderTargetWriteMask;
1269 m_Desc.RenderTarget[renderTargetIndex].SrcBlend = renderTargetBlendDesc.SrcBlend;
1270 m_Desc.RenderTarget[renderTargetIndex].SrcBlendAlpha = renderTargetBlendDesc.SrcBlendAlpha;
1271 }
1272 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
1273 {
1274 return D3D12_STATE_SUBOBJECT_TYPE_BLEND;
1275 }
1276 operator const D3D12_BLEND_DESC& () const noexcept { return m_Desc; }
1277 operator D3D12_BLEND_DESC& () noexcept { return m_Desc; }
1278private:
1279 void Init() noexcept
1280 {
1281 SUBOBJECT_HELPER_BASE::Init();
1282 }
1283 void* Data() noexcept override { return &m_Desc; }
1284 CD3DX12_BLEND_DESC m_Desc;
1285};
1286
1287//------------------------------------------------------------------------------------------------
1288class CD3DX12_RASTERIZER_SUBOBJECT
1289 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
1290{
1291public:
1292 CD3DX12_RASTERIZER_SUBOBJECT()
1293 : m_Desc(CD3DX12_RASTERIZER_DESC2(D3D12_DEFAULT))
1294 {
1295 Init();
1296 }
1297 CD3DX12_RASTERIZER_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1298 : m_Desc(CD3DX12_RASTERIZER_DESC2(D3D12_DEFAULT))
1299 {
1300 Init();
1301 AddToStateObject(ContainingStateObject);
1302 }
1303 CD3DX12_RASTERIZER_SUBOBJECT(const D3D12_RASTERIZER_DESC2 &desc)
1304 : m_Desc(desc)
1305 {
1306 Init();
1307 }
1308 CD3DX12_RASTERIZER_SUBOBJECT(const D3D12_RASTERIZER_DESC2 &desc, CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1309 : m_Desc(desc)
1310 {
1311 Init();
1312 AddToStateObject(ContainingStateObject);
1313 }
1314 void SetFillMode(D3D12_FILL_MODE fillMode)
1315 {
1316 m_Desc.FillMode = fillMode;
1317 }
1318 void SetCullMode(D3D12_CULL_MODE cullMode)
1319 {
1320 m_Desc.CullMode = cullMode;
1321 }
1322 void SetFrontCounterClockwise(BOOL frontCounterClockwise)
1323 {
1324 m_Desc.FrontCounterClockwise = frontCounterClockwise;
1325 }
1326 void SetDepthBias(FLOAT depthBias)
1327 {
1328 m_Desc.DepthBias = depthBias;
1329 }
1330 void SetDepthBiasClamp(FLOAT depthBiasClamp)
1331 {
1332 m_Desc.DepthBiasClamp = depthBiasClamp;
1333 }
1334 void SetSlopeScaledDepthBias(FLOAT slopeScaledDepthBias)
1335 {
1336 m_Desc.SlopeScaledDepthBias = slopeScaledDepthBias;
1337 }
1338 void SetDepthClipEnable(BOOL depthClipEnable)
1339 {
1340 m_Desc.DepthClipEnable = depthClipEnable;
1341 }
1342 void SetLineRasterizationMode(D3D12_LINE_RASTERIZATION_MODE lineRasterizationMode)
1343 {
1344 m_Desc.LineRasterizationMode = lineRasterizationMode;
1345 }
1346 void SetForcedSampleCount(UINT forcedSampleCount)
1347 {
1348 m_Desc.ForcedSampleCount = forcedSampleCount;
1349 }
1350 void SetConservativeRaster(D3D12_CONSERVATIVE_RASTERIZATION_MODE conservativeRaster)
1351 {
1352 m_Desc.ConservativeRaster = conservativeRaster;
1353 }
1354 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
1355 {
1356 return D3D12_STATE_SUBOBJECT_TYPE_RASTERIZER;
1357 }
1358 operator const D3D12_RASTERIZER_DESC2& () const noexcept { return m_Desc; }
1359 operator D3D12_RASTERIZER_DESC2& () noexcept { return m_Desc; }
1360private:
1361 void Init() noexcept
1362 {
1363 SUBOBJECT_HELPER_BASE::Init();
1364 }
1365 void* Data() noexcept override { return &m_Desc; }
1366 CD3DX12_RASTERIZER_DESC2 m_Desc;
1367};
1368
1369//------------------------------------------------------------------------------------------------
1370class CD3DX12_DEPTH_STENCIL2_SUBOBJECT
1371 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
1372{
1373public:
1374 CD3DX12_DEPTH_STENCIL2_SUBOBJECT()
1375 : m_Desc(CD3DX12_DEPTH_STENCIL_DESC2(D3D12_DEFAULT))
1376 {
1377 Init();
1378 }
1379 CD3DX12_DEPTH_STENCIL2_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1380 : m_Desc(CD3DX12_DEPTH_STENCIL_DESC2(D3D12_DEFAULT))
1381 {
1382 Init();
1383 AddToStateObject(ContainingStateObject);
1384 }
1385 CD3DX12_DEPTH_STENCIL2_SUBOBJECT(const D3D12_DEPTH_STENCIL_DESC2 &desc)
1386 : m_Desc(desc)
1387 {
1388 Init();
1389 }
1390 CD3DX12_DEPTH_STENCIL2_SUBOBJECT(const D3D12_DEPTH_STENCIL_DESC2 &desc, CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1391 : m_Desc(desc)
1392 {
1393 Init();
1394 AddToStateObject(ContainingStateObject);
1395 }
1396 void SetDepthEnable(BOOL depthEnable)
1397 {
1398 m_Desc.DepthEnable = depthEnable;
1399 }
1400 void SetDepthWriteMask(D3D12_DEPTH_WRITE_MASK depthWriteMask)
1401 {
1402 m_Desc.DepthWriteMask = depthWriteMask;
1403 }
1404 void SetDepthFunc(D3D12_COMPARISON_FUNC depthFunc)
1405 {
1406 m_Desc.DepthFunc = depthFunc;
1407 }
1408 void SetStencilEnable(BOOL stencilEnable)
1409 {
1410 m_Desc.StencilEnable = stencilEnable;
1411 }
1412 void SetFrontFace(D3D12_DEPTH_STENCILOP_DESC1 frontFace)
1413 {
1414 m_Desc.FrontFace = {
1415 frontFace.StencilFailOp,
1416 frontFace.StencilDepthFailOp,
1417 frontFace.StencilPassOp,
1418 frontFace.StencilFunc,
1419 frontFace.StencilReadMask,
1420 frontFace.StencilWriteMask
1421 };
1422 }
1423 void SetBackFace(D3D12_DEPTH_STENCILOP_DESC1 backFace)
1424 {
1425 m_Desc.BackFace = {
1426 backFace.StencilFailOp,
1427 backFace.StencilDepthFailOp,
1428 backFace.StencilPassOp,
1429 backFace.StencilFunc,
1430 backFace.StencilReadMask,
1431 backFace.StencilWriteMask
1432 };
1433 }
1434 void SetDepthBoundsTestEnable(BOOL depthBoundsTestEnable)
1435 {
1436 m_Desc.DepthBoundsTestEnable = depthBoundsTestEnable;
1437 }
1438 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
1439 {
1440 return D3D12_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL2;
1441 }
1442 operator const D3D12_DEPTH_STENCIL_DESC2& () const noexcept { return m_Desc; }
1443 operator D3D12_DEPTH_STENCIL_DESC2& () noexcept { return m_Desc; }
1444private:
1445 void Init() noexcept
1446 {
1447 SUBOBJECT_HELPER_BASE::Init();
1448 }
1449 void* Data() noexcept override { return &m_Desc; }
1450 CD3DX12_DEPTH_STENCIL_DESC2 m_Desc;
1451};
1452
1453//------------------------------------------------------------------------------------------------
1454class CD3DX12_INPUT_LAYOUT_SUBOBJECT
1455 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
1456{
1457public:
1458 CD3DX12_INPUT_LAYOUT_SUBOBJECT()
1459 {
1460 Init();
1461 }
1462 CD3DX12_INPUT_LAYOUT_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1463 {
1464 Init();
1465 AddToStateObject(ContainingStateObject);
1466 }
1467 void AddInputLayoutElementDesc(D3D12_INPUT_ELEMENT_DESC inputLayoutElementDesc)
1468 {
1469 m_inputLayoutElements.emplace_back(
1470 D3D12_INPUT_ELEMENT_DESC{
1471 m_Strings.LocalCopy(inputLayoutElementDesc.SemanticName),
1472 inputLayoutElementDesc.SemanticIndex,
1473 inputLayoutElementDesc.Format,
1474 inputLayoutElementDesc.InputSlot,
1475 inputLayoutElementDesc.AlignedByteOffset,
1476 inputLayoutElementDesc.InputSlotClass,
1477 inputLayoutElementDesc.InstanceDataStepRate
1478 });
1479 ++m_Desc.NumElements;
1480 // Below: using ugly way to get pointer in case .data() is not defined
1481 m_Desc.pInputElementDescs = &m_inputLayoutElements[0];
1482 }
1483 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
1484 {
1485 return D3D12_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT;
1486 }
1487 operator const D3D12_INPUT_LAYOUT_DESC& () const noexcept { return m_Desc; }
1488private:
1489 void Init() noexcept
1490 {
1491 SUBOBJECT_HELPER_BASE::Init();
1492 m_Desc = {};
1493 m_inputLayoutElements.clear();
1494 }
1495 void* Data() noexcept override { return &m_Desc; }
1496 D3D12_INPUT_LAYOUT_DESC m_Desc;
1497 std::vector<D3D12_INPUT_ELEMENT_DESC> m_inputLayoutElements;
1498 CD3DX12_STATE_OBJECT_DESC::StringContainer<LPCSTR, std::string> m_Strings;
1499};
1500
1501//------------------------------------------------------------------------------------------------
1502class CD3DX12_IB_STRIP_CUT_VALUE_SUBOBJECT
1503 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
1504{
1505public:
1506 CD3DX12_IB_STRIP_CUT_VALUE_SUBOBJECT()
1507 : m_Desc(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_DISABLED)
1508 {
1509 Init();
1510 }
1511 CD3DX12_IB_STRIP_CUT_VALUE_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1512 : m_Desc(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_DISABLED)
1513 {
1514 Init();
1515 AddToStateObject(ContainingStateObject);
1516 }
1517 CD3DX12_IB_STRIP_CUT_VALUE_SUBOBJECT(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE desc)
1518 : m_Desc(desc)
1519 {
1520 Init();
1521 }
1522 CD3DX12_IB_STRIP_CUT_VALUE_SUBOBJECT(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE desc, CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1523 : m_Desc(desc)
1524 {
1525 Init();
1526 AddToStateObject(ContainingStateObject);
1527 }
1528 void SetIBStripCutValue(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE ibStripCutValue)
1529 {
1530 m_Desc = ibStripCutValue;
1531 }
1532 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
1533 {
1534 return D3D12_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE;
1535 }
1536 operator const D3D12_INDEX_BUFFER_STRIP_CUT_VALUE& () const noexcept { return m_Desc; }
1537 operator D3D12_INDEX_BUFFER_STRIP_CUT_VALUE& () noexcept { return m_Desc; }
1538private:
1539 void Init() noexcept
1540 {
1541 SUBOBJECT_HELPER_BASE::Init();
1542 }
1543 void* Data() noexcept override { return &m_Desc; }
1544 D3D12_INDEX_BUFFER_STRIP_CUT_VALUE m_Desc;
1545};
1546
1547//------------------------------------------------------------------------------------------------
1548class CD3DX12_PRIMITIVE_TOPOLOGY_SUBOBJECT
1549 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
1550{
1551public:
1552 CD3DX12_PRIMITIVE_TOPOLOGY_SUBOBJECT()
1553 : m_Desc(D3D12_PRIMITIVE_TOPOLOGY_TYPE_UNDEFINED)
1554 {
1555 Init();
1556 }
1557 CD3DX12_PRIMITIVE_TOPOLOGY_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1558 : m_Desc(D3D12_PRIMITIVE_TOPOLOGY_TYPE_UNDEFINED)
1559 {
1560 Init();
1561 AddToStateObject(ContainingStateObject);
1562 }
1563 CD3DX12_PRIMITIVE_TOPOLOGY_SUBOBJECT(D3D12_PRIMITIVE_TOPOLOGY_TYPE desc)
1564 : m_Desc(desc)
1565 {
1566 Init();
1567 }
1568 CD3DX12_PRIMITIVE_TOPOLOGY_SUBOBJECT(D3D12_PRIMITIVE_TOPOLOGY_TYPE desc, CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1569 : m_Desc(desc)
1570 {
1571 Init();
1572 AddToStateObject(ContainingStateObject);
1573 }
1574 void SetPrimitiveTopologyType(D3D12_PRIMITIVE_TOPOLOGY_TYPE primitiveTopologytype)
1575 {
1576 m_Desc = primitiveTopologytype;
1577 }
1578 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
1579 {
1580 return D3D12_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY;
1581 }
1582 operator const D3D12_PRIMITIVE_TOPOLOGY_TYPE& () const noexcept { return m_Desc; }
1583 operator D3D12_PRIMITIVE_TOPOLOGY_TYPE& () noexcept { return m_Desc; }
1584private:
1585 void Init() noexcept
1586 {
1587 SUBOBJECT_HELPER_BASE::Init();
1588 }
1589 void* Data() noexcept override { return &m_Desc; }
1590 D3D12_PRIMITIVE_TOPOLOGY_TYPE m_Desc;
1591};
1592
1593//------------------------------------------------------------------------------------------------
1594class CD3DX12_RENDER_TARGET_FORMATS_SUBOBJECT
1595 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
1596{
1597public:
1598 CD3DX12_RENDER_TARGET_FORMATS_SUBOBJECT()
1599 : m_Desc({})
1600 {
1601 Init();
1602 }
1603 CD3DX12_RENDER_TARGET_FORMATS_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1604 : m_Desc({})
1605 {
1606 Init();
1607 AddToStateObject(ContainingStateObject);
1608 }
1609 CD3DX12_RENDER_TARGET_FORMATS_SUBOBJECT(const D3D12_RT_FORMAT_ARRAY &desc)
1610 : m_Desc(desc)
1611 {
1612 Init();
1613 }
1614 CD3DX12_RENDER_TARGET_FORMATS_SUBOBJECT(const D3D12_RT_FORMAT_ARRAY &desc, CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1615 : m_Desc(desc)
1616 {
1617 Init();
1618 AddToStateObject(ContainingStateObject);
1619 }
1620 void SetNumRenderTargets(UINT numRenderTargets)
1621 {
1622 m_Desc.NumRenderTargets = numRenderTargets;
1623 }
1624 void SetRenderTargetFormat(UINT renderTarget, DXGI_FORMAT renderTargetFormat)
1625 {
1626 m_Desc.RTFormats[renderTarget] = renderTargetFormat;
1627 }
1628 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
1629 {
1630 return D3D12_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS;
1631 }
1632 operator const D3D12_RT_FORMAT_ARRAY& () const noexcept { return m_Desc; }
1633 operator D3D12_RT_FORMAT_ARRAY& () noexcept { return m_Desc; }
1634private:
1635 void Init() noexcept
1636 {
1637 SUBOBJECT_HELPER_BASE::Init();
1638 }
1639 void* Data() noexcept override { return &m_Desc; }
1640 D3D12_RT_FORMAT_ARRAY m_Desc;
1641};
1642
1643//------------------------------------------------------------------------------------------------
1644class CD3DX12_DEPTH_STENCIL_FORMAT_SUBOBJECT
1645 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
1646{
1647public:
1648 CD3DX12_DEPTH_STENCIL_FORMAT_SUBOBJECT()
1649 : m_Desc(DXGI_FORMAT_UNKNOWN)
1650 {
1651 Init();
1652 }
1653 CD3DX12_DEPTH_STENCIL_FORMAT_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1654 : m_Desc(DXGI_FORMAT_UNKNOWN)
1655 {
1656 Init();
1657 AddToStateObject(ContainingStateObject);
1658 }
1659 CD3DX12_DEPTH_STENCIL_FORMAT_SUBOBJECT(DXGI_FORMAT desc)
1660 : m_Desc(desc)
1661 {
1662 Init();
1663 }
1664 CD3DX12_DEPTH_STENCIL_FORMAT_SUBOBJECT(DXGI_FORMAT desc, CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1665 : m_Desc(desc)
1666 {
1667 Init();
1668 AddToStateObject(ContainingStateObject);
1669 }
1670 void SetDepthStencilFormat(DXGI_FORMAT depthStencilFormat)
1671 {
1672 m_Desc = depthStencilFormat;
1673 }
1674 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
1675 {
1676 return D3D12_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT;
1677 }
1678 operator const DXGI_FORMAT& () const noexcept { return m_Desc; }
1679 operator DXGI_FORMAT& () noexcept { return m_Desc; }
1680private:
1681 void Init() noexcept
1682 {
1683 SUBOBJECT_HELPER_BASE::Init();
1684 }
1685 void* Data() noexcept override { return &m_Desc; }
1686 DXGI_FORMAT m_Desc;
1687};
1688
1689//------------------------------------------------------------------------------------------------
1690class CD3DX12_SAMPLE_DESC_SUBOBJECT
1691 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
1692{
1693public:
1694 CD3DX12_SAMPLE_DESC_SUBOBJECT()
1695 : m_Desc({1, 0})
1696 {
1697 Init();
1698 }
1699 CD3DX12_SAMPLE_DESC_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1700 : m_Desc({1, 0})
1701 {
1702 Init();
1703 AddToStateObject(ContainingStateObject);
1704 }
1705 CD3DX12_SAMPLE_DESC_SUBOBJECT(const DXGI_SAMPLE_DESC &desc)
1706 : m_Desc(desc)
1707 {
1708 Init();
1709 }
1710 CD3DX12_SAMPLE_DESC_SUBOBJECT(const DXGI_SAMPLE_DESC &desc, CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1711 : m_Desc(desc)
1712 {
1713 Init();
1714 AddToStateObject(ContainingStateObject);
1715 }
1716 void SetCount(UINT count)
1717 {
1718 m_Desc.Count = count;
1719 }
1720 void SetQuality(UINT quality)
1721 {
1722 m_Desc.Quality = quality;
1723 }
1724 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
1725 {
1726 return D3D12_STATE_SUBOBJECT_TYPE_SAMPLE_DESC;
1727 }
1728 operator const DXGI_SAMPLE_DESC& () const noexcept { return m_Desc; }
1729 operator DXGI_SAMPLE_DESC& () noexcept { return m_Desc; }
1730private:
1731 void Init() noexcept
1732 {
1733 SUBOBJECT_HELPER_BASE::Init();
1734 m_Desc = {};
1735 }
1736 void* Data() noexcept override { return &m_Desc; }
1737 DXGI_SAMPLE_DESC m_Desc;
1738};
1739
1740//------------------------------------------------------------------------------------------------
1741class CD3DX12_FLAGS_SUBOBJECT
1742 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
1743{
1744public:
1745 CD3DX12_FLAGS_SUBOBJECT()
1746 : m_Desc(D3D12_PIPELINE_STATE_FLAG_NONE)
1747 {
1748 Init();
1749 }
1750 CD3DX12_FLAGS_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1751 : m_Desc(D3D12_PIPELINE_STATE_FLAG_NONE)
1752 {
1753 Init();
1754 AddToStateObject(ContainingStateObject);
1755 }
1756 CD3DX12_FLAGS_SUBOBJECT(D3D12_PIPELINE_STATE_FLAGS desc)
1757 : m_Desc(desc)
1758 {
1759 Init();
1760 }
1761 CD3DX12_FLAGS_SUBOBJECT(D3D12_PIPELINE_STATE_FLAGS desc, CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1762 : m_Desc(desc)
1763 {
1764 Init();
1765 AddToStateObject(ContainingStateObject);
1766 }
1767 void SetFlags(D3D12_PIPELINE_STATE_FLAGS flags)
1768 {
1769 m_Desc = flags;
1770 }
1771 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
1772 {
1773 return D3D12_STATE_SUBOBJECT_TYPE_FLAGS;
1774 }
1775 operator const D3D12_PIPELINE_STATE_FLAGS& () const noexcept { return m_Desc; }
1776 operator D3D12_PIPELINE_STATE_FLAGS& () noexcept { return m_Desc; }
1777private:
1778 void Init() noexcept
1779 {
1780 SUBOBJECT_HELPER_BASE::Init();
1781 }
1782 void* Data() noexcept override { return &m_Desc; }
1783 D3D12_PIPELINE_STATE_FLAGS m_Desc;
1784};
1785
1786//------------------------------------------------------------------------------------------------
1787class CD3DX12_VIEW_INSTANCING_SUBOBJECT
1788 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
1789{
1790public:
1791 CD3DX12_VIEW_INSTANCING_SUBOBJECT()
1792 {
1793 Init();
1794 }
1795 CD3DX12_VIEW_INSTANCING_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1796 {
1797 Init();
1798 AddToStateObject(ContainingStateObject);
1799 }
1800 void AddViewInstanceLocation(D3D12_VIEW_INSTANCE_LOCATION viewInstanceLocation)
1801 {
1802 m_Desc.ViewInstanceCount++;
1803 m_viewInstanceLocations.emplace_back(
1804 D3D12_VIEW_INSTANCE_LOCATION
1805 {
1806 viewInstanceLocation.ViewportArrayIndex,
1807 viewInstanceLocation.RenderTargetArrayIndex
1808 }
1809 );
1810 // Below: using ugly way to get pointer in case .data() is not defined
1811 m_Desc.pViewInstanceLocations = &m_viewInstanceLocations[0];
1812 }
1813 void SetFlags(D3D12_VIEW_INSTANCING_FLAGS flags)
1814 {
1815 m_Desc.Flags = flags;
1816 }
1817 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
1818 {
1819 return D3D12_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING;
1820 }
1821 operator const D3D12_VIEW_INSTANCING_DESC& () const noexcept { return m_Desc; }
1822private:
1823 void Init() noexcept
1824 {
1825 SUBOBJECT_HELPER_BASE::Init();
1826 m_Desc = CD3DX12_VIEW_INSTANCING_DESC(D3D12_DEFAULT);
1827 m_viewInstanceLocations.clear();
1828 }
1829 void* Data() noexcept override { return &m_Desc; }
1830 CD3DX12_VIEW_INSTANCING_DESC m_Desc;
1831 std::vector<D3D12_VIEW_INSTANCE_LOCATION> m_viewInstanceLocations;
1832};
1833
1834//------------------------------------------------------------------------------------------------
1835class CD3DX12_DEPTH_STENCIL_SUBOBJECT
1836 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
1837{
1838public:
1839 CD3DX12_DEPTH_STENCIL_SUBOBJECT()
1840 : m_Desc(CD3DX12_DEPTH_STENCIL_DESC(D3D12_DEFAULT))
1841 {
1842 Init();
1843 }
1844 CD3DX12_DEPTH_STENCIL_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1845 : m_Desc(CD3DX12_DEPTH_STENCIL_DESC(D3D12_DEFAULT))
1846 {
1847 Init();
1848 AddToStateObject(ContainingStateObject);
1849 }
1850 CD3DX12_DEPTH_STENCIL_SUBOBJECT(const D3D12_DEPTH_STENCIL_DESC &desc)
1851 : m_Desc(desc)
1852 {
1853 Init();
1854 }
1855 CD3DX12_DEPTH_STENCIL_SUBOBJECT(const D3D12_DEPTH_STENCIL_DESC &desc, CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1856 : m_Desc(desc)
1857 {
1858 Init();
1859 AddToStateObject(ContainingStateObject);
1860 }
1861 void SetDepthEnable(BOOL depthEnable)
1862 {
1863 m_Desc.DepthEnable = depthEnable;
1864 }
1865 void SetDepthWriteMask(D3D12_DEPTH_WRITE_MASK depthWriteMask)
1866 {
1867 m_Desc.DepthWriteMask = depthWriteMask;
1868 }
1869 void SetDepthFunc(D3D12_COMPARISON_FUNC depthFunc)
1870 {
1871 m_Desc.DepthFunc = depthFunc;
1872 }
1873 void SetStencilEnable(BOOL stencilEnable)
1874 {
1875 m_Desc.StencilEnable = stencilEnable;
1876 }
1877 void SetStencilReadMask(UINT8 stencilReadMask)
1878 {
1879 m_Desc.StencilReadMask = stencilReadMask;
1880 }
1881 void SetStencilWriteMask(UINT8 stencilWriteMask)
1882 {
1883 m_Desc.StencilWriteMask = stencilWriteMask;
1884 }
1885 void SetFrontFace(D3D12_DEPTH_STENCILOP_DESC frontFace)
1886 {
1887 m_Desc.FrontFace = {
1888 frontFace.StencilFailOp,
1889 frontFace.StencilDepthFailOp,
1890 frontFace.StencilPassOp,
1891 frontFace.StencilFunc
1892 };
1893 }
1894 void SetBackFace(D3D12_DEPTH_STENCILOP_DESC backFace)
1895 {
1896 m_Desc.BackFace = {
1897 backFace.StencilFailOp,
1898 backFace.StencilDepthFailOp,
1899 backFace.StencilPassOp,
1900 backFace.StencilFunc
1901 };
1902 }
1903 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
1904 {
1905 return D3D12_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL;
1906 }
1907 operator const D3D12_DEPTH_STENCIL_DESC& () const noexcept { return m_Desc; }
1908 operator D3D12_DEPTH_STENCIL_DESC& () noexcept { return m_Desc; }
1909private:
1910 void Init() noexcept
1911 {
1912 SUBOBJECT_HELPER_BASE::Init();
1913 }
1914 void* Data() noexcept override { return &m_Desc; }
1915 CD3DX12_DEPTH_STENCIL_DESC m_Desc;
1916};
1917
1918//------------------------------------------------------------------------------------------------
1919class CD3DX12_DEPTH_STENCIL1_SUBOBJECT
1920 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
1921{
1922public:
1923 CD3DX12_DEPTH_STENCIL1_SUBOBJECT()
1924 : m_Desc(CD3DX12_DEPTH_STENCIL_DESC1(D3D12_DEFAULT))
1925 {
1926 Init();
1927 }
1928 CD3DX12_DEPTH_STENCIL1_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1929 : m_Desc(CD3DX12_DEPTH_STENCIL_DESC1(D3D12_DEFAULT))
1930 {
1931 Init();
1932 AddToStateObject(ContainingStateObject);
1933 }
1934 CD3DX12_DEPTH_STENCIL1_SUBOBJECT(const D3D12_DEPTH_STENCIL_DESC1 &desc)
1935 : m_Desc(desc)
1936 {
1937 Init();
1938 }
1939 CD3DX12_DEPTH_STENCIL1_SUBOBJECT(const D3D12_DEPTH_STENCIL_DESC1 &desc, CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
1940 : m_Desc(desc)
1941 {
1942 Init();
1943 AddToStateObject(ContainingStateObject);
1944 }
1945 void SetDepthEnable(BOOL depthEnable)
1946 {
1947 m_Desc.DepthEnable = depthEnable;
1948 }
1949 void SetDepthWriteMask(D3D12_DEPTH_WRITE_MASK depthWriteMask)
1950 {
1951 m_Desc.DepthWriteMask = depthWriteMask;
1952 }
1953 void SetDepthFunc(D3D12_COMPARISON_FUNC depthFunc)
1954 {
1955 m_Desc.DepthFunc = depthFunc;
1956 }
1957 void SetStencilEnable(BOOL stencilEnable)
1958 {
1959 m_Desc.StencilEnable = stencilEnable;
1960 }
1961 void SetStencilReadMask(UINT8 stencilReadMask)
1962 {
1963 m_Desc.StencilReadMask = stencilReadMask;
1964 }
1965 void SetStencilWriteMask(UINT8 stencilWriteMask)
1966 {
1967 m_Desc.StencilWriteMask = stencilWriteMask;
1968 }
1969 void SetFrontFace(D3D12_DEPTH_STENCILOP_DESC frontFace)
1970 {
1971 m_Desc.FrontFace = {
1972 frontFace.StencilFailOp,
1973 frontFace.StencilDepthFailOp,
1974 frontFace.StencilPassOp,
1975 frontFace.StencilFunc
1976 };
1977 }
1978 void SetBackFace(D3D12_DEPTH_STENCILOP_DESC backFace)
1979 {
1980 m_Desc.BackFace = {
1981 backFace.StencilFailOp,
1982 backFace.StencilDepthFailOp,
1983 backFace.StencilPassOp,
1984 backFace.StencilFunc
1985 };
1986 }
1987 void SetDepthBoundsTestEnable(BOOL depthBoundsTestEnable)
1988 {
1989 m_Desc.DepthBoundsTestEnable = depthBoundsTestEnable;
1990 }
1991 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
1992 {
1993 return D3D12_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1;
1994 }
1995 operator const D3D12_DEPTH_STENCIL_DESC1& () const noexcept { return m_Desc; }
1996 operator D3D12_DEPTH_STENCIL_DESC1& () noexcept { return m_Desc; }
1997private:
1998 void Init() noexcept
1999 {
2000 SUBOBJECT_HELPER_BASE::Init();
2001 }
2002 void* Data() noexcept override { return &m_Desc; }
2003 CD3DX12_DEPTH_STENCIL_DESC1 m_Desc;
2004};
2005
2006//------------------------------------------------------------------------------------------------
2007class CD3DX12_SAMPLE_MASK_SUBOBJECT
2008 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
2009{
2010public:
2011 CD3DX12_SAMPLE_MASK_SUBOBJECT()
2012 : m_Desc(0xffffffffu)
2013 {
2014 Init();
2015 }
2016 CD3DX12_SAMPLE_MASK_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
2017 : m_Desc(0xffffffffu)
2018 {
2019 Init();
2020 AddToStateObject(ContainingStateObject);
2021 }
2022 CD3DX12_SAMPLE_MASK_SUBOBJECT(UINT desc)
2023 : m_Desc(desc)
2024 {
2025 Init();
2026 }
2027 CD3DX12_SAMPLE_MASK_SUBOBJECT(UINT desc, CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
2028 : m_Desc(desc)
2029 {
2030 Init();
2031 AddToStateObject(ContainingStateObject);
2032 }
2033 void SetSampleMask(UINT sampleMask)
2034 {
2035 m_Desc = sampleMask;
2036 }
2037 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
2038 {
2039 return D3D12_STATE_SUBOBJECT_TYPE_SAMPLE_MASK;
2040 }
2041 operator const UINT& () const noexcept { return m_Desc; }
2042 operator UINT& () noexcept { return m_Desc; }
2043private:
2044 void Init() noexcept
2045 {
2046 SUBOBJECT_HELPER_BASE::Init();
2047 }
2048 void* Data() noexcept override { return &m_Desc; }
2049 UINT m_Desc;
2050};
2051
2052//------------------------------------------------------------------------------------------------
2053class CD3DX12_GENERIC_PROGRAM_SUBOBJECT
2054 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
2055{
2056public:
2057 CD3DX12_GENERIC_PROGRAM_SUBOBJECT()
2058 {
2059 Init();
2060 }
2061 CD3DX12_GENERIC_PROGRAM_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
2062 {
2063 Init();
2064 AddToStateObject(ContainingStateObject);
2065 }
2066 void SetProgramName(LPCWSTR ProgramName)
2067 {
2068 m_Desc.ProgramName = m_Strings.LocalCopy(ProgramName);
2069 }
2070 void AddExport(LPCWSTR exportName)
2071 {
2072 m_Exports.emplace_back(m_Strings.LocalCopy(exportName));
2073 m_Desc.NumExports++;
2074 // Below: using ugly way to get pointer in case .data() is not defined
2075 m_Desc.pExports = &m_Exports[0];
2076 }
2077 void AddSubobject(const D3D12_STATE_SUBOBJECT& subobject)
2078 {
2079 m_Subobjects.emplace_back(&subobject);
2080 m_Desc.NumSubobjects++;
2081 // Below: using ugly way to get pointer in case .data() is not defined
2082 m_Desc.ppSubobjects = &m_Subobjects[0];
2083 }
2084 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
2085 {
2086 return D3D12_STATE_SUBOBJECT_TYPE_GENERIC_PROGRAM;
2087 }
2088 operator const D3D12_GENERIC_PROGRAM_DESC& () const noexcept { return m_Desc; }
2089private:
2090 void Init() noexcept
2091 {
2092 SUBOBJECT_HELPER_BASE::Init();
2093 m_Desc = {};
2094 }
2095 void* Data() noexcept override { return &m_Desc; }
2096 D3D12_GENERIC_PROGRAM_DESC m_Desc;
2097 std::vector<LPCWSTR> m_Exports;
2098 std::vector<D3D12_STATE_SUBOBJECT const*> m_Subobjects;
2099 CD3DX12_STATE_OBJECT_DESC::StringContainer<LPCWSTR, std::wstring> m_Strings;
2100};
2101
2102//------------------------------------------------------------------------------------------------
2103class CD3DX12_NODE_OUTPUT_OVERRIDES
2104{
2105public:
2106 CD3DX12_NODE_OUTPUT_OVERRIDES(const D3D12_NODE_OUTPUT_OVERRIDES** ppOwner, UINT* pNumOutputOverrides) noexcept
2107 {
2108 m_Desc.clear();
2109 m_ppOwner = ppOwner;
2110 *m_ppOwner = nullptr;
2111 m_pNumOutputOverrides = pNumOutputOverrides;
2112 *m_pNumOutputOverrides = 0;
2113 }
2114 void NewOutputOverride()
2115 {
2116 m_Desc.emplace_back(D3D12_NODE_OUTPUT_OVERRIDES{});
2117 *m_ppOwner = m_Desc.data();
2118 (*m_pNumOutputOverrides)++;
2119 }
2120 void OutputIndex(UINT index)
2121 {
2122 m_Desc.back().OutputIndex = index;
2123 }
2124 void NewName(LPCWSTR Name, UINT ArrayIndex = 0)
2125 {
2126 m_NodeIDs.emplace_front(D3D12_NODE_ID{ m_Strings.LocalCopy(Name),ArrayIndex });
2127 m_Desc.back().pNewName = &m_NodeIDs.front();
2128 }
2129 void AllowSparseNodes(BOOL bAllow)
2130 {
2131 m_UINTs.emplace_front((UINT)bAllow);
2132 m_Desc.back().pAllowSparseNodes = (BOOL*)&m_UINTs.front();
2133 }
2134 void MaxOutputRecords(UINT maxOutputRecords) noexcept
2135 {
2136 m_UINTs.emplace_front(maxOutputRecords);
2137 m_Desc.back().pMaxRecords = &m_UINTs.front();
2138 }
2139 void MaxOutputRecordsSharedWith(UINT outputIndex) noexcept
2140 {
2141 m_UINTs.emplace_front(outputIndex);
2142 m_Desc.back().pMaxRecordsSharedWithOutputIndex = &m_UINTs.front();
2143 }
2144private:
2145 std::vector<D3D12_NODE_OUTPUT_OVERRIDES> m_Desc;
2146 // Cached parameters
2147 CD3DX12_STATE_OBJECT_DESC::StringContainer<LPCWSTR, std::wstring> m_Strings;
2148 std::forward_list<UINT> m_UINTs;
2149 std::forward_list<D3D12_NODE_ID> m_NodeIDs;
2150 const D3D12_NODE_OUTPUT_OVERRIDES** m_ppOwner;
2151 UINT* m_pNumOutputOverrides;
2152};
2153
2154//------------------------------------------------------------------------------------------------
2155class CD3DX12_WORK_GRAPH_SUBOBJECT;
2156
2157//------------------------------------------------------------------------------------------------
2158class CD3DX12_NODE_HELPER_BASE
2159{
2160protected:
2161 struct Backreference
2162 {
2163 CD3DX12_WORK_GRAPH_SUBOBJECT *m_pGraph;
2164 UINT m_NodeIndex;
2165 };
2166public:
2167 CD3DX12_NODE_HELPER_BASE(const Backreference &BackRef)
2168 : m_BackRef(BackRef)
2169 {
2170 }
2171 virtual ~CD3DX12_NODE_HELPER_BASE() = default;
2172protected:
2173 D3D12_NODE *GetNode() const;
2174 const Backreference m_BackRef;
2175 CD3DX12_STATE_OBJECT_DESC::StringContainer<LPCWSTR, std::wstring> m_Strings;
2176};
2177
2178//------------------------------------------------------------------------------------------------
2179class CD3DX12_SHADER_NODE // Not specifying launch mode.
2180 // Don't need to distinguish if no parameter overriding is happening
2181 : public CD3DX12_NODE_HELPER_BASE
2182{
2183public:
2184 CD3DX12_SHADER_NODE(
2185 const Backreference &BackRef,
2186 LPCWSTR _Shader = nullptr)
2187 : CD3DX12_NODE_HELPER_BASE(BackRef)
2188 {
2189 GetNode()->NodeType = D3D12_NODE_TYPE_SHADER;
2190 Shader(_Shader);
2191 }
2192 void Shader(LPCWSTR _Shader)
2193 {
2194 GetNode()->Shader.Shader = m_Strings.LocalCopy(_Shader);
2195 }
2196 LPCWSTR GetShaderName() const { return GetNode()->Shader.Shader; }
2197};
2198
2199#endif // D3D12_SDK_VERSION >= 612
2200
2201
2202#if defined(D3D12_SDK_VERSION) && (D3D12_SDK_VERSION >= 612)
2203
2204//------------------------------------------------------------------------------------------------
2205// Use this class when defining a broadcasting launch node where configuration parameters
2206// need to be overridden. If overrides are not needed, just use CD3DX12_COMPUTE_SHADER_NODE
2207class CD3DX12_BROADCASTING_LAUNCH_NODE_OVERRIDES
2208 : public CD3DX12_NODE_HELPER_BASE
2209{
2210public:
2211 CD3DX12_BROADCASTING_LAUNCH_NODE_OVERRIDES(
2212 const Backreference &BackRef,
2213 LPCWSTR _Shader = nullptr) :
2214 CD3DX12_NODE_HELPER_BASE(BackRef),
2215 m_NodeOutputOverrides(&Overrides.pOutputOverrides, &Overrides.NumOutputOverrides)
2216 {
2217 Overrides = {};
2218 D3D12_NODE *pNode = GetNode();
2219 pNode->NodeType = D3D12_NODE_TYPE_SHADER;
2220 pNode->Shader.OverridesType = D3D12_NODE_OVERRIDES_TYPE_BROADCASTING_LAUNCH;
2221 pNode->Shader.pBroadcastingLaunchOverrides = &Overrides;
2222 Shader(_Shader);
2223 }
2224 void Shader(LPCWSTR _Shader)
2225 {
2226 GetNode()->Shader.Shader = m_Strings.LocalCopy(_Shader);
2227 }
2228 LPCWSTR GetShaderName() const { return GetNode()->Shader.Shader; }
2229 void LocalRootArgumentsTableIndex(UINT index)
2230 {
2231 m_UINTs.emplace_front(index);
2232 Overrides.pLocalRootArgumentsTableIndex = &m_UINTs.front();
2233 }
2234 void ProgramEntry(BOOL bIsProgramEntry)
2235 {
2236 m_UINTs.emplace_front(bIsProgramEntry);
2237 Overrides.pProgramEntry = (BOOL*)&m_UINTs.front();
2238 }
2239 void NewName(D3D12_NODE_ID NodeID)
2240 {
2241 m_NodeIDs.emplace_front(D3D12_NODE_ID{ m_Strings.LocalCopy(NodeID.Name),NodeID.ArrayIndex });
2242 Overrides.pNewName = &m_NodeIDs.front();
2243 }
2244 void ShareInputOf(D3D12_NODE_ID NodeID)
2245 {
2246 m_NodeIDs.emplace_front(D3D12_NODE_ID{ m_Strings.LocalCopy(NodeID.Name),NodeID.ArrayIndex });
2247 Overrides.pShareInputOf = &m_NodeIDs.front();
2248 }
2249 void DispatchGrid(UINT x, UINT y, UINT z)
2250 {
2251 m_UINT3s.emplace_front(UINT3{ x,y,z });
2252 Overrides.pDispatchGrid = (UINT*)&m_UINT3s.front();
2253 }
2254 void MaxDispatchGrid(UINT x, UINT y, UINT z)
2255 {
2256 m_UINT3s.emplace_front(UINT3{x,y,z});
2257 Overrides.pMaxDispatchGrid = (UINT*)&m_UINT3s.front();
2258 }
2259 CD3DX12_NODE_OUTPUT_OVERRIDES& NodeOutputOverrides()
2260 {
2261 return m_NodeOutputOverrides;
2262 }
2263 D3D12_BROADCASTING_LAUNCH_OVERRIDES Overrides;
2264private:
2265 // Cached parameters
2266 std::forward_list<UINT> m_UINTs;
2267 struct UINT3
2268 {
2269 UINT x;
2270 UINT y;
2271 UINT z;
2272 };
2273 std::forward_list<UINT3> m_UINT3s;
2274 std::forward_list<D3D12_NODE_ID> m_NodeIDs;
2275 CD3DX12_NODE_OUTPUT_OVERRIDES m_NodeOutputOverrides;
2276};
2277
2278//------------------------------------------------------------------------------------------------
2279// Use this class when defining a coalescing launch node where configuration parameters
2280// need to be overridden. If overrides are not needed, just use CD3DX12_COMPUTE_SHADER_NODE
2281class CD3DX12_COALESCING_LAUNCH_NODE_OVERRIDES
2282 : public CD3DX12_NODE_HELPER_BASE
2283{
2284public:
2285 CD3DX12_COALESCING_LAUNCH_NODE_OVERRIDES(
2286 const Backreference &BackRef,
2287 LPCWSTR _Shader = nullptr) :
2288 CD3DX12_NODE_HELPER_BASE(BackRef),
2289 m_NodeOutputOverrides(&Overrides.pOutputOverrides, &Overrides.NumOutputOverrides)
2290 {
2291 Overrides = {};
2292 D3D12_NODE *pNode = GetNode();
2293 pNode->NodeType = D3D12_NODE_TYPE_SHADER;
2294 pNode->Shader.OverridesType = D3D12_NODE_OVERRIDES_TYPE_COALESCING_LAUNCH;
2295 pNode->Shader.pCoalescingLaunchOverrides = &Overrides;
2296 Shader(_Shader);
2297 }
2298 void Shader(LPCWSTR _Shader)
2299 {
2300 GetNode()->Shader.Shader = m_Strings.LocalCopy(_Shader);
2301 }
2302 LPCWSTR GetShaderName() const { return GetNode()->Shader.Shader; }
2303 void LocalRootArgumentsTableIndex(UINT index)
2304 {
2305 m_UINTs.emplace_front(index);
2306 Overrides.pLocalRootArgumentsTableIndex = &m_UINTs.front();
2307 }
2308 void ProgramEntry(BOOL bIsProgramEntry)
2309 {
2310 m_UINTs.emplace_front(bIsProgramEntry);
2311 Overrides.pProgramEntry = (BOOL*)&m_UINTs.front();
2312 }
2313 void NewName(D3D12_NODE_ID NodeID)
2314 {
2315 m_NodeIDs.emplace_front(D3D12_NODE_ID{ m_Strings.LocalCopy(NodeID.Name),NodeID.ArrayIndex });
2316 Overrides.pNewName = &m_NodeIDs.front();
2317 }
2318 void ShareInputOf(D3D12_NODE_ID NodeID)
2319 {
2320 m_NodeIDs.emplace_front(D3D12_NODE_ID{ m_Strings.LocalCopy(NodeID.Name),NodeID.ArrayIndex });
2321 Overrides.pShareInputOf = &m_NodeIDs.front();
2322 }
2323 CD3DX12_NODE_OUTPUT_OVERRIDES& NodeOutputOverrides()
2324 {
2325 return m_NodeOutputOverrides;
2326 }
2327 D3D12_COALESCING_LAUNCH_OVERRIDES Overrides;
2328private:
2329 // Cached parameters
2330 std::forward_list<UINT> m_UINTs;
2331 struct UINT3
2332 {
2333 UINT x;
2334 UINT y;
2335 UINT z;
2336 };
2337 std::forward_list<UINT3> m_UINT3s;
2338 std::forward_list<D3D12_NODE_ID> m_NodeIDs;
2339 CD3DX12_NODE_OUTPUT_OVERRIDES m_NodeOutputOverrides;
2340};
2341
2342//------------------------------------------------------------------------------------------------
2343// Use this class when defining a thread launch node where configuration parameters
2344// need to be overridden. If overrides are not needed, just use CD3DX12_COMPUTE_SHADER_NODE
2345class CD3DX12_THREAD_LAUNCH_NODE_OVERRIDES
2346 : public CD3DX12_NODE_HELPER_BASE
2347{
2348public:
2349 CD3DX12_THREAD_LAUNCH_NODE_OVERRIDES(
2350 const Backreference &BackRef,
2351 LPCWSTR _Shader = nullptr) :
2352 CD3DX12_NODE_HELPER_BASE(BackRef),
2353 m_NodeOutputOverrides(&Overrides.pOutputOverrides, &Overrides.NumOutputOverrides)
2354 {
2355 Overrides = {};
2356 D3D12_NODE *pNode = GetNode();
2357 pNode->NodeType = D3D12_NODE_TYPE_SHADER;
2358 pNode->Shader.OverridesType = D3D12_NODE_OVERRIDES_TYPE_THREAD_LAUNCH;
2359 pNode->Shader.pThreadLaunchOverrides = &Overrides;
2360 Shader(_Shader);
2361 }
2362 void Shader(LPCWSTR _Shader)
2363 {
2364 GetNode()->Shader.Shader = m_Strings.LocalCopy(_Shader);
2365 }
2366 LPCWSTR GetShaderName() const { return GetNode()->Shader.Shader; }
2367 void LocalRootArgumentsTableIndex(UINT index)
2368 {
2369 m_UINTs.emplace_front(index);
2370 Overrides.pLocalRootArgumentsTableIndex = &m_UINTs.front();
2371 }
2372 void ProgramEntry(BOOL bIsProgramEntry)
2373 {
2374 m_UINTs.emplace_front(bIsProgramEntry);
2375 Overrides.pProgramEntry = (BOOL*)&m_UINTs.front();
2376 }
2377 void NewName(D3D12_NODE_ID NodeID)
2378 {
2379 m_NodeIDs.emplace_front(D3D12_NODE_ID{ m_Strings.LocalCopy(NodeID.Name),NodeID.ArrayIndex });
2380 Overrides.pNewName = &m_NodeIDs.front();
2381 }
2382 void ShareInputOf(D3D12_NODE_ID NodeID)
2383 {
2384 m_NodeIDs.emplace_front(D3D12_NODE_ID{ m_Strings.LocalCopy(NodeID.Name),NodeID.ArrayIndex });
2385 Overrides.pShareInputOf = &m_NodeIDs.front();
2386 }
2387 CD3DX12_NODE_OUTPUT_OVERRIDES& NodeOutputOverrides()
2388 {
2389 return m_NodeOutputOverrides;
2390 }
2391 D3D12_THREAD_LAUNCH_OVERRIDES Overrides;
2392private:
2393 // Cached parameters
2394 std::forward_list<UINT> m_UINTs;
2395 std::forward_list<D3D12_NODE_ID> m_NodeIDs;
2396 CD3DX12_NODE_OUTPUT_OVERRIDES m_NodeOutputOverrides;
2397};
2398
2399//------------------------------------------------------------------------------------------------
2400// Use this class when defining a node where configuration parameters
2401// need to be overridden for parameters that are common to all launch node types.
2402// This option is a convenience if you don't want to determine what the launch mode is
2403// and just want to override a setting that isn't specific to launch mode.
2404// If overrides are not needed, just use CD3DX12_COMPUTE_SHADER_NODE
2405class CD3DX12_COMMON_COMPUTE_NODE_OVERRIDES
2406 : public CD3DX12_NODE_HELPER_BASE
2407{
2408public:
2409 CD3DX12_COMMON_COMPUTE_NODE_OVERRIDES(
2410 const Backreference &BackRef,
2411 LPCWSTR _Shader = nullptr) :
2412 CD3DX12_NODE_HELPER_BASE(BackRef),
2413 m_NodeOutputOverrides(&Overrides.pOutputOverrides, &Overrides.NumOutputOverrides)
2414 {
2415 Overrides = {};
2416 D3D12_NODE *pNode = GetNode();
2417 pNode->NodeType = D3D12_NODE_TYPE_SHADER;
2418 pNode->Shader.OverridesType = D3D12_NODE_OVERRIDES_TYPE_COMMON_COMPUTE;
2419 pNode->Shader.pThreadLaunchOverrides = &Overrides;
2420 Shader(_Shader);
2421 }
2422 void Shader(LPCWSTR _Shader)
2423 {
2424 GetNode()->Shader.Shader = m_Strings.LocalCopy(_Shader);
2425 }
2426 LPCWSTR GetShaderName() const { return GetNode()->Shader.Shader; }
2427 void LocalRootArgumentsTableIndex(UINT index)
2428 {
2429 m_UINTs.emplace_front(index);
2430 Overrides.pLocalRootArgumentsTableIndex = &m_UINTs.front();
2431 }
2432 void ProgramEntry(BOOL bIsProgramEntry)
2433 {
2434 m_UINTs.emplace_front(bIsProgramEntry);
2435 Overrides.pProgramEntry = (BOOL*)&m_UINTs.front();
2436 }
2437 void NewName(D3D12_NODE_ID NodeID)
2438 {
2439 m_NodeIDs.emplace_front(D3D12_NODE_ID{ m_Strings.LocalCopy(NodeID.Name),NodeID.ArrayIndex });
2440 Overrides.pNewName = &m_NodeIDs.front();
2441 }
2442 void ShareInputOf(D3D12_NODE_ID NodeID)
2443 {
2444 m_NodeIDs.emplace_front(D3D12_NODE_ID{ m_Strings.LocalCopy(NodeID.Name),NodeID.ArrayIndex });
2445 Overrides.pShareInputOf = &m_NodeIDs.front();
2446 }
2447 CD3DX12_NODE_OUTPUT_OVERRIDES& NodeOutputOverrides()
2448 {
2449 return m_NodeOutputOverrides;
2450 }
2451 D3D12_THREAD_LAUNCH_OVERRIDES Overrides;
2452private:
2453 // Cached parameters
2454 std::forward_list<UINT> m_UINTs;
2455 std::forward_list<D3D12_NODE_ID> m_NodeIDs;
2456 CD3DX12_NODE_OUTPUT_OVERRIDES m_NodeOutputOverrides;
2457};
2458
2459//------------------------------------------------------------------------------------------------
2460class CD3DX12_WORK_GRAPH_SUBOBJECT
2461 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
2462{
2463public:
2464 CD3DX12_WORK_GRAPH_SUBOBJECT() noexcept
2465 {
2466 Init();
2467 }
2468 CD3DX12_WORK_GRAPH_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
2469 {
2470 Init();
2471 AddToStateObject(ContainingStateObject);
2472 }
2473 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
2474 {
2475 return D3D12_STATE_SUBOBJECT_TYPE_WORK_GRAPH;
2476 }
2477 void IncludeAllAvailableNodes()
2478 {
2479 m_Desc.Flags |= D3D12_WORK_GRAPH_FLAG_INCLUDE_ALL_AVAILABLE_NODES;
2480 }
2481
2482
2483 void SetProgramName(LPCWSTR ProgramName)
2484 {
2485 m_Desc.ProgramName = m_Strings.LocalCopy(ProgramName);
2486 }
2487 void AddEntrypoint(D3D12_NODE_ID Entrypoint)
2488 {
2489 m_Entrypoints.emplace_back(D3D12_NODE_ID{ m_Strings.LocalCopy(Entrypoint.Name),Entrypoint.ArrayIndex });
2490 m_Desc.NumEntrypoints++;
2491 m_Desc.pEntrypoints = m_Entrypoints.data();
2492 }
2493
2494 template<typename T>
2495 T* CreateNode()
2496 {
2497 m_NodeDescs.push_back({});
2498 m_Desc.NumExplicitlyDefinedNodes++;
2499 m_Desc.pExplicitlyDefinedNodes = m_NodeDescs.data();
2500 T* pNodeHelper = new T({this, (UINT)m_NodeDescs.size() - 1});
2501 m_OwnedNodeHelpers.emplace_back(pNodeHelper);
2502 return pNodeHelper;
2503 }
2504 CD3DX12_SHADER_NODE* CreateShaderNode(LPCWSTR Shader = nullptr)
2505 {
2506 auto pNode = CreateNode<CD3DX12_SHADER_NODE>();
2507 pNode->Shader(Shader);
2508 return pNode;
2509 }
2510 CD3DX12_BROADCASTING_LAUNCH_NODE_OVERRIDES* CreateBroadcastingLaunchNodeOverrides(LPCWSTR Shader = nullptr)
2511 {
2512 auto pNode = CreateNode<CD3DX12_BROADCASTING_LAUNCH_NODE_OVERRIDES>();
2513 pNode->Shader(Shader);
2514 return pNode;
2515 }
2516 CD3DX12_COALESCING_LAUNCH_NODE_OVERRIDES* CreateCoalescingLaunchNodeOverrides(LPCWSTR Shader = nullptr)
2517 {
2518 auto pNode = CreateNode<CD3DX12_COALESCING_LAUNCH_NODE_OVERRIDES>();
2519 pNode->Shader(Shader);
2520 return pNode;
2521 }
2522 CD3DX12_THREAD_LAUNCH_NODE_OVERRIDES* CreateThreadLaunchNodeOverrides(LPCWSTR Shader = nullptr)
2523 {
2524 auto pNode = CreateNode<CD3DX12_THREAD_LAUNCH_NODE_OVERRIDES>();
2525 pNode->Shader(Shader);
2526 return pNode;
2527 }
2528 CD3DX12_COMMON_COMPUTE_NODE_OVERRIDES* CreateCommonComputeNodeOverrides(LPCWSTR Shader = nullptr)
2529 {
2530 auto pNode = CreateNode<CD3DX12_COMMON_COMPUTE_NODE_OVERRIDES>();
2531 pNode->Shader(Shader);
2532 return pNode;
2533 }
2534#endif // D3D12_SDK_VERSION >= 612
2535
2536
2537#if defined(D3D12_SDK_VERSION) && (D3D12_SDK_VERSION >= 612)
2538
2539 operator const D3D12_WORK_GRAPH_DESC& () noexcept
2540 {
2541 return m_Desc;
2542 }
2543private:
2544 void Init() noexcept
2545 {
2546 SUBOBJECT_HELPER_BASE::Init();
2547 m_Desc = {};
2548 m_Entrypoints.clear();
2549 m_NodeDescs.clear();
2550 }
2551 void* Data() noexcept override { return &m_Desc; }
2552 D3D12_WORK_GRAPH_DESC m_Desc;
2553 std::vector<D3D12_NODE_ID> m_Entrypoints;
2554 std::vector<D3D12_NODE> m_NodeDescs;
2555 CD3DX12_STATE_OBJECT_DESC::StringContainer<LPCWSTR, std::wstring> m_Strings;
2556 std::vector<std::unique_ptr<const CD3DX12_NODE_HELPER_BASE>> m_OwnedNodeHelpers;
2557 friend class CD3DX12_NODE_HELPER_BASE;
2558};
2559
2560inline D3D12_NODE * CD3DX12_NODE_HELPER_BASE::GetNode() const
2561{
2562 return &m_BackRef.m_pGraph->m_NodeDescs[m_BackRef.m_NodeIndex];
2563}
2564#endif // D3D12_SDK_VERSION >= 612
2565
2566#undef D3DX12_COM_PTR
2567#undef D3DX12_COM_PTR_GET
2568#undef D3DX12_COM_PTR_ADDRESSOF
2569
2570
generated by cgit v1.2.3 (git 2.25.1) at 2025-12-04 13:54:22 +0000