aboutsummaryrefslogtreecommitdiff
path: root/contrib/DirectX-Headers/include/directx/d3dx12.h
diff options
context:
space:
mode:
Diffstat (limited to 'contrib/DirectX-Headers/include/directx/d3dx12.h')
-rw-r--r--contrib/DirectX-Headers/include/directx/d3dx12.h4049
1 files changed, 4049 insertions, 0 deletions
diff --git a/contrib/DirectX-Headers/include/directx/d3dx12.h b/contrib/DirectX-Headers/include/directx/d3dx12.h
new file mode 100644
index 0000000..b135598
--- /dev/null
+++ b/contrib/DirectX-Headers/include/directx/d3dx12.h
@@ -0,0 +1,4049 @@
1//*********************************************************
2//
3// Copyright (c) Microsoft Corporation.
4// Licensed under the MIT License (MIT).
5//
6//*********************************************************
7
8#ifndef __D3DX12_H__
9#define __D3DX12_H__
10
11#include "d3d12.h"
12
13#if defined( __cplusplus )
14
15struct CD3DX12_DEFAULT {};
16extern const DECLSPEC_SELECTANY CD3DX12_DEFAULT D3D12_DEFAULT;
17
18//------------------------------------------------------------------------------------------------
19inline bool operator==( const D3D12_VIEWPORT& l, const D3D12_VIEWPORT& r ) noexcept
20{
21 return l.TopLeftX == r.TopLeftX && l.TopLeftY == r.TopLeftY && l.Width == r.Width &&
22 l.Height == r.Height && l.MinDepth == r.MinDepth && l.MaxDepth == r.MaxDepth;
23}
24
25//------------------------------------------------------------------------------------------------
26inline bool operator!=( const D3D12_VIEWPORT& l, const D3D12_VIEWPORT& r ) noexcept
27{ return !( l == r ); }
28
29//------------------------------------------------------------------------------------------------
30struct CD3DX12_RECT : public D3D12_RECT
31{
32 CD3DX12_RECT() = default;
33 explicit CD3DX12_RECT( const D3D12_RECT& o ) noexcept :
34 D3D12_RECT( o )
35 {}
36 explicit CD3DX12_RECT(
37 LONG Left,
38 LONG Top,
39 LONG Right,
40 LONG Bottom ) noexcept
41 {
42 left = Left;
43 top = Top;
44 right = Right;
45 bottom = Bottom;
46 }
47};
48
49//------------------------------------------------------------------------------------------------
50struct CD3DX12_VIEWPORT : public D3D12_VIEWPORT
51{
52 CD3DX12_VIEWPORT() = default;
53 explicit CD3DX12_VIEWPORT( const D3D12_VIEWPORT& o ) noexcept :
54 D3D12_VIEWPORT( o )
55 {}
56 explicit CD3DX12_VIEWPORT(
57 FLOAT topLeftX,
58 FLOAT topLeftY,
59 FLOAT width,
60 FLOAT height,
61 FLOAT minDepth = D3D12_MIN_DEPTH,
62 FLOAT maxDepth = D3D12_MAX_DEPTH ) noexcept
63 {
64 TopLeftX = topLeftX;
65 TopLeftY = topLeftY;
66 Width = width;
67 Height = height;
68 MinDepth = minDepth;
69 MaxDepth = maxDepth;
70 }
71 explicit CD3DX12_VIEWPORT(
72 _In_ ID3D12Resource* pResource,
73 UINT mipSlice = 0,
74 FLOAT topLeftX = 0.0f,
75 FLOAT topLeftY = 0.0f,
76 FLOAT minDepth = D3D12_MIN_DEPTH,
77 FLOAT maxDepth = D3D12_MAX_DEPTH ) noexcept
78 {
79 auto Desc = pResource->GetDesc();
80 const UINT64 SubresourceWidth = Desc.Width >> mipSlice;
81 const UINT64 SubresourceHeight = Desc.Height >> mipSlice;
82 switch (Desc.Dimension)
83 {
84 case D3D12_RESOURCE_DIMENSION_BUFFER:
85 TopLeftX = topLeftX;
86 TopLeftY = 0.0f;
87 Width = float(Desc.Width) - topLeftX;
88 Height = 1.0f;
89 break;
90 case D3D12_RESOURCE_DIMENSION_TEXTURE1D:
91 TopLeftX = topLeftX;
92 TopLeftY = 0.0f;
93 Width = (SubresourceWidth ? float(SubresourceWidth) : 1.0f) - topLeftX;
94 Height = 1.0f;
95 break;
96 case D3D12_RESOURCE_DIMENSION_TEXTURE2D:
97 case D3D12_RESOURCE_DIMENSION_TEXTURE3D:
98 TopLeftX = topLeftX;
99 TopLeftY = topLeftY;
100 Width = (SubresourceWidth ? float(SubresourceWidth) : 1.0f) - topLeftX;
101 Height = (SubresourceHeight ? float(SubresourceHeight) : 1.0f) - topLeftY;
102 break;
103 default: break;
104 }
105
106 MinDepth = minDepth;
107 MaxDepth = maxDepth;
108 }
109};
110
111//------------------------------------------------------------------------------------------------
112struct CD3DX12_BOX : public D3D12_BOX
113{
114 CD3DX12_BOX() = default;
115 explicit CD3DX12_BOX( const D3D12_BOX& o ) noexcept :
116 D3D12_BOX( o )
117 {}
118 explicit CD3DX12_BOX(
119 LONG Left,
120 LONG Right ) noexcept
121 {
122 left = static_cast<UINT>(Left);
123 top = 0;
124 front = 0;
125 right = static_cast<UINT>(Right);
126 bottom = 1;
127 back = 1;
128 }
129 explicit CD3DX12_BOX(
130 LONG Left,
131 LONG Top,
132 LONG Right,
133 LONG Bottom ) noexcept
134 {
135 left = static_cast<UINT>(Left);
136 top = static_cast<UINT>(Top);
137 front = 0;
138 right = static_cast<UINT>(Right);
139 bottom = static_cast<UINT>(Bottom);
140 back = 1;
141 }
142 explicit CD3DX12_BOX(
143 LONG Left,
144 LONG Top,
145 LONG Front,
146 LONG Right,
147 LONG Bottom,
148 LONG Back ) noexcept
149 {
150 left = static_cast<UINT>(Left);
151 top = static_cast<UINT>(Top);
152 front = static_cast<UINT>(Front);
153 right = static_cast<UINT>(Right);
154 bottom = static_cast<UINT>(Bottom);
155 back = static_cast<UINT>(Back);
156 }
157};
158inline bool operator==( const D3D12_BOX& l, const D3D12_BOX& r ) noexcept
159{
160 return l.left == r.left && l.top == r.top && l.front == r.front &&
161 l.right == r.right && l.bottom == r.bottom && l.back == r.back;
162}
163inline bool operator!=( const D3D12_BOX& l, const D3D12_BOX& r ) noexcept
164{ return !( l == r ); }
165
166//------------------------------------------------------------------------------------------------
167struct CD3DX12_DEPTH_STENCIL_DESC : public D3D12_DEPTH_STENCIL_DESC
168{
169 CD3DX12_DEPTH_STENCIL_DESC() = default;
170 explicit CD3DX12_DEPTH_STENCIL_DESC( const D3D12_DEPTH_STENCIL_DESC& o ) noexcept :
171 D3D12_DEPTH_STENCIL_DESC( o )
172 {}
173 explicit CD3DX12_DEPTH_STENCIL_DESC( CD3DX12_DEFAULT ) noexcept
174 {
175 DepthEnable = TRUE;
176 DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL;
177 DepthFunc = D3D12_COMPARISON_FUNC_LESS;
178 StencilEnable = FALSE;
179 StencilReadMask = D3D12_DEFAULT_STENCIL_READ_MASK;
180 StencilWriteMask = D3D12_DEFAULT_STENCIL_WRITE_MASK;
181 const D3D12_DEPTH_STENCILOP_DESC defaultStencilOp =
182 { D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_COMPARISON_FUNC_ALWAYS };
183 FrontFace = defaultStencilOp;
184 BackFace = defaultStencilOp;
185 }
186 explicit CD3DX12_DEPTH_STENCIL_DESC(
187 BOOL depthEnable,
188 D3D12_DEPTH_WRITE_MASK depthWriteMask,
189 D3D12_COMPARISON_FUNC depthFunc,
190 BOOL stencilEnable,
191 UINT8 stencilReadMask,
192 UINT8 stencilWriteMask,
193 D3D12_STENCIL_OP frontStencilFailOp,
194 D3D12_STENCIL_OP frontStencilDepthFailOp,
195 D3D12_STENCIL_OP frontStencilPassOp,
196 D3D12_COMPARISON_FUNC frontStencilFunc,
197 D3D12_STENCIL_OP backStencilFailOp,
198 D3D12_STENCIL_OP backStencilDepthFailOp,
199 D3D12_STENCIL_OP backStencilPassOp,
200 D3D12_COMPARISON_FUNC backStencilFunc ) noexcept
201 {
202 DepthEnable = depthEnable;
203 DepthWriteMask = depthWriteMask;
204 DepthFunc = depthFunc;
205 StencilEnable = stencilEnable;
206 StencilReadMask = stencilReadMask;
207 StencilWriteMask = stencilWriteMask;
208 FrontFace.StencilFailOp = frontStencilFailOp;
209 FrontFace.StencilDepthFailOp = frontStencilDepthFailOp;
210 FrontFace.StencilPassOp = frontStencilPassOp;
211 FrontFace.StencilFunc = frontStencilFunc;
212 BackFace.StencilFailOp = backStencilFailOp;
213 BackFace.StencilDepthFailOp = backStencilDepthFailOp;
214 BackFace.StencilPassOp = backStencilPassOp;
215 BackFace.StencilFunc = backStencilFunc;
216 }
217};
218
219//------------------------------------------------------------------------------------------------
220struct CD3DX12_DEPTH_STENCIL_DESC1 : public D3D12_DEPTH_STENCIL_DESC1
221{
222 CD3DX12_DEPTH_STENCIL_DESC1() = default;
223 explicit CD3DX12_DEPTH_STENCIL_DESC1( const D3D12_DEPTH_STENCIL_DESC1& o ) noexcept :
224 D3D12_DEPTH_STENCIL_DESC1( o )
225 {}
226 explicit CD3DX12_DEPTH_STENCIL_DESC1( const D3D12_DEPTH_STENCIL_DESC& o ) noexcept
227 {
228 DepthEnable = o.DepthEnable;
229 DepthWriteMask = o.DepthWriteMask;
230 DepthFunc = o.DepthFunc;
231 StencilEnable = o.StencilEnable;
232 StencilReadMask = o.StencilReadMask;
233 StencilWriteMask = o.StencilWriteMask;
234 FrontFace.StencilFailOp = o.FrontFace.StencilFailOp;
235 FrontFace.StencilDepthFailOp = o.FrontFace.StencilDepthFailOp;
236 FrontFace.StencilPassOp = o.FrontFace.StencilPassOp;
237 FrontFace.StencilFunc = o.FrontFace.StencilFunc;
238 BackFace.StencilFailOp = o.BackFace.StencilFailOp;
239 BackFace.StencilDepthFailOp = o.BackFace.StencilDepthFailOp;
240 BackFace.StencilPassOp = o.BackFace.StencilPassOp;
241 BackFace.StencilFunc = o.BackFace.StencilFunc;
242 DepthBoundsTestEnable = FALSE;
243 }
244 explicit CD3DX12_DEPTH_STENCIL_DESC1( CD3DX12_DEFAULT ) noexcept
245 {
246 DepthEnable = TRUE;
247 DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL;
248 DepthFunc = D3D12_COMPARISON_FUNC_LESS;
249 StencilEnable = FALSE;
250 StencilReadMask = D3D12_DEFAULT_STENCIL_READ_MASK;
251 StencilWriteMask = D3D12_DEFAULT_STENCIL_WRITE_MASK;
252 const D3D12_DEPTH_STENCILOP_DESC defaultStencilOp =
253 { D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_COMPARISON_FUNC_ALWAYS };
254 FrontFace = defaultStencilOp;
255 BackFace = defaultStencilOp;
256 DepthBoundsTestEnable = FALSE;
257 }
258 explicit CD3DX12_DEPTH_STENCIL_DESC1(
259 BOOL depthEnable,
260 D3D12_DEPTH_WRITE_MASK depthWriteMask,
261 D3D12_COMPARISON_FUNC depthFunc,
262 BOOL stencilEnable,
263 UINT8 stencilReadMask,
264 UINT8 stencilWriteMask,
265 D3D12_STENCIL_OP frontStencilFailOp,
266 D3D12_STENCIL_OP frontStencilDepthFailOp,
267 D3D12_STENCIL_OP frontStencilPassOp,
268 D3D12_COMPARISON_FUNC frontStencilFunc,
269 D3D12_STENCIL_OP backStencilFailOp,
270 D3D12_STENCIL_OP backStencilDepthFailOp,
271 D3D12_STENCIL_OP backStencilPassOp,
272 D3D12_COMPARISON_FUNC backStencilFunc,
273 BOOL depthBoundsTestEnable ) noexcept
274 {
275 DepthEnable = depthEnable;
276 DepthWriteMask = depthWriteMask;
277 DepthFunc = depthFunc;
278 StencilEnable = stencilEnable;
279 StencilReadMask = stencilReadMask;
280 StencilWriteMask = stencilWriteMask;
281 FrontFace.StencilFailOp = frontStencilFailOp;
282 FrontFace.StencilDepthFailOp = frontStencilDepthFailOp;
283 FrontFace.StencilPassOp = frontStencilPassOp;
284 FrontFace.StencilFunc = frontStencilFunc;
285 BackFace.StencilFailOp = backStencilFailOp;
286 BackFace.StencilDepthFailOp = backStencilDepthFailOp;
287 BackFace.StencilPassOp = backStencilPassOp;
288 BackFace.StencilFunc = backStencilFunc;
289 DepthBoundsTestEnable = depthBoundsTestEnable;
290 }
291 operator D3D12_DEPTH_STENCIL_DESC() const noexcept
292 {
293 D3D12_DEPTH_STENCIL_DESC D;
294 D.DepthEnable = DepthEnable;
295 D.DepthWriteMask = DepthWriteMask;
296 D.DepthFunc = DepthFunc;
297 D.StencilEnable = StencilEnable;
298 D.StencilReadMask = StencilReadMask;
299 D.StencilWriteMask = StencilWriteMask;
300 D.FrontFace.StencilFailOp = FrontFace.StencilFailOp;
301 D.FrontFace.StencilDepthFailOp = FrontFace.StencilDepthFailOp;
302 D.FrontFace.StencilPassOp = FrontFace.StencilPassOp;
303 D.FrontFace.StencilFunc = FrontFace.StencilFunc;
304 D.BackFace.StencilFailOp = BackFace.StencilFailOp;
305 D.BackFace.StencilDepthFailOp = BackFace.StencilDepthFailOp;
306 D.BackFace.StencilPassOp = BackFace.StencilPassOp;
307 D.BackFace.StencilFunc = BackFace.StencilFunc;
308 return D;
309 }
310};
311
312//------------------------------------------------------------------------------------------------
313struct CD3DX12_BLEND_DESC : public D3D12_BLEND_DESC
314{
315 CD3DX12_BLEND_DESC() = default;
316 explicit CD3DX12_BLEND_DESC( const D3D12_BLEND_DESC& o ) noexcept :
317 D3D12_BLEND_DESC( o )
318 {}
319 explicit CD3DX12_BLEND_DESC( CD3DX12_DEFAULT ) noexcept
320 {
321 AlphaToCoverageEnable = FALSE;
322 IndependentBlendEnable = FALSE;
323 const D3D12_RENDER_TARGET_BLEND_DESC defaultRenderTargetBlendDesc =
324 {
325 FALSE,FALSE,
326 D3D12_BLEND_ONE, D3D12_BLEND_ZERO, D3D12_BLEND_OP_ADD,
327 D3D12_BLEND_ONE, D3D12_BLEND_ZERO, D3D12_BLEND_OP_ADD,
328 D3D12_LOGIC_OP_NOOP,
329 D3D12_COLOR_WRITE_ENABLE_ALL,
330 };
331 for (UINT i = 0; i < D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
332 RenderTarget[ i ] = defaultRenderTargetBlendDesc;
333 }
334};
335
336//------------------------------------------------------------------------------------------------
337struct CD3DX12_RASTERIZER_DESC : public D3D12_RASTERIZER_DESC
338{
339 CD3DX12_RASTERIZER_DESC() = default;
340 explicit CD3DX12_RASTERIZER_DESC( const D3D12_RASTERIZER_DESC& o ) noexcept :
341 D3D12_RASTERIZER_DESC( o )
342 {}
343 explicit CD3DX12_RASTERIZER_DESC( CD3DX12_DEFAULT ) noexcept
344 {
345 FillMode = D3D12_FILL_MODE_SOLID;
346 CullMode = D3D12_CULL_MODE_BACK;
347 FrontCounterClockwise = FALSE;
348 DepthBias = D3D12_DEFAULT_DEPTH_BIAS;
349 DepthBiasClamp = D3D12_DEFAULT_DEPTH_BIAS_CLAMP;
350 SlopeScaledDepthBias = D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS;
351 DepthClipEnable = TRUE;
352 MultisampleEnable = FALSE;
353 AntialiasedLineEnable = FALSE;
354 ForcedSampleCount = 0;
355 ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF;
356 }
357 explicit CD3DX12_RASTERIZER_DESC(
358 D3D12_FILL_MODE fillMode,
359 D3D12_CULL_MODE cullMode,
360 BOOL frontCounterClockwise,
361 INT depthBias,
362 FLOAT depthBiasClamp,
363 FLOAT slopeScaledDepthBias,
364 BOOL depthClipEnable,
365 BOOL multisampleEnable,
366 BOOL antialiasedLineEnable,
367 UINT forcedSampleCount,
368 D3D12_CONSERVATIVE_RASTERIZATION_MODE conservativeRaster) noexcept
369 {
370 FillMode = fillMode;
371 CullMode = cullMode;
372 FrontCounterClockwise = frontCounterClockwise;
373 DepthBias = depthBias;
374 DepthBiasClamp = depthBiasClamp;
375 SlopeScaledDepthBias = slopeScaledDepthBias;
376 DepthClipEnable = depthClipEnable;
377 MultisampleEnable = multisampleEnable;
378 AntialiasedLineEnable = antialiasedLineEnable;
379 ForcedSampleCount = forcedSampleCount;
380 ConservativeRaster = conservativeRaster;
381 }
382};
383
384//------------------------------------------------------------------------------------------------
385struct CD3DX12_RESOURCE_ALLOCATION_INFO : public D3D12_RESOURCE_ALLOCATION_INFO
386{
387 CD3DX12_RESOURCE_ALLOCATION_INFO() = default;
388 explicit CD3DX12_RESOURCE_ALLOCATION_INFO( const D3D12_RESOURCE_ALLOCATION_INFO& o ) noexcept :
389 D3D12_RESOURCE_ALLOCATION_INFO( o )
390 {}
391 CD3DX12_RESOURCE_ALLOCATION_INFO(
392 UINT64 size,
393 UINT64 alignment ) noexcept
394 {
395 SizeInBytes = size;
396 Alignment = alignment;
397 }
398};
399
400//------------------------------------------------------------------------------------------------
401struct CD3DX12_HEAP_PROPERTIES : public D3D12_HEAP_PROPERTIES
402{
403 CD3DX12_HEAP_PROPERTIES() = default;
404 explicit CD3DX12_HEAP_PROPERTIES(const D3D12_HEAP_PROPERTIES &o) noexcept :
405 D3D12_HEAP_PROPERTIES(o)
406 {}
407 CD3DX12_HEAP_PROPERTIES(
408 D3D12_CPU_PAGE_PROPERTY cpuPageProperty,
409 D3D12_MEMORY_POOL memoryPoolPreference,
410 UINT creationNodeMask = 1,
411 UINT nodeMask = 1 ) noexcept
412 {
413 Type = D3D12_HEAP_TYPE_CUSTOM;
414 CPUPageProperty = cpuPageProperty;
415 MemoryPoolPreference = memoryPoolPreference;
416 CreationNodeMask = creationNodeMask;
417 VisibleNodeMask = nodeMask;
418 }
419 explicit CD3DX12_HEAP_PROPERTIES(
420 D3D12_HEAP_TYPE type,
421 UINT creationNodeMask = 1,
422 UINT nodeMask = 1 ) noexcept
423 {
424 Type = type;
425 CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
426 MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
427 CreationNodeMask = creationNodeMask;
428 VisibleNodeMask = nodeMask;
429 }
430 bool IsCPUAccessible() const noexcept
431 {
432 return Type == D3D12_HEAP_TYPE_UPLOAD || Type == D3D12_HEAP_TYPE_READBACK || (Type == D3D12_HEAP_TYPE_CUSTOM &&
433 (CPUPageProperty == D3D12_CPU_PAGE_PROPERTY_WRITE_COMBINE || CPUPageProperty == D3D12_CPU_PAGE_PROPERTY_WRITE_BACK));
434 }
435};
436inline bool operator==( const D3D12_HEAP_PROPERTIES& l, const D3D12_HEAP_PROPERTIES& r ) noexcept
437{
438 return l.Type == r.Type && l.CPUPageProperty == r.CPUPageProperty &&
439 l.MemoryPoolPreference == r.MemoryPoolPreference &&
440 l.CreationNodeMask == r.CreationNodeMask &&
441 l.VisibleNodeMask == r.VisibleNodeMask;
442}
443inline bool operator!=( const D3D12_HEAP_PROPERTIES& l, const D3D12_HEAP_PROPERTIES& r ) noexcept
444{ return !( l == r ); }
445
446//------------------------------------------------------------------------------------------------
447struct CD3DX12_HEAP_DESC : public D3D12_HEAP_DESC
448{
449 CD3DX12_HEAP_DESC() = default;
450 explicit CD3DX12_HEAP_DESC(const D3D12_HEAP_DESC &o) noexcept :
451 D3D12_HEAP_DESC(o)
452 {}
453 CD3DX12_HEAP_DESC(
454 UINT64 size,
455 D3D12_HEAP_PROPERTIES properties,
456 UINT64 alignment = 0,
457 D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) noexcept
458 {
459 SizeInBytes = size;
460 Properties = properties;
461 Alignment = alignment;
462 Flags = flags;
463 }
464 CD3DX12_HEAP_DESC(
465 UINT64 size,
466 D3D12_HEAP_TYPE type,
467 UINT64 alignment = 0,
468 D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) noexcept
469 {
470 SizeInBytes = size;
471 Properties = CD3DX12_HEAP_PROPERTIES( type );
472 Alignment = alignment;
473 Flags = flags;
474 }
475 CD3DX12_HEAP_DESC(
476 UINT64 size,
477 D3D12_CPU_PAGE_PROPERTY cpuPageProperty,
478 D3D12_MEMORY_POOL memoryPoolPreference,
479 UINT64 alignment = 0,
480 D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) noexcept
481 {
482 SizeInBytes = size;
483 Properties = CD3DX12_HEAP_PROPERTIES( cpuPageProperty, memoryPoolPreference );
484 Alignment = alignment;
485 Flags = flags;
486 }
487 CD3DX12_HEAP_DESC(
488 const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
489 D3D12_HEAP_PROPERTIES properties,
490 D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) noexcept
491 {
492 SizeInBytes = resAllocInfo.SizeInBytes;
493 Properties = properties;
494 Alignment = resAllocInfo.Alignment;
495 Flags = flags;
496 }
497 CD3DX12_HEAP_DESC(
498 const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
499 D3D12_HEAP_TYPE type,
500 D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) noexcept
501 {
502 SizeInBytes = resAllocInfo.SizeInBytes;
503 Properties = CD3DX12_HEAP_PROPERTIES( type );
504 Alignment = resAllocInfo.Alignment;
505 Flags = flags;
506 }
507 CD3DX12_HEAP_DESC(
508 const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
509 D3D12_CPU_PAGE_PROPERTY cpuPageProperty,
510 D3D12_MEMORY_POOL memoryPoolPreference,
511 D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) noexcept
512 {
513 SizeInBytes = resAllocInfo.SizeInBytes;
514 Properties = CD3DX12_HEAP_PROPERTIES( cpuPageProperty, memoryPoolPreference );
515 Alignment = resAllocInfo.Alignment;
516 Flags = flags;
517 }
518 bool IsCPUAccessible() const noexcept
519 { return static_cast< const CD3DX12_HEAP_PROPERTIES* >( &Properties )->IsCPUAccessible(); }
520};
521inline bool operator==( const D3D12_HEAP_DESC& l, const D3D12_HEAP_DESC& r ) noexcept
522{
523 return l.SizeInBytes == r.SizeInBytes &&
524 l.Properties == r.Properties &&
525 l.Alignment == r.Alignment &&
526 l.Flags == r.Flags;
527}
528inline bool operator!=( const D3D12_HEAP_DESC& l, const D3D12_HEAP_DESC& r ) noexcept
529{ return !( l == r ); }
530
531//------------------------------------------------------------------------------------------------
532struct CD3DX12_CLEAR_VALUE : public D3D12_CLEAR_VALUE
533{
534 CD3DX12_CLEAR_VALUE() = default;
535 explicit CD3DX12_CLEAR_VALUE(const D3D12_CLEAR_VALUE &o) noexcept :
536 D3D12_CLEAR_VALUE(o)
537 {}
538 CD3DX12_CLEAR_VALUE(
539 DXGI_FORMAT format,
540 const FLOAT color[4] ) noexcept
541 {
542 Format = format;
543 memcpy( Color, color, sizeof( Color ) );
544 }
545 CD3DX12_CLEAR_VALUE(
546 DXGI_FORMAT format,
547 FLOAT depth,
548 UINT8 stencil ) noexcept
549 {
550 Format = format;
551 memset( &Color, 0, sizeof( Color ) );
552 /* Use memcpy to preserve NAN values */
553 memcpy( &DepthStencil.Depth, &depth, sizeof( depth ) );
554 DepthStencil.Stencil = stencil;
555 }
556};
557
558//------------------------------------------------------------------------------------------------
559struct CD3DX12_RANGE : public D3D12_RANGE
560{
561 CD3DX12_RANGE() = default;
562 explicit CD3DX12_RANGE(const D3D12_RANGE &o) noexcept :
563 D3D12_RANGE(o)
564 {}
565 CD3DX12_RANGE(
566 SIZE_T begin,
567 SIZE_T end ) noexcept
568 {
569 Begin = begin;
570 End = end;
571 }
572};
573
574//------------------------------------------------------------------------------------------------
575struct CD3DX12_RANGE_UINT64 : public D3D12_RANGE_UINT64
576{
577 CD3DX12_RANGE_UINT64() = default;
578 explicit CD3DX12_RANGE_UINT64(const D3D12_RANGE_UINT64 &o) noexcept :
579 D3D12_RANGE_UINT64(o)
580 {}
581 CD3DX12_RANGE_UINT64(
582 UINT64 begin,
583 UINT64 end ) noexcept
584 {
585 Begin = begin;
586 End = end;
587 }
588};
589
590//------------------------------------------------------------------------------------------------
591struct CD3DX12_SUBRESOURCE_RANGE_UINT64 : public D3D12_SUBRESOURCE_RANGE_UINT64
592{
593 CD3DX12_SUBRESOURCE_RANGE_UINT64() = default;
594 explicit CD3DX12_SUBRESOURCE_RANGE_UINT64(const D3D12_SUBRESOURCE_RANGE_UINT64 &o) noexcept :
595 D3D12_SUBRESOURCE_RANGE_UINT64(o)
596 {}
597 CD3DX12_SUBRESOURCE_RANGE_UINT64(
598 UINT subresource,
599 const D3D12_RANGE_UINT64& range ) noexcept
600 {
601 Subresource = subresource;
602 Range = range;
603 }
604 CD3DX12_SUBRESOURCE_RANGE_UINT64(
605 UINT subresource,
606 UINT64 begin,
607 UINT64 end ) noexcept
608 {
609 Subresource = subresource;
610 Range.Begin = begin;
611 Range.End = end;
612 }
613};
614
615//------------------------------------------------------------------------------------------------
616struct CD3DX12_SHADER_BYTECODE : public D3D12_SHADER_BYTECODE
617{
618 CD3DX12_SHADER_BYTECODE() = default;
619 explicit CD3DX12_SHADER_BYTECODE(const D3D12_SHADER_BYTECODE &o) noexcept :
620 D3D12_SHADER_BYTECODE(o)
621 {}
622 CD3DX12_SHADER_BYTECODE(
623 _In_ ID3DBlob* pShaderBlob ) noexcept
624 {
625 pShaderBytecode = pShaderBlob->GetBufferPointer();
626 BytecodeLength = pShaderBlob->GetBufferSize();
627 }
628 CD3DX12_SHADER_BYTECODE(
629 const void* _pShaderBytecode,
630 SIZE_T bytecodeLength ) noexcept
631 {
632 pShaderBytecode = _pShaderBytecode;
633 BytecodeLength = bytecodeLength;
634 }
635};
636
637//------------------------------------------------------------------------------------------------
638struct CD3DX12_TILED_RESOURCE_COORDINATE : public D3D12_TILED_RESOURCE_COORDINATE
639{
640 CD3DX12_TILED_RESOURCE_COORDINATE() = default;
641 explicit CD3DX12_TILED_RESOURCE_COORDINATE(const D3D12_TILED_RESOURCE_COORDINATE &o) noexcept :
642 D3D12_TILED_RESOURCE_COORDINATE(o)
643 {}
644 CD3DX12_TILED_RESOURCE_COORDINATE(
645 UINT x,
646 UINT y,
647 UINT z,
648 UINT subresource ) noexcept
649 {
650 X = x;
651 Y = y;
652 Z = z;
653 Subresource = subresource;
654 }
655};
656
657//------------------------------------------------------------------------------------------------
658struct CD3DX12_TILE_REGION_SIZE : public D3D12_TILE_REGION_SIZE
659{
660 CD3DX12_TILE_REGION_SIZE() = default;
661 explicit CD3DX12_TILE_REGION_SIZE(const D3D12_TILE_REGION_SIZE &o) noexcept :
662 D3D12_TILE_REGION_SIZE(o)
663 {}
664 CD3DX12_TILE_REGION_SIZE(
665 UINT numTiles,
666 BOOL useBox,
667 UINT width,
668 UINT16 height,
669 UINT16 depth ) noexcept
670 {
671 NumTiles = numTiles;
672 UseBox = useBox;
673 Width = width;
674 Height = height;
675 Depth = depth;
676 }
677};
678
679//------------------------------------------------------------------------------------------------
680struct CD3DX12_SUBRESOURCE_TILING : public D3D12_SUBRESOURCE_TILING
681{
682 CD3DX12_SUBRESOURCE_TILING() = default;
683 explicit CD3DX12_SUBRESOURCE_TILING(const D3D12_SUBRESOURCE_TILING &o) noexcept :
684 D3D12_SUBRESOURCE_TILING(o)
685 {}
686 CD3DX12_SUBRESOURCE_TILING(
687 UINT widthInTiles,
688 UINT16 heightInTiles,
689 UINT16 depthInTiles,
690 UINT startTileIndexInOverallResource ) noexcept
691 {
692 WidthInTiles = widthInTiles;
693 HeightInTiles = heightInTiles;
694 DepthInTiles = depthInTiles;
695 StartTileIndexInOverallResource = startTileIndexInOverallResource;
696 }
697};
698
699//------------------------------------------------------------------------------------------------
700struct CD3DX12_TILE_SHAPE : public D3D12_TILE_SHAPE
701{
702 CD3DX12_TILE_SHAPE() = default;
703 explicit CD3DX12_TILE_SHAPE(const D3D12_TILE_SHAPE &o) noexcept :
704 D3D12_TILE_SHAPE(o)
705 {}
706 CD3DX12_TILE_SHAPE(
707 UINT widthInTexels,
708 UINT heightInTexels,
709 UINT depthInTexels ) noexcept
710 {
711 WidthInTexels = widthInTexels;
712 HeightInTexels = heightInTexels;
713 DepthInTexels = depthInTexels;
714 }
715};
716
717//------------------------------------------------------------------------------------------------
718struct CD3DX12_RESOURCE_BARRIER : public D3D12_RESOURCE_BARRIER
719{
720 CD3DX12_RESOURCE_BARRIER() = default;
721 explicit CD3DX12_RESOURCE_BARRIER(const D3D12_RESOURCE_BARRIER &o) noexcept :
722 D3D12_RESOURCE_BARRIER(o)
723 {}
724 static inline CD3DX12_RESOURCE_BARRIER Transition(
725 _In_ ID3D12Resource* pResource,
726 D3D12_RESOURCE_STATES stateBefore,
727 D3D12_RESOURCE_STATES stateAfter,
728 UINT subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES,
729 D3D12_RESOURCE_BARRIER_FLAGS flags = D3D12_RESOURCE_BARRIER_FLAG_NONE) noexcept
730 {
731 CD3DX12_RESOURCE_BARRIER result = {};
732 D3D12_RESOURCE_BARRIER &barrier = result;
733 result.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
734 result.Flags = flags;
735 barrier.Transition.pResource = pResource;
736 barrier.Transition.StateBefore = stateBefore;
737 barrier.Transition.StateAfter = stateAfter;
738 barrier.Transition.Subresource = subresource;
739 return result;
740 }
741 static inline CD3DX12_RESOURCE_BARRIER Aliasing(
742 _In_ ID3D12Resource* pResourceBefore,
743 _In_ ID3D12Resource* pResourceAfter) noexcept
744 {
745 CD3DX12_RESOURCE_BARRIER result = {};
746 D3D12_RESOURCE_BARRIER &barrier = result;
747 result.Type = D3D12_RESOURCE_BARRIER_TYPE_ALIASING;
748 barrier.Aliasing.pResourceBefore = pResourceBefore;
749 barrier.Aliasing.pResourceAfter = pResourceAfter;
750 return result;
751 }
752 static inline CD3DX12_RESOURCE_BARRIER UAV(
753 _In_ ID3D12Resource* pResource) noexcept
754 {
755 CD3DX12_RESOURCE_BARRIER result = {};
756 D3D12_RESOURCE_BARRIER &barrier = result;
757 result.Type = D3D12_RESOURCE_BARRIER_TYPE_UAV;
758 barrier.UAV.pResource = pResource;
759 return result;
760 }
761};
762
763//------------------------------------------------------------------------------------------------
764struct CD3DX12_PACKED_MIP_INFO : public D3D12_PACKED_MIP_INFO
765{
766 CD3DX12_PACKED_MIP_INFO() = default;
767 explicit CD3DX12_PACKED_MIP_INFO(const D3D12_PACKED_MIP_INFO &o) noexcept :
768 D3D12_PACKED_MIP_INFO(o)
769 {}
770 CD3DX12_PACKED_MIP_INFO(
771 UINT8 numStandardMips,
772 UINT8 numPackedMips,
773 UINT numTilesForPackedMips,
774 UINT startTileIndexInOverallResource ) noexcept
775 {
776 NumStandardMips = numStandardMips;
777 NumPackedMips = numPackedMips;
778 NumTilesForPackedMips = numTilesForPackedMips;
779 StartTileIndexInOverallResource = startTileIndexInOverallResource;
780 }
781};
782
783//------------------------------------------------------------------------------------------------
784struct CD3DX12_SUBRESOURCE_FOOTPRINT : public D3D12_SUBRESOURCE_FOOTPRINT
785{
786 CD3DX12_SUBRESOURCE_FOOTPRINT() = default;
787 explicit CD3DX12_SUBRESOURCE_FOOTPRINT(const D3D12_SUBRESOURCE_FOOTPRINT &o) noexcept :
788 D3D12_SUBRESOURCE_FOOTPRINT(o)
789 {}
790 CD3DX12_SUBRESOURCE_FOOTPRINT(
791 DXGI_FORMAT format,
792 UINT width,
793 UINT height,
794 UINT depth,
795 UINT rowPitch ) noexcept
796 {
797 Format = format;
798 Width = width;
799 Height = height;
800 Depth = depth;
801 RowPitch = rowPitch;
802 }
803 explicit CD3DX12_SUBRESOURCE_FOOTPRINT(
804 const D3D12_RESOURCE_DESC& resDesc,
805 UINT rowPitch ) noexcept
806 {
807 Format = resDesc.Format;
808 Width = UINT( resDesc.Width );
809 Height = resDesc.Height;
810 Depth = (resDesc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? resDesc.DepthOrArraySize : 1);
811 RowPitch = rowPitch;
812 }
813};
814
815//------------------------------------------------------------------------------------------------
816struct CD3DX12_TEXTURE_COPY_LOCATION : public D3D12_TEXTURE_COPY_LOCATION
817{
818 CD3DX12_TEXTURE_COPY_LOCATION() = default;
819 explicit CD3DX12_TEXTURE_COPY_LOCATION(const D3D12_TEXTURE_COPY_LOCATION &o) noexcept :
820 D3D12_TEXTURE_COPY_LOCATION(o)
821 {}
822 CD3DX12_TEXTURE_COPY_LOCATION(_In_ ID3D12Resource* pRes) noexcept
823 {
824 pResource = pRes;
825 Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
826 PlacedFootprint = {};
827 }
828 CD3DX12_TEXTURE_COPY_LOCATION(_In_ ID3D12Resource* pRes, D3D12_PLACED_SUBRESOURCE_FOOTPRINT const& Footprint) noexcept
829 {
830 pResource = pRes;
831 Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
832 PlacedFootprint = Footprint;
833 }
834 CD3DX12_TEXTURE_COPY_LOCATION(_In_ ID3D12Resource* pRes, UINT Sub) noexcept
835 {
836 pResource = pRes;
837 Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
838 PlacedFootprint = {};
839 SubresourceIndex = Sub;
840 }
841};
842
843//------------------------------------------------------------------------------------------------
844struct CD3DX12_DESCRIPTOR_RANGE : public D3D12_DESCRIPTOR_RANGE
845{
846 CD3DX12_DESCRIPTOR_RANGE() = default;
847 explicit CD3DX12_DESCRIPTOR_RANGE(const D3D12_DESCRIPTOR_RANGE &o) noexcept :
848 D3D12_DESCRIPTOR_RANGE(o)
849 {}
850 CD3DX12_DESCRIPTOR_RANGE(
851 D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
852 UINT numDescriptors,
853 UINT baseShaderRegister,
854 UINT registerSpace = 0,
855 UINT offsetInDescriptorsFromTableStart =
856 D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) noexcept
857 {
858 Init(rangeType, numDescriptors, baseShaderRegister, registerSpace, offsetInDescriptorsFromTableStart);
859 }
860
861 inline void Init(
862 D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
863 UINT numDescriptors,
864 UINT baseShaderRegister,
865 UINT registerSpace = 0,
866 UINT offsetInDescriptorsFromTableStart =
867 D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) noexcept
868 {
869 Init(*this, rangeType, numDescriptors, baseShaderRegister, registerSpace, offsetInDescriptorsFromTableStart);
870 }
871
872 static inline void Init(
873 _Out_ D3D12_DESCRIPTOR_RANGE &range,
874 D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
875 UINT numDescriptors,
876 UINT baseShaderRegister,
877 UINT registerSpace = 0,
878 UINT offsetInDescriptorsFromTableStart =
879 D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) noexcept
880 {
881 range.RangeType = rangeType;
882 range.NumDescriptors = numDescriptors;
883 range.BaseShaderRegister = baseShaderRegister;
884 range.RegisterSpace = registerSpace;
885 range.OffsetInDescriptorsFromTableStart = offsetInDescriptorsFromTableStart;
886 }
887};
888
889//------------------------------------------------------------------------------------------------
890struct CD3DX12_ROOT_DESCRIPTOR_TABLE : public D3D12_ROOT_DESCRIPTOR_TABLE
891{
892 CD3DX12_ROOT_DESCRIPTOR_TABLE() = default;
893 explicit CD3DX12_ROOT_DESCRIPTOR_TABLE(const D3D12_ROOT_DESCRIPTOR_TABLE &o) noexcept :
894 D3D12_ROOT_DESCRIPTOR_TABLE(o)
895 {}
896 CD3DX12_ROOT_DESCRIPTOR_TABLE(
897 UINT numDescriptorRanges,
898 _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges) noexcept
899 {
900 Init(numDescriptorRanges, _pDescriptorRanges);
901 }
902
903 inline void Init(
904 UINT numDescriptorRanges,
905 _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges) noexcept
906 {
907 Init(*this, numDescriptorRanges, _pDescriptorRanges);
908 }
909
910 static inline void Init(
911 _Out_ D3D12_ROOT_DESCRIPTOR_TABLE &rootDescriptorTable,
912 UINT numDescriptorRanges,
913 _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges) noexcept
914 {
915 rootDescriptorTable.NumDescriptorRanges = numDescriptorRanges;
916 rootDescriptorTable.pDescriptorRanges = _pDescriptorRanges;
917 }
918};
919
920//------------------------------------------------------------------------------------------------
921struct CD3DX12_ROOT_CONSTANTS : public D3D12_ROOT_CONSTANTS
922{
923 CD3DX12_ROOT_CONSTANTS() = default;
924 explicit CD3DX12_ROOT_CONSTANTS(const D3D12_ROOT_CONSTANTS &o) noexcept :
925 D3D12_ROOT_CONSTANTS(o)
926 {}
927 CD3DX12_ROOT_CONSTANTS(
928 UINT num32BitValues,
929 UINT shaderRegister,
930 UINT registerSpace = 0) noexcept
931 {
932 Init(num32BitValues, shaderRegister, registerSpace);
933 }
934
935 inline void Init(
936 UINT num32BitValues,
937 UINT shaderRegister,
938 UINT registerSpace = 0) noexcept
939 {
940 Init(*this, num32BitValues, shaderRegister, registerSpace);
941 }
942
943 static inline void Init(
944 _Out_ D3D12_ROOT_CONSTANTS &rootConstants,
945 UINT num32BitValues,
946 UINT shaderRegister,
947 UINT registerSpace = 0) noexcept
948 {
949 rootConstants.Num32BitValues = num32BitValues;
950 rootConstants.ShaderRegister = shaderRegister;
951 rootConstants.RegisterSpace = registerSpace;
952 }
953};
954
955//------------------------------------------------------------------------------------------------
956struct CD3DX12_ROOT_DESCRIPTOR : public D3D12_ROOT_DESCRIPTOR
957{
958 CD3DX12_ROOT_DESCRIPTOR() = default;
959 explicit CD3DX12_ROOT_DESCRIPTOR(const D3D12_ROOT_DESCRIPTOR &o) noexcept :
960 D3D12_ROOT_DESCRIPTOR(o)
961 {}
962 CD3DX12_ROOT_DESCRIPTOR(
963 UINT shaderRegister,
964 UINT registerSpace = 0) noexcept
965 {
966 Init(shaderRegister, registerSpace);
967 }
968
969 inline void Init(
970 UINT shaderRegister,
971 UINT registerSpace = 0) noexcept
972 {
973 Init(*this, shaderRegister, registerSpace);
974 }
975
976 static inline void Init(_Out_ D3D12_ROOT_DESCRIPTOR &table, UINT shaderRegister, UINT registerSpace = 0) noexcept
977 {
978 table.ShaderRegister = shaderRegister;
979 table.RegisterSpace = registerSpace;
980 }
981};
982
983//------------------------------------------------------------------------------------------------
984struct CD3DX12_ROOT_PARAMETER : public D3D12_ROOT_PARAMETER
985{
986 CD3DX12_ROOT_PARAMETER() = default;
987 explicit CD3DX12_ROOT_PARAMETER(const D3D12_ROOT_PARAMETER &o) noexcept :
988 D3D12_ROOT_PARAMETER(o)
989 {}
990
991 static inline void InitAsDescriptorTable(
992 _Out_ D3D12_ROOT_PARAMETER &rootParam,
993 UINT numDescriptorRanges,
994 _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* pDescriptorRanges,
995 D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
996 {
997 rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
998 rootParam.ShaderVisibility = visibility;
999 CD3DX12_ROOT_DESCRIPTOR_TABLE::Init(rootParam.DescriptorTable, numDescriptorRanges, pDescriptorRanges);
1000 }
1001
1002 static inline void InitAsConstants(
1003 _Out_ D3D12_ROOT_PARAMETER &rootParam,
1004 UINT num32BitValues,
1005 UINT shaderRegister,
1006 UINT registerSpace = 0,
1007 D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
1008 {
1009 rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS;
1010 rootParam.ShaderVisibility = visibility;
1011 CD3DX12_ROOT_CONSTANTS::Init(rootParam.Constants, num32BitValues, shaderRegister, registerSpace);
1012 }
1013
1014 static inline void InitAsConstantBufferView(
1015 _Out_ D3D12_ROOT_PARAMETER &rootParam,
1016 UINT shaderRegister,
1017 UINT registerSpace = 0,
1018 D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
1019 {
1020 rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
1021 rootParam.ShaderVisibility = visibility;
1022 CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister, registerSpace);
1023 }
1024
1025 static inline void InitAsShaderResourceView(
1026 _Out_ D3D12_ROOT_PARAMETER &rootParam,
1027 UINT shaderRegister,
1028 UINT registerSpace = 0,
1029 D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
1030 {
1031 rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_SRV;
1032 rootParam.ShaderVisibility = visibility;
1033 CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister, registerSpace);
1034 }
1035
1036 static inline void InitAsUnorderedAccessView(
1037 _Out_ D3D12_ROOT_PARAMETER &rootParam,
1038 UINT shaderRegister,
1039 UINT registerSpace = 0,
1040 D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
1041 {
1042 rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_UAV;
1043 rootParam.ShaderVisibility = visibility;
1044 CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister, registerSpace);
1045 }
1046
1047 inline void InitAsDescriptorTable(
1048 UINT numDescriptorRanges,
1049 _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* pDescriptorRanges,
1050 D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
1051 {
1052 InitAsDescriptorTable(*this, numDescriptorRanges, pDescriptorRanges, visibility);
1053 }
1054
1055 inline void InitAsConstants(
1056 UINT num32BitValues,
1057 UINT shaderRegister,
1058 UINT registerSpace = 0,
1059 D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
1060 {
1061 InitAsConstants(*this, num32BitValues, shaderRegister, registerSpace, visibility);
1062 }
1063
1064 inline void InitAsConstantBufferView(
1065 UINT shaderRegister,
1066 UINT registerSpace = 0,
1067 D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
1068 {
1069 InitAsConstantBufferView(*this, shaderRegister, registerSpace, visibility);
1070 }
1071
1072 inline void InitAsShaderResourceView(
1073 UINT shaderRegister,
1074 UINT registerSpace = 0,
1075 D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
1076 {
1077 InitAsShaderResourceView(*this, shaderRegister, registerSpace, visibility);
1078 }
1079
1080 inline void InitAsUnorderedAccessView(
1081 UINT shaderRegister,
1082 UINT registerSpace = 0,
1083 D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
1084 {
1085 InitAsUnorderedAccessView(*this, shaderRegister, registerSpace, visibility);
1086 }
1087};
1088
1089//------------------------------------------------------------------------------------------------
1090struct CD3DX12_STATIC_SAMPLER_DESC : public D3D12_STATIC_SAMPLER_DESC
1091{
1092 CD3DX12_STATIC_SAMPLER_DESC() = default;
1093 explicit CD3DX12_STATIC_SAMPLER_DESC(const D3D12_STATIC_SAMPLER_DESC &o) noexcept :
1094 D3D12_STATIC_SAMPLER_DESC(o)
1095 {}
1096 CD3DX12_STATIC_SAMPLER_DESC(
1097 UINT shaderRegister,
1098 D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC,
1099 D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
1100 D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
1101 D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
1102 FLOAT mipLODBias = 0,
1103 UINT maxAnisotropy = 16,
1104 D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL,
1105 D3D12_STATIC_BORDER_COLOR borderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE,
1106 FLOAT minLOD = 0.f,
1107 FLOAT maxLOD = D3D12_FLOAT32_MAX,
1108 D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL,
1109 UINT registerSpace = 0) noexcept
1110 {
1111 Init(
1112 shaderRegister,
1113 filter,
1114 addressU,
1115 addressV,
1116 addressW,
1117 mipLODBias,
1118 maxAnisotropy,
1119 comparisonFunc,
1120 borderColor,
1121 minLOD,
1122 maxLOD,
1123 shaderVisibility,
1124 registerSpace);
1125 }
1126
1127 static inline void Init(
1128 _Out_ D3D12_STATIC_SAMPLER_DESC &samplerDesc,
1129 UINT shaderRegister,
1130 D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC,
1131 D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
1132 D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
1133 D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
1134 FLOAT mipLODBias = 0,
1135 UINT maxAnisotropy = 16,
1136 D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL,
1137 D3D12_STATIC_BORDER_COLOR borderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE,
1138 FLOAT minLOD = 0.f,
1139 FLOAT maxLOD = D3D12_FLOAT32_MAX,
1140 D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL,
1141 UINT registerSpace = 0) noexcept
1142 {
1143 samplerDesc.ShaderRegister = shaderRegister;
1144 samplerDesc.Filter = filter;
1145 samplerDesc.AddressU = addressU;
1146 samplerDesc.AddressV = addressV;
1147 samplerDesc.AddressW = addressW;
1148 samplerDesc.MipLODBias = mipLODBias;
1149 samplerDesc.MaxAnisotropy = maxAnisotropy;
1150 samplerDesc.ComparisonFunc = comparisonFunc;
1151 samplerDesc.BorderColor = borderColor;
1152 samplerDesc.MinLOD = minLOD;
1153 samplerDesc.MaxLOD = maxLOD;
1154 samplerDesc.ShaderVisibility = shaderVisibility;
1155 samplerDesc.RegisterSpace = registerSpace;
1156 }
1157 inline void Init(
1158 UINT shaderRegister,
1159 D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC,
1160 D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
1161 D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
1162 D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
1163 FLOAT mipLODBias = 0,
1164 UINT maxAnisotropy = 16,
1165 D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL,
1166 D3D12_STATIC_BORDER_COLOR borderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE,
1167 FLOAT minLOD = 0.f,
1168 FLOAT maxLOD = D3D12_FLOAT32_MAX,
1169 D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL,
1170 UINT registerSpace = 0) noexcept
1171 {
1172 Init(
1173 *this,
1174 shaderRegister,
1175 filter,
1176 addressU,
1177 addressV,
1178 addressW,
1179 mipLODBias,
1180 maxAnisotropy,
1181 comparisonFunc,
1182 borderColor,
1183 minLOD,
1184 maxLOD,
1185 shaderVisibility,
1186 registerSpace);
1187 }
1188
1189};
1190
1191//------------------------------------------------------------------------------------------------
1192struct CD3DX12_ROOT_SIGNATURE_DESC : public D3D12_ROOT_SIGNATURE_DESC
1193{
1194 CD3DX12_ROOT_SIGNATURE_DESC() = default;
1195 explicit CD3DX12_ROOT_SIGNATURE_DESC(const D3D12_ROOT_SIGNATURE_DESC &o) noexcept :
1196 D3D12_ROOT_SIGNATURE_DESC(o)
1197 {}
1198 CD3DX12_ROOT_SIGNATURE_DESC(
1199 UINT numParameters,
1200 _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
1201 UINT numStaticSamplers = 0,
1202 _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
1203 D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
1204 {
1205 Init(numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
1206 }
1207 CD3DX12_ROOT_SIGNATURE_DESC(CD3DX12_DEFAULT) noexcept
1208 {
1209 Init(0, nullptr, 0, nullptr, D3D12_ROOT_SIGNATURE_FLAG_NONE);
1210 }
1211
1212 inline void Init(
1213 UINT numParameters,
1214 _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
1215 UINT numStaticSamplers = 0,
1216 _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
1217 D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
1218 {
1219 Init(*this, numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
1220 }
1221
1222 static inline void Init(
1223 _Out_ D3D12_ROOT_SIGNATURE_DESC &desc,
1224 UINT numParameters,
1225 _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
1226 UINT numStaticSamplers = 0,
1227 _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
1228 D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
1229 {
1230 desc.NumParameters = numParameters;
1231 desc.pParameters = _pParameters;
1232 desc.NumStaticSamplers = numStaticSamplers;
1233 desc.pStaticSamplers = _pStaticSamplers;
1234 desc.Flags = flags;
1235 }
1236};
1237
1238//------------------------------------------------------------------------------------------------
1239struct CD3DX12_DESCRIPTOR_RANGE1 : public D3D12_DESCRIPTOR_RANGE1
1240{
1241 CD3DX12_DESCRIPTOR_RANGE1() = default;
1242 explicit CD3DX12_DESCRIPTOR_RANGE1(const D3D12_DESCRIPTOR_RANGE1 &o) noexcept :
1243 D3D12_DESCRIPTOR_RANGE1(o)
1244 {}
1245 CD3DX12_DESCRIPTOR_RANGE1(
1246 D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
1247 UINT numDescriptors,
1248 UINT baseShaderRegister,
1249 UINT registerSpace = 0,
1250 D3D12_DESCRIPTOR_RANGE_FLAGS flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE,
1251 UINT offsetInDescriptorsFromTableStart =
1252 D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) noexcept
1253 {
1254 Init(rangeType, numDescriptors, baseShaderRegister, registerSpace, flags, offsetInDescriptorsFromTableStart);
1255 }
1256
1257 inline void Init(
1258 D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
1259 UINT numDescriptors,
1260 UINT baseShaderRegister,
1261 UINT registerSpace = 0,
1262 D3D12_DESCRIPTOR_RANGE_FLAGS flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE,
1263 UINT offsetInDescriptorsFromTableStart =
1264 D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) noexcept
1265 {
1266 Init(*this, rangeType, numDescriptors, baseShaderRegister, registerSpace, flags, offsetInDescriptorsFromTableStart);
1267 }
1268
1269 static inline void Init(
1270 _Out_ D3D12_DESCRIPTOR_RANGE1 &range,
1271 D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
1272 UINT numDescriptors,
1273 UINT baseShaderRegister,
1274 UINT registerSpace = 0,
1275 D3D12_DESCRIPTOR_RANGE_FLAGS flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE,
1276 UINT offsetInDescriptorsFromTableStart =
1277 D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) noexcept
1278 {
1279 range.RangeType = rangeType;
1280 range.NumDescriptors = numDescriptors;
1281 range.BaseShaderRegister = baseShaderRegister;
1282 range.RegisterSpace = registerSpace;
1283 range.Flags = flags;
1284 range.OffsetInDescriptorsFromTableStart = offsetInDescriptorsFromTableStart;
1285 }
1286};
1287
1288//------------------------------------------------------------------------------------------------
1289struct CD3DX12_ROOT_DESCRIPTOR_TABLE1 : public D3D12_ROOT_DESCRIPTOR_TABLE1
1290{
1291 CD3DX12_ROOT_DESCRIPTOR_TABLE1() = default;
1292 explicit CD3DX12_ROOT_DESCRIPTOR_TABLE1(const D3D12_ROOT_DESCRIPTOR_TABLE1 &o) noexcept :
1293 D3D12_ROOT_DESCRIPTOR_TABLE1(o)
1294 {}
1295 CD3DX12_ROOT_DESCRIPTOR_TABLE1(
1296 UINT numDescriptorRanges,
1297 _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* _pDescriptorRanges) noexcept
1298 {
1299 Init(numDescriptorRanges, _pDescriptorRanges);
1300 }
1301
1302 inline void Init(
1303 UINT numDescriptorRanges,
1304 _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* _pDescriptorRanges) noexcept
1305 {
1306 Init(*this, numDescriptorRanges, _pDescriptorRanges);
1307 }
1308
1309 static inline void Init(
1310 _Out_ D3D12_ROOT_DESCRIPTOR_TABLE1 &rootDescriptorTable,
1311 UINT numDescriptorRanges,
1312 _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* _pDescriptorRanges) noexcept
1313 {
1314 rootDescriptorTable.NumDescriptorRanges = numDescriptorRanges;
1315 rootDescriptorTable.pDescriptorRanges = _pDescriptorRanges;
1316 }
1317};
1318
1319//------------------------------------------------------------------------------------------------
1320struct CD3DX12_ROOT_DESCRIPTOR1 : public D3D12_ROOT_DESCRIPTOR1
1321{
1322 CD3DX12_ROOT_DESCRIPTOR1() = default;
1323 explicit CD3DX12_ROOT_DESCRIPTOR1(const D3D12_ROOT_DESCRIPTOR1 &o) noexcept :
1324 D3D12_ROOT_DESCRIPTOR1(o)
1325 {}
1326 CD3DX12_ROOT_DESCRIPTOR1(
1327 UINT shaderRegister,
1328 UINT registerSpace = 0,
1329 D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE) noexcept
1330 {
1331 Init(shaderRegister, registerSpace, flags);
1332 }
1333
1334 inline void Init(
1335 UINT shaderRegister,
1336 UINT registerSpace = 0,
1337 D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE) noexcept
1338 {
1339 Init(*this, shaderRegister, registerSpace, flags);
1340 }
1341
1342 static inline void Init(
1343 _Out_ D3D12_ROOT_DESCRIPTOR1 &table,
1344 UINT shaderRegister,
1345 UINT registerSpace = 0,
1346 D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE) noexcept
1347 {
1348 table.ShaderRegister = shaderRegister;
1349 table.RegisterSpace = registerSpace;
1350 table.Flags = flags;
1351 }
1352};
1353
1354//------------------------------------------------------------------------------------------------
1355struct CD3DX12_ROOT_PARAMETER1 : public D3D12_ROOT_PARAMETER1
1356{
1357 CD3DX12_ROOT_PARAMETER1() = default;
1358 explicit CD3DX12_ROOT_PARAMETER1(const D3D12_ROOT_PARAMETER1 &o) noexcept :
1359 D3D12_ROOT_PARAMETER1(o)
1360 {}
1361
1362 static inline void InitAsDescriptorTable(
1363 _Out_ D3D12_ROOT_PARAMETER1 &rootParam,
1364 UINT numDescriptorRanges,
1365 _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* pDescriptorRanges,
1366 D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
1367 {
1368 rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
1369 rootParam.ShaderVisibility = visibility;
1370 CD3DX12_ROOT_DESCRIPTOR_TABLE1::Init(rootParam.DescriptorTable, numDescriptorRanges, pDescriptorRanges);
1371 }
1372
1373 static inline void InitAsConstants(
1374 _Out_ D3D12_ROOT_PARAMETER1 &rootParam,
1375 UINT num32BitValues,
1376 UINT shaderRegister,
1377 UINT registerSpace = 0,
1378 D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
1379 {
1380 rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS;
1381 rootParam.ShaderVisibility = visibility;
1382 CD3DX12_ROOT_CONSTANTS::Init(rootParam.Constants, num32BitValues, shaderRegister, registerSpace);
1383 }
1384
1385 static inline void InitAsConstantBufferView(
1386 _Out_ D3D12_ROOT_PARAMETER1 &rootParam,
1387 UINT shaderRegister,
1388 UINT registerSpace = 0,
1389 D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
1390 D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
1391 {
1392 rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
1393 rootParam.ShaderVisibility = visibility;
1394 CD3DX12_ROOT_DESCRIPTOR1::Init(rootParam.Descriptor, shaderRegister, registerSpace, flags);
1395 }
1396
1397 static inline void InitAsShaderResourceView(
1398 _Out_ D3D12_ROOT_PARAMETER1 &rootParam,
1399 UINT shaderRegister,
1400 UINT registerSpace = 0,
1401 D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
1402 D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
1403 {
1404 rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_SRV;
1405 rootParam.ShaderVisibility = visibility;
1406 CD3DX12_ROOT_DESCRIPTOR1::Init(rootParam.Descriptor, shaderRegister, registerSpace, flags);
1407 }
1408
1409 static inline void InitAsUnorderedAccessView(
1410 _Out_ D3D12_ROOT_PARAMETER1 &rootParam,
1411 UINT shaderRegister,
1412 UINT registerSpace = 0,
1413 D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
1414 D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
1415 {
1416 rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_UAV;
1417 rootParam.ShaderVisibility = visibility;
1418 CD3DX12_ROOT_DESCRIPTOR1::Init(rootParam.Descriptor, shaderRegister, registerSpace, flags);
1419 }
1420
1421 inline void InitAsDescriptorTable(
1422 UINT numDescriptorRanges,
1423 _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* pDescriptorRanges,
1424 D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
1425 {
1426 InitAsDescriptorTable(*this, numDescriptorRanges, pDescriptorRanges, visibility);
1427 }
1428
1429 inline void InitAsConstants(
1430 UINT num32BitValues,
1431 UINT shaderRegister,
1432 UINT registerSpace = 0,
1433 D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
1434 {
1435 InitAsConstants(*this, num32BitValues, shaderRegister, registerSpace, visibility);
1436 }
1437
1438 inline void InitAsConstantBufferView(
1439 UINT shaderRegister,
1440 UINT registerSpace = 0,
1441 D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
1442 D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
1443 {
1444 InitAsConstantBufferView(*this, shaderRegister, registerSpace, flags, visibility);
1445 }
1446
1447 inline void InitAsShaderResourceView(
1448 UINT shaderRegister,
1449 UINT registerSpace = 0,
1450 D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
1451 D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
1452 {
1453 InitAsShaderResourceView(*this, shaderRegister, registerSpace, flags, visibility);
1454 }
1455
1456 inline void InitAsUnorderedAccessView(
1457 UINT shaderRegister,
1458 UINT registerSpace = 0,
1459 D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
1460 D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) noexcept
1461 {
1462 InitAsUnorderedAccessView(*this, shaderRegister, registerSpace, flags, visibility);
1463 }
1464};
1465
1466//------------------------------------------------------------------------------------------------
1467struct CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC : public D3D12_VERSIONED_ROOT_SIGNATURE_DESC
1468{
1469 CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC() = default;
1470 explicit CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC &o) noexcept :
1471 D3D12_VERSIONED_ROOT_SIGNATURE_DESC(o)
1472 {}
1473 explicit CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(const D3D12_ROOT_SIGNATURE_DESC &o) noexcept
1474 {
1475 Version = D3D_ROOT_SIGNATURE_VERSION_1_0;
1476 Desc_1_0 = o;
1477 }
1478 explicit CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(const D3D12_ROOT_SIGNATURE_DESC1 &o) noexcept
1479 {
1480 Version = D3D_ROOT_SIGNATURE_VERSION_1_1;
1481 Desc_1_1 = o;
1482 }
1483 CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(
1484 UINT numParameters,
1485 _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
1486 UINT numStaticSamplers = 0,
1487 _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
1488 D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
1489 {
1490 Init_1_0(numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
1491 }
1492 CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(
1493 UINT numParameters,
1494 _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER1* _pParameters,
1495 UINT numStaticSamplers = 0,
1496 _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
1497 D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
1498 {
1499 Init_1_1(numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
1500 }
1501 CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(CD3DX12_DEFAULT) noexcept
1502 {
1503 Init_1_1(0, nullptr, 0, nullptr, D3D12_ROOT_SIGNATURE_FLAG_NONE);
1504 }
1505
1506 inline void Init_1_0(
1507 UINT numParameters,
1508 _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
1509 UINT numStaticSamplers = 0,
1510 _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
1511 D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
1512 {
1513 Init_1_0(*this, numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
1514 }
1515
1516 static inline void Init_1_0(
1517 _Out_ D3D12_VERSIONED_ROOT_SIGNATURE_DESC &desc,
1518 UINT numParameters,
1519 _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
1520 UINT numStaticSamplers = 0,
1521 _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
1522 D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
1523 {
1524 desc.Version = D3D_ROOT_SIGNATURE_VERSION_1_0;
1525 desc.Desc_1_0.NumParameters = numParameters;
1526 desc.Desc_1_0.pParameters = _pParameters;
1527 desc.Desc_1_0.NumStaticSamplers = numStaticSamplers;
1528 desc.Desc_1_0.pStaticSamplers = _pStaticSamplers;
1529 desc.Desc_1_0.Flags = flags;
1530 }
1531
1532 inline void Init_1_1(
1533 UINT numParameters,
1534 _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER1* _pParameters,
1535 UINT numStaticSamplers = 0,
1536 _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
1537 D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
1538 {
1539 Init_1_1(*this, numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
1540 }
1541
1542 static inline void Init_1_1(
1543 _Out_ D3D12_VERSIONED_ROOT_SIGNATURE_DESC &desc,
1544 UINT numParameters,
1545 _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER1* _pParameters,
1546 UINT numStaticSamplers = 0,
1547 _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr,
1548 D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) noexcept
1549 {
1550 desc.Version = D3D_ROOT_SIGNATURE_VERSION_1_1;
1551 desc.Desc_1_1.NumParameters = numParameters;
1552 desc.Desc_1_1.pParameters = _pParameters;
1553 desc.Desc_1_1.NumStaticSamplers = numStaticSamplers;
1554 desc.Desc_1_1.pStaticSamplers = _pStaticSamplers;
1555 desc.Desc_1_1.Flags = flags;
1556 }
1557};
1558
1559//------------------------------------------------------------------------------------------------
1560struct CD3DX12_CPU_DESCRIPTOR_HANDLE : public D3D12_CPU_DESCRIPTOR_HANDLE
1561{
1562 CD3DX12_CPU_DESCRIPTOR_HANDLE() = default;
1563 explicit CD3DX12_CPU_DESCRIPTOR_HANDLE(const D3D12_CPU_DESCRIPTOR_HANDLE &o) noexcept :
1564 D3D12_CPU_DESCRIPTOR_HANDLE(o)
1565 {}
1566 CD3DX12_CPU_DESCRIPTOR_HANDLE(CD3DX12_DEFAULT) noexcept { ptr = 0; }
1567 CD3DX12_CPU_DESCRIPTOR_HANDLE(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &other, INT offsetScaledByIncrementSize) noexcept
1568 {
1569 InitOffsetted(other, offsetScaledByIncrementSize);
1570 }
1571 CD3DX12_CPU_DESCRIPTOR_HANDLE(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &other, INT offsetInDescriptors, UINT descriptorIncrementSize) noexcept
1572 {
1573 InitOffsetted(other, offsetInDescriptors, descriptorIncrementSize);
1574 }
1575 CD3DX12_CPU_DESCRIPTOR_HANDLE& Offset(INT offsetInDescriptors, UINT descriptorIncrementSize) noexcept
1576 {
1577 ptr = SIZE_T(INT64(ptr) + INT64(offsetInDescriptors) * INT64(descriptorIncrementSize));
1578 return *this;
1579 }
1580 CD3DX12_CPU_DESCRIPTOR_HANDLE& Offset(INT offsetScaledByIncrementSize) noexcept
1581 {
1582 ptr = SIZE_T(INT64(ptr) + INT64(offsetScaledByIncrementSize));
1583 return *this;
1584 }
1585 bool operator==(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE& other) const noexcept
1586 {
1587 return (ptr == other.ptr);
1588 }
1589 bool operator!=(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE& other) const noexcept
1590 {
1591 return (ptr != other.ptr);
1592 }
1593 CD3DX12_CPU_DESCRIPTOR_HANDLE &operator=(const D3D12_CPU_DESCRIPTOR_HANDLE &other) noexcept
1594 {
1595 ptr = other.ptr;
1596 return *this;
1597 }
1598
1599 inline void InitOffsetted(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize) noexcept
1600 {
1601 InitOffsetted(*this, base, offsetScaledByIncrementSize);
1602 }
1603
1604 inline void InitOffsetted(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize) noexcept
1605 {
1606 InitOffsetted(*this, base, offsetInDescriptors, descriptorIncrementSize);
1607 }
1608
1609 static inline void InitOffsetted(_Out_ D3D12_CPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize) noexcept
1610 {
1611 handle.ptr = SIZE_T(INT64(base.ptr) + INT64(offsetScaledByIncrementSize));
1612 }
1613
1614 static inline void InitOffsetted(_Out_ D3D12_CPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize) noexcept
1615 {
1616 handle.ptr = SIZE_T(INT64(base.ptr) + INT64(offsetInDescriptors) * INT64(descriptorIncrementSize));
1617 }
1618};
1619
1620//------------------------------------------------------------------------------------------------
1621struct CD3DX12_GPU_DESCRIPTOR_HANDLE : public D3D12_GPU_DESCRIPTOR_HANDLE
1622{
1623 CD3DX12_GPU_DESCRIPTOR_HANDLE() = default;
1624 explicit CD3DX12_GPU_DESCRIPTOR_HANDLE(const D3D12_GPU_DESCRIPTOR_HANDLE &o) noexcept :
1625 D3D12_GPU_DESCRIPTOR_HANDLE(o)
1626 {}
1627 CD3DX12_GPU_DESCRIPTOR_HANDLE(CD3DX12_DEFAULT) noexcept { ptr = 0; }
1628 CD3DX12_GPU_DESCRIPTOR_HANDLE(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &other, INT offsetScaledByIncrementSize) noexcept
1629 {
1630 InitOffsetted(other, offsetScaledByIncrementSize);
1631 }
1632 CD3DX12_GPU_DESCRIPTOR_HANDLE(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &other, INT offsetInDescriptors, UINT descriptorIncrementSize) noexcept
1633 {
1634 InitOffsetted(other, offsetInDescriptors, descriptorIncrementSize);
1635 }
1636 CD3DX12_GPU_DESCRIPTOR_HANDLE& Offset(INT offsetInDescriptors, UINT descriptorIncrementSize) noexcept
1637 {
1638 ptr = UINT64(INT64(ptr) + INT64(offsetInDescriptors) * INT64(descriptorIncrementSize));
1639 return *this;
1640 }
1641 CD3DX12_GPU_DESCRIPTOR_HANDLE& Offset(INT offsetScaledByIncrementSize) noexcept
1642 {
1643 ptr = UINT64(INT64(ptr) + INT64(offsetScaledByIncrementSize));
1644 return *this;
1645 }
1646 inline bool operator==(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE& other) const noexcept
1647 {
1648 return (ptr == other.ptr);
1649 }
1650 inline bool operator!=(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE& other) const noexcept
1651 {
1652 return (ptr != other.ptr);
1653 }
1654 CD3DX12_GPU_DESCRIPTOR_HANDLE &operator=(const D3D12_GPU_DESCRIPTOR_HANDLE &other) noexcept
1655 {
1656 ptr = other.ptr;
1657 return *this;
1658 }
1659
1660 inline void InitOffsetted(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize) noexcept
1661 {
1662 InitOffsetted(*this, base, offsetScaledByIncrementSize);
1663 }
1664
1665 inline void InitOffsetted(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize) noexcept
1666 {
1667 InitOffsetted(*this, base, offsetInDescriptors, descriptorIncrementSize);
1668 }
1669
1670 static inline void InitOffsetted(_Out_ D3D12_GPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize) noexcept
1671 {
1672 handle.ptr = UINT64(INT64(base.ptr) + INT64(offsetScaledByIncrementSize));
1673 }
1674
1675 static inline void InitOffsetted(_Out_ D3D12_GPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize) noexcept
1676 {
1677 handle.ptr = UINT64(INT64(base.ptr) + INT64(offsetInDescriptors) * INT64(descriptorIncrementSize));
1678 }
1679};
1680
1681//------------------------------------------------------------------------------------------------
1682inline constexpr UINT D3D12CalcSubresource( UINT MipSlice, UINT ArraySlice, UINT PlaneSlice, UINT MipLevels, UINT ArraySize ) noexcept
1683{
1684 return MipSlice + ArraySlice * MipLevels + PlaneSlice * MipLevels * ArraySize;
1685}
1686
1687//------------------------------------------------------------------------------------------------
1688template <typename T, typename U, typename V>
1689inline void D3D12DecomposeSubresource( UINT Subresource, UINT MipLevels, UINT ArraySize, _Out_ T& MipSlice, _Out_ U& ArraySlice, _Out_ V& PlaneSlice ) noexcept
1690{
1691 MipSlice = static_cast<T>(Subresource % MipLevels);
1692 ArraySlice = static_cast<U>((Subresource / MipLevels) % ArraySize);
1693 PlaneSlice = static_cast<V>(Subresource / (MipLevels * ArraySize));
1694}
1695
1696//------------------------------------------------------------------------------------------------
1697inline UINT8 D3D12GetFormatPlaneCount(
1698 _In_ ID3D12Device* pDevice,
1699 DXGI_FORMAT Format
1700 ) noexcept
1701{
1702 D3D12_FEATURE_DATA_FORMAT_INFO formatInfo = { Format, 0 };
1703 if (FAILED(pDevice->CheckFeatureSupport(D3D12_FEATURE_FORMAT_INFO, &formatInfo, sizeof(formatInfo))))
1704 {
1705 return 0;
1706 }
1707 return formatInfo.PlaneCount;
1708}
1709
1710//------------------------------------------------------------------------------------------------
1711struct CD3DX12_RESOURCE_DESC : public D3D12_RESOURCE_DESC
1712{
1713 CD3DX12_RESOURCE_DESC() = default;
1714 explicit CD3DX12_RESOURCE_DESC( const D3D12_RESOURCE_DESC& o ) noexcept :
1715 D3D12_RESOURCE_DESC( o )
1716 {}
1717 CD3DX12_RESOURCE_DESC(
1718 D3D12_RESOURCE_DIMENSION dimension,
1719 UINT64 alignment,
1720 UINT64 width,
1721 UINT height,
1722 UINT16 depthOrArraySize,
1723 UINT16 mipLevels,
1724 DXGI_FORMAT format,
1725 UINT sampleCount,
1726 UINT sampleQuality,
1727 D3D12_TEXTURE_LAYOUT layout,
1728 D3D12_RESOURCE_FLAGS flags ) noexcept
1729 {
1730 Dimension = dimension;
1731 Alignment = alignment;
1732 Width = width;
1733 Height = height;
1734 DepthOrArraySize = depthOrArraySize;
1735 MipLevels = mipLevels;
1736 Format = format;
1737 SampleDesc.Count = sampleCount;
1738 SampleDesc.Quality = sampleQuality;
1739 Layout = layout;
1740 Flags = flags;
1741 }
1742 static inline CD3DX12_RESOURCE_DESC Buffer(
1743 const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
1744 D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE ) noexcept
1745 {
1746 return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_BUFFER, resAllocInfo.Alignment, resAllocInfo.SizeInBytes,
1747 1, 1, 1, DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags );
1748 }
1749 static inline CD3DX12_RESOURCE_DESC Buffer(
1750 UINT64 width,
1751 D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
1752 UINT64 alignment = 0 ) noexcept
1753 {
1754 return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_BUFFER, alignment, width, 1, 1, 1,
1755 DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags );
1756 }
1757 static inline CD3DX12_RESOURCE_DESC Tex1D(
1758 DXGI_FORMAT format,
1759 UINT64 width,
1760 UINT16 arraySize = 1,
1761 UINT16 mipLevels = 0,
1762 D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
1763 D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
1764 UINT64 alignment = 0 ) noexcept
1765 {
1766 return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_TEXTURE1D, alignment, width, 1, arraySize,
1767 mipLevels, format, 1, 0, layout, flags );
1768 }
1769 static inline CD3DX12_RESOURCE_DESC Tex2D(
1770 DXGI_FORMAT format,
1771 UINT64 width,
1772 UINT height,
1773 UINT16 arraySize = 1,
1774 UINT16 mipLevels = 0,
1775 UINT sampleCount = 1,
1776 UINT sampleQuality = 0,
1777 D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
1778 D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
1779 UINT64 alignment = 0 ) noexcept
1780 {
1781 return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_TEXTURE2D, alignment, width, height, arraySize,
1782 mipLevels, format, sampleCount, sampleQuality, layout, flags );
1783 }
1784 static inline CD3DX12_RESOURCE_DESC Tex3D(
1785 DXGI_FORMAT format,
1786 UINT64 width,
1787 UINT height,
1788 UINT16 depth,
1789 UINT16 mipLevels = 0,
1790 D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
1791 D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
1792 UINT64 alignment = 0 ) noexcept
1793 {
1794 return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_TEXTURE3D, alignment, width, height, depth,
1795 mipLevels, format, 1, 0, layout, flags );
1796 }
1797 inline UINT16 Depth() const noexcept
1798 { return (Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize : 1); }
1799 inline UINT16 ArraySize() const noexcept
1800 { return (Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize : 1); }
1801 inline UINT8 PlaneCount(_In_ ID3D12Device* pDevice) const noexcept
1802 { return D3D12GetFormatPlaneCount(pDevice, Format); }
1803 inline UINT Subresources(_In_ ID3D12Device* pDevice) const noexcept
1804 { return MipLevels * ArraySize() * PlaneCount(pDevice); }
1805 inline UINT CalcSubresource(UINT MipSlice, UINT ArraySlice, UINT PlaneSlice) noexcept
1806 { return D3D12CalcSubresource(MipSlice, ArraySlice, PlaneSlice, MipLevels, ArraySize()); }
1807};
1808inline bool operator==( const D3D12_RESOURCE_DESC& l, const D3D12_RESOURCE_DESC& r ) noexcept
1809{
1810 return l.Dimension == r.Dimension &&
1811 l.Alignment == r.Alignment &&
1812 l.Width == r.Width &&
1813 l.Height == r.Height &&
1814 l.DepthOrArraySize == r.DepthOrArraySize &&
1815 l.MipLevels == r.MipLevels &&
1816 l.Format == r.Format &&
1817 l.SampleDesc.Count == r.SampleDesc.Count &&
1818 l.SampleDesc.Quality == r.SampleDesc.Quality &&
1819 l.Layout == r.Layout &&
1820 l.Flags == r.Flags;
1821}
1822inline bool operator!=( const D3D12_RESOURCE_DESC& l, const D3D12_RESOURCE_DESC& r ) noexcept
1823{ return !( l == r ); }
1824
1825//------------------------------------------------------------------------------------------------
1826struct CD3DX12_RESOURCE_DESC1 : public D3D12_RESOURCE_DESC1
1827{
1828 CD3DX12_RESOURCE_DESC1() = default;
1829 explicit CD3DX12_RESOURCE_DESC1( const D3D12_RESOURCE_DESC1& o ) noexcept :
1830 D3D12_RESOURCE_DESC1( o )
1831 {}
1832 CD3DX12_RESOURCE_DESC1(
1833 D3D12_RESOURCE_DIMENSION dimension,
1834 UINT64 alignment,
1835 UINT64 width,
1836 UINT height,
1837 UINT16 depthOrArraySize,
1838 UINT16 mipLevels,
1839 DXGI_FORMAT format,
1840 UINT sampleCount,
1841 UINT sampleQuality,
1842 D3D12_TEXTURE_LAYOUT layout,
1843 D3D12_RESOURCE_FLAGS flags,
1844 UINT samplerFeedbackMipRegionWidth = 0,
1845 UINT samplerFeedbackMipRegionHeight = 0,
1846 UINT samplerFeedbackMipRegionDepth = 0) noexcept
1847 {
1848 Dimension = dimension;
1849 Alignment = alignment;
1850 Width = width;
1851 Height = height;
1852 DepthOrArraySize = depthOrArraySize;
1853 MipLevels = mipLevels;
1854 Format = format;
1855 SampleDesc.Count = sampleCount;
1856 SampleDesc.Quality = sampleQuality;
1857 Layout = layout;
1858 Flags = flags;
1859 SamplerFeedbackMipRegion.Width = samplerFeedbackMipRegionWidth;
1860 SamplerFeedbackMipRegion.Height = samplerFeedbackMipRegionHeight;
1861 SamplerFeedbackMipRegion.Depth = samplerFeedbackMipRegionDepth;
1862 }
1863 static inline CD3DX12_RESOURCE_DESC1 Buffer(
1864 const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
1865 D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE ) noexcept
1866 {
1867 return CD3DX12_RESOURCE_DESC1( D3D12_RESOURCE_DIMENSION_BUFFER, resAllocInfo.Alignment, resAllocInfo.SizeInBytes,
1868 1, 1, 1, DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags, 0, 0, 0 );
1869 }
1870 static inline CD3DX12_RESOURCE_DESC1 Buffer(
1871 UINT64 width,
1872 D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
1873 UINT64 alignment = 0 ) noexcept
1874 {
1875 return CD3DX12_RESOURCE_DESC1( D3D12_RESOURCE_DIMENSION_BUFFER, alignment, width, 1, 1, 1,
1876 DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags, 0, 0, 0 );
1877 }
1878 static inline CD3DX12_RESOURCE_DESC1 Tex1D(
1879 DXGI_FORMAT format,
1880 UINT64 width,
1881 UINT16 arraySize = 1,
1882 UINT16 mipLevels = 0,
1883 D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
1884 D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
1885 UINT64 alignment = 0 ) noexcept
1886 {
1887 return CD3DX12_RESOURCE_DESC1( D3D12_RESOURCE_DIMENSION_TEXTURE1D, alignment, width, 1, arraySize,
1888 mipLevels, format, 1, 0, layout, flags, 0, 0, 0 );
1889 }
1890 static inline CD3DX12_RESOURCE_DESC1 Tex2D(
1891 DXGI_FORMAT format,
1892 UINT64 width,
1893 UINT height,
1894 UINT16 arraySize = 1,
1895 UINT16 mipLevels = 0,
1896 UINT sampleCount = 1,
1897 UINT sampleQuality = 0,
1898 D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
1899 D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
1900 UINT64 alignment = 0,
1901 UINT samplerFeedbackMipRegionWidth = 0,
1902 UINT samplerFeedbackMipRegionHeight = 0,
1903 UINT samplerFeedbackMipRegionDepth = 0) noexcept
1904 {
1905 return CD3DX12_RESOURCE_DESC1( D3D12_RESOURCE_DIMENSION_TEXTURE2D, alignment, width, height, arraySize,
1906 mipLevels, format, sampleCount, sampleQuality, layout, flags, samplerFeedbackMipRegionWidth,
1907 samplerFeedbackMipRegionHeight, samplerFeedbackMipRegionDepth );
1908 }
1909 static inline CD3DX12_RESOURCE_DESC1 Tex3D(
1910 DXGI_FORMAT format,
1911 UINT64 width,
1912 UINT height,
1913 UINT16 depth,
1914 UINT16 mipLevels = 0,
1915 D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
1916 D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
1917 UINT64 alignment = 0 ) noexcept
1918 {
1919 return CD3DX12_RESOURCE_DESC1( D3D12_RESOURCE_DIMENSION_TEXTURE3D, alignment, width, height, depth,
1920 mipLevels, format, 1, 0, layout, flags, 0, 0, 0 );
1921 }
1922 inline UINT16 Depth() const noexcept
1923 { return (Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize : 1); }
1924 inline UINT16 ArraySize() const noexcept
1925 { return (Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize : 1); }
1926 inline UINT8 PlaneCount(_In_ ID3D12Device* pDevice) const noexcept
1927 { return D3D12GetFormatPlaneCount(pDevice, Format); }
1928 inline UINT Subresources(_In_ ID3D12Device* pDevice) const noexcept
1929 { return MipLevels * ArraySize() * PlaneCount(pDevice); }
1930 inline UINT CalcSubresource(UINT MipSlice, UINT ArraySlice, UINT PlaneSlice) noexcept
1931 { return D3D12CalcSubresource(MipSlice, ArraySlice, PlaneSlice, MipLevels, ArraySize()); }
1932};
1933inline bool operator==( const D3D12_RESOURCE_DESC1& l, const D3D12_RESOURCE_DESC1& r ) noexcept
1934{
1935 return l.Dimension == r.Dimension &&
1936 l.Alignment == r.Alignment &&
1937 l.Width == r.Width &&
1938 l.Height == r.Height &&
1939 l.DepthOrArraySize == r.DepthOrArraySize &&
1940 l.MipLevels == r.MipLevels &&
1941 l.Format == r.Format &&
1942 l.SampleDesc.Count == r.SampleDesc.Count &&
1943 l.SampleDesc.Quality == r.SampleDesc.Quality &&
1944 l.Layout == r.Layout &&
1945 l.Flags == r.Flags &&
1946 l.SamplerFeedbackMipRegion.Width == r.SamplerFeedbackMipRegion.Width &&
1947 l.SamplerFeedbackMipRegion.Height == r.SamplerFeedbackMipRegion.Height &&
1948 l.SamplerFeedbackMipRegion.Depth == r.SamplerFeedbackMipRegion.Depth;
1949}
1950inline bool operator!=( const D3D12_RESOURCE_DESC1& l, const D3D12_RESOURCE_DESC1& r ) noexcept
1951{ return !( l == r ); }
1952
1953//------------------------------------------------------------------------------------------------
1954struct CD3DX12_VIEW_INSTANCING_DESC : public D3D12_VIEW_INSTANCING_DESC
1955{
1956 CD3DX12_VIEW_INSTANCING_DESC() = default;
1957 explicit CD3DX12_VIEW_INSTANCING_DESC( const D3D12_VIEW_INSTANCING_DESC& o ) noexcept :
1958 D3D12_VIEW_INSTANCING_DESC( o )
1959 {}
1960 explicit CD3DX12_VIEW_INSTANCING_DESC( CD3DX12_DEFAULT ) noexcept
1961 {
1962 ViewInstanceCount = 0;
1963 pViewInstanceLocations = nullptr;
1964 Flags = D3D12_VIEW_INSTANCING_FLAG_NONE;
1965 }
1966 explicit CD3DX12_VIEW_INSTANCING_DESC(
1967 UINT InViewInstanceCount,
1968 const D3D12_VIEW_INSTANCE_LOCATION* InViewInstanceLocations,
1969 D3D12_VIEW_INSTANCING_FLAGS InFlags) noexcept
1970 {
1971 ViewInstanceCount = InViewInstanceCount;
1972 pViewInstanceLocations = InViewInstanceLocations;
1973 Flags = InFlags;
1974 }
1975};
1976
1977//------------------------------------------------------------------------------------------------
1978// Row-by-row memcpy
1979inline void MemcpySubresource(
1980 _In_ const D3D12_MEMCPY_DEST* pDest,
1981 _In_ const D3D12_SUBRESOURCE_DATA* pSrc,
1982 SIZE_T RowSizeInBytes,
1983 UINT NumRows,
1984 UINT NumSlices) noexcept
1985{
1986 for (UINT z = 0; z < NumSlices; ++z)
1987 {
1988 auto pDestSlice = static_cast<BYTE*>(pDest->pData) + pDest->SlicePitch * z;
1989 auto pSrcSlice = static_cast<const BYTE*>(pSrc->pData) + pSrc->SlicePitch * LONG_PTR(z);
1990 for (UINT y = 0; y < NumRows; ++y)
1991 {
1992 memcpy(pDestSlice + pDest->RowPitch * y,
1993 pSrcSlice + pSrc->RowPitch * LONG_PTR(y),
1994 RowSizeInBytes);
1995 }
1996 }
1997}
1998
1999//------------------------------------------------------------------------------------------------
2000// Row-by-row memcpy
2001inline void MemcpySubresource(
2002 _In_ const D3D12_MEMCPY_DEST* pDest,
2003 _In_ const void* pResourceData,
2004 _In_ const D3D12_SUBRESOURCE_INFO* pSrc,
2005 SIZE_T RowSizeInBytes,
2006 UINT NumRows,
2007 UINT NumSlices) noexcept
2008{
2009 for (UINT z = 0; z < NumSlices; ++z)
2010 {
2011 auto pDestSlice = static_cast<BYTE*>(pDest->pData) + pDest->SlicePitch * z;
2012 auto pSrcSlice = (static_cast<const BYTE*>(pResourceData) + pSrc->Offset) + pSrc->DepthPitch * ULONG_PTR(z);
2013 for (UINT y = 0; y < NumRows; ++y)
2014 {
2015 memcpy(pDestSlice + pDest->RowPitch * y,
2016 pSrcSlice + pSrc->RowPitch * ULONG_PTR(y),
2017 RowSizeInBytes);
2018 }
2019 }
2020}
2021
2022//------------------------------------------------------------------------------------------------
2023// Returns required size of a buffer to be used for data upload
2024inline UINT64 GetRequiredIntermediateSize(
2025 _In_ ID3D12Resource* pDestinationResource,
2026 _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
2027 _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources) noexcept
2028{
2029 auto Desc = pDestinationResource->GetDesc();
2030 UINT64 RequiredSize = 0;
2031
2032 ID3D12Device* pDevice = nullptr;
2033 pDestinationResource->GetDevice(IID_ID3D12Device, reinterpret_cast<void**>(&pDevice));
2034 pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, 0, nullptr, nullptr, nullptr, &RequiredSize);
2035 pDevice->Release();
2036
2037 return RequiredSize;
2038}
2039
2040//------------------------------------------------------------------------------------------------
2041// All arrays must be populated (e.g. by calling GetCopyableFootprints)
2042inline UINT64 UpdateSubresources(
2043 _In_ ID3D12GraphicsCommandList* pCmdList,
2044 _In_ ID3D12Resource* pDestinationResource,
2045 _In_ ID3D12Resource* pIntermediate,
2046 _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
2047 _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources,
2048 UINT64 RequiredSize,
2049 _In_reads_(NumSubresources) const D3D12_PLACED_SUBRESOURCE_FOOTPRINT* pLayouts,
2050 _In_reads_(NumSubresources) const UINT* pNumRows,
2051 _In_reads_(NumSubresources) const UINT64* pRowSizesInBytes,
2052 _In_reads_(NumSubresources) const D3D12_SUBRESOURCE_DATA* pSrcData) noexcept
2053{
2054 // Minor validation
2055 auto IntermediateDesc = pIntermediate->GetDesc();
2056 auto DestinationDesc = pDestinationResource->GetDesc();
2057 if (IntermediateDesc.Dimension != D3D12_RESOURCE_DIMENSION_BUFFER ||
2058 IntermediateDesc.Width < RequiredSize + pLayouts[0].Offset ||
2059 RequiredSize > SIZE_T(-1) ||
2060 (DestinationDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER &&
2061 (FirstSubresource != 0 || NumSubresources != 1)))
2062 {
2063 return 0;
2064 }
2065
2066 BYTE* pData;
2067 HRESULT hr = pIntermediate->Map(0, nullptr, reinterpret_cast<void**>(&pData));
2068 if (FAILED(hr))
2069 {
2070 return 0;
2071 }
2072
2073 for (UINT i = 0; i < NumSubresources; ++i)
2074 {
2075 if (pRowSizesInBytes[i] > SIZE_T(-1)) return 0;
2076 D3D12_MEMCPY_DEST DestData = { pData + pLayouts[i].Offset, pLayouts[i].Footprint.RowPitch, SIZE_T(pLayouts[i].Footprint.RowPitch) * SIZE_T(pNumRows[i]) };
2077 MemcpySubresource(&DestData, &pSrcData[i], static_cast<SIZE_T>(pRowSizesInBytes[i]), pNumRows[i], pLayouts[i].Footprint.Depth);
2078 }
2079 pIntermediate->Unmap(0, nullptr);
2080
2081 if (DestinationDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER)
2082 {
2083 pCmdList->CopyBufferRegion(
2084 pDestinationResource, 0, pIntermediate, pLayouts[0].Offset, pLayouts[0].Footprint.Width);
2085 }
2086 else
2087 {
2088 for (UINT i = 0; i < NumSubresources; ++i)
2089 {
2090 CD3DX12_TEXTURE_COPY_LOCATION Dst(pDestinationResource, i + FirstSubresource);
2091 CD3DX12_TEXTURE_COPY_LOCATION Src(pIntermediate, pLayouts[i]);
2092 pCmdList->CopyTextureRegion(&Dst, 0, 0, 0, &Src, nullptr);
2093 }
2094 }
2095 return RequiredSize;
2096}
2097
2098//------------------------------------------------------------------------------------------------
2099// All arrays must be populated (e.g. by calling GetCopyableFootprints)
2100inline UINT64 UpdateSubresources(
2101 _In_ ID3D12GraphicsCommandList* pCmdList,
2102 _In_ ID3D12Resource* pDestinationResource,
2103 _In_ ID3D12Resource* pIntermediate,
2104 _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
2105 _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources,
2106 UINT64 RequiredSize,
2107 _In_reads_(NumSubresources) const D3D12_PLACED_SUBRESOURCE_FOOTPRINT* pLayouts,
2108 _In_reads_(NumSubresources) const UINT* pNumRows,
2109 _In_reads_(NumSubresources) const UINT64* pRowSizesInBytes,
2110 _In_ const void* pResourceData,
2111 _In_reads_(NumSubresources) const D3D12_SUBRESOURCE_INFO* pSrcData) noexcept
2112{
2113 // Minor validation
2114 auto IntermediateDesc = pIntermediate->GetDesc();
2115 auto DestinationDesc = pDestinationResource->GetDesc();
2116 if (IntermediateDesc.Dimension != D3D12_RESOURCE_DIMENSION_BUFFER ||
2117 IntermediateDesc.Width < RequiredSize + pLayouts[0].Offset ||
2118 RequiredSize > SIZE_T(-1) ||
2119 (DestinationDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER &&
2120 (FirstSubresource != 0 || NumSubresources != 1)))
2121 {
2122 return 0;
2123 }
2124
2125 BYTE* pData;
2126 HRESULT hr = pIntermediate->Map(0, nullptr, reinterpret_cast<void**>(&pData));
2127 if (FAILED(hr))
2128 {
2129 return 0;
2130 }
2131
2132 for (UINT i = 0; i < NumSubresources; ++i)
2133 {
2134 if (pRowSizesInBytes[i] > SIZE_T(-1)) return 0;
2135 D3D12_MEMCPY_DEST DestData = { pData + pLayouts[i].Offset, pLayouts[i].Footprint.RowPitch, SIZE_T(pLayouts[i].Footprint.RowPitch) * SIZE_T(pNumRows[i]) };
2136 MemcpySubresource(&DestData, pResourceData, &pSrcData[i], static_cast<SIZE_T>(pRowSizesInBytes[i]), pNumRows[i], pLayouts[i].Footprint.Depth);
2137 }
2138 pIntermediate->Unmap(0, nullptr);
2139
2140 if (DestinationDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER)
2141 {
2142 pCmdList->CopyBufferRegion(
2143 pDestinationResource, 0, pIntermediate, pLayouts[0].Offset, pLayouts[0].Footprint.Width);
2144 }
2145 else
2146 {
2147 for (UINT i = 0; i < NumSubresources; ++i)
2148 {
2149 CD3DX12_TEXTURE_COPY_LOCATION Dst(pDestinationResource, i + FirstSubresource);
2150 CD3DX12_TEXTURE_COPY_LOCATION Src(pIntermediate, pLayouts[i]);
2151 pCmdList->CopyTextureRegion(&Dst, 0, 0, 0, &Src, nullptr);
2152 }
2153 }
2154 return RequiredSize;
2155}
2156
2157//------------------------------------------------------------------------------------------------
2158// Heap-allocating UpdateSubresources implementation
2159inline UINT64 UpdateSubresources(
2160 _In_ ID3D12GraphicsCommandList* pCmdList,
2161 _In_ ID3D12Resource* pDestinationResource,
2162 _In_ ID3D12Resource* pIntermediate,
2163 UINT64 IntermediateOffset,
2164 _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
2165 _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources,
2166 _In_reads_(NumSubresources) const D3D12_SUBRESOURCE_DATA* pSrcData) noexcept
2167{
2168 UINT64 RequiredSize = 0;
2169 auto MemToAlloc = static_cast<UINT64>(sizeof(D3D12_PLACED_SUBRESOURCE_FOOTPRINT) + sizeof(UINT) + sizeof(UINT64)) * NumSubresources;
2170 if (MemToAlloc > SIZE_MAX)
2171 {
2172 return 0;
2173 }
2174 void* pMem = HeapAlloc(GetProcessHeap(), 0, static_cast<SIZE_T>(MemToAlloc));
2175 if (pMem == nullptr)
2176 {
2177 return 0;
2178 }
2179 auto pLayouts = static_cast<D3D12_PLACED_SUBRESOURCE_FOOTPRINT*>(pMem);
2180 auto pRowSizesInBytes = reinterpret_cast<UINT64*>(pLayouts + NumSubresources);
2181 auto pNumRows = reinterpret_cast<UINT*>(pRowSizesInBytes + NumSubresources);
2182
2183 auto Desc = pDestinationResource->GetDesc();
2184 ID3D12Device* pDevice = nullptr;
2185 pDestinationResource->GetDevice(IID_ID3D12Device, reinterpret_cast<void**>(&pDevice));
2186 pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, IntermediateOffset, pLayouts, pNumRows, pRowSizesInBytes, &RequiredSize);
2187 pDevice->Release();
2188
2189 UINT64 Result = UpdateSubresources(pCmdList, pDestinationResource, pIntermediate, FirstSubresource, NumSubresources, RequiredSize, pLayouts, pNumRows, pRowSizesInBytes, pSrcData);
2190 HeapFree(GetProcessHeap(), 0, pMem);
2191 return Result;
2192}
2193
2194//------------------------------------------------------------------------------------------------
2195// Heap-allocating UpdateSubresources implementation
2196inline UINT64 UpdateSubresources(
2197 _In_ ID3D12GraphicsCommandList* pCmdList,
2198 _In_ ID3D12Resource* pDestinationResource,
2199 _In_ ID3D12Resource* pIntermediate,
2200 UINT64 IntermediateOffset,
2201 _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
2202 _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources,
2203 _In_ const void* pResourceData,
2204 _In_reads_(NumSubresources) D3D12_SUBRESOURCE_INFO* pSrcData) noexcept
2205{
2206 UINT64 RequiredSize = 0;
2207 auto MemToAlloc = static_cast<UINT64>(sizeof(D3D12_PLACED_SUBRESOURCE_FOOTPRINT) + sizeof(UINT) + sizeof(UINT64)) * NumSubresources;
2208 if (MemToAlloc > SIZE_MAX)
2209 {
2210 return 0;
2211 }
2212 void* pMem = HeapAlloc(GetProcessHeap(), 0, static_cast<SIZE_T>(MemToAlloc));
2213 if (pMem == nullptr)
2214 {
2215 return 0;
2216 }
2217 auto pLayouts = reinterpret_cast<D3D12_PLACED_SUBRESOURCE_FOOTPRINT*>(pMem);
2218 auto pRowSizesInBytes = reinterpret_cast<UINT64*>(pLayouts + NumSubresources);
2219 auto pNumRows = reinterpret_cast<UINT*>(pRowSizesInBytes + NumSubresources);
2220
2221 auto Desc = pDestinationResource->GetDesc();
2222 ID3D12Device* pDevice = nullptr;
2223 pDestinationResource->GetDevice(IID_ID3D12Device, reinterpret_cast<void**>(&pDevice));
2224 pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, IntermediateOffset, pLayouts, pNumRows, pRowSizesInBytes, &RequiredSize);
2225 pDevice->Release();
2226
2227 UINT64 Result = UpdateSubresources(pCmdList, pDestinationResource, pIntermediate, FirstSubresource, NumSubresources, RequiredSize, pLayouts, pNumRows, pRowSizesInBytes, pResourceData, pSrcData);
2228 HeapFree(GetProcessHeap(), 0, pMem);
2229 return Result;
2230}
2231
2232//------------------------------------------------------------------------------------------------
2233// Stack-allocating UpdateSubresources implementation
2234template <UINT MaxSubresources>
2235inline UINT64 UpdateSubresources(
2236 _In_ ID3D12GraphicsCommandList* pCmdList,
2237 _In_ ID3D12Resource* pDestinationResource,
2238 _In_ ID3D12Resource* pIntermediate,
2239 UINT64 IntermediateOffset,
2240 _In_range_(0,MaxSubresources) UINT FirstSubresource,
2241 _In_range_(1,MaxSubresources-FirstSubresource) UINT NumSubresources,
2242 _In_reads_(NumSubresources) const D3D12_SUBRESOURCE_DATA* pSrcData) noexcept
2243{
2244 UINT64 RequiredSize = 0;
2245 D3D12_PLACED_SUBRESOURCE_FOOTPRINT Layouts[MaxSubresources];
2246 UINT NumRows[MaxSubresources];
2247 UINT64 RowSizesInBytes[MaxSubresources];
2248
2249 auto Desc = pDestinationResource->GetDesc();
2250 ID3D12Device* pDevice = nullptr;
2251 pDestinationResource->GetDevice(IID_ID3D12Device, reinterpret_cast<void**>(&pDevice));
2252 pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, IntermediateOffset, Layouts, NumRows, RowSizesInBytes, &RequiredSize);
2253 pDevice->Release();
2254
2255 return UpdateSubresources(pCmdList, pDestinationResource, pIntermediate, FirstSubresource, NumSubresources, RequiredSize, Layouts, NumRows, RowSizesInBytes, pSrcData);
2256}
2257
2258//------------------------------------------------------------------------------------------------
2259// Stack-allocating UpdateSubresources implementation
2260template <UINT MaxSubresources>
2261inline UINT64 UpdateSubresources(
2262 _In_ ID3D12GraphicsCommandList* pCmdList,
2263 _In_ ID3D12Resource* pDestinationResource,
2264 _In_ ID3D12Resource* pIntermediate,
2265 UINT64 IntermediateOffset,
2266 _In_range_(0,MaxSubresources) UINT FirstSubresource,
2267 _In_range_(1,MaxSubresources-FirstSubresource) UINT NumSubresources,
2268 _In_ const void* pResourceData,
2269 _In_reads_(NumSubresources) D3D12_SUBRESOURCE_INFO* pSrcData) noexcept
2270{
2271 UINT64 RequiredSize = 0;
2272 D3D12_PLACED_SUBRESOURCE_FOOTPRINT Layouts[MaxSubresources];
2273 UINT NumRows[MaxSubresources];
2274 UINT64 RowSizesInBytes[MaxSubresources];
2275
2276 auto Desc = pDestinationResource->GetDesc();
2277 ID3D12Device* pDevice = nullptr;
2278 pDestinationResource->GetDevice(IID_ID3D12Device, reinterpret_cast<void**>(&pDevice));
2279 pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, IntermediateOffset, Layouts, NumRows, RowSizesInBytes, &RequiredSize);
2280 pDevice->Release();
2281
2282 return UpdateSubresources(pCmdList, pDestinationResource, pIntermediate, FirstSubresource, NumSubresources, RequiredSize, Layouts, NumRows, RowSizesInBytes, pResourceData, pSrcData);
2283}
2284
2285//------------------------------------------------------------------------------------------------
2286inline constexpr bool D3D12IsLayoutOpaque( D3D12_TEXTURE_LAYOUT Layout ) noexcept
2287{ return Layout == D3D12_TEXTURE_LAYOUT_UNKNOWN || Layout == D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE; }
2288
2289//------------------------------------------------------------------------------------------------
2290template <typename t_CommandListType>
2291inline ID3D12CommandList * const * CommandListCast(t_CommandListType * const * pp) noexcept
2292{
2293 // This cast is useful for passing strongly typed command list pointers into
2294 // ExecuteCommandLists.
2295 // This cast is valid as long as the const-ness is respected. D3D12 APIs do
2296 // respect the const-ness of their arguments.
2297 return reinterpret_cast<ID3D12CommandList * const *>(pp);
2298}
2299
2300//------------------------------------------------------------------------------------------------
2301// D3D12 exports a new method for serializing root signatures in the Windows 10 Anniversary Update.
2302// To help enable root signature 1.1 features when they are available and not require maintaining
2303// two code paths for building root signatures, this helper method reconstructs a 1.0 signature when
2304// 1.1 is not supported.
2305inline HRESULT D3DX12SerializeVersionedRootSignature(
2306 _In_ const D3D12_VERSIONED_ROOT_SIGNATURE_DESC* pRootSignatureDesc,
2307 D3D_ROOT_SIGNATURE_VERSION MaxVersion,
2308 _Outptr_ ID3DBlob** ppBlob,
2309 _Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorBlob) noexcept
2310{
2311 if (ppErrorBlob != nullptr)
2312 {
2313 *ppErrorBlob = nullptr;
2314 }
2315
2316 switch (MaxVersion)
2317 {
2318 case D3D_ROOT_SIGNATURE_VERSION_1_0:
2319 switch (pRootSignatureDesc->Version)
2320 {
2321 case D3D_ROOT_SIGNATURE_VERSION_1_0:
2322 return D3D12SerializeRootSignature(&pRootSignatureDesc->Desc_1_0, D3D_ROOT_SIGNATURE_VERSION_1, ppBlob, ppErrorBlob);
2323
2324 case D3D_ROOT_SIGNATURE_VERSION_1_1:
2325 {
2326 HRESULT hr = S_OK;
2327 const D3D12_ROOT_SIGNATURE_DESC1& desc_1_1 = pRootSignatureDesc->Desc_1_1;
2328
2329 const SIZE_T ParametersSize = sizeof(D3D12_ROOT_PARAMETER) * desc_1_1.NumParameters;
2330 void* pParameters = (ParametersSize > 0) ? HeapAlloc(GetProcessHeap(), 0, ParametersSize) : nullptr;
2331 if (ParametersSize > 0 && pParameters == nullptr)
2332 {
2333 hr = E_OUTOFMEMORY;
2334 }
2335 auto pParameters_1_0 = static_cast<D3D12_ROOT_PARAMETER*>(pParameters);
2336
2337 if (SUCCEEDED(hr))
2338 {
2339 for (UINT n = 0; n < desc_1_1.NumParameters; n++)
2340 {
2341 __analysis_assume(ParametersSize == sizeof(D3D12_ROOT_PARAMETER) * desc_1_1.NumParameters);
2342 pParameters_1_0[n].ParameterType = desc_1_1.pParameters[n].ParameterType;
2343 pParameters_1_0[n].ShaderVisibility = desc_1_1.pParameters[n].ShaderVisibility;
2344
2345 switch (desc_1_1.pParameters[n].ParameterType)
2346 {
2347 case D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS:
2348 pParameters_1_0[n].Constants.Num32BitValues = desc_1_1.pParameters[n].Constants.Num32BitValues;
2349 pParameters_1_0[n].Constants.RegisterSpace = desc_1_1.pParameters[n].Constants.RegisterSpace;
2350 pParameters_1_0[n].Constants.ShaderRegister = desc_1_1.pParameters[n].Constants.ShaderRegister;
2351 break;
2352
2353 case D3D12_ROOT_PARAMETER_TYPE_CBV:
2354 case D3D12_ROOT_PARAMETER_TYPE_SRV:
2355 case D3D12_ROOT_PARAMETER_TYPE_UAV:
2356 pParameters_1_0[n].Descriptor.RegisterSpace = desc_1_1.pParameters[n].Descriptor.RegisterSpace;
2357 pParameters_1_0[n].Descriptor.ShaderRegister = desc_1_1.pParameters[n].Descriptor.ShaderRegister;
2358 break;
2359
2360 case D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE:
2361 const D3D12_ROOT_DESCRIPTOR_TABLE1& table_1_1 = desc_1_1.pParameters[n].DescriptorTable;
2362
2363 const SIZE_T DescriptorRangesSize = sizeof(D3D12_DESCRIPTOR_RANGE) * table_1_1.NumDescriptorRanges;
2364 void* pDescriptorRanges = (DescriptorRangesSize > 0 && SUCCEEDED(hr)) ? HeapAlloc(GetProcessHeap(), 0, DescriptorRangesSize) : nullptr;
2365 if (DescriptorRangesSize > 0 && pDescriptorRanges == nullptr)
2366 {
2367 hr = E_OUTOFMEMORY;
2368 }
2369 auto pDescriptorRanges_1_0 = static_cast<D3D12_DESCRIPTOR_RANGE*>(pDescriptorRanges);
2370
2371 if (SUCCEEDED(hr))
2372 {
2373 for (UINT x = 0; x < table_1_1.NumDescriptorRanges; x++)
2374 {
2375 __analysis_assume(DescriptorRangesSize == sizeof(D3D12_DESCRIPTOR_RANGE) * table_1_1.NumDescriptorRanges);
2376 pDescriptorRanges_1_0[x].BaseShaderRegister = table_1_1.pDescriptorRanges[x].BaseShaderRegister;
2377 pDescriptorRanges_1_0[x].NumDescriptors = table_1_1.pDescriptorRanges[x].NumDescriptors;
2378 pDescriptorRanges_1_0[x].OffsetInDescriptorsFromTableStart = table_1_1.pDescriptorRanges[x].OffsetInDescriptorsFromTableStart;
2379 pDescriptorRanges_1_0[x].RangeType = table_1_1.pDescriptorRanges[x].RangeType;
2380 pDescriptorRanges_1_0[x].RegisterSpace = table_1_1.pDescriptorRanges[x].RegisterSpace;
2381 }
2382 }
2383
2384 D3D12_ROOT_DESCRIPTOR_TABLE& table_1_0 = pParameters_1_0[n].DescriptorTable;
2385 table_1_0.NumDescriptorRanges = table_1_1.NumDescriptorRanges;
2386 table_1_0.pDescriptorRanges = pDescriptorRanges_1_0;
2387 }
2388 }
2389 }
2390
2391 if (SUCCEEDED(hr))
2392 {
2393 CD3DX12_ROOT_SIGNATURE_DESC desc_1_0(desc_1_1.NumParameters, pParameters_1_0, desc_1_1.NumStaticSamplers, desc_1_1.pStaticSamplers, desc_1_1.Flags);
2394 hr = D3D12SerializeRootSignature(&desc_1_0, D3D_ROOT_SIGNATURE_VERSION_1, ppBlob, ppErrorBlob);
2395 }
2396
2397 if (pParameters)
2398 {
2399 for (UINT n = 0; n < desc_1_1.NumParameters; n++)
2400 {
2401 if (desc_1_1.pParameters[n].ParameterType == D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE)
2402 {
2403 auto pDescriptorRanges_1_0 = pParameters_1_0[n].DescriptorTable.pDescriptorRanges;
2404 HeapFree(GetProcessHeap(), 0, reinterpret_cast<void*>(const_cast<D3D12_DESCRIPTOR_RANGE*>(pDescriptorRanges_1_0)));
2405 }
2406 }
2407 HeapFree(GetProcessHeap(), 0, pParameters);
2408 }
2409 return hr;
2410 }
2411 }
2412 break;
2413
2414 case D3D_ROOT_SIGNATURE_VERSION_1_1:
2415 return D3D12SerializeVersionedRootSignature(pRootSignatureDesc, ppBlob, ppErrorBlob);
2416 }
2417
2418 return E_INVALIDARG;
2419}
2420
2421//------------------------------------------------------------------------------------------------
2422struct CD3DX12_RT_FORMAT_ARRAY : public D3D12_RT_FORMAT_ARRAY
2423{
2424 CD3DX12_RT_FORMAT_ARRAY() = default;
2425 explicit CD3DX12_RT_FORMAT_ARRAY(const D3D12_RT_FORMAT_ARRAY& o) noexcept
2426 : D3D12_RT_FORMAT_ARRAY(o)
2427 {}
2428 explicit CD3DX12_RT_FORMAT_ARRAY(_In_reads_(NumFormats) const DXGI_FORMAT* pFormats, UINT NumFormats) noexcept
2429 {
2430 NumRenderTargets = NumFormats;
2431 memcpy(RTFormats, pFormats, sizeof(RTFormats));
2432 // assumes ARRAY_SIZE(pFormats) == ARRAY_SIZE(RTFormats)
2433 }
2434};
2435
2436//------------------------------------------------------------------------------------------------
2437// Pipeline State Stream Helpers
2438//------------------------------------------------------------------------------------------------
2439
2440//------------------------------------------------------------------------------------------------
2441// Stream Subobjects, i.e. elements of a stream
2442
2443struct DefaultSampleMask { operator UINT() noexcept { return UINT_MAX; } };
2444struct DefaultSampleDesc { operator DXGI_SAMPLE_DESC() noexcept { return DXGI_SAMPLE_DESC{1, 0}; } };
2445
2446#pragma warning(push)
2447#pragma warning(disable : 4324)
2448template <typename InnerStructType, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE Type, typename DefaultArg = InnerStructType>
2449class alignas(void*) CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT
2450{
2451private:
2452 D3D12_PIPELINE_STATE_SUBOBJECT_TYPE _Type;
2453 InnerStructType _Inner;
2454public:
2455 CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT() noexcept : _Type(Type), _Inner(DefaultArg()) {}
2456 CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT(InnerStructType const& i) noexcept : _Type(Type), _Inner(i) {}
2457 CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT& operator=(InnerStructType const& i) noexcept { _Type = Type; _Inner = i; return *this; }
2458 operator InnerStructType const&() const noexcept { return _Inner; }
2459 operator InnerStructType&() noexcept { return _Inner; }
2460 InnerStructType* operator&() noexcept { return &_Inner; }
2461 InnerStructType const* operator&() const noexcept { return &_Inner; }
2462};
2463#pragma warning(pop)
2464typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_PIPELINE_STATE_FLAGS, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS> CD3DX12_PIPELINE_STATE_STREAM_FLAGS;
2465typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< UINT, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_NODE_MASK> CD3DX12_PIPELINE_STATE_STREAM_NODE_MASK;
2466typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< ID3D12RootSignature*, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE> CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE;
2467typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_INPUT_LAYOUT_DESC, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT> CD3DX12_PIPELINE_STATE_STREAM_INPUT_LAYOUT;
2468typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_INDEX_BUFFER_STRIP_CUT_VALUE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE> CD3DX12_PIPELINE_STATE_STREAM_IB_STRIP_CUT_VALUE;
2469typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_PRIMITIVE_TOPOLOGY_TYPE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY> CD3DX12_PIPELINE_STATE_STREAM_PRIMITIVE_TOPOLOGY;
2470typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VS> CD3DX12_PIPELINE_STATE_STREAM_VS;
2471typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_GS> CD3DX12_PIPELINE_STATE_STREAM_GS;
2472typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_STREAM_OUTPUT_DESC, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT> CD3DX12_PIPELINE_STATE_STREAM_STREAM_OUTPUT;
2473typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_HS> CD3DX12_PIPELINE_STATE_STREAM_HS;
2474typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DS> CD3DX12_PIPELINE_STATE_STREAM_DS;
2475typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PS> CD3DX12_PIPELINE_STATE_STREAM_PS;
2476typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_AS> CD3DX12_PIPELINE_STATE_STREAM_AS;
2477typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MS> CD3DX12_PIPELINE_STATE_STREAM_MS;
2478typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CS> CD3DX12_PIPELINE_STATE_STREAM_CS;
2479typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< CD3DX12_BLEND_DESC, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_BLEND, CD3DX12_DEFAULT> CD3DX12_PIPELINE_STATE_STREAM_BLEND_DESC;
2480typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< CD3DX12_DEPTH_STENCIL_DESC, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL, CD3DX12_DEFAULT> CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL;
2481typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< CD3DX12_DEPTH_STENCIL_DESC1, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1, CD3DX12_DEFAULT> CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL1;
2482typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< DXGI_FORMAT, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT> CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL_FORMAT;
2483typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< CD3DX12_RASTERIZER_DESC, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER, CD3DX12_DEFAULT> CD3DX12_PIPELINE_STATE_STREAM_RASTERIZER;
2484typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_RT_FORMAT_ARRAY, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS> CD3DX12_PIPELINE_STATE_STREAM_RENDER_TARGET_FORMATS;
2485typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< DXGI_SAMPLE_DESC, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_DESC, DefaultSampleDesc> CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_DESC;
2486typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< UINT, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_MASK, DefaultSampleMask> CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_MASK;
2487typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_CACHED_PIPELINE_STATE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CACHED_PSO> CD3DX12_PIPELINE_STATE_STREAM_CACHED_PSO;
2488typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< CD3DX12_VIEW_INSTANCING_DESC, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING, CD3DX12_DEFAULT> CD3DX12_PIPELINE_STATE_STREAM_VIEW_INSTANCING;
2489
2490//------------------------------------------------------------------------------------------------
2491// Stream Parser Helpers
2492
2493struct ID3DX12PipelineParserCallbacks
2494{
2495 // Subobject Callbacks
2496 virtual void FlagsCb(D3D12_PIPELINE_STATE_FLAGS) {}
2497 virtual void NodeMaskCb(UINT) {}
2498 virtual void RootSignatureCb(ID3D12RootSignature*) {}
2499 virtual void InputLayoutCb(const D3D12_INPUT_LAYOUT_DESC&) {}
2500 virtual void IBStripCutValueCb(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE) {}
2501 virtual void PrimitiveTopologyTypeCb(D3D12_PRIMITIVE_TOPOLOGY_TYPE) {}
2502 virtual void VSCb(const D3D12_SHADER_BYTECODE&) {}
2503 virtual void GSCb(const D3D12_SHADER_BYTECODE&) {}
2504 virtual void StreamOutputCb(const D3D12_STREAM_OUTPUT_DESC&) {}
2505 virtual void HSCb(const D3D12_SHADER_BYTECODE&) {}
2506 virtual void DSCb(const D3D12_SHADER_BYTECODE&) {}
2507 virtual void PSCb(const D3D12_SHADER_BYTECODE&) {}
2508 virtual void CSCb(const D3D12_SHADER_BYTECODE&) {}
2509 virtual void ASCb(const D3D12_SHADER_BYTECODE&) {}
2510 virtual void MSCb(const D3D12_SHADER_BYTECODE&) {}
2511 virtual void BlendStateCb(const D3D12_BLEND_DESC&) {}
2512 virtual void DepthStencilStateCb(const D3D12_DEPTH_STENCIL_DESC&) {}
2513 virtual void DepthStencilState1Cb(const D3D12_DEPTH_STENCIL_DESC1&) {}
2514 virtual void DSVFormatCb(DXGI_FORMAT) {}
2515 virtual void RasterizerStateCb(const D3D12_RASTERIZER_DESC&) {}
2516 virtual void RTVFormatsCb(const D3D12_RT_FORMAT_ARRAY&) {}
2517 virtual void SampleDescCb(const DXGI_SAMPLE_DESC&) {}
2518 virtual void SampleMaskCb(UINT) {}
2519 virtual void ViewInstancingCb(const D3D12_VIEW_INSTANCING_DESC&) {}
2520 virtual void CachedPSOCb(const D3D12_CACHED_PIPELINE_STATE&) {}
2521
2522 // Error Callbacks
2523 virtual void ErrorBadInputParameter(UINT /*ParameterIndex*/) {}
2524 virtual void ErrorDuplicateSubobject(D3D12_PIPELINE_STATE_SUBOBJECT_TYPE /*DuplicateType*/) {}
2525 virtual void ErrorUnknownSubobject(UINT /*UnknownTypeValue*/) {}
2526
2527 virtual ~ID3DX12PipelineParserCallbacks() = default;
2528};
2529
2530struct D3DX12_MESH_SHADER_PIPELINE_STATE_DESC
2531{
2532 ID3D12RootSignature* pRootSignature;
2533 D3D12_SHADER_BYTECODE AS;
2534 D3D12_SHADER_BYTECODE MS;
2535 D3D12_SHADER_BYTECODE PS;
2536 D3D12_BLEND_DESC BlendState;
2537 UINT SampleMask;
2538 D3D12_RASTERIZER_DESC RasterizerState;
2539 D3D12_DEPTH_STENCIL_DESC DepthStencilState;
2540 D3D12_PRIMITIVE_TOPOLOGY_TYPE PrimitiveTopologyType;
2541 UINT NumRenderTargets;
2542 DXGI_FORMAT RTVFormats[ D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT ];
2543 DXGI_FORMAT DSVFormat;
2544 DXGI_SAMPLE_DESC SampleDesc;
2545 UINT NodeMask;
2546 D3D12_CACHED_PIPELINE_STATE CachedPSO;
2547 D3D12_PIPELINE_STATE_FLAGS Flags;
2548};
2549
2550// CD3DX12_PIPELINE_STATE_STREAM2 Works on OS Build 19041+ (where there is a new mesh shader pipeline).
2551// Use CD3DX12_PIPELINE_STATE_STREAM1 for OS Build 16299+ (where there is a new view instancing subobject).
2552// Use CD3DX12_PIPELINE_STATE_STREAM for OS Build 15063+ support.
2553struct CD3DX12_PIPELINE_STATE_STREAM2
2554{
2555 CD3DX12_PIPELINE_STATE_STREAM2() = default;
2556 // Mesh and amplification shaders must be set manually, since they do not have representation in D3D12_GRAPHICS_PIPELINE_STATE_DESC
2557 CD3DX12_PIPELINE_STATE_STREAM2(const D3D12_GRAPHICS_PIPELINE_STATE_DESC& Desc) noexcept
2558 : Flags(Desc.Flags)
2559 , NodeMask(Desc.NodeMask)
2560 , pRootSignature(Desc.pRootSignature)
2561 , InputLayout(Desc.InputLayout)
2562 , IBStripCutValue(Desc.IBStripCutValue)
2563 , PrimitiveTopologyType(Desc.PrimitiveTopologyType)
2564 , VS(Desc.VS)
2565 , GS(Desc.GS)
2566 , StreamOutput(Desc.StreamOutput)
2567 , HS(Desc.HS)
2568 , DS(Desc.DS)
2569 , PS(Desc.PS)
2570 , BlendState(CD3DX12_BLEND_DESC(Desc.BlendState))
2571 , DepthStencilState(CD3DX12_DEPTH_STENCIL_DESC1(Desc.DepthStencilState))
2572 , DSVFormat(Desc.DSVFormat)
2573 , RasterizerState(CD3DX12_RASTERIZER_DESC(Desc.RasterizerState))
2574 , RTVFormats(CD3DX12_RT_FORMAT_ARRAY(Desc.RTVFormats, Desc.NumRenderTargets))
2575 , SampleDesc(Desc.SampleDesc)
2576 , SampleMask(Desc.SampleMask)
2577 , CachedPSO(Desc.CachedPSO)
2578 , ViewInstancingDesc(CD3DX12_VIEW_INSTANCING_DESC(CD3DX12_DEFAULT()))
2579 {}
2580 CD3DX12_PIPELINE_STATE_STREAM2(const D3DX12_MESH_SHADER_PIPELINE_STATE_DESC& Desc) noexcept
2581 : Flags(Desc.Flags)
2582 , NodeMask(Desc.NodeMask)
2583 , pRootSignature(Desc.pRootSignature)
2584 , PrimitiveTopologyType(Desc.PrimitiveTopologyType)
2585 , PS(Desc.PS)
2586 , AS(Desc.AS)
2587 , MS(Desc.MS)
2588 , BlendState(CD3DX12_BLEND_DESC(Desc.BlendState))
2589 , DepthStencilState(CD3DX12_DEPTH_STENCIL_DESC1(Desc.DepthStencilState))
2590 , DSVFormat(Desc.DSVFormat)
2591 , RasterizerState(CD3DX12_RASTERIZER_DESC(Desc.RasterizerState))
2592 , RTVFormats(CD3DX12_RT_FORMAT_ARRAY(Desc.RTVFormats, Desc.NumRenderTargets))
2593 , SampleDesc(Desc.SampleDesc)
2594 , SampleMask(Desc.SampleMask)
2595 , CachedPSO(Desc.CachedPSO)
2596 , ViewInstancingDesc(CD3DX12_VIEW_INSTANCING_DESC(CD3DX12_DEFAULT()))
2597 {}
2598 CD3DX12_PIPELINE_STATE_STREAM2(const D3D12_COMPUTE_PIPELINE_STATE_DESC& Desc) noexcept
2599 : Flags(Desc.Flags)
2600 , NodeMask(Desc.NodeMask)
2601 , pRootSignature(Desc.pRootSignature)
2602 , CS(CD3DX12_SHADER_BYTECODE(Desc.CS))
2603 , CachedPSO(Desc.CachedPSO)
2604 {
2605 static_cast<D3D12_DEPTH_STENCIL_DESC1&>(DepthStencilState).DepthEnable = false;
2606 }
2607 CD3DX12_PIPELINE_STATE_STREAM_FLAGS Flags;
2608 CD3DX12_PIPELINE_STATE_STREAM_NODE_MASK NodeMask;
2609 CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE pRootSignature;
2610 CD3DX12_PIPELINE_STATE_STREAM_INPUT_LAYOUT InputLayout;
2611 CD3DX12_PIPELINE_STATE_STREAM_IB_STRIP_CUT_VALUE IBStripCutValue;
2612 CD3DX12_PIPELINE_STATE_STREAM_PRIMITIVE_TOPOLOGY PrimitiveTopologyType;
2613 CD3DX12_PIPELINE_STATE_STREAM_VS VS;
2614 CD3DX12_PIPELINE_STATE_STREAM_GS GS;
2615 CD3DX12_PIPELINE_STATE_STREAM_STREAM_OUTPUT StreamOutput;
2616 CD3DX12_PIPELINE_STATE_STREAM_HS HS;
2617 CD3DX12_PIPELINE_STATE_STREAM_DS DS;
2618 CD3DX12_PIPELINE_STATE_STREAM_PS PS;
2619 CD3DX12_PIPELINE_STATE_STREAM_AS AS;
2620 CD3DX12_PIPELINE_STATE_STREAM_MS MS;
2621 CD3DX12_PIPELINE_STATE_STREAM_CS CS;
2622 CD3DX12_PIPELINE_STATE_STREAM_BLEND_DESC BlendState;
2623 CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL1 DepthStencilState;
2624 CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL_FORMAT DSVFormat;
2625 CD3DX12_PIPELINE_STATE_STREAM_RASTERIZER RasterizerState;
2626 CD3DX12_PIPELINE_STATE_STREAM_RENDER_TARGET_FORMATS RTVFormats;
2627 CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_DESC SampleDesc;
2628 CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_MASK SampleMask;
2629 CD3DX12_PIPELINE_STATE_STREAM_CACHED_PSO CachedPSO;
2630 CD3DX12_PIPELINE_STATE_STREAM_VIEW_INSTANCING ViewInstancingDesc;
2631 D3D12_GRAPHICS_PIPELINE_STATE_DESC GraphicsDescV0() const noexcept
2632 {
2633 D3D12_GRAPHICS_PIPELINE_STATE_DESC D;
2634 D.Flags = this->Flags;
2635 D.NodeMask = this->NodeMask;
2636 D.pRootSignature = this->pRootSignature;
2637 D.InputLayout = this->InputLayout;
2638 D.IBStripCutValue = this->IBStripCutValue;
2639 D.PrimitiveTopologyType = this->PrimitiveTopologyType;
2640 D.VS = this->VS;
2641 D.GS = this->GS;
2642 D.StreamOutput = this->StreamOutput;
2643 D.HS = this->HS;
2644 D.DS = this->DS;
2645 D.PS = this->PS;
2646 D.BlendState = this->BlendState;
2647 D.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC1(D3D12_DEPTH_STENCIL_DESC1(this->DepthStencilState));
2648 D.DSVFormat = this->DSVFormat;
2649 D.RasterizerState = this->RasterizerState;
2650 D.NumRenderTargets = D3D12_RT_FORMAT_ARRAY(this->RTVFormats).NumRenderTargets;
2651 memcpy(D.RTVFormats, D3D12_RT_FORMAT_ARRAY(this->RTVFormats).RTFormats, sizeof(D.RTVFormats));
2652 D.SampleDesc = this->SampleDesc;
2653 D.SampleMask = this->SampleMask;
2654 D.CachedPSO = this->CachedPSO;
2655 return D;
2656 }
2657 D3D12_COMPUTE_PIPELINE_STATE_DESC ComputeDescV0() const noexcept
2658 {
2659 D3D12_COMPUTE_PIPELINE_STATE_DESC D;
2660 D.Flags = this->Flags;
2661 D.NodeMask = this->NodeMask;
2662 D.pRootSignature = this->pRootSignature;
2663 D.CS = this->CS;
2664 D.CachedPSO = this->CachedPSO;
2665 return D;
2666 }
2667};
2668
2669// CD3DX12_PIPELINE_STATE_STREAM1 Works on OS Build 16299+ (where there is a new view instancing subobject).
2670// Use CD3DX12_PIPELINE_STATE_STREAM for OS Build 15063+ support.
2671struct CD3DX12_PIPELINE_STATE_STREAM1
2672{
2673 CD3DX12_PIPELINE_STATE_STREAM1() = default;
2674 // Mesh and amplification shaders must be set manually, since they do not have representation in D3D12_GRAPHICS_PIPELINE_STATE_DESC
2675 CD3DX12_PIPELINE_STATE_STREAM1(const D3D12_GRAPHICS_PIPELINE_STATE_DESC& Desc) noexcept
2676 : Flags(Desc.Flags)
2677 , NodeMask(Desc.NodeMask)
2678 , pRootSignature(Desc.pRootSignature)
2679 , InputLayout(Desc.InputLayout)
2680 , IBStripCutValue(Desc.IBStripCutValue)
2681 , PrimitiveTopologyType(Desc.PrimitiveTopologyType)
2682 , VS(Desc.VS)
2683 , GS(Desc.GS)
2684 , StreamOutput(Desc.StreamOutput)
2685 , HS(Desc.HS)
2686 , DS(Desc.DS)
2687 , PS(Desc.PS)
2688 , BlendState(CD3DX12_BLEND_DESC(Desc.BlendState))
2689 , DepthStencilState(CD3DX12_DEPTH_STENCIL_DESC1(Desc.DepthStencilState))
2690 , DSVFormat(Desc.DSVFormat)
2691 , RasterizerState(CD3DX12_RASTERIZER_DESC(Desc.RasterizerState))
2692 , RTVFormats(CD3DX12_RT_FORMAT_ARRAY(Desc.RTVFormats, Desc.NumRenderTargets))
2693 , SampleDesc(Desc.SampleDesc)
2694 , SampleMask(Desc.SampleMask)
2695 , CachedPSO(Desc.CachedPSO)
2696 , ViewInstancingDesc(CD3DX12_VIEW_INSTANCING_DESC(CD3DX12_DEFAULT()))
2697 {}
2698 CD3DX12_PIPELINE_STATE_STREAM1(const D3DX12_MESH_SHADER_PIPELINE_STATE_DESC& Desc) noexcept
2699 : Flags(Desc.Flags)
2700 , NodeMask(Desc.NodeMask)
2701 , pRootSignature(Desc.pRootSignature)
2702 , PrimitiveTopologyType(Desc.PrimitiveTopologyType)
2703 , PS(Desc.PS)
2704 , BlendState(CD3DX12_BLEND_DESC(Desc.BlendState))
2705 , DepthStencilState(CD3DX12_DEPTH_STENCIL_DESC1(Desc.DepthStencilState))
2706 , DSVFormat(Desc.DSVFormat)
2707 , RasterizerState(CD3DX12_RASTERIZER_DESC(Desc.RasterizerState))
2708 , RTVFormats(CD3DX12_RT_FORMAT_ARRAY(Desc.RTVFormats, Desc.NumRenderTargets))
2709 , SampleDesc(Desc.SampleDesc)
2710 , SampleMask(Desc.SampleMask)
2711 , CachedPSO(Desc.CachedPSO)
2712 , ViewInstancingDesc(CD3DX12_VIEW_INSTANCING_DESC(CD3DX12_DEFAULT()))
2713 {}
2714 CD3DX12_PIPELINE_STATE_STREAM1(const D3D12_COMPUTE_PIPELINE_STATE_DESC& Desc) noexcept
2715 : Flags(Desc.Flags)
2716 , NodeMask(Desc.NodeMask)
2717 , pRootSignature(Desc.pRootSignature)
2718 , CS(CD3DX12_SHADER_BYTECODE(Desc.CS))
2719 , CachedPSO(Desc.CachedPSO)
2720 {
2721 static_cast<D3D12_DEPTH_STENCIL_DESC1&>(DepthStencilState).DepthEnable = false;
2722 }
2723 CD3DX12_PIPELINE_STATE_STREAM_FLAGS Flags;
2724 CD3DX12_PIPELINE_STATE_STREAM_NODE_MASK NodeMask;
2725 CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE pRootSignature;
2726 CD3DX12_PIPELINE_STATE_STREAM_INPUT_LAYOUT InputLayout;
2727 CD3DX12_PIPELINE_STATE_STREAM_IB_STRIP_CUT_VALUE IBStripCutValue;
2728 CD3DX12_PIPELINE_STATE_STREAM_PRIMITIVE_TOPOLOGY PrimitiveTopologyType;
2729 CD3DX12_PIPELINE_STATE_STREAM_VS VS;
2730 CD3DX12_PIPELINE_STATE_STREAM_GS GS;
2731 CD3DX12_PIPELINE_STATE_STREAM_STREAM_OUTPUT StreamOutput;
2732 CD3DX12_PIPELINE_STATE_STREAM_HS HS;
2733 CD3DX12_PIPELINE_STATE_STREAM_DS DS;
2734 CD3DX12_PIPELINE_STATE_STREAM_PS PS;
2735 CD3DX12_PIPELINE_STATE_STREAM_CS CS;
2736 CD3DX12_PIPELINE_STATE_STREAM_BLEND_DESC BlendState;
2737 CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL1 DepthStencilState;
2738 CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL_FORMAT DSVFormat;
2739 CD3DX12_PIPELINE_STATE_STREAM_RASTERIZER RasterizerState;
2740 CD3DX12_PIPELINE_STATE_STREAM_RENDER_TARGET_FORMATS RTVFormats;
2741 CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_DESC SampleDesc;
2742 CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_MASK SampleMask;
2743 CD3DX12_PIPELINE_STATE_STREAM_CACHED_PSO CachedPSO;
2744 CD3DX12_PIPELINE_STATE_STREAM_VIEW_INSTANCING ViewInstancingDesc;
2745 D3D12_GRAPHICS_PIPELINE_STATE_DESC GraphicsDescV0() const noexcept
2746 {
2747 D3D12_GRAPHICS_PIPELINE_STATE_DESC D;
2748 D.Flags = this->Flags;
2749 D.NodeMask = this->NodeMask;
2750 D.pRootSignature = this->pRootSignature;
2751 D.InputLayout = this->InputLayout;
2752 D.IBStripCutValue = this->IBStripCutValue;
2753 D.PrimitiveTopologyType = this->PrimitiveTopologyType;
2754 D.VS = this->VS;
2755 D.GS = this->GS;
2756 D.StreamOutput = this->StreamOutput;
2757 D.HS = this->HS;
2758 D.DS = this->DS;
2759 D.PS = this->PS;
2760 D.BlendState = this->BlendState;
2761 D.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC1(D3D12_DEPTH_STENCIL_DESC1(this->DepthStencilState));
2762 D.DSVFormat = this->DSVFormat;
2763 D.RasterizerState = this->RasterizerState;
2764 D.NumRenderTargets = D3D12_RT_FORMAT_ARRAY(this->RTVFormats).NumRenderTargets;
2765 memcpy(D.RTVFormats, D3D12_RT_FORMAT_ARRAY(this->RTVFormats).RTFormats, sizeof(D.RTVFormats));
2766 D.SampleDesc = this->SampleDesc;
2767 D.SampleMask = this->SampleMask;
2768 D.CachedPSO = this->CachedPSO;
2769 return D;
2770 }
2771 D3D12_COMPUTE_PIPELINE_STATE_DESC ComputeDescV0() const noexcept
2772 {
2773 D3D12_COMPUTE_PIPELINE_STATE_DESC D;
2774 D.Flags = this->Flags;
2775 D.NodeMask = this->NodeMask;
2776 D.pRootSignature = this->pRootSignature;
2777 D.CS = this->CS;
2778 D.CachedPSO = this->CachedPSO;
2779 return D;
2780 }
2781};
2782
2783
2784struct CD3DX12_PIPELINE_MESH_STATE_STREAM
2785{
2786 CD3DX12_PIPELINE_MESH_STATE_STREAM() = default;
2787 CD3DX12_PIPELINE_MESH_STATE_STREAM(const D3DX12_MESH_SHADER_PIPELINE_STATE_DESC& Desc) noexcept
2788 : Flags(Desc.Flags)
2789 , NodeMask(Desc.NodeMask)
2790 , pRootSignature(Desc.pRootSignature)
2791 , PS(Desc.PS)
2792 , AS(Desc.AS)
2793 , MS(Desc.MS)
2794 , BlendState(CD3DX12_BLEND_DESC(Desc.BlendState))
2795 , DepthStencilState(CD3DX12_DEPTH_STENCIL_DESC1(Desc.DepthStencilState))
2796 , DSVFormat(Desc.DSVFormat)
2797 , RasterizerState(CD3DX12_RASTERIZER_DESC(Desc.RasterizerState))
2798 , RTVFormats(CD3DX12_RT_FORMAT_ARRAY(Desc.RTVFormats, Desc.NumRenderTargets))
2799 , SampleDesc(Desc.SampleDesc)
2800 , SampleMask(Desc.SampleMask)
2801 , CachedPSO(Desc.CachedPSO)
2802 , ViewInstancingDesc(CD3DX12_VIEW_INSTANCING_DESC(CD3DX12_DEFAULT()))
2803 {}
2804 CD3DX12_PIPELINE_STATE_STREAM_FLAGS Flags;
2805 CD3DX12_PIPELINE_STATE_STREAM_NODE_MASK NodeMask;
2806 CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE pRootSignature;
2807 CD3DX12_PIPELINE_STATE_STREAM_PS PS;
2808 CD3DX12_PIPELINE_STATE_STREAM_AS AS;
2809 CD3DX12_PIPELINE_STATE_STREAM_MS MS;
2810 CD3DX12_PIPELINE_STATE_STREAM_BLEND_DESC BlendState;
2811 CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL1 DepthStencilState;
2812 CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL_FORMAT DSVFormat;
2813 CD3DX12_PIPELINE_STATE_STREAM_RASTERIZER RasterizerState;
2814 CD3DX12_PIPELINE_STATE_STREAM_RENDER_TARGET_FORMATS RTVFormats;
2815 CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_DESC SampleDesc;
2816 CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_MASK SampleMask;
2817 CD3DX12_PIPELINE_STATE_STREAM_CACHED_PSO CachedPSO;
2818 CD3DX12_PIPELINE_STATE_STREAM_VIEW_INSTANCING ViewInstancingDesc;
2819 D3DX12_MESH_SHADER_PIPELINE_STATE_DESC MeshShaderDescV0() const noexcept
2820 {
2821 D3DX12_MESH_SHADER_PIPELINE_STATE_DESC D;
2822 D.Flags = this->Flags;
2823 D.NodeMask = this->NodeMask;
2824 D.pRootSignature = this->pRootSignature;
2825 D.PS = this->PS;
2826 D.AS = this->AS;
2827 D.MS = this->MS;
2828 D.BlendState = this->BlendState;
2829 D.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC1(D3D12_DEPTH_STENCIL_DESC1(this->DepthStencilState));
2830 D.DSVFormat = this->DSVFormat;
2831 D.RasterizerState = this->RasterizerState;
2832 D.NumRenderTargets = D3D12_RT_FORMAT_ARRAY(this->RTVFormats).NumRenderTargets;
2833 memcpy(D.RTVFormats, D3D12_RT_FORMAT_ARRAY(this->RTVFormats).RTFormats, sizeof(D.RTVFormats));
2834 D.SampleDesc = this->SampleDesc;
2835 D.SampleMask = this->SampleMask;
2836 D.CachedPSO = this->CachedPSO;
2837 return D;
2838 }
2839};
2840
2841// CD3DX12_PIPELINE_STATE_STREAM works on OS Build 15063+ but does not support new subobject(s) added in OS Build 16299+.
2842// See CD3DX12_PIPELINE_STATE_STREAM1 for instance.
2843struct CD3DX12_PIPELINE_STATE_STREAM
2844{
2845 CD3DX12_PIPELINE_STATE_STREAM() = default;
2846 CD3DX12_PIPELINE_STATE_STREAM(const D3D12_GRAPHICS_PIPELINE_STATE_DESC& Desc) noexcept
2847 : Flags(Desc.Flags)
2848 , NodeMask(Desc.NodeMask)
2849 , pRootSignature(Desc.pRootSignature)
2850 , InputLayout(Desc.InputLayout)
2851 , IBStripCutValue(Desc.IBStripCutValue)
2852 , PrimitiveTopologyType(Desc.PrimitiveTopologyType)
2853 , VS(Desc.VS)
2854 , GS(Desc.GS)
2855 , StreamOutput(Desc.StreamOutput)
2856 , HS(Desc.HS)
2857 , DS(Desc.DS)
2858 , PS(Desc.PS)
2859 , BlendState(CD3DX12_BLEND_DESC(Desc.BlendState))
2860 , DepthStencilState(CD3DX12_DEPTH_STENCIL_DESC1(Desc.DepthStencilState))
2861 , DSVFormat(Desc.DSVFormat)
2862 , RasterizerState(CD3DX12_RASTERIZER_DESC(Desc.RasterizerState))
2863 , RTVFormats(CD3DX12_RT_FORMAT_ARRAY(Desc.RTVFormats, Desc.NumRenderTargets))
2864 , SampleDesc(Desc.SampleDesc)
2865 , SampleMask(Desc.SampleMask)
2866 , CachedPSO(Desc.CachedPSO)
2867 {}
2868 CD3DX12_PIPELINE_STATE_STREAM(const D3D12_COMPUTE_PIPELINE_STATE_DESC& Desc) noexcept
2869 : Flags(Desc.Flags)
2870 , NodeMask(Desc.NodeMask)
2871 , pRootSignature(Desc.pRootSignature)
2872 , CS(CD3DX12_SHADER_BYTECODE(Desc.CS))
2873 , CachedPSO(Desc.CachedPSO)
2874 {}
2875 CD3DX12_PIPELINE_STATE_STREAM_FLAGS Flags;
2876 CD3DX12_PIPELINE_STATE_STREAM_NODE_MASK NodeMask;
2877 CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE pRootSignature;
2878 CD3DX12_PIPELINE_STATE_STREAM_INPUT_LAYOUT InputLayout;
2879 CD3DX12_PIPELINE_STATE_STREAM_IB_STRIP_CUT_VALUE IBStripCutValue;
2880 CD3DX12_PIPELINE_STATE_STREAM_PRIMITIVE_TOPOLOGY PrimitiveTopologyType;
2881 CD3DX12_PIPELINE_STATE_STREAM_VS VS;
2882 CD3DX12_PIPELINE_STATE_STREAM_GS GS;
2883 CD3DX12_PIPELINE_STATE_STREAM_STREAM_OUTPUT StreamOutput;
2884 CD3DX12_PIPELINE_STATE_STREAM_HS HS;
2885 CD3DX12_PIPELINE_STATE_STREAM_DS DS;
2886 CD3DX12_PIPELINE_STATE_STREAM_PS PS;
2887 CD3DX12_PIPELINE_STATE_STREAM_CS CS;
2888 CD3DX12_PIPELINE_STATE_STREAM_BLEND_DESC BlendState;
2889 CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL1 DepthStencilState;
2890 CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL_FORMAT DSVFormat;
2891 CD3DX12_PIPELINE_STATE_STREAM_RASTERIZER RasterizerState;
2892 CD3DX12_PIPELINE_STATE_STREAM_RENDER_TARGET_FORMATS RTVFormats;
2893 CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_DESC SampleDesc;
2894 CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_MASK SampleMask;
2895 CD3DX12_PIPELINE_STATE_STREAM_CACHED_PSO CachedPSO;
2896 D3D12_GRAPHICS_PIPELINE_STATE_DESC GraphicsDescV0() const noexcept
2897 {
2898 D3D12_GRAPHICS_PIPELINE_STATE_DESC D;
2899 D.Flags = this->Flags;
2900 D.NodeMask = this->NodeMask;
2901 D.pRootSignature = this->pRootSignature;
2902 D.InputLayout = this->InputLayout;
2903 D.IBStripCutValue = this->IBStripCutValue;
2904 D.PrimitiveTopologyType = this->PrimitiveTopologyType;
2905 D.VS = this->VS;
2906 D.GS = this->GS;
2907 D.StreamOutput = this->StreamOutput;
2908 D.HS = this->HS;
2909 D.DS = this->DS;
2910 D.PS = this->PS;
2911 D.BlendState = this->BlendState;
2912 D.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC1(D3D12_DEPTH_STENCIL_DESC1(this->DepthStencilState));
2913 D.DSVFormat = this->DSVFormat;
2914 D.RasterizerState = this->RasterizerState;
2915 D.NumRenderTargets = D3D12_RT_FORMAT_ARRAY(this->RTVFormats).NumRenderTargets;
2916 memcpy(D.RTVFormats, D3D12_RT_FORMAT_ARRAY(this->RTVFormats).RTFormats, sizeof(D.RTVFormats));
2917 D.SampleDesc = this->SampleDesc;
2918 D.SampleMask = this->SampleMask;
2919 D.CachedPSO = this->CachedPSO;
2920 return D;
2921 }
2922 D3D12_COMPUTE_PIPELINE_STATE_DESC ComputeDescV0() const noexcept
2923 {
2924 D3D12_COMPUTE_PIPELINE_STATE_DESC D;
2925 D.Flags = this->Flags;
2926 D.NodeMask = this->NodeMask;
2927 D.pRootSignature = this->pRootSignature;
2928 D.CS = this->CS;
2929 D.CachedPSO = this->CachedPSO;
2930 return D;
2931 }
2932};
2933
2934struct CD3DX12_PIPELINE_STATE_STREAM2_PARSE_HELPER : public ID3DX12PipelineParserCallbacks
2935{
2936 CD3DX12_PIPELINE_STATE_STREAM2 PipelineStream;
2937 CD3DX12_PIPELINE_STATE_STREAM2_PARSE_HELPER() noexcept
2938 : SeenDSS(false)
2939 {
2940 // Adjust defaults to account for absent members.
2941 PipelineStream.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
2942
2943 // Depth disabled if no DSV format specified.
2944 static_cast<D3D12_DEPTH_STENCIL_DESC1&>(PipelineStream.DepthStencilState).DepthEnable = false;
2945 }
2946
2947 // ID3DX12PipelineParserCallbacks
2948 void FlagsCb(D3D12_PIPELINE_STATE_FLAGS Flags) override {PipelineStream.Flags = Flags;}
2949 void NodeMaskCb(UINT NodeMask) override {PipelineStream.NodeMask = NodeMask;}
2950 void RootSignatureCb(ID3D12RootSignature* pRootSignature) override {PipelineStream.pRootSignature = pRootSignature;}
2951 void InputLayoutCb(const D3D12_INPUT_LAYOUT_DESC& InputLayout) override {PipelineStream.InputLayout = InputLayout;}
2952 void IBStripCutValueCb(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE IBStripCutValue) override {PipelineStream.IBStripCutValue = IBStripCutValue;}
2953 void PrimitiveTopologyTypeCb(D3D12_PRIMITIVE_TOPOLOGY_TYPE PrimitiveTopologyType) override {PipelineStream.PrimitiveTopologyType = PrimitiveTopologyType;}
2954 void VSCb(const D3D12_SHADER_BYTECODE& VS) override {PipelineStream.VS = VS;}
2955 void GSCb(const D3D12_SHADER_BYTECODE& GS) override {PipelineStream.GS = GS;}
2956 void StreamOutputCb(const D3D12_STREAM_OUTPUT_DESC& StreamOutput) override {PipelineStream.StreamOutput = StreamOutput;}
2957 void HSCb(const D3D12_SHADER_BYTECODE& HS) override {PipelineStream.HS = HS;}
2958 void DSCb(const D3D12_SHADER_BYTECODE& DS) override {PipelineStream.DS = DS;}
2959 void PSCb(const D3D12_SHADER_BYTECODE& PS) override {PipelineStream.PS = PS;}
2960 void CSCb(const D3D12_SHADER_BYTECODE& CS) override {PipelineStream.CS = CS;}
2961 void ASCb(const D3D12_SHADER_BYTECODE& AS) override {PipelineStream.AS = AS;}
2962 void MSCb(const D3D12_SHADER_BYTECODE& MS) override {PipelineStream.MS = MS;}
2963 void BlendStateCb(const D3D12_BLEND_DESC& BlendState) override {PipelineStream.BlendState = CD3DX12_BLEND_DESC(BlendState);}
2964 void DepthStencilStateCb(const D3D12_DEPTH_STENCIL_DESC& DepthStencilState) override
2965 {
2966 PipelineStream.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC1(DepthStencilState);
2967 SeenDSS = true;
2968 }
2969 void DepthStencilState1Cb(const D3D12_DEPTH_STENCIL_DESC1& DepthStencilState) override
2970 {
2971 PipelineStream.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC1(DepthStencilState);
2972 SeenDSS = true;
2973 }
2974 void DSVFormatCb(DXGI_FORMAT DSVFormat) override
2975 {
2976 PipelineStream.DSVFormat = DSVFormat;
2977 if (!SeenDSS && DSVFormat != DXGI_FORMAT_UNKNOWN)
2978 {
2979 // Re-enable depth for the default state.
2980 static_cast<D3D12_DEPTH_STENCIL_DESC1&>(PipelineStream.DepthStencilState).DepthEnable = true;
2981 }
2982 }
2983 void RasterizerStateCb(const D3D12_RASTERIZER_DESC& RasterizerState) override {PipelineStream.RasterizerState = CD3DX12_RASTERIZER_DESC(RasterizerState);}
2984 void RTVFormatsCb(const D3D12_RT_FORMAT_ARRAY& RTVFormats) override {PipelineStream.RTVFormats = RTVFormats;}
2985 void SampleDescCb(const DXGI_SAMPLE_DESC& SampleDesc) override {PipelineStream.SampleDesc = SampleDesc;}
2986 void SampleMaskCb(UINT SampleMask) override {PipelineStream.SampleMask = SampleMask;}
2987 void ViewInstancingCb(const D3D12_VIEW_INSTANCING_DESC& ViewInstancingDesc) override {PipelineStream.ViewInstancingDesc = CD3DX12_VIEW_INSTANCING_DESC(ViewInstancingDesc);}
2988 void CachedPSOCb(const D3D12_CACHED_PIPELINE_STATE& CachedPSO) override {PipelineStream.CachedPSO = CachedPSO;}
2989
2990private:
2991 bool SeenDSS;
2992};
2993
2994
2995struct CD3DX12_PIPELINE_STATE_STREAM_PARSE_HELPER : public ID3DX12PipelineParserCallbacks
2996{
2997 CD3DX12_PIPELINE_STATE_STREAM1 PipelineStream;
2998 CD3DX12_PIPELINE_STATE_STREAM_PARSE_HELPER() noexcept
2999 : SeenDSS(false)
3000 {
3001 // Adjust defaults to account for absent members.
3002 PipelineStream.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
3003
3004 // Depth disabled if no DSV format specified.
3005 static_cast<D3D12_DEPTH_STENCIL_DESC1&>(PipelineStream.DepthStencilState).DepthEnable = false;
3006 }
3007
3008 // ID3DX12PipelineParserCallbacks
3009 void FlagsCb(D3D12_PIPELINE_STATE_FLAGS Flags) override {PipelineStream.Flags = Flags;}
3010 void NodeMaskCb(UINT NodeMask) override {PipelineStream.NodeMask = NodeMask;}
3011 void RootSignatureCb(ID3D12RootSignature* pRootSignature) override {PipelineStream.pRootSignature = pRootSignature;}
3012 void InputLayoutCb(const D3D12_INPUT_LAYOUT_DESC& InputLayout) override {PipelineStream.InputLayout = InputLayout;}
3013 void IBStripCutValueCb(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE IBStripCutValue) override {PipelineStream.IBStripCutValue = IBStripCutValue;}
3014 void PrimitiveTopologyTypeCb(D3D12_PRIMITIVE_TOPOLOGY_TYPE PrimitiveTopologyType) override {PipelineStream.PrimitiveTopologyType = PrimitiveTopologyType;}
3015 void VSCb(const D3D12_SHADER_BYTECODE& VS) override {PipelineStream.VS = VS;}
3016 void GSCb(const D3D12_SHADER_BYTECODE& GS) override {PipelineStream.GS = GS;}
3017 void StreamOutputCb(const D3D12_STREAM_OUTPUT_DESC& StreamOutput) override {PipelineStream.StreamOutput = StreamOutput;}
3018 void HSCb(const D3D12_SHADER_BYTECODE& HS) override {PipelineStream.HS = HS;}
3019 void DSCb(const D3D12_SHADER_BYTECODE& DS) override {PipelineStream.DS = DS;}
3020 void PSCb(const D3D12_SHADER_BYTECODE& PS) override {PipelineStream.PS = PS;}
3021 void CSCb(const D3D12_SHADER_BYTECODE& CS) override {PipelineStream.CS = CS;}
3022 void BlendStateCb(const D3D12_BLEND_DESC& BlendState) override {PipelineStream.BlendState = CD3DX12_BLEND_DESC(BlendState);}
3023 void DepthStencilStateCb(const D3D12_DEPTH_STENCIL_DESC& DepthStencilState) override
3024 {
3025 PipelineStream.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC1(DepthStencilState);
3026 SeenDSS = true;
3027 }
3028 void DepthStencilState1Cb(const D3D12_DEPTH_STENCIL_DESC1& DepthStencilState) override
3029 {
3030 PipelineStream.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC1(DepthStencilState);
3031 SeenDSS = true;
3032 }
3033 void DSVFormatCb(DXGI_FORMAT DSVFormat) override
3034 {
3035 PipelineStream.DSVFormat = DSVFormat;
3036 if (!SeenDSS && DSVFormat != DXGI_FORMAT_UNKNOWN)
3037 {
3038 // Re-enable depth for the default state.
3039 static_cast<D3D12_DEPTH_STENCIL_DESC1&>(PipelineStream.DepthStencilState).DepthEnable = true;
3040 }
3041 }
3042 void RasterizerStateCb(const D3D12_RASTERIZER_DESC& RasterizerState) override {PipelineStream.RasterizerState = CD3DX12_RASTERIZER_DESC(RasterizerState);}
3043 void RTVFormatsCb(const D3D12_RT_FORMAT_ARRAY& RTVFormats) override {PipelineStream.RTVFormats = RTVFormats;}
3044 void SampleDescCb(const DXGI_SAMPLE_DESC& SampleDesc) override {PipelineStream.SampleDesc = SampleDesc;}
3045 void SampleMaskCb(UINT SampleMask) override {PipelineStream.SampleMask = SampleMask;}
3046 void ViewInstancingCb(const D3D12_VIEW_INSTANCING_DESC& ViewInstancingDesc) override {PipelineStream.ViewInstancingDesc = CD3DX12_VIEW_INSTANCING_DESC(ViewInstancingDesc);}
3047 void CachedPSOCb(const D3D12_CACHED_PIPELINE_STATE& CachedPSO) override {PipelineStream.CachedPSO = CachedPSO;}
3048
3049private:
3050 bool SeenDSS;
3051};
3052
3053inline D3D12_PIPELINE_STATE_SUBOBJECT_TYPE D3DX12GetBaseSubobjectType(D3D12_PIPELINE_STATE_SUBOBJECT_TYPE SubobjectType) noexcept
3054{
3055 switch (SubobjectType)
3056 {
3057 case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1:
3058 return D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL;
3059 default:
3060 return SubobjectType;
3061 }
3062}
3063
3064inline HRESULT D3DX12ParsePipelineStream(const D3D12_PIPELINE_STATE_STREAM_DESC& Desc, ID3DX12PipelineParserCallbacks* pCallbacks)
3065{
3066 if (pCallbacks == nullptr)
3067 {
3068 return E_INVALIDARG;
3069 }
3070
3071 if (Desc.SizeInBytes == 0 || Desc.pPipelineStateSubobjectStream == nullptr)
3072 {
3073 pCallbacks->ErrorBadInputParameter(1); // first parameter issue
3074 return E_INVALIDARG;
3075 }
3076
3077 bool SubobjectSeen[D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MAX_VALID] = {};
3078 for (SIZE_T CurOffset = 0, SizeOfSubobject = 0; CurOffset < Desc.SizeInBytes; CurOffset += SizeOfSubobject)
3079 {
3080 BYTE* pStream = static_cast<BYTE*>(Desc.pPipelineStateSubobjectStream)+CurOffset;
3081 auto SubobjectType = *reinterpret_cast<D3D12_PIPELINE_STATE_SUBOBJECT_TYPE*>(pStream);
3082 if (SubobjectType < 0 || SubobjectType >= D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MAX_VALID)
3083 {
3084 pCallbacks->ErrorUnknownSubobject(SubobjectType);
3085 return E_INVALIDARG;
3086 }
3087 if (SubobjectSeen[D3DX12GetBaseSubobjectType(SubobjectType)])
3088 {
3089 pCallbacks->ErrorDuplicateSubobject(SubobjectType);
3090 return E_INVALIDARG; // disallow subobject duplicates in a stream
3091 }
3092 SubobjectSeen[SubobjectType] = true;
3093 switch (SubobjectType)
3094 {
3095 case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE:
3096 pCallbacks->RootSignatureCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::pRootSignature)*>(pStream));
3097 SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::pRootSignature);
3098 break;
3099 case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VS:
3100 pCallbacks->VSCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::VS)*>(pStream));
3101 SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::VS);
3102 break;
3103 case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PS:
3104 pCallbacks->PSCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::PS)*>(pStream));
3105 SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::PS);
3106 break;
3107 case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DS:
3108 pCallbacks->DSCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::DS)*>(pStream));
3109 SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::DS);
3110 break;
3111 case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_HS:
3112 pCallbacks->HSCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::HS)*>(pStream));
3113 SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::HS);
3114 break;
3115 case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_GS:
3116 pCallbacks->GSCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::GS)*>(pStream));
3117 SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::GS);
3118 break;
3119 case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CS:
3120 pCallbacks->CSCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::CS)*>(pStream));
3121 SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::CS);
3122 break;
3123 case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_AS:
3124 pCallbacks->ASCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM2::AS)*>(pStream));
3125 SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM2::AS);
3126 break;
3127 case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MS:
3128 pCallbacks->MSCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM2::MS)*>(pStream));
3129 SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM2::MS);
3130 break;
3131 case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT:
3132 pCallbacks->StreamOutputCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::StreamOutput)*>(pStream));
3133 SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::StreamOutput);
3134 break;
3135 case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_BLEND:
3136 pCallbacks->BlendStateCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::BlendState)*>(pStream));
3137 SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::BlendState);
3138 break;
3139 case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_MASK:
3140 pCallbacks->SampleMaskCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::SampleMask)*>(pStream));
3141 SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::SampleMask);
3142 break;
3143 case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER:
3144 pCallbacks->RasterizerStateCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::RasterizerState)*>(pStream));
3145 SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::RasterizerState);
3146 break;
3147 case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL:
3148 pCallbacks->DepthStencilStateCb(*reinterpret_cast<CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL*>(pStream));
3149 SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL);
3150 break;
3151 case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1:
3152 pCallbacks->DepthStencilState1Cb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::DepthStencilState)*>(pStream));
3153 SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::DepthStencilState);
3154 break;
3155 case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT:
3156 pCallbacks->InputLayoutCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::InputLayout)*>(pStream));
3157 SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::InputLayout);
3158 break;
3159 case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE:
3160 pCallbacks->IBStripCutValueCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::IBStripCutValue)*>(pStream));
3161 SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::IBStripCutValue);
3162 break;
3163 case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY:
3164 pCallbacks->PrimitiveTopologyTypeCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::PrimitiveTopologyType)*>(pStream));
3165 SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::PrimitiveTopologyType);
3166 break;
3167 case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS:
3168 pCallbacks->RTVFormatsCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::RTVFormats)*>(pStream));
3169 SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::RTVFormats);
3170 break;
3171 case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT:
3172 pCallbacks->DSVFormatCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::DSVFormat)*>(pStream));
3173 SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::DSVFormat);
3174 break;
3175 case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_DESC:
3176 pCallbacks->SampleDescCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::SampleDesc)*>(pStream));
3177 SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::SampleDesc);
3178 break;
3179 case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_NODE_MASK:
3180 pCallbacks->NodeMaskCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::NodeMask)*>(pStream));
3181 SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::NodeMask);
3182 break;
3183 case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CACHED_PSO:
3184 pCallbacks->CachedPSOCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::CachedPSO)*>(pStream));
3185 SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::CachedPSO);
3186 break;
3187 case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS:
3188 pCallbacks->FlagsCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::Flags)*>(pStream));
3189 SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::Flags);
3190 break;
3191 case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING:
3192 pCallbacks->ViewInstancingCb(*reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM1::ViewInstancingDesc)*>(pStream));
3193 SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM1::ViewInstancingDesc);
3194 break;
3195 default:
3196 pCallbacks->ErrorUnknownSubobject(SubobjectType);
3197 return E_INVALIDARG;
3198 }
3199 }
3200
3201 return S_OK;
3202}
3203
3204//------------------------------------------------------------------------------------------------
3205inline bool operator==( const D3D12_CLEAR_VALUE &a, const D3D12_CLEAR_VALUE &b) noexcept
3206{
3207 if (a.Format != b.Format) return false;
3208 if (a.Format == DXGI_FORMAT_D24_UNORM_S8_UINT
3209 || a.Format == DXGI_FORMAT_D16_UNORM
3210 || a.Format == DXGI_FORMAT_D32_FLOAT
3211 || a.Format == DXGI_FORMAT_D32_FLOAT_S8X24_UINT)
3212 {
3213 return (a.DepthStencil.Depth == b.DepthStencil.Depth) &&
3214 (a.DepthStencil.Stencil == b.DepthStencil.Stencil);
3215 } else {
3216 return (a.Color[0] == b.Color[0]) &&
3217 (a.Color[1] == b.Color[1]) &&
3218 (a.Color[2] == b.Color[2]) &&
3219 (a.Color[3] == b.Color[3]);
3220 }
3221}
3222inline bool operator==( const D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS &a, const D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS &b) noexcept
3223{
3224 return a.ClearValue == b.ClearValue;
3225}
3226inline bool operator==( const D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS &a, const D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS &b) noexcept
3227{
3228 if (a.pSrcResource != b.pSrcResource) return false;
3229 if (a.pDstResource != b.pDstResource) return false;
3230 if (a.SubresourceCount != b.SubresourceCount) return false;
3231 if (a.Format != b.Format) return false;
3232 if (a.ResolveMode != b.ResolveMode) return false;
3233 if (a.PreserveResolveSource != b.PreserveResolveSource) return false;
3234 return true;
3235}
3236inline bool operator==( const D3D12_RENDER_PASS_BEGINNING_ACCESS &a, const D3D12_RENDER_PASS_BEGINNING_ACCESS &b) noexcept
3237{
3238 if (a.Type != b.Type) return false;
3239 if (a.Type == D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR && !(a.Clear == b.Clear)) return false;
3240 return true;
3241}
3242inline bool operator==( const D3D12_RENDER_PASS_ENDING_ACCESS &a, const D3D12_RENDER_PASS_ENDING_ACCESS &b) noexcept
3243{
3244 if (a.Type != b.Type) return false;
3245 if (a.Type == D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE && !(a.Resolve == b.Resolve)) return false;
3246 return true;
3247}
3248inline bool operator==( const D3D12_RENDER_PASS_RENDER_TARGET_DESC &a, const D3D12_RENDER_PASS_RENDER_TARGET_DESC &b) noexcept
3249{
3250 if (a.cpuDescriptor.ptr != b.cpuDescriptor.ptr) return false;
3251 if (!(a.BeginningAccess == b.BeginningAccess)) return false;
3252 if (!(a.EndingAccess == b.EndingAccess)) return false;
3253 return true;
3254}
3255inline bool operator==( const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC &a, const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC &b) noexcept
3256{
3257 if (a.cpuDescriptor.ptr != b.cpuDescriptor.ptr) return false;
3258 if (!(a.DepthBeginningAccess == b.DepthBeginningAccess)) return false;
3259 if (!(a.StencilBeginningAccess == b.StencilBeginningAccess)) return false;
3260 if (!(a.DepthEndingAccess == b.DepthEndingAccess)) return false;
3261 if (!(a.StencilEndingAccess == b.StencilEndingAccess)) return false;
3262 return true;
3263}
3264
3265
3266#ifndef D3DX12_NO_STATE_OBJECT_HELPERS
3267
3268//================================================================================================
3269// D3DX12 State Object Creation Helpers
3270//
3271// Helper classes for creating new style state objects out of an arbitrary set of subobjects.
3272// Uses STL
3273//
3274// Start by instantiating CD3DX12_STATE_OBJECT_DESC (see it's public methods).
3275// One of its methods is CreateSubobject(), which has a comment showing a couple of options for
3276// defining subobjects using the helper classes for each subobject (CD3DX12_DXIL_LIBRARY_SUBOBJECT
3277// etc.). The subobject helpers each have methods specific to the subobject for configuring it's
3278// contents.
3279//
3280//================================================================================================
3281#include <list>
3282#include <vector>
3283#include <string>
3284#include <memory>
3285#ifndef D3DX12_USE_ATL
3286#include <wrl/client.h>
3287#define D3DX12_COM_PTR Microsoft::WRL::ComPtr
3288#define D3DX12_COM_PTR_GET(x) x.Get()
3289#define D3DX12_COM_PTR_ADDRESSOF(x) x.GetAddressOf()
3290#else
3291#include <atlbase.h>
3292#define D3DX12_COM_PTR ATL::CComPtr
3293#define D3DX12_COM_PTR_GET(x) x.p
3294#define D3DX12_COM_PTR_ADDRESSOF(x) &x.p
3295#endif
3296
3297//------------------------------------------------------------------------------------------------
3298class CD3DX12_STATE_OBJECT_DESC
3299{
3300public:
3301 CD3DX12_STATE_OBJECT_DESC() noexcept
3302 {
3303 Init(D3D12_STATE_OBJECT_TYPE_COLLECTION);
3304 }
3305 CD3DX12_STATE_OBJECT_DESC(D3D12_STATE_OBJECT_TYPE Type) noexcept
3306 {
3307 Init(Type);
3308 }
3309 void SetStateObjectType(D3D12_STATE_OBJECT_TYPE Type) noexcept { m_Desc.Type = Type; }
3310 operator const D3D12_STATE_OBJECT_DESC&()
3311 {
3312 // Do final preparation work
3313 m_RepointedAssociations.clear();
3314 m_SubobjectArray.clear();
3315 m_SubobjectArray.reserve(m_Desc.NumSubobjects);
3316 // Flatten subobjects into an array (each flattened subobject still has a
3317 // member that's a pointer to it's desc that's not flattened)
3318 for (auto Iter = m_SubobjectList.begin();
3319 Iter != m_SubobjectList.end(); Iter++)
3320 {
3321 m_SubobjectArray.push_back(*Iter);
3322 // Store new location in array so we can redirect pointers contained in subobjects
3323 Iter->pSubobjectArrayLocation = &m_SubobjectArray.back();
3324 }
3325 // For subobjects with pointer fields, create a new copy of those subobject definitions
3326 // with fixed pointers
3327 for (UINT i = 0; i < m_Desc.NumSubobjects; i++)
3328 {
3329 if (m_SubobjectArray[i].Type == D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION)
3330 {
3331 auto pOriginalSubobjectAssociation =
3332 static_cast<const D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION*>(m_SubobjectArray[i].pDesc);
3333 D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION Repointed = *pOriginalSubobjectAssociation;
3334 auto pWrapper =
3335 static_cast<const SUBOBJECT_WRAPPER*>(pOriginalSubobjectAssociation->pSubobjectToAssociate);
3336 Repointed.pSubobjectToAssociate = pWrapper->pSubobjectArrayLocation;
3337 m_RepointedAssociations.push_back(Repointed);
3338 m_SubobjectArray[i].pDesc = &m_RepointedAssociations.back();
3339 }
3340 }
3341 // Below: using ugly way to get pointer in case .data() is not defined
3342 m_Desc.pSubobjects = m_Desc.NumSubobjects ? &m_SubobjectArray[0] : nullptr;
3343 return m_Desc;
3344 }
3345 operator const D3D12_STATE_OBJECT_DESC*()
3346 {
3347 // Cast calls the above final preparation work
3348 return &static_cast<const D3D12_STATE_OBJECT_DESC&>(*this);
3349 }
3350
3351 // CreateSubobject creates a sububject helper (e.g. CD3DX12_HIT_GROUP_SUBOBJECT)
3352 // whose lifetime is owned by this class.
3353 // e.g.
3354 //
3355 // CD3DX12_STATE_OBJECT_DESC Collection1(D3D12_STATE_OBJECT_TYPE_COLLECTION);
3356 // auto Lib0 = Collection1.CreateSubobject<CD3DX12_DXIL_LIBRARY_SUBOBJECT>();
3357 // Lib0->SetDXILLibrary(&pMyAppDxilLibs[0]);
3358 // Lib0->DefineExport(L"rayGenShader0"); // in practice these export listings might be
3359 // // data/engine driven
3360 // etc.
3361 //
3362 // Alternatively, users can instantiate sububject helpers explicitly, such as via local
3363 // variables instead, passing the state object desc that should point to it into the helper
3364 // constructor (or call mySubobjectHelper.AddToStateObject(Collection1)).
3365 // In this alternative scenario, the user must keep the subobject alive as long as the state
3366 // object it is associated with is alive, else it's pointer references will be stale.
3367 // e.g.
3368 //
3369 // CD3DX12_STATE_OBJECT_DESC RaytracingState2(D3D12_STATE_OBJECT_TYPE_RAYTRACING_PIPELINE);
3370 // CD3DX12_DXIL_LIBRARY_SUBOBJECT LibA(RaytracingState2);
3371 // LibA.SetDXILLibrary(&pMyAppDxilLibs[4]); // not manually specifying exports
3372 // // - meaning all exports in the libraries
3373 // // are exported
3374 // etc.
3375
3376 template<typename T>
3377 T* CreateSubobject()
3378 {
3379 T* pSubobject = new T(*this);
3380 m_OwnedSubobjectHelpers.emplace_back(pSubobject);
3381 return pSubobject;
3382 }
3383
3384private:
3385 D3D12_STATE_SUBOBJECT* TrackSubobject(D3D12_STATE_SUBOBJECT_TYPE Type, void* pDesc)
3386 {
3387 SUBOBJECT_WRAPPER Subobject;
3388 Subobject.pSubobjectArrayLocation = nullptr;
3389 Subobject.Type = Type;
3390 Subobject.pDesc = pDesc;
3391 m_SubobjectList.push_back(Subobject);
3392 m_Desc.NumSubobjects++;
3393 return &m_SubobjectList.back();
3394 }
3395 void Init(D3D12_STATE_OBJECT_TYPE Type) noexcept
3396 {
3397 SetStateObjectType(Type);
3398 m_Desc.pSubobjects = nullptr;
3399 m_Desc.NumSubobjects = 0;
3400 m_SubobjectList.clear();
3401 m_SubobjectArray.clear();
3402 m_RepointedAssociations.clear();
3403 }
3404 typedef struct SUBOBJECT_WRAPPER : public D3D12_STATE_SUBOBJECT
3405 {
3406 D3D12_STATE_SUBOBJECT* pSubobjectArrayLocation; // new location when flattened into array
3407 // for repointing pointers in subobjects
3408 } SUBOBJECT_WRAPPER;
3409 D3D12_STATE_OBJECT_DESC m_Desc;
3410 std::list<SUBOBJECT_WRAPPER> m_SubobjectList; // Pointers to list nodes handed out so
3411 // these can be edited live
3412 std::vector<D3D12_STATE_SUBOBJECT> m_SubobjectArray; // Built at the end, copying list contents
3413
3414 std::list<D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION>
3415 m_RepointedAssociations; // subobject type that contains pointers to other subobjects,
3416 // repointed to flattened array
3417
3418 class StringContainer
3419 {
3420 public:
3421 LPCWSTR LocalCopy(LPCWSTR string, bool bSingleString = false)
3422 {
3423 if (string)
3424 {
3425 if (bSingleString)
3426 {
3427 m_Strings.clear();
3428 m_Strings.push_back(string);
3429 }
3430 else
3431 {
3432 m_Strings.push_back(string);
3433 }
3434 return m_Strings.back().c_str();
3435 }
3436 else
3437 {
3438 return nullptr;
3439 }
3440 }
3441 void clear() noexcept { m_Strings.clear(); }
3442 private:
3443 std::list<std::wstring> m_Strings;
3444 };
3445
3446 class SUBOBJECT_HELPER_BASE
3447 {
3448 public:
3449 SUBOBJECT_HELPER_BASE() noexcept { Init(); }
3450 virtual ~SUBOBJECT_HELPER_BASE() = default;
3451 virtual D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept = 0;
3452 void AddToStateObject(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
3453 {
3454 m_pSubobject = ContainingStateObject.TrackSubobject(Type(), Data());
3455 }
3456 protected:
3457 virtual void* Data() noexcept = 0;
3458 void Init() noexcept { m_pSubobject = nullptr; }
3459 D3D12_STATE_SUBOBJECT* m_pSubobject;
3460 };
3461
3462#if(__cplusplus >= 201103L)
3463 std::list<std::unique_ptr<const SUBOBJECT_HELPER_BASE>> m_OwnedSubobjectHelpers;
3464#else
3465 class OWNED_HELPER
3466 {
3467 public:
3468 OWNED_HELPER(const SUBOBJECT_HELPER_BASE* pHelper) noexcept { m_pHelper = pHelper; }
3469 ~OWNED_HELPER() { delete m_pHelper; }
3470 const SUBOBJECT_HELPER_BASE* m_pHelper;
3471 };
3472
3473 std::list<OWNED_HELPER> m_OwnedSubobjectHelpers;
3474#endif
3475
3476 friend class CD3DX12_DXIL_LIBRARY_SUBOBJECT;
3477 friend class CD3DX12_EXISTING_COLLECTION_SUBOBJECT;
3478 friend class CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT;
3479 friend class CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
3480 friend class CD3DX12_HIT_GROUP_SUBOBJECT;
3481 friend class CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT;
3482 friend class CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT;
3483 friend class CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT;
3484 friend class CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT;
3485 friend class CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT;
3486 friend class CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT;
3487 friend class CD3DX12_NODE_MASK_SUBOBJECT;
3488};
3489
3490//------------------------------------------------------------------------------------------------
3491class CD3DX12_DXIL_LIBRARY_SUBOBJECT
3492 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
3493{
3494public:
3495 CD3DX12_DXIL_LIBRARY_SUBOBJECT() noexcept
3496 {
3497 Init();
3498 }
3499 CD3DX12_DXIL_LIBRARY_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
3500 {
3501 Init();
3502 AddToStateObject(ContainingStateObject);
3503 }
3504 void SetDXILLibrary(const D3D12_SHADER_BYTECODE* pCode) noexcept
3505 {
3506 static const D3D12_SHADER_BYTECODE Default = {};
3507 m_Desc.DXILLibrary = pCode ? *pCode : Default;
3508 }
3509 void DefineExport(
3510 LPCWSTR Name,
3511 LPCWSTR ExportToRename = nullptr,
3512 D3D12_EXPORT_FLAGS Flags = D3D12_EXPORT_FLAG_NONE)
3513 {
3514 D3D12_EXPORT_DESC Export;
3515 Export.Name = m_Strings.LocalCopy(Name);
3516 Export.ExportToRename = m_Strings.LocalCopy(ExportToRename);
3517 Export.Flags = Flags;
3518 m_Exports.push_back(Export);
3519 m_Desc.pExports = &m_Exports[0]; // using ugly way to get pointer in case .data() is not defined
3520 m_Desc.NumExports = static_cast<UINT>(m_Exports.size());
3521 }
3522 template<size_t N>
3523 void DefineExports(LPCWSTR(&Exports)[N])
3524 {
3525 for (UINT i = 0; i < N; i++)
3526 {
3527 DefineExport(Exports[i]);
3528 }
3529 }
3530 void DefineExports(const LPCWSTR* Exports, UINT N)
3531 {
3532 for (UINT i = 0; i < N; i++)
3533 {
3534 DefineExport(Exports[i]);
3535 }
3536 }
3537 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
3538 {
3539 return D3D12_STATE_SUBOBJECT_TYPE_DXIL_LIBRARY;
3540 }
3541 operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
3542 operator const D3D12_DXIL_LIBRARY_DESC&() const noexcept { return m_Desc; }
3543private:
3544 void Init() noexcept
3545 {
3546 SUBOBJECT_HELPER_BASE::Init();
3547 m_Desc = {};
3548 m_Strings.clear();
3549 m_Exports.clear();
3550 }
3551 void* Data() noexcept override { return &m_Desc; }
3552 D3D12_DXIL_LIBRARY_DESC m_Desc;
3553 CD3DX12_STATE_OBJECT_DESC::StringContainer m_Strings;
3554 std::vector<D3D12_EXPORT_DESC> m_Exports;
3555};
3556
3557//------------------------------------------------------------------------------------------------
3558class CD3DX12_EXISTING_COLLECTION_SUBOBJECT
3559 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
3560{
3561public:
3562 CD3DX12_EXISTING_COLLECTION_SUBOBJECT() noexcept
3563 {
3564 Init();
3565 }
3566 CD3DX12_EXISTING_COLLECTION_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
3567 {
3568 Init();
3569 AddToStateObject(ContainingStateObject);
3570 }
3571 void SetExistingCollection(ID3D12StateObject*pExistingCollection) noexcept
3572 {
3573 m_Desc.pExistingCollection = pExistingCollection;
3574 m_CollectionRef = pExistingCollection;
3575 }
3576 void DefineExport(
3577 LPCWSTR Name,
3578 LPCWSTR ExportToRename = nullptr,
3579 D3D12_EXPORT_FLAGS Flags = D3D12_EXPORT_FLAG_NONE)
3580 {
3581 D3D12_EXPORT_DESC Export;
3582 Export.Name = m_Strings.LocalCopy(Name);
3583 Export.ExportToRename = m_Strings.LocalCopy(ExportToRename);
3584 Export.Flags = Flags;
3585 m_Exports.push_back(Export);
3586 m_Desc.pExports = &m_Exports[0]; // using ugly way to get pointer in case .data() is not defined
3587 m_Desc.NumExports = static_cast<UINT>(m_Exports.size());
3588 }
3589 template<size_t N>
3590 void DefineExports(LPCWSTR(&Exports)[N])
3591 {
3592 for (UINT i = 0; i < N; i++)
3593 {
3594 DefineExport(Exports[i]);
3595 }
3596 }
3597 void DefineExports(const LPCWSTR* Exports, UINT N)
3598 {
3599 for (UINT i = 0; i < N; i++)
3600 {
3601 DefineExport(Exports[i]);
3602 }
3603 }
3604 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
3605 {
3606 return D3D12_STATE_SUBOBJECT_TYPE_EXISTING_COLLECTION;
3607 }
3608 operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
3609 operator const D3D12_EXISTING_COLLECTION_DESC&() const noexcept { return m_Desc; }
3610private:
3611 void Init() noexcept
3612 {
3613 SUBOBJECT_HELPER_BASE::Init();
3614 m_Desc = {};
3615 m_CollectionRef = nullptr;
3616 m_Strings.clear();
3617 m_Exports.clear();
3618 }
3619 void* Data() noexcept override { return &m_Desc; }
3620 D3D12_EXISTING_COLLECTION_DESC m_Desc;
3621 D3DX12_COM_PTR<ID3D12StateObject> m_CollectionRef;
3622 CD3DX12_STATE_OBJECT_DESC::StringContainer m_Strings;
3623 std::vector<D3D12_EXPORT_DESC> m_Exports;
3624};
3625
3626//------------------------------------------------------------------------------------------------
3627class CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT
3628 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
3629{
3630public:
3631 CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT() noexcept
3632 {
3633 Init();
3634 }
3635 CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
3636 {
3637 Init();
3638 AddToStateObject(ContainingStateObject);
3639 }
3640 void SetSubobjectToAssociate(const D3D12_STATE_SUBOBJECT& SubobjectToAssociate) noexcept
3641 {
3642 m_Desc.pSubobjectToAssociate = &SubobjectToAssociate;
3643 }
3644 void AddExport(LPCWSTR Export)
3645 {
3646 m_Desc.NumExports++;
3647 m_Exports.push_back(m_Strings.LocalCopy(Export));
3648 m_Desc.pExports = &m_Exports[0]; // using ugly way to get pointer in case .data() is not defined
3649 }
3650 template<size_t N>
3651 void AddExports(LPCWSTR (&Exports)[N])
3652 {
3653 for (UINT i = 0; i < N; i++)
3654 {
3655 AddExport(Exports[i]);
3656 }
3657 }
3658 void AddExports(const LPCWSTR* Exports, UINT N)
3659 {
3660 for (UINT i = 0; i < N; i++)
3661 {
3662 AddExport(Exports[i]);
3663 }
3664 }
3665 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
3666 {
3667 return D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
3668 }
3669 operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
3670 operator const D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION&() const noexcept { return m_Desc; }
3671private:
3672 void Init() noexcept
3673 {
3674 SUBOBJECT_HELPER_BASE::Init();
3675 m_Desc = {};
3676 m_Strings.clear();
3677 m_Exports.clear();
3678 }
3679 void* Data() noexcept override { return &m_Desc; }
3680 D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION m_Desc;
3681 CD3DX12_STATE_OBJECT_DESC::StringContainer m_Strings;
3682 std::vector<LPCWSTR> m_Exports;
3683};
3684
3685//------------------------------------------------------------------------------------------------
3686class CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION
3687 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
3688{
3689public:
3690 CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION() noexcept
3691 {
3692 Init();
3693 }
3694 CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
3695 {
3696 Init();
3697 AddToStateObject(ContainingStateObject);
3698 }
3699 void SetSubobjectNameToAssociate(LPCWSTR SubobjectToAssociate)
3700 {
3701 m_Desc.SubobjectToAssociate = m_SubobjectName.LocalCopy(SubobjectToAssociate, true);
3702 }
3703 void AddExport(LPCWSTR Export)
3704 {
3705 m_Desc.NumExports++;
3706 m_Exports.push_back(m_Strings.LocalCopy(Export));
3707 m_Desc.pExports = &m_Exports[0]; // using ugly way to get pointer in case .data() is not defined
3708 }
3709 template<size_t N>
3710 void AddExports(LPCWSTR (&Exports)[N])
3711 {
3712 for (UINT i = 0; i < N; i++)
3713 {
3714 AddExport(Exports[i]);
3715 }
3716 }
3717 void AddExports(const LPCWSTR* Exports, UINT N)
3718 {
3719 for (UINT i = 0; i < N; i++)
3720 {
3721 AddExport(Exports[i]);
3722 }
3723 }
3724 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
3725 {
3726 return D3D12_STATE_SUBOBJECT_TYPE_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
3727 }
3728 operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
3729 operator const D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION&() const noexcept { return m_Desc; }
3730private:
3731 void Init() noexcept
3732 {
3733 SUBOBJECT_HELPER_BASE::Init();
3734 m_Desc = {};
3735 m_Strings.clear();
3736 m_SubobjectName.clear();
3737 m_Exports.clear();
3738 }
3739 void* Data() noexcept override { return &m_Desc; }
3740 D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION m_Desc;
3741 CD3DX12_STATE_OBJECT_DESC::StringContainer m_Strings;
3742 CD3DX12_STATE_OBJECT_DESC::StringContainer m_SubobjectName;
3743 std::vector<LPCWSTR> m_Exports;
3744};
3745
3746//------------------------------------------------------------------------------------------------
3747class CD3DX12_HIT_GROUP_SUBOBJECT
3748 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
3749{
3750public:
3751 CD3DX12_HIT_GROUP_SUBOBJECT() noexcept
3752 {
3753 Init();
3754 }
3755 CD3DX12_HIT_GROUP_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
3756 {
3757 Init();
3758 AddToStateObject(ContainingStateObject);
3759 }
3760 void SetHitGroupExport(LPCWSTR exportName)
3761 {
3762 m_Desc.HitGroupExport = m_Strings[0].LocalCopy(exportName, true);
3763 }
3764 void SetHitGroupType(D3D12_HIT_GROUP_TYPE Type) noexcept { m_Desc.Type = Type; }
3765 void SetAnyHitShaderImport(LPCWSTR importName)
3766 {
3767 m_Desc.AnyHitShaderImport = m_Strings[1].LocalCopy(importName, true);
3768 }
3769 void SetClosestHitShaderImport(LPCWSTR importName)
3770 {
3771 m_Desc.ClosestHitShaderImport = m_Strings[2].LocalCopy(importName, true);
3772 }
3773 void SetIntersectionShaderImport(LPCWSTR importName)
3774 {
3775 m_Desc.IntersectionShaderImport = m_Strings[3].LocalCopy(importName, true);
3776 }
3777 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
3778 {
3779 return D3D12_STATE_SUBOBJECT_TYPE_HIT_GROUP;
3780 }
3781 operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
3782 operator const D3D12_HIT_GROUP_DESC&() const noexcept { return m_Desc; }
3783private:
3784 void Init() noexcept
3785 {
3786 SUBOBJECT_HELPER_BASE::Init();
3787 m_Desc = {};
3788 for (UINT i = 0; i < m_NumStrings; i++)
3789 {
3790 m_Strings[i].clear();
3791 }
3792 }
3793 void* Data() noexcept override { return &m_Desc; }
3794 D3D12_HIT_GROUP_DESC m_Desc;
3795 static const UINT m_NumStrings = 4;
3796 CD3DX12_STATE_OBJECT_DESC::StringContainer
3797 m_Strings[m_NumStrings]; // one string for every entrypoint name
3798};
3799
3800//------------------------------------------------------------------------------------------------
3801class CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT
3802 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
3803{
3804public:
3805 CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT() noexcept
3806 {
3807 Init();
3808 }
3809 CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
3810 {
3811 Init();
3812 AddToStateObject(ContainingStateObject);
3813 }
3814 void Config(UINT MaxPayloadSizeInBytes, UINT MaxAttributeSizeInBytes) noexcept
3815 {
3816 m_Desc.MaxPayloadSizeInBytes = MaxPayloadSizeInBytes;
3817 m_Desc.MaxAttributeSizeInBytes = MaxAttributeSizeInBytes;
3818 }
3819 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
3820 {
3821 return D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_SHADER_CONFIG;
3822 }
3823 operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
3824 operator const D3D12_RAYTRACING_SHADER_CONFIG&() const noexcept { return m_Desc; }
3825private:
3826 void Init() noexcept
3827 {
3828 SUBOBJECT_HELPER_BASE::Init();
3829 m_Desc = {};
3830 }
3831 void* Data() noexcept override { return &m_Desc; }
3832 D3D12_RAYTRACING_SHADER_CONFIG m_Desc;
3833};
3834
3835//------------------------------------------------------------------------------------------------
3836class CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT
3837 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
3838{
3839public:
3840 CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT() noexcept
3841 {
3842 Init();
3843 }
3844 CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
3845 {
3846 Init();
3847 AddToStateObject(ContainingStateObject);
3848 }
3849 void Config(UINT MaxTraceRecursionDepth) noexcept
3850 {
3851 m_Desc.MaxTraceRecursionDepth = MaxTraceRecursionDepth;
3852 }
3853 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
3854 {
3855 return D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG;
3856 }
3857 operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
3858 operator const D3D12_RAYTRACING_PIPELINE_CONFIG&() const noexcept { return m_Desc; }
3859private:
3860 void Init() noexcept
3861 {
3862 SUBOBJECT_HELPER_BASE::Init();
3863 m_Desc = {};
3864 }
3865 void* Data() noexcept override { return &m_Desc; }
3866 D3D12_RAYTRACING_PIPELINE_CONFIG m_Desc;
3867};
3868
3869//------------------------------------------------------------------------------------------------
3870class CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT
3871 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
3872{
3873public:
3874 CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT() noexcept
3875 {
3876 Init();
3877 }
3878 CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
3879 {
3880 Init();
3881 AddToStateObject(ContainingStateObject);
3882 }
3883 void Config(UINT MaxTraceRecursionDepth, D3D12_RAYTRACING_PIPELINE_FLAGS Flags) noexcept
3884 {
3885 m_Desc.MaxTraceRecursionDepth = MaxTraceRecursionDepth;
3886 m_Desc.Flags = Flags;
3887 }
3888 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
3889 {
3890 return D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG1;
3891 }
3892 operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
3893 operator const D3D12_RAYTRACING_PIPELINE_CONFIG1&() const noexcept { return m_Desc; }
3894private:
3895 void Init() noexcept
3896 {
3897 SUBOBJECT_HELPER_BASE::Init();
3898 m_Desc = {};
3899 }
3900 void* Data() noexcept override { return &m_Desc; }
3901 D3D12_RAYTRACING_PIPELINE_CONFIG1 m_Desc;
3902};
3903
3904//------------------------------------------------------------------------------------------------
3905class CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT
3906 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
3907{
3908public:
3909 CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT() noexcept
3910 {
3911 Init();
3912 }
3913 CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
3914 {
3915 Init();
3916 AddToStateObject(ContainingStateObject);
3917 }
3918 void SetRootSignature(ID3D12RootSignature* pRootSig) noexcept
3919 {
3920 m_pRootSig = pRootSig;
3921 }
3922 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
3923 {
3924 return D3D12_STATE_SUBOBJECT_TYPE_GLOBAL_ROOT_SIGNATURE;
3925 }
3926 operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
3927 operator ID3D12RootSignature*() const noexcept { return D3DX12_COM_PTR_GET(m_pRootSig); }
3928private:
3929 void Init() noexcept
3930 {
3931 SUBOBJECT_HELPER_BASE::Init();
3932 m_pRootSig = nullptr;
3933 }
3934 void* Data() noexcept override { return D3DX12_COM_PTR_ADDRESSOF(m_pRootSig); }
3935 D3DX12_COM_PTR<ID3D12RootSignature> m_pRootSig;
3936};
3937
3938//------------------------------------------------------------------------------------------------
3939class CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT
3940 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
3941{
3942public:
3943 CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT() noexcept
3944 {
3945 Init();
3946 }
3947 CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
3948 {
3949 Init();
3950 AddToStateObject(ContainingStateObject);
3951 }
3952 void SetRootSignature(ID3D12RootSignature* pRootSig) noexcept
3953 {
3954 m_pRootSig = pRootSig;
3955 }
3956 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
3957 {
3958 return D3D12_STATE_SUBOBJECT_TYPE_LOCAL_ROOT_SIGNATURE;
3959 }
3960 operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
3961 operator ID3D12RootSignature*() const noexcept { return D3DX12_COM_PTR_GET(m_pRootSig); }
3962private:
3963 void Init() noexcept
3964 {
3965 SUBOBJECT_HELPER_BASE::Init();
3966 m_pRootSig = nullptr;
3967 }
3968 void* Data() noexcept override { return D3DX12_COM_PTR_ADDRESSOF(m_pRootSig); }
3969 D3DX12_COM_PTR<ID3D12RootSignature> m_pRootSig;
3970};
3971
3972//------------------------------------------------------------------------------------------------
3973class CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT
3974 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
3975{
3976public:
3977 CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT() noexcept
3978 {
3979 Init();
3980 }
3981 CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
3982 {
3983 Init();
3984 AddToStateObject(ContainingStateObject);
3985 }
3986 void SetFlags(D3D12_STATE_OBJECT_FLAGS Flags) noexcept
3987 {
3988 m_Desc.Flags = Flags;
3989 }
3990 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
3991 {
3992 return D3D12_STATE_SUBOBJECT_TYPE_STATE_OBJECT_CONFIG;
3993 }
3994 operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
3995 operator const D3D12_STATE_OBJECT_CONFIG&() const noexcept { return m_Desc; }
3996private:
3997 void Init() noexcept
3998 {
3999 SUBOBJECT_HELPER_BASE::Init();
4000 m_Desc = {};
4001 }
4002 void* Data() noexcept override { return &m_Desc; }
4003 D3D12_STATE_OBJECT_CONFIG m_Desc;
4004};
4005
4006//------------------------------------------------------------------------------------------------
4007class CD3DX12_NODE_MASK_SUBOBJECT
4008 : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
4009{
4010public:
4011 CD3DX12_NODE_MASK_SUBOBJECT() noexcept
4012 {
4013 Init();
4014 }
4015 CD3DX12_NODE_MASK_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
4016 {
4017 Init();
4018 AddToStateObject(ContainingStateObject);
4019 }
4020 void SetNodeMask(UINT NodeMask) noexcept
4021 {
4022 m_Desc.NodeMask = NodeMask;
4023 }
4024 D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
4025 {
4026 return D3D12_STATE_SUBOBJECT_TYPE_NODE_MASK;
4027 }
4028 operator const D3D12_STATE_SUBOBJECT&() const noexcept { return *m_pSubobject; }
4029 operator const D3D12_NODE_MASK&() const noexcept { return m_Desc; }
4030private:
4031 void Init() noexcept
4032 {
4033 SUBOBJECT_HELPER_BASE::Init();
4034 m_Desc = {};
4035 }
4036 void* Data() noexcept override { return &m_Desc; }
4037 D3D12_NODE_MASK m_Desc;
4038};
4039
4040#undef D3DX12_COM_PTR
4041#undef D3DX12_COM_PTR_GET
4042#undef D3DX12_COM_PTR_ADDRESSOF
4043#endif // #ifndef D3DX12_NO_STATE_OBJECT_HELPERS
4044
4045#endif // defined( __cplusplus )
4046
4047#endif //__D3DX12_H__
4048
4049
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-18 17:53:05 +0000