aboutsummaryrefslogtreecommitdiff
path: root/contrib/DirectX-Headers-1.618.2/include/directx/d3dx12_core.h
diff options
context:
space:
mode:
author3gg <3gg@shellblade.net>2025-12-02 16:39:36 -0800
committer3gg <3gg@shellblade.net>2025-12-02 16:39:36 -0800
commit6c8ae19be66cee247980a48e736a4e05d14de179 (patch)
treed860767907bf0cbe17ec66422e11bea700cf56d9 /contrib/DirectX-Headers-1.618.2/include/directx/d3dx12_core.h
parent8f594c8ebd11f0e5f8a0c6369c3fe7383d250cbe (diff)
Immediate-mode renderer, triangle demo, shader compilation in cmake, Agility SDKHEADmain
Diffstat (limited to 'contrib/DirectX-Headers-1.618.2/include/directx/d3dx12_core.h')
-rw-r--r--contrib/DirectX-Headers-1.618.2/include/directx/d3dx12_core.h2072
1 files changed, 2072 insertions, 0 deletions
diff --git a/contrib/DirectX-Headers-1.618.2/include/directx/d3dx12_core.h b/contrib/DirectX-Headers-1.618.2/include/directx/d3dx12_core.h
new file mode 100644
index 0000000..092a039
--- /dev/null
+++ b/contrib/DirectX-Headers-1.618.2/include/directx/d3dx12_core.h
@@ -0,0 +1,2072 @@
1//*********************************************************
2//
3// Copyright (c) Microsoft Corporation.
4// Licensed under the MIT License (MIT).
5//
6//*********************************************************
7
8#pragma once
9
10#ifndef __cplusplus
11#error D3DX12 requires C++
12#endif
13
14#include <string.h>
15#include "d3d12.h"
16#include "d3dx12_default.h"
17
18//------------------------------------------------------------------------------------------------
19#ifndef D3DX12_ASSERT
20 #ifdef assert
21 #define D3DX12_ASSERT(x) assert(x)
22 #else
23 #define D3DX12_ASSERT(x)
24 #endif
25#endif
26
27//------------------------------------------------------------------------------------------------
28template <typename t_CommandListType>
29inline ID3D12CommandList * const * CommandListCast(t_CommandListType * const * pp) noexcept
30{
31 // This cast is useful for passing strongly typed command list pointers into
32 // ExecuteCommandLists.
33 // This cast is valid as long as the const-ness is respected. D3D12 APIs do
34 // respect the const-ness of their arguments.
35 return reinterpret_cast<ID3D12CommandList * const *>(pp);
36}
37
38#ifdef D3DX12_USE_ARRAY_COM_PTR
39#include <vector>
40//------------------------------------------------------------------------------------------------
41// CArrayComPtr - Useful RAII container of raw IUnknown pointers.
42template<typename _T>
43class CArrayComPtr
44{
45 std::vector<_T *> m_array;
46
47public:
48 class CProxyPtr
49 {
50 _T *&pObj;
51
52 CProxyPtr(_T *&obj) :
53 pObj(obj) {}
54
55 public:
56 operator _T*() { return pObj; }
57 _T **operator&() { return &pObj; }
58 CProxyPtr &operator=(_T*&obj)
59 {
60 if(pObj)
61 pObj->Release();
62
63 pObj = obj;
64
65 if(pObj)
66 pObj->AddRef();
67 }
68
69 friend class CArrayComPtr<_T>;
70 };
71
72public:
73 CArrayComPtr() = default;
74
75 CArrayComPtr(size_t size) :
76 m_array(size) {
77 }
78
79 CArrayComPtr(const CArrayComPtr &o)
80 {
81 m_array = o.m_array;
82 for (size_t i = 0; i < m_array.size(); ++i)
83 {
84 m_array[i]->AddRef();
85 }
86 }
87
88 CArrayComPtr(CArrayComPtr &&o) = default;
89
90 ~CArrayComPtr()
91 {
92 for (auto ptr : m_array)
93 {
94 if (ptr)
95 {
96 ptr->Release();
97 }
98 }
99 }
100
101 _T *const *Get() { return m_array.data(); }
102
103 void Assign(size_t index, _T *ptr)
104 {
105 if (index >= m_array.size())
106 {
107 Resize(index + 1);
108 }
109
110 // Release the old pointer if it exists
111 if (m_array[index])
112 {
113 m_array[index]->Release();
114 }
115
116 // Assign the new pointer and AddRef it if not null
117 m_array[index] = ptr;
118 if (ptr)
119 {
120 ptr->AddRef();
121 }
122 }
123
124 void Resize(size_t size)
125 {
126 // If shrinking, release any pointers that will be discarded
127 if (size < m_array.size())
128 {
129 for (size_t i = size; i < m_array.size(); ++i)
130 {
131 if (m_array[i])
132 {
133 m_array[i]->Release();
134 }
135 }
136 }
137
138 // Resize the vector, initializing new elements to nullptr
139 m_array.resize(size, nullptr);
140 }
141
142 void PushBack(_T *ptr)
143 {
144 // AddRef if not null
145 if (ptr)
146 {
147 ptr->AddRef();
148 }
149 m_array.push_back(ptr);
150 }
151
152 CProxyPtr operator[](size_t index)
153 {
154 return CProxyPtr(m_array[index]);
155 }
156};
157#endif
158//------------------------------------------------------------------------------------------------
159inline bool operator==( const D3D12_VIEWPORT& l, const D3D12_VIEWPORT& r ) noexcept
160{
161 return l.TopLeftX == r.TopLeftX && l.TopLeftY == r.TopLeftY && l.Width == r.Width &&
162 l.Height == r.Height && l.MinDepth == r.MinDepth && l.MaxDepth == r.MaxDepth;
163}
164
165//------------------------------------------------------------------------------------------------
166inline bool operator!=( const D3D12_VIEWPORT& l, const D3D12_VIEWPORT& r ) noexcept
167{ return !( l == r ); }
168
169//------------------------------------------------------------------------------------------------
170struct CD3DX12_RECT : public D3D12_RECT
171{
172 CD3DX12_RECT() = default;
173 explicit CD3DX12_RECT( const D3D12_RECT& o ) noexcept :
174 D3D12_RECT( o )
175 {}
176 explicit CD3DX12_RECT(
177 LONG Left,
178 LONG Top,
179 LONG Right,
180 LONG Bottom ) noexcept
181 {
182 left = Left;
183 top = Top;
184 right = Right;
185 bottom = Bottom;
186 }
187};
188
189//------------------------------------------------------------------------------------------------
190struct CD3DX12_VIEWPORT : public D3D12_VIEWPORT
191{
192 CD3DX12_VIEWPORT() = default;
193 explicit CD3DX12_VIEWPORT( const D3D12_VIEWPORT& o ) noexcept :
194 D3D12_VIEWPORT( o )
195 {}
196 explicit CD3DX12_VIEWPORT(
197 FLOAT topLeftX,
198 FLOAT topLeftY,
199 FLOAT width,
200 FLOAT height,
201 FLOAT minDepth = D3D12_MIN_DEPTH,
202 FLOAT maxDepth = D3D12_MAX_DEPTH ) noexcept
203 {
204 TopLeftX = topLeftX;
205 TopLeftY = topLeftY;
206 Width = width;
207 Height = height;
208 MinDepth = minDepth;
209 MaxDepth = maxDepth;
210 }
211 explicit CD3DX12_VIEWPORT(
212 _In_ ID3D12Resource* pResource,
213 UINT mipSlice = 0,
214 FLOAT topLeftX = 0.0f,
215 FLOAT topLeftY = 0.0f,
216 FLOAT minDepth = D3D12_MIN_DEPTH,
217 FLOAT maxDepth = D3D12_MAX_DEPTH ) noexcept
218 {
219#if defined(_MSC_VER) || !defined(_WIN32)
220 const auto Desc = pResource->GetDesc();
221#else
222 D3D12_RESOURCE_DESC tmpDesc;
223 const auto& Desc = *pResource->GetDesc(&tmpDesc);
224#endif
225 const UINT64 SubresourceWidth = Desc.Width >> mipSlice;
226 const UINT64 SubresourceHeight = Desc.Height >> mipSlice;
227 switch (Desc.Dimension)
228 {
229 case D3D12_RESOURCE_DIMENSION_BUFFER:
230 TopLeftX = topLeftX;
231 TopLeftY = 0.0f;
232 Width = float(Desc.Width) - topLeftX;
233 Height = 1.0f;
234 break;
235 case D3D12_RESOURCE_DIMENSION_TEXTURE1D:
236 TopLeftX = topLeftX;
237 TopLeftY = 0.0f;
238 Width = (SubresourceWidth ? float(SubresourceWidth) : 1.0f) - topLeftX;
239 Height = 1.0f;
240 break;
241 case D3D12_RESOURCE_DIMENSION_TEXTURE2D:
242 case D3D12_RESOURCE_DIMENSION_TEXTURE3D:
243 TopLeftX = topLeftX;
244 TopLeftY = topLeftY;
245 Width = (SubresourceWidth ? float(SubresourceWidth) : 1.0f) - topLeftX;
246 Height = (SubresourceHeight ? float(SubresourceHeight) : 1.0f) - topLeftY;
247 break;
248 default: break;
249 }
250
251 MinDepth = minDepth;
252 MaxDepth = maxDepth;
253 }
254};
255
256//------------------------------------------------------------------------------------------------
257struct CD3DX12_BOX : public D3D12_BOX
258{
259 CD3DX12_BOX() = default;
260 explicit CD3DX12_BOX( const D3D12_BOX& o ) noexcept :
261 D3D12_BOX( o )
262 {}
263 explicit CD3DX12_BOX(
264 LONG Left,
265 LONG Right ) noexcept
266 {
267 left = static_cast<UINT>(Left);
268 top = 0;
269 front = 0;
270 right = static_cast<UINT>(Right);
271 bottom = 1;
272 back = 1;
273 }
274 explicit CD3DX12_BOX(
275 LONG Left,
276 LONG Top,
277 LONG Right,
278 LONG Bottom ) noexcept
279 {
280 left = static_cast<UINT>(Left);
281 top = static_cast<UINT>(Top);
282 front = 0;
283 right = static_cast<UINT>(Right);
284 bottom = static_cast<UINT>(Bottom);
285 back = 1;
286 }
287 explicit CD3DX12_BOX(
288 LONG Left,
289 LONG Top,
290 LONG Front,
291 LONG Right,
292 LONG Bottom,
293 LONG Back ) noexcept
294 {
295 left = static_cast<UINT>(Left);
296 top = static_cast<UINT>(Top);
297 front = static_cast<UINT>(Front);
298 right = static_cast<UINT>(Right);
299 bottom = static_cast<UINT>(Bottom);
300 back = static_cast<UINT>(Back);
301 }
302};
303inline bool operator==( const D3D12_BOX& l, const D3D12_BOX& r ) noexcept
304{
305 return l.left == r.left && l.top == r.top && l.front == r.front &&
306 l.right == r.right && l.bottom == r.bottom && l.back == r.back;
307}
308inline bool operator!=( const D3D12_BOX& l, const D3D12_BOX& r ) noexcept
309{ return !( l == r ); }
310
311//------------------------------------------------------------------------------------------------
312struct CD3DX12_DEPTH_STENCIL_DESC : public D3D12_DEPTH_STENCIL_DESC
313{
314 CD3DX12_DEPTH_STENCIL_DESC() = default;
315 explicit CD3DX12_DEPTH_STENCIL_DESC( const D3D12_DEPTH_STENCIL_DESC& o ) noexcept :
316 D3D12_DEPTH_STENCIL_DESC( o )
317 {}
318 explicit CD3DX12_DEPTH_STENCIL_DESC( CD3DX12_DEFAULT ) noexcept
319 {
320 DepthEnable = TRUE;
321 DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL;
322 DepthFunc = D3D12_COMPARISON_FUNC_LESS;
323 StencilEnable = FALSE;
324 StencilReadMask = D3D12_DEFAULT_STENCIL_READ_MASK;
325 StencilWriteMask = D3D12_DEFAULT_STENCIL_WRITE_MASK;
326 const D3D12_DEPTH_STENCILOP_DESC defaultStencilOp =
327 { D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_COMPARISON_FUNC_ALWAYS };
328 FrontFace = defaultStencilOp;
329 BackFace = defaultStencilOp;
330 }
331 explicit CD3DX12_DEPTH_STENCIL_DESC(
332 BOOL depthEnable,
333 D3D12_DEPTH_WRITE_MASK depthWriteMask,
334 D3D12_COMPARISON_FUNC depthFunc,
335 BOOL stencilEnable,
336 UINT8 stencilReadMask,
337 UINT8 stencilWriteMask,
338 D3D12_STENCIL_OP frontStencilFailOp,
339 D3D12_STENCIL_OP frontStencilDepthFailOp,
340 D3D12_STENCIL_OP frontStencilPassOp,
341 D3D12_COMPARISON_FUNC frontStencilFunc,
342 D3D12_STENCIL_OP backStencilFailOp,
343 D3D12_STENCIL_OP backStencilDepthFailOp,
344 D3D12_STENCIL_OP backStencilPassOp,
345 D3D12_COMPARISON_FUNC backStencilFunc ) noexcept
346 {
347 DepthEnable = depthEnable;
348 DepthWriteMask = depthWriteMask;
349 DepthFunc = depthFunc;
350 StencilEnable = stencilEnable;
351 StencilReadMask = stencilReadMask;
352 StencilWriteMask = stencilWriteMask;
353 FrontFace.StencilFailOp = frontStencilFailOp;
354 FrontFace.StencilDepthFailOp = frontStencilDepthFailOp;
355 FrontFace.StencilPassOp = frontStencilPassOp;
356 FrontFace.StencilFunc = frontStencilFunc;
357 BackFace.StencilFailOp = backStencilFailOp;
358 BackFace.StencilDepthFailOp = backStencilDepthFailOp;
359 BackFace.StencilPassOp = backStencilPassOp;
360 BackFace.StencilFunc = backStencilFunc;
361 }
362};
363
364//------------------------------------------------------------------------------------------------
365struct CD3DX12_DEPTH_STENCIL_DESC1 : public D3D12_DEPTH_STENCIL_DESC1
366{
367 CD3DX12_DEPTH_STENCIL_DESC1() = default;
368 explicit CD3DX12_DEPTH_STENCIL_DESC1( const D3D12_DEPTH_STENCIL_DESC1& o ) noexcept :
369 D3D12_DEPTH_STENCIL_DESC1( o )
370 {}
371 explicit CD3DX12_DEPTH_STENCIL_DESC1( const D3D12_DEPTH_STENCIL_DESC& o ) noexcept
372 {
373 DepthEnable = o.DepthEnable;
374 DepthWriteMask = o.DepthWriteMask;
375 DepthFunc = o.DepthFunc;
376 StencilEnable = o.StencilEnable;
377 StencilReadMask = o.StencilReadMask;
378 StencilWriteMask = o.StencilWriteMask;
379 FrontFace.StencilFailOp = o.FrontFace.StencilFailOp;
380 FrontFace.StencilDepthFailOp = o.FrontFace.StencilDepthFailOp;
381 FrontFace.StencilPassOp = o.FrontFace.StencilPassOp;
382 FrontFace.StencilFunc = o.FrontFace.StencilFunc;
383 BackFace.StencilFailOp = o.BackFace.StencilFailOp;
384 BackFace.StencilDepthFailOp = o.BackFace.StencilDepthFailOp;
385 BackFace.StencilPassOp = o.BackFace.StencilPassOp;
386 BackFace.StencilFunc = o.BackFace.StencilFunc;
387 DepthBoundsTestEnable = FALSE;
388 }
389 explicit CD3DX12_DEPTH_STENCIL_DESC1( CD3DX12_DEFAULT ) noexcept
390 {
391 DepthEnable = TRUE;
392 DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL;
393 DepthFunc = D3D12_COMPARISON_FUNC_LESS;
394 StencilEnable = FALSE;
395 StencilReadMask = D3D12_DEFAULT_STENCIL_READ_MASK;
396 StencilWriteMask = D3D12_DEFAULT_STENCIL_WRITE_MASK;
397 const D3D12_DEPTH_STENCILOP_DESC defaultStencilOp =
398 { D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_COMPARISON_FUNC_ALWAYS };
399 FrontFace = defaultStencilOp;
400 BackFace = defaultStencilOp;
401 DepthBoundsTestEnable = FALSE;
402 }
403 explicit CD3DX12_DEPTH_STENCIL_DESC1(
404 BOOL depthEnable,
405 D3D12_DEPTH_WRITE_MASK depthWriteMask,
406 D3D12_COMPARISON_FUNC depthFunc,
407 BOOL stencilEnable,
408 UINT8 stencilReadMask,
409 UINT8 stencilWriteMask,
410 D3D12_STENCIL_OP frontStencilFailOp,
411 D3D12_STENCIL_OP frontStencilDepthFailOp,
412 D3D12_STENCIL_OP frontStencilPassOp,
413 D3D12_COMPARISON_FUNC frontStencilFunc,
414 D3D12_STENCIL_OP backStencilFailOp,
415 D3D12_STENCIL_OP backStencilDepthFailOp,
416 D3D12_STENCIL_OP backStencilPassOp,
417 D3D12_COMPARISON_FUNC backStencilFunc,
418 BOOL depthBoundsTestEnable ) noexcept
419 {
420 DepthEnable = depthEnable;
421 DepthWriteMask = depthWriteMask;
422 DepthFunc = depthFunc;
423 StencilEnable = stencilEnable;
424 StencilReadMask = stencilReadMask;
425 StencilWriteMask = stencilWriteMask;
426 FrontFace.StencilFailOp = frontStencilFailOp;
427 FrontFace.StencilDepthFailOp = frontStencilDepthFailOp;
428 FrontFace.StencilPassOp = frontStencilPassOp;
429 FrontFace.StencilFunc = frontStencilFunc;
430 BackFace.StencilFailOp = backStencilFailOp;
431 BackFace.StencilDepthFailOp = backStencilDepthFailOp;
432 BackFace.StencilPassOp = backStencilPassOp;
433 BackFace.StencilFunc = backStencilFunc;
434 DepthBoundsTestEnable = depthBoundsTestEnable;
435 }
436 operator D3D12_DEPTH_STENCIL_DESC() const noexcept
437 {
438 D3D12_DEPTH_STENCIL_DESC D;
439 D.DepthEnable = DepthEnable;
440 D.DepthWriteMask = DepthWriteMask;
441 D.DepthFunc = DepthFunc;
442 D.StencilEnable = StencilEnable;
443 D.StencilReadMask = StencilReadMask;
444 D.StencilWriteMask = StencilWriteMask;
445 D.FrontFace.StencilFailOp = FrontFace.StencilFailOp;
446 D.FrontFace.StencilDepthFailOp = FrontFace.StencilDepthFailOp;
447 D.FrontFace.StencilPassOp = FrontFace.StencilPassOp;
448 D.FrontFace.StencilFunc = FrontFace.StencilFunc;
449 D.BackFace.StencilFailOp = BackFace.StencilFailOp;
450 D.BackFace.StencilDepthFailOp = BackFace.StencilDepthFailOp;
451 D.BackFace.StencilPassOp = BackFace.StencilPassOp;
452 D.BackFace.StencilFunc = BackFace.StencilFunc;
453 return D;
454 }
455};
456
457//------------------------------------------------------------------------------------------------
458#if defined(D3D12_SDK_VERSION) && (D3D12_SDK_VERSION >= 606)
459struct CD3DX12_DEPTH_STENCIL_DESC2 : public D3D12_DEPTH_STENCIL_DESC2
460{
461 CD3DX12_DEPTH_STENCIL_DESC2() = default;
462 explicit CD3DX12_DEPTH_STENCIL_DESC2( const D3D12_DEPTH_STENCIL_DESC2& o ) noexcept :
463 D3D12_DEPTH_STENCIL_DESC2( o )
464 {}
465 explicit CD3DX12_DEPTH_STENCIL_DESC2( const D3D12_DEPTH_STENCIL_DESC1& o ) noexcept
466 {
467 DepthEnable = o.DepthEnable;
468 DepthWriteMask = o.DepthWriteMask;
469 DepthFunc = o.DepthFunc;
470 StencilEnable = o.StencilEnable;
471 FrontFace.StencilFailOp = o.FrontFace.StencilFailOp;
472 FrontFace.StencilDepthFailOp = o.FrontFace.StencilDepthFailOp;
473 FrontFace.StencilPassOp = o.FrontFace.StencilPassOp;
474 FrontFace.StencilFunc = o.FrontFace.StencilFunc;
475 FrontFace.StencilReadMask = o.StencilReadMask;
476 FrontFace.StencilWriteMask = o.StencilWriteMask;
477
478 BackFace.StencilFailOp = o.BackFace.StencilFailOp;
479 BackFace.StencilDepthFailOp = o.BackFace.StencilDepthFailOp;
480 BackFace.StencilPassOp = o.BackFace.StencilPassOp;
481 BackFace.StencilFunc = o.BackFace.StencilFunc;
482 BackFace.StencilReadMask = o.StencilReadMask;
483 BackFace.StencilWriteMask = o.StencilWriteMask;
484 DepthBoundsTestEnable = o.DepthBoundsTestEnable;
485 }
486 explicit CD3DX12_DEPTH_STENCIL_DESC2( const D3D12_DEPTH_STENCIL_DESC& o ) noexcept
487 {
488 DepthEnable = o.DepthEnable;
489 DepthWriteMask = o.DepthWriteMask;
490 DepthFunc = o.DepthFunc;
491 StencilEnable = o.StencilEnable;
492
493 FrontFace.StencilFailOp = o.FrontFace.StencilFailOp;
494 FrontFace.StencilDepthFailOp = o.FrontFace.StencilDepthFailOp;
495 FrontFace.StencilPassOp = o.FrontFace.StencilPassOp;
496 FrontFace.StencilFunc = o.FrontFace.StencilFunc;
497 FrontFace.StencilReadMask = o.StencilReadMask;
498 FrontFace.StencilWriteMask = o.StencilWriteMask;
499
500 BackFace.StencilFailOp = o.BackFace.StencilFailOp;
501 BackFace.StencilDepthFailOp = o.BackFace.StencilDepthFailOp;
502 BackFace.StencilPassOp = o.BackFace.StencilPassOp;
503 BackFace.StencilFunc = o.BackFace.StencilFunc;
504 BackFace.StencilReadMask = o.StencilReadMask;
505 BackFace.StencilWriteMask = o.StencilWriteMask;
506
507 DepthBoundsTestEnable = FALSE;
508 }
509 explicit CD3DX12_DEPTH_STENCIL_DESC2( CD3DX12_DEFAULT ) noexcept
510 {
511 DepthEnable = TRUE;
512 DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL;
513 DepthFunc = D3D12_COMPARISON_FUNC_LESS;
514 StencilEnable = FALSE;
515 const D3D12_DEPTH_STENCILOP_DESC1 defaultStencilOp =
516 { D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_COMPARISON_FUNC_ALWAYS, D3D12_DEFAULT_STENCIL_READ_MASK, D3D12_DEFAULT_STENCIL_WRITE_MASK };
517 FrontFace = defaultStencilOp;
518 BackFace = defaultStencilOp;
519 DepthBoundsTestEnable = FALSE;
520 }
521 explicit CD3DX12_DEPTH_STENCIL_DESC2(
522 BOOL depthEnable,
523 D3D12_DEPTH_WRITE_MASK depthWriteMask,
524 D3D12_COMPARISON_FUNC depthFunc,
525 BOOL stencilEnable,
526 D3D12_STENCIL_OP frontStencilFailOp,
527 D3D12_STENCIL_OP frontStencilDepthFailOp,
528 D3D12_STENCIL_OP frontStencilPassOp,
529 D3D12_COMPARISON_FUNC frontStencilFunc,
530 UINT8 frontStencilReadMask,
531 UINT8 frontStencilWriteMask,
532 D3D12_STENCIL_OP backStencilFailOp,
533 D3D12_STENCIL_OP backStencilDepthFailOp,
534 D3D12_STENCIL_OP backStencilPassOp,
535 D3D12_COMPARISON_FUNC backStencilFunc,
536 UINT8 backStencilReadMask,
537 UINT8 backStencilWriteMask,
538 BOOL depthBoundsTestEnable ) noexcept
539 {
540 DepthEnable = depthEnable;
541 DepthWriteMask = depthWriteMask;
542 DepthFunc = depthFunc;
543 StencilEnable = stencilEnable;
544
545 FrontFace.StencilFailOp = frontStencilFailOp;
546 FrontFace.StencilDepthFailOp = frontStencilDepthFailOp;
547 FrontFace.StencilPassOp = frontStencilPassOp;
548 FrontFace.StencilFunc = frontStencilFunc;
549 FrontFace.StencilReadMask = frontStencilReadMask;
550 FrontFace.StencilWriteMask = frontStencilWriteMask;
551
552 BackFace.StencilFailOp = backStencilFailOp;
553 BackFace.StencilDepthFailOp = backStencilDepthFailOp;
554 BackFace.StencilPassOp = backStencilPassOp;
555 BackFace.StencilFunc = backStencilFunc;
556 BackFace.StencilReadMask = backStencilReadMask;
557 BackFace.StencilWriteMask = backStencilWriteMask;
558
559 DepthBoundsTestEnable = depthBoundsTestEnable;
560 }
561
562 operator D3D12_DEPTH_STENCIL_DESC() const noexcept
563 {
564 D3D12_DEPTH_STENCIL_DESC D;
565 D.DepthEnable = DepthEnable;
566 D.DepthWriteMask = DepthWriteMask;
567 D.DepthFunc = DepthFunc;
568 D.StencilEnable = StencilEnable;
569 D.StencilReadMask = FrontFace.StencilReadMask;
570 D.StencilWriteMask = FrontFace.StencilWriteMask;
571 D.FrontFace.StencilFailOp = FrontFace.StencilFailOp;
572 D.FrontFace.StencilDepthFailOp = FrontFace.StencilDepthFailOp;
573 D.FrontFace.StencilPassOp = FrontFace.StencilPassOp;
574 D.FrontFace.StencilFunc = FrontFace.StencilFunc;
575 D.BackFace.StencilFailOp = BackFace.StencilFailOp;
576 D.BackFace.StencilDepthFailOp = BackFace.StencilDepthFailOp;
577 D.BackFace.StencilPassOp = BackFace.StencilPassOp;
578 D.BackFace.StencilFunc = BackFace.StencilFunc;
579 return D;
580 }
581};
582#endif // D3D12_SDK_VERSION >= 606
583
584//------------------------------------------------------------------------------------------------
585struct CD3DX12_BLEND_DESC : public D3D12_BLEND_DESC
586{
587 CD3DX12_BLEND_DESC() = default;
588 explicit CD3DX12_BLEND_DESC( const D3D12_BLEND_DESC& o ) noexcept :
589 D3D12_BLEND_DESC( o )
590 {}
591 explicit CD3DX12_BLEND_DESC( CD3DX12_DEFAULT ) noexcept
592 {
593 AlphaToCoverageEnable = FALSE;
594 IndependentBlendEnable = FALSE;
595 const D3D12_RENDER_TARGET_BLEND_DESC defaultRenderTargetBlendDesc =
596 {
597 FALSE,FALSE,
598 D3D12_BLEND_ONE, D3D12_BLEND_ZERO, D3D12_BLEND_OP_ADD,
599 D3D12_BLEND_ONE, D3D12_BLEND_ZERO, D3D12_BLEND_OP_ADD,
600 D3D12_LOGIC_OP_NOOP,
601 D3D12_COLOR_WRITE_ENABLE_ALL,
602 };
603 for (UINT i = 0; i < D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
604 RenderTarget[ i ] = defaultRenderTargetBlendDesc;
605 }
606};
607
608//------------------------------------------------------------------------------------------------
609struct CD3DX12_RASTERIZER_DESC : public D3D12_RASTERIZER_DESC
610{
611 CD3DX12_RASTERIZER_DESC() = default;
612 explicit CD3DX12_RASTERIZER_DESC( const D3D12_RASTERIZER_DESC& o ) noexcept :
613 D3D12_RASTERIZER_DESC( o )
614 {}
615 explicit CD3DX12_RASTERIZER_DESC( CD3DX12_DEFAULT ) noexcept
616 {
617 FillMode = D3D12_FILL_MODE_SOLID;
618 CullMode = D3D12_CULL_MODE_BACK;
619 FrontCounterClockwise = FALSE;
620 DepthBias = D3D12_DEFAULT_DEPTH_BIAS;
621 DepthBiasClamp = D3D12_DEFAULT_DEPTH_BIAS_CLAMP;
622 SlopeScaledDepthBias = D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS;
623 DepthClipEnable = TRUE;
624 MultisampleEnable = FALSE;
625 AntialiasedLineEnable = FALSE;
626 ForcedSampleCount = 0;
627 ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF;
628 }
629 explicit CD3DX12_RASTERIZER_DESC(
630 D3D12_FILL_MODE fillMode,
631 D3D12_CULL_MODE cullMode,
632 BOOL frontCounterClockwise,
633 INT depthBias,
634 FLOAT depthBiasClamp,
635 FLOAT slopeScaledDepthBias,
636 BOOL depthClipEnable,
637 BOOL multisampleEnable,
638 BOOL antialiasedLineEnable,
639 UINT forcedSampleCount,
640 D3D12_CONSERVATIVE_RASTERIZATION_MODE conservativeRaster) noexcept
641 {
642 FillMode = fillMode;
643 CullMode = cullMode;
644 FrontCounterClockwise = frontCounterClockwise;
645 DepthBias = depthBias;
646 DepthBiasClamp = depthBiasClamp;
647 SlopeScaledDepthBias = slopeScaledDepthBias;
648 DepthClipEnable = depthClipEnable;
649 MultisampleEnable = multisampleEnable;
650 AntialiasedLineEnable = antialiasedLineEnable;
651 ForcedSampleCount = forcedSampleCount;
652 ConservativeRaster = conservativeRaster;
653 }
654};
655
656
657//------------------------------------------------------------------------------------------------
658#if defined(D3D12_SDK_VERSION) && (D3D12_SDK_VERSION >= 608)
659struct CD3DX12_RASTERIZER_DESC1 : public D3D12_RASTERIZER_DESC1
660{
661 CD3DX12_RASTERIZER_DESC1() = default;
662 explicit CD3DX12_RASTERIZER_DESC1(const D3D12_RASTERIZER_DESC1& o) noexcept :
663 D3D12_RASTERIZER_DESC1(o)
664
665 {
666 }
667 explicit CD3DX12_RASTERIZER_DESC1(const D3D12_RASTERIZER_DESC& o) noexcept
668 {
669 FillMode = o.FillMode;
670 CullMode = o.CullMode;
671 FrontCounterClockwise = o.FrontCounterClockwise;
672 DepthBias = static_cast<FLOAT>(o.DepthBias);
673 DepthBiasClamp = o.DepthBiasClamp;
674 SlopeScaledDepthBias = o.SlopeScaledDepthBias;
675 DepthClipEnable = o.DepthClipEnable;
676 MultisampleEnable = o.MultisampleEnable;
677 AntialiasedLineEnable = o.AntialiasedLineEnable;
678 ForcedSampleCount = o.ForcedSampleCount;
679 ConservativeRaster = o.ConservativeRaster;
680 }
681 explicit CD3DX12_RASTERIZER_DESC1(CD3DX12_DEFAULT) noexcept
682 {
683 FillMode = D3D12_FILL_MODE_SOLID;
684 CullMode = D3D12_CULL_MODE_BACK;
685 FrontCounterClockwise = FALSE;
686 DepthBias = D3D12_DEFAULT_DEPTH_BIAS;
687 DepthBiasClamp = D3D12_DEFAULT_DEPTH_BIAS_CLAMP;
688 SlopeScaledDepthBias = D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS;
689 DepthClipEnable = TRUE;
690 MultisampleEnable = FALSE;
691 AntialiasedLineEnable = FALSE;
692 ForcedSampleCount = 0;
693 ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF;
694 }
695 explicit CD3DX12_RASTERIZER_DESC1(
696 D3D12_FILL_MODE fillMode,
697 D3D12_CULL_MODE cullMode,
698 BOOL frontCounterClockwise,
699 FLOAT depthBias,
700 FLOAT depthBiasClamp,
701 FLOAT slopeScaledDepthBias,
702 BOOL depthClipEnable,
703 BOOL multisampleEnable,
704 BOOL antialiasedLineEnable,
705 UINT forcedSampleCount,
706 D3D12_CONSERVATIVE_RASTERIZATION_MODE conservativeRaster) noexcept
707 {
708 FillMode = fillMode;
709 CullMode = cullMode;
710 FrontCounterClockwise = frontCounterClockwise;
711 DepthBias = depthBias;
712 DepthBiasClamp = depthBiasClamp;
713 SlopeScaledDepthBias = slopeScaledDepthBias;
714 DepthClipEnable = depthClipEnable;
715 MultisampleEnable = multisampleEnable;
716 AntialiasedLineEnable = antialiasedLineEnable;
717 ForcedSampleCount = forcedSampleCount;
718 ConservativeRaster = conservativeRaster;
719 }
720
721
722 operator D3D12_RASTERIZER_DESC() const noexcept
723 {
724 D3D12_RASTERIZER_DESC o;
725
726 o.FillMode = FillMode;
727 o.CullMode = CullMode;
728 o.FrontCounterClockwise = FrontCounterClockwise;
729 o.DepthBias = static_cast<INT>(DepthBias);
730 o.DepthBiasClamp = DepthBiasClamp;
731 o.SlopeScaledDepthBias = SlopeScaledDepthBias;
732 o.DepthClipEnable = DepthClipEnable;
733 o.MultisampleEnable = MultisampleEnable;
734 o.AntialiasedLineEnable = AntialiasedLineEnable;
735 o.ForcedSampleCount = ForcedSampleCount;
736 o.ConservativeRaster = ConservativeRaster;
737
738 return o;
739 }
740};
741#endif // D3D12_SDK_VERSION >= 608
742
743//------------------------------------------------------------------------------------------------
744#if defined(D3D12_SDK_VERSION) && (D3D12_SDK_VERSION >= 610)
745struct CD3DX12_RASTERIZER_DESC2 : public D3D12_RASTERIZER_DESC2
746{
747 CD3DX12_RASTERIZER_DESC2() = default;
748 explicit CD3DX12_RASTERIZER_DESC2(const D3D12_RASTERIZER_DESC2& o) noexcept :
749 D3D12_RASTERIZER_DESC2(o)
750
751 {
752 }
753 explicit CD3DX12_RASTERIZER_DESC2(const D3D12_RASTERIZER_DESC1& o) noexcept
754 {
755 FillMode = o.FillMode;
756 CullMode = o.CullMode;
757 FrontCounterClockwise = o.FrontCounterClockwise;
758 DepthBias = o.DepthBias;
759 DepthBiasClamp = o.DepthBiasClamp;
760 SlopeScaledDepthBias = o.SlopeScaledDepthBias;
761 DepthClipEnable = o.DepthClipEnable;
762 LineRasterizationMode = D3D12_LINE_RASTERIZATION_MODE_ALIASED;
763 if (o.MultisampleEnable)
764 {
765 LineRasterizationMode = D3D12_LINE_RASTERIZATION_MODE_QUADRILATERAL_WIDE;
766 }
767 else if (o.AntialiasedLineEnable)
768 {
769 LineRasterizationMode = D3D12_LINE_RASTERIZATION_MODE_ALPHA_ANTIALIASED;
770 }
771 ForcedSampleCount = o.ForcedSampleCount;
772 ConservativeRaster = o.ConservativeRaster;
773 }
774 explicit CD3DX12_RASTERIZER_DESC2(const D3D12_RASTERIZER_DESC& o) noexcept
775 : CD3DX12_RASTERIZER_DESC2(CD3DX12_RASTERIZER_DESC1(o))
776 {
777 }
778 explicit CD3DX12_RASTERIZER_DESC2(CD3DX12_DEFAULT) noexcept
779 {
780 FillMode = D3D12_FILL_MODE_SOLID;
781 CullMode = D3D12_CULL_MODE_BACK;
782 FrontCounterClockwise = FALSE;
783 DepthBias = D3D12_DEFAULT_DEPTH_BIAS;
784 DepthBiasClamp = D3D12_DEFAULT_DEPTH_BIAS_CLAMP;
785 SlopeScaledDepthBias = D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS;
786 DepthClipEnable = TRUE;
787 LineRasterizationMode = D3D12_LINE_RASTERIZATION_MODE_ALIASED;
788 ForcedSampleCount = 0;
789 ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF;
790 }
791 explicit CD3DX12_RASTERIZER_DESC2(
792 D3D12_FILL_MODE fillMode,
793 D3D12_CULL_MODE cullMode,
794 BOOL frontCounterClockwise,
795 FLOAT depthBias,
796 FLOAT depthBiasClamp,
797 FLOAT slopeScaledDepthBias,
798 BOOL depthClipEnable,
799 D3D12_LINE_RASTERIZATION_MODE lineRasterizationMode,
800 UINT forcedSampleCount,
801 D3D12_CONSERVATIVE_RASTERIZATION_MODE conservativeRaster) noexcept
802 {
803 FillMode = fillMode;
804 CullMode = cullMode;
805 FrontCounterClockwise = frontCounterClockwise;
806 DepthBias = depthBias;
807 DepthBiasClamp = depthBiasClamp;
808 SlopeScaledDepthBias = slopeScaledDepthBias;
809 DepthClipEnable = depthClipEnable;
810 LineRasterizationMode = lineRasterizationMode;
811 ForcedSampleCount = forcedSampleCount;
812 ConservativeRaster = conservativeRaster;
813 }
814
815
816 operator D3D12_RASTERIZER_DESC1() const noexcept
817 {
818 D3D12_RASTERIZER_DESC1 o;
819
820 o.FillMode = FillMode;
821 o.CullMode = CullMode;
822 o.FrontCounterClockwise = FrontCounterClockwise;
823 o.DepthBias = DepthBias;
824 o.DepthBiasClamp = DepthBiasClamp;
825 o.SlopeScaledDepthBias = SlopeScaledDepthBias;
826 o.DepthClipEnable = DepthClipEnable;
827 o.MultisampleEnable = FALSE;
828 o.AntialiasedLineEnable = FALSE;
829 if (LineRasterizationMode == D3D12_LINE_RASTERIZATION_MODE_ALPHA_ANTIALIASED)
830 {
831 o.AntialiasedLineEnable = TRUE;
832 }
833 else if (LineRasterizationMode != D3D12_LINE_RASTERIZATION_MODE_ALIASED)
834 {
835 o.MultisampleEnable = TRUE;
836 }
837 o.ForcedSampleCount = ForcedSampleCount;
838 o.ConservativeRaster = ConservativeRaster;
839
840 return o;
841 }
842 operator D3D12_RASTERIZER_DESC() const noexcept
843 {
844 return static_cast<D3D12_RASTERIZER_DESC>(CD3DX12_RASTERIZER_DESC1(static_cast<D3D12_RASTERIZER_DESC1>(*this)));
845 }
846};
847#endif // D3D12_SDK_VERSION >= 610
848
849//------------------------------------------------------------------------------------------------
850struct CD3DX12_RESOURCE_ALLOCATION_INFO : public D3D12_RESOURCE_ALLOCATION_INFO
851{
852 CD3DX12_RESOURCE_ALLOCATION_INFO() = default;
853 explicit CD3DX12_RESOURCE_ALLOCATION_INFO( const D3D12_RESOURCE_ALLOCATION_INFO& o ) noexcept :
854 D3D12_RESOURCE_ALLOCATION_INFO( o )
855 {}
856 CD3DX12_RESOURCE_ALLOCATION_INFO(
857 UINT64 size,
858 UINT64 alignment ) noexcept
859 {
860 SizeInBytes = size;
861 Alignment = alignment;
862 }
863};
864
865//------------------------------------------------------------------------------------------------
866struct CD3DX12_HEAP_PROPERTIES : public D3D12_HEAP_PROPERTIES
867{
868 CD3DX12_HEAP_PROPERTIES() = default;
869 explicit CD3DX12_HEAP_PROPERTIES(const D3D12_HEAP_PROPERTIES &o) noexcept :
870 D3D12_HEAP_PROPERTIES(o)
871 {}
872 CD3DX12_HEAP_PROPERTIES(
873 D3D12_CPU_PAGE_PROPERTY cpuPageProperty,
874 D3D12_MEMORY_POOL memoryPoolPreference,
875 UINT creationNodeMask = 1,
876 UINT nodeMask = 1 ) noexcept
877 {
878 Type = D3D12_HEAP_TYPE_CUSTOM;
879 CPUPageProperty = cpuPageProperty;
880 MemoryPoolPreference = memoryPoolPreference;
881 CreationNodeMask = creationNodeMask;
882 VisibleNodeMask = nodeMask;
883 }
884 explicit CD3DX12_HEAP_PROPERTIES(
885 D3D12_HEAP_TYPE type,
886 UINT creationNodeMask = 1,
887 UINT nodeMask = 1 ) noexcept
888 {
889 Type = type;
890 CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
891 MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
892 CreationNodeMask = creationNodeMask;
893 VisibleNodeMask = nodeMask;
894 }
895 bool IsCPUAccessible() const noexcept
896 {
897 return Type == D3D12_HEAP_TYPE_UPLOAD || Type == D3D12_HEAP_TYPE_READBACK
898#if defined(D3D12_SDK_VERSION) && (D3D12_SDK_VERSION >= 609)
899 || Type == D3D12_HEAP_TYPE_GPU_UPLOAD
900#endif
901 || (Type == D3D12_HEAP_TYPE_CUSTOM &&
902 (CPUPageProperty == D3D12_CPU_PAGE_PROPERTY_WRITE_COMBINE || CPUPageProperty == D3D12_CPU_PAGE_PROPERTY_WRITE_BACK));
903 }
904};
905inline bool operator==( const D3D12_HEAP_PROPERTIES& l, const D3D12_HEAP_PROPERTIES& r ) noexcept
906{
907 return l.Type == r.Type && l.CPUPageProperty == r.CPUPageProperty &&
908 l.MemoryPoolPreference == r.MemoryPoolPreference &&
909 l.CreationNodeMask == r.CreationNodeMask &&
910 l.VisibleNodeMask == r.VisibleNodeMask;
911}
912inline bool operator!=( const D3D12_HEAP_PROPERTIES& l, const D3D12_HEAP_PROPERTIES& r ) noexcept
913{ return !( l == r ); }
914
915//------------------------------------------------------------------------------------------------
916struct CD3DX12_HEAP_DESC : public D3D12_HEAP_DESC
917{
918 CD3DX12_HEAP_DESC() = default;
919 explicit CD3DX12_HEAP_DESC(const D3D12_HEAP_DESC &o) noexcept :
920 D3D12_HEAP_DESC(o)
921 {}
922 CD3DX12_HEAP_DESC(
923 UINT64 size,
924 D3D12_HEAP_PROPERTIES properties,
925 UINT64 alignment = 0,
926 D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) noexcept
927 {
928 SizeInBytes = size;
929 Properties = properties;
930 Alignment = alignment;
931 Flags = flags;
932 }
933 CD3DX12_HEAP_DESC(
934 UINT64 size,
935 D3D12_HEAP_TYPE type,
936 UINT64 alignment = 0,
937 D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) noexcept
938 {
939 SizeInBytes = size;
940 Properties = CD3DX12_HEAP_PROPERTIES( type );
941 Alignment = alignment;
942 Flags = flags;
943 }
944 CD3DX12_HEAP_DESC(
945 UINT64 size,
946 D3D12_CPU_PAGE_PROPERTY cpuPageProperty,
947 D3D12_MEMORY_POOL memoryPoolPreference,
948 UINT64 alignment = 0,
949 D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) noexcept
950 {
951 SizeInBytes = size;
952 Properties = CD3DX12_HEAP_PROPERTIES( cpuPageProperty, memoryPoolPreference );
953 Alignment = alignment;
954 Flags = flags;
955 }
956 CD3DX12_HEAP_DESC(
957 const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
958 D3D12_HEAP_PROPERTIES properties,
959 D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) noexcept
960 {
961 SizeInBytes = resAllocInfo.SizeInBytes;
962 Properties = properties;
963 Alignment = resAllocInfo.Alignment;
964 Flags = flags;
965 }
966 CD3DX12_HEAP_DESC(
967 const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
968 D3D12_HEAP_TYPE type,
969 D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) noexcept
970 {
971 SizeInBytes = resAllocInfo.SizeInBytes;
972 Properties = CD3DX12_HEAP_PROPERTIES( type );
973 Alignment = resAllocInfo.Alignment;
974 Flags = flags;
975 }
976 CD3DX12_HEAP_DESC(
977 const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
978 D3D12_CPU_PAGE_PROPERTY cpuPageProperty,
979 D3D12_MEMORY_POOL memoryPoolPreference,
980 D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) noexcept
981 {
982 SizeInBytes = resAllocInfo.SizeInBytes;
983 Properties = CD3DX12_HEAP_PROPERTIES( cpuPageProperty, memoryPoolPreference );
984 Alignment = resAllocInfo.Alignment;
985 Flags = flags;
986 }
987 bool IsCPUAccessible() const noexcept
988 { return static_cast< const CD3DX12_HEAP_PROPERTIES* >( &Properties )->IsCPUAccessible(); }
989};
990inline bool operator==( const D3D12_HEAP_DESC& l, const D3D12_HEAP_DESC& r ) noexcept
991{
992 return l.SizeInBytes == r.SizeInBytes &&
993 l.Properties == r.Properties &&
994 l.Alignment == r.Alignment &&
995 l.Flags == r.Flags;
996}
997inline bool operator!=( const D3D12_HEAP_DESC& l, const D3D12_HEAP_DESC& r ) noexcept
998{ return !( l == r ); }
999
1000//------------------------------------------------------------------------------------------------
1001struct CD3DX12_CLEAR_VALUE : public D3D12_CLEAR_VALUE
1002{
1003 CD3DX12_CLEAR_VALUE() = default;
1004 explicit CD3DX12_CLEAR_VALUE(const D3D12_CLEAR_VALUE &o) noexcept :
1005 D3D12_CLEAR_VALUE(o)
1006 {}
1007 CD3DX12_CLEAR_VALUE(
1008 DXGI_FORMAT format,
1009 const FLOAT color[4] ) noexcept
1010 {
1011 Format = format;
1012 memcpy( Color, color, sizeof( Color ) );
1013 }
1014 CD3DX12_CLEAR_VALUE(
1015 DXGI_FORMAT format,
1016 FLOAT depth,
1017 UINT8 stencil ) noexcept
1018 {
1019 Format = format;
1020 memset( &Color, 0, sizeof( Color ) );
1021 /* Use memcpy to preserve NAN values */
1022 memcpy( &DepthStencil.Depth, &depth, sizeof( depth ) );
1023 DepthStencil.Stencil = stencil;
1024 }
1025};
1026
1027//------------------------------------------------------------------------------------------------
1028inline bool operator==( const D3D12_CLEAR_VALUE &a, const D3D12_CLEAR_VALUE &b) noexcept
1029{
1030 if (a.Format != b.Format) return false;
1031 if (a.Format == DXGI_FORMAT_D24_UNORM_S8_UINT
1032 || a.Format == DXGI_FORMAT_D16_UNORM
1033 || a.Format == DXGI_FORMAT_D32_FLOAT
1034 || a.Format == DXGI_FORMAT_D32_FLOAT_S8X24_UINT)
1035 {
1036 return (a.DepthStencil.Depth == b.DepthStencil.Depth) &&
1037 (a.DepthStencil.Stencil == b.DepthStencil.Stencil);
1038 } else {
1039 return (a.Color[0] == b.Color[0]) &&
1040 (a.Color[1] == b.Color[1]) &&
1041 (a.Color[2] == b.Color[2]) &&
1042 (a.Color[3] == b.Color[3]);
1043 }
1044}
1045
1046//------------------------------------------------------------------------------------------------
1047struct CD3DX12_RANGE : public D3D12_RANGE
1048{
1049 CD3DX12_RANGE() = default;
1050 explicit CD3DX12_RANGE(const D3D12_RANGE &o) noexcept :
1051 D3D12_RANGE(o)
1052 {}
1053 CD3DX12_RANGE(
1054 SIZE_T begin,
1055 SIZE_T end ) noexcept
1056 {
1057 Begin = begin;
1058 End = end;
1059 }
1060};
1061
1062//------------------------------------------------------------------------------------------------
1063struct CD3DX12_RANGE_UINT64 : public D3D12_RANGE_UINT64
1064{
1065 CD3DX12_RANGE_UINT64() = default;
1066 explicit CD3DX12_RANGE_UINT64(const D3D12_RANGE_UINT64 &o) noexcept :
1067 D3D12_RANGE_UINT64(o)
1068 {}
1069 CD3DX12_RANGE_UINT64(
1070 UINT64 begin,
1071 UINT64 end ) noexcept
1072 {
1073 Begin = begin;
1074 End = end;
1075 }
1076};
1077
1078//------------------------------------------------------------------------------------------------
1079struct CD3DX12_SUBRESOURCE_RANGE_UINT64 : public D3D12_SUBRESOURCE_RANGE_UINT64
1080{
1081 CD3DX12_SUBRESOURCE_RANGE_UINT64() = default;
1082 explicit CD3DX12_SUBRESOURCE_RANGE_UINT64(const D3D12_SUBRESOURCE_RANGE_UINT64 &o) noexcept :
1083 D3D12_SUBRESOURCE_RANGE_UINT64(o)
1084 {}
1085 CD3DX12_SUBRESOURCE_RANGE_UINT64(
1086 UINT subresource,
1087 const D3D12_RANGE_UINT64& range ) noexcept
1088 {
1089 Subresource = subresource;
1090 Range = range;
1091 }
1092 CD3DX12_SUBRESOURCE_RANGE_UINT64(
1093 UINT subresource,
1094 UINT64 begin,
1095 UINT64 end ) noexcept
1096 {
1097 Subresource = subresource;
1098 Range.Begin = begin;
1099 Range.End = end;
1100 }
1101};
1102
1103//------------------------------------------------------------------------------------------------
1104struct CD3DX12_SHADER_BYTECODE : public D3D12_SHADER_BYTECODE
1105{
1106 CD3DX12_SHADER_BYTECODE() = default;
1107 explicit CD3DX12_SHADER_BYTECODE(const D3D12_SHADER_BYTECODE &o) noexcept :
1108 D3D12_SHADER_BYTECODE(o)
1109 {}
1110 CD3DX12_SHADER_BYTECODE(
1111 _In_ ID3DBlob* pShaderBlob ) noexcept
1112 {
1113 pShaderBytecode = pShaderBlob->GetBufferPointer();
1114 BytecodeLength = pShaderBlob->GetBufferSize();
1115 }
1116 CD3DX12_SHADER_BYTECODE(
1117 const void* _pShaderBytecode,
1118 SIZE_T bytecodeLength ) noexcept
1119 {
1120 pShaderBytecode = _pShaderBytecode;
1121 BytecodeLength = bytecodeLength;
1122 }
1123};
1124
1125//------------------------------------------------------------------------------------------------
1126struct CD3DX12_TILED_RESOURCE_COORDINATE : public D3D12_TILED_RESOURCE_COORDINATE
1127{
1128 CD3DX12_TILED_RESOURCE_COORDINATE() = default;
1129 explicit CD3DX12_TILED_RESOURCE_COORDINATE(const D3D12_TILED_RESOURCE_COORDINATE &o) noexcept :
1130 D3D12_TILED_RESOURCE_COORDINATE(o)
1131 {}
1132 CD3DX12_TILED_RESOURCE_COORDINATE(
1133 UINT x,
1134 UINT y,
1135 UINT z,
1136 UINT subresource ) noexcept
1137 {
1138 X = x;
1139 Y = y;
1140 Z = z;
1141 Subresource = subresource;
1142 }
1143};
1144
1145//------------------------------------------------------------------------------------------------
1146struct CD3DX12_TILE_REGION_SIZE : public D3D12_TILE_REGION_SIZE
1147{
1148 CD3DX12_TILE_REGION_SIZE() = default;
1149 explicit CD3DX12_TILE_REGION_SIZE(const D3D12_TILE_REGION_SIZE &o) noexcept :
1150 D3D12_TILE_REGION_SIZE(o)
1151 {}
1152 CD3DX12_TILE_REGION_SIZE(
1153 UINT numTiles,
1154 BOOL useBox,
1155 UINT width,
1156 UINT16 height,
1157 UINT16 depth ) noexcept
1158 {
1159 NumTiles = numTiles;
1160 UseBox = useBox;
1161 Width = width;
1162 Height = height;
1163 Depth = depth;
1164 }
1165};
1166
1167//------------------------------------------------------------------------------------------------
1168struct CD3DX12_SUBRESOURCE_TILING : public D3D12_SUBRESOURCE_TILING
1169{
1170 CD3DX12_SUBRESOURCE_TILING() = default;
1171 explicit CD3DX12_SUBRESOURCE_TILING(const D3D12_SUBRESOURCE_TILING &o) noexcept :
1172 D3D12_SUBRESOURCE_TILING(o)
1173 {}
1174 CD3DX12_SUBRESOURCE_TILING(
1175 UINT widthInTiles,
1176 UINT16 heightInTiles,
1177 UINT16 depthInTiles,
1178 UINT startTileIndexInOverallResource ) noexcept
1179 {
1180 WidthInTiles = widthInTiles;
1181 HeightInTiles = heightInTiles;
1182 DepthInTiles = depthInTiles;
1183 StartTileIndexInOverallResource = startTileIndexInOverallResource;
1184 }
1185};
1186
1187//------------------------------------------------------------------------------------------------
1188struct CD3DX12_TILE_SHAPE : public D3D12_TILE_SHAPE
1189{
1190 CD3DX12_TILE_SHAPE() = default;
1191 explicit CD3DX12_TILE_SHAPE(const D3D12_TILE_SHAPE &o) noexcept :
1192 D3D12_TILE_SHAPE(o)
1193 {}
1194 CD3DX12_TILE_SHAPE(
1195 UINT widthInTexels,
1196 UINT heightInTexels,
1197 UINT depthInTexels ) noexcept
1198 {
1199 WidthInTexels = widthInTexels;
1200 HeightInTexels = heightInTexels;
1201 DepthInTexels = depthInTexels;
1202 }
1203};
1204
1205//------------------------------------------------------------------------------------------------
1206struct CD3DX12_PACKED_MIP_INFO : public D3D12_PACKED_MIP_INFO
1207{
1208 CD3DX12_PACKED_MIP_INFO() = default;
1209 explicit CD3DX12_PACKED_MIP_INFO(const D3D12_PACKED_MIP_INFO &o) noexcept :
1210 D3D12_PACKED_MIP_INFO(o)
1211 {}
1212 CD3DX12_PACKED_MIP_INFO(
1213 UINT8 numStandardMips,
1214 UINT8 numPackedMips,
1215 UINT numTilesForPackedMips,
1216 UINT startTileIndexInOverallResource ) noexcept
1217 {
1218 NumStandardMips = numStandardMips;
1219 NumPackedMips = numPackedMips;
1220 NumTilesForPackedMips = numTilesForPackedMips;
1221 StartTileIndexInOverallResource = startTileIndexInOverallResource;
1222 }
1223};
1224
1225//------------------------------------------------------------------------------------------------
1226struct CD3DX12_SUBRESOURCE_FOOTPRINT : public D3D12_SUBRESOURCE_FOOTPRINT
1227{
1228 CD3DX12_SUBRESOURCE_FOOTPRINT() = default;
1229 explicit CD3DX12_SUBRESOURCE_FOOTPRINT(const D3D12_SUBRESOURCE_FOOTPRINT &o) noexcept :
1230 D3D12_SUBRESOURCE_FOOTPRINT(o)
1231 {}
1232 CD3DX12_SUBRESOURCE_FOOTPRINT(
1233 DXGI_FORMAT format,
1234 UINT width,
1235 UINT height,
1236 UINT depth,
1237 UINT rowPitch ) noexcept
1238 {
1239 Format = format;
1240 Width = width;
1241 Height = height;
1242 Depth = depth;
1243 RowPitch = rowPitch;
1244 }
1245 explicit CD3DX12_SUBRESOURCE_FOOTPRINT(
1246 const D3D12_RESOURCE_DESC& resDesc,
1247 UINT rowPitch ) noexcept
1248 {
1249 Format = resDesc.Format;
1250 Width = UINT( resDesc.Width );
1251 Height = resDesc.Height;
1252 Depth = (resDesc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? resDesc.DepthOrArraySize : 1u);
1253 RowPitch = rowPitch;
1254 }
1255};
1256
1257//------------------------------------------------------------------------------------------------
1258struct CD3DX12_TEXTURE_COPY_LOCATION : public D3D12_TEXTURE_COPY_LOCATION
1259{
1260 CD3DX12_TEXTURE_COPY_LOCATION() = default;
1261 explicit CD3DX12_TEXTURE_COPY_LOCATION(const D3D12_TEXTURE_COPY_LOCATION &o) noexcept :
1262 D3D12_TEXTURE_COPY_LOCATION(o)
1263 {}
1264 CD3DX12_TEXTURE_COPY_LOCATION(_In_ ID3D12Resource* pRes) noexcept
1265 {
1266 pResource = pRes;
1267 Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
1268 PlacedFootprint = {};
1269 }
1270 CD3DX12_TEXTURE_COPY_LOCATION(_In_ ID3D12Resource* pRes, D3D12_PLACED_SUBRESOURCE_FOOTPRINT const& Footprint) noexcept
1271 {
1272 pResource = pRes;
1273 Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
1274 PlacedFootprint = Footprint;
1275 }
1276 CD3DX12_TEXTURE_COPY_LOCATION(_In_ ID3D12Resource* pRes, UINT Sub) noexcept
1277 {
1278 pResource = pRes;
1279 Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
1280 PlacedFootprint = {};
1281 SubresourceIndex = Sub;
1282 }
1283};
1284
1285//------------------------------------------------------------------------------------------------
1286constexpr UINT D3D12CalcSubresource( UINT MipSlice, UINT ArraySlice, UINT PlaneSlice, UINT MipLevels, UINT ArraySize ) noexcept
1287{
1288 return MipSlice + ArraySlice * MipLevels + PlaneSlice * MipLevels * ArraySize;
1289}
1290
1291//------------------------------------------------------------------------------------------------
1292inline UINT8 D3D12GetFormatPlaneCount(
1293 _In_ ID3D12Device* pDevice,
1294 DXGI_FORMAT Format
1295 ) noexcept
1296{
1297 D3D12_FEATURE_DATA_FORMAT_INFO formatInfo = { Format, 0 };
1298 if (FAILED(pDevice->CheckFeatureSupport(D3D12_FEATURE_FORMAT_INFO, &formatInfo, sizeof(formatInfo))))
1299 {
1300 return 0;
1301 }
1302 return formatInfo.PlaneCount;
1303}
1304
1305//------------------------------------------------------------------------------------------------
1306struct CD3DX12_RESOURCE_DESC : public D3D12_RESOURCE_DESC
1307{
1308 CD3DX12_RESOURCE_DESC() = default;
1309 explicit CD3DX12_RESOURCE_DESC( const D3D12_RESOURCE_DESC& o ) noexcept :
1310 D3D12_RESOURCE_DESC( o )
1311 {}
1312 CD3DX12_RESOURCE_DESC(
1313 D3D12_RESOURCE_DIMENSION dimension,
1314 UINT64 alignment,
1315 UINT64 width,
1316 UINT height,
1317 UINT16 depthOrArraySize,
1318 UINT16 mipLevels,
1319 DXGI_FORMAT format,
1320 UINT sampleCount,
1321 UINT sampleQuality,
1322 D3D12_TEXTURE_LAYOUT layout,
1323 D3D12_RESOURCE_FLAGS flags ) noexcept
1324 {
1325 Dimension = dimension;
1326 Alignment = alignment;
1327 Width = width;
1328 Height = height;
1329 DepthOrArraySize = depthOrArraySize;
1330 MipLevels = mipLevels;
1331 Format = format;
1332 SampleDesc.Count = sampleCount;
1333 SampleDesc.Quality = sampleQuality;
1334 Layout = layout;
1335 Flags = flags;
1336 }
1337 static inline CD3DX12_RESOURCE_DESC Buffer(
1338 const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
1339 D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE ) noexcept
1340 {
1341 return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_BUFFER, resAllocInfo.Alignment, resAllocInfo.SizeInBytes,
1342 1, 1, 1, DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags );
1343 }
1344 static inline CD3DX12_RESOURCE_DESC Buffer(
1345 UINT64 width,
1346 D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
1347 UINT64 alignment = 0 ) noexcept
1348 {
1349 return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_BUFFER, alignment, width, 1, 1, 1,
1350 DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags );
1351 }
1352 static inline CD3DX12_RESOURCE_DESC Tex1D(
1353 DXGI_FORMAT format,
1354 UINT64 width,
1355 UINT16 arraySize = 1,
1356 UINT16 mipLevels = 0,
1357 D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
1358 D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
1359 UINT64 alignment = 0 ) noexcept
1360 {
1361 return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_TEXTURE1D, alignment, width, 1, arraySize,
1362 mipLevels, format, 1, 0, layout, flags );
1363 }
1364 static inline CD3DX12_RESOURCE_DESC Tex2D(
1365 DXGI_FORMAT format,
1366 UINT64 width,
1367 UINT height,
1368 UINT16 arraySize = 1,
1369 UINT16 mipLevels = 0,
1370 UINT sampleCount = 1,
1371 UINT sampleQuality = 0,
1372 D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
1373 D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
1374 UINT64 alignment = 0 ) noexcept
1375 {
1376 return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_TEXTURE2D, alignment, width, height, arraySize,
1377 mipLevels, format, sampleCount, sampleQuality, layout, flags );
1378 }
1379 static inline CD3DX12_RESOURCE_DESC Tex3D(
1380 DXGI_FORMAT format,
1381 UINT64 width,
1382 UINT height,
1383 UINT16 depth,
1384 UINT16 mipLevels = 0,
1385 D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
1386 D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
1387 UINT64 alignment = 0 ) noexcept
1388 {
1389 return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_TEXTURE3D, alignment, width, height, depth,
1390 mipLevels, format, 1, 0, layout, flags );
1391 }
1392 inline UINT16 Depth() const noexcept
1393 { return (Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize : 1u); }
1394 inline UINT16 ArraySize() const noexcept
1395 { return (Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize : 1u); }
1396 inline UINT8 PlaneCount(_In_ ID3D12Device* pDevice) const noexcept
1397 { return D3D12GetFormatPlaneCount(pDevice, Format); }
1398 inline UINT Subresources(_In_ ID3D12Device* pDevice) const noexcept
1399 { return static_cast<UINT>(MipLevels) * ArraySize() * PlaneCount(pDevice); }
1400 inline UINT CalcSubresource(UINT MipSlice, UINT ArraySlice, UINT PlaneSlice) noexcept
1401 { return D3D12CalcSubresource(MipSlice, ArraySlice, PlaneSlice, MipLevels, ArraySize()); }
1402};
1403inline bool operator==( const D3D12_RESOURCE_DESC& l, const D3D12_RESOURCE_DESC& r ) noexcept
1404{
1405 return l.Dimension == r.Dimension &&
1406 l.Alignment == r.Alignment &&
1407 l.Width == r.Width &&
1408 l.Height == r.Height &&
1409 l.DepthOrArraySize == r.DepthOrArraySize &&
1410 l.MipLevels == r.MipLevels &&
1411 l.Format == r.Format &&
1412 l.SampleDesc.Count == r.SampleDesc.Count &&
1413 l.SampleDesc.Quality == r.SampleDesc.Quality &&
1414 l.Layout == r.Layout &&
1415 l.Flags == r.Flags;
1416}
1417inline bool operator!=( const D3D12_RESOURCE_DESC& l, const D3D12_RESOURCE_DESC& r ) noexcept
1418{ return !( l == r ); }
1419
1420//------------------------------------------------------------------------------------------------
1421struct CD3DX12_RESOURCE_DESC1 : public D3D12_RESOURCE_DESC1
1422{
1423 CD3DX12_RESOURCE_DESC1() = default;
1424 explicit CD3DX12_RESOURCE_DESC1( const D3D12_RESOURCE_DESC1& o ) noexcept :
1425 D3D12_RESOURCE_DESC1( o )
1426 {}
1427 explicit CD3DX12_RESOURCE_DESC1( const D3D12_RESOURCE_DESC& o ) noexcept
1428 {
1429 Dimension = o.Dimension;
1430 Alignment = o.Alignment;
1431 Width = o.Width;
1432 Height = o.Height;
1433 DepthOrArraySize = o.DepthOrArraySize;
1434 MipLevels = o.MipLevels;
1435 Format = o.Format;
1436 SampleDesc = o.SampleDesc;
1437 Layout = o.Layout;
1438 Flags = o.Flags;
1439 SamplerFeedbackMipRegion = {};
1440 }
1441 CD3DX12_RESOURCE_DESC1(
1442 D3D12_RESOURCE_DIMENSION dimension,
1443 UINT64 alignment,
1444 UINT64 width,
1445 UINT height,
1446 UINT16 depthOrArraySize,
1447 UINT16 mipLevels,
1448 DXGI_FORMAT format,
1449 UINT sampleCount,
1450 UINT sampleQuality,
1451 D3D12_TEXTURE_LAYOUT layout,
1452 D3D12_RESOURCE_FLAGS flags,
1453 UINT samplerFeedbackMipRegionWidth = 0,
1454 UINT samplerFeedbackMipRegionHeight = 0,
1455 UINT samplerFeedbackMipRegionDepth = 0) noexcept
1456 {
1457 Dimension = dimension;
1458 Alignment = alignment;
1459 Width = width;
1460 Height = height;
1461 DepthOrArraySize = depthOrArraySize;
1462 MipLevels = mipLevels;
1463 Format = format;
1464 SampleDesc.Count = sampleCount;
1465 SampleDesc.Quality = sampleQuality;
1466 Layout = layout;
1467 Flags = flags;
1468 SamplerFeedbackMipRegion.Width = samplerFeedbackMipRegionWidth;
1469 SamplerFeedbackMipRegion.Height = samplerFeedbackMipRegionHeight;
1470 SamplerFeedbackMipRegion.Depth = samplerFeedbackMipRegionDepth;
1471 }
1472
1473 static inline CD3DX12_RESOURCE_DESC1 Buffer(
1474 const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
1475 D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE ) noexcept
1476 {
1477 return CD3DX12_RESOURCE_DESC1( D3D12_RESOURCE_DIMENSION_BUFFER, resAllocInfo.Alignment, resAllocInfo.SizeInBytes,
1478 1, 1, 1, DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags, 0, 0, 0 );
1479 }
1480 static inline CD3DX12_RESOURCE_DESC1 Buffer(
1481 UINT64 width,
1482 D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
1483 UINT64 alignment = 0 ) noexcept
1484 {
1485 return CD3DX12_RESOURCE_DESC1( D3D12_RESOURCE_DIMENSION_BUFFER, alignment, width, 1, 1, 1,
1486 DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags, 0, 0, 0 );
1487 }
1488 static inline CD3DX12_RESOURCE_DESC1 Tex1D(
1489 DXGI_FORMAT format,
1490 UINT64 width,
1491 UINT16 arraySize = 1,
1492 UINT16 mipLevels = 0,
1493 D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
1494 D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
1495 UINT64 alignment = 0 ) noexcept
1496 {
1497 return CD3DX12_RESOURCE_DESC1( D3D12_RESOURCE_DIMENSION_TEXTURE1D, alignment, width, 1, arraySize,
1498 mipLevels, format, 1, 0, layout, flags, 0, 0, 0 );
1499 }
1500 static inline CD3DX12_RESOURCE_DESC1 Tex2D(
1501 DXGI_FORMAT format,
1502 UINT64 width,
1503 UINT height,
1504 UINT16 arraySize = 1,
1505 UINT16 mipLevels = 0,
1506 UINT sampleCount = 1,
1507 UINT sampleQuality = 0,
1508 D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
1509 D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
1510 UINT64 alignment = 0,
1511 UINT samplerFeedbackMipRegionWidth = 0,
1512 UINT samplerFeedbackMipRegionHeight = 0,
1513 UINT samplerFeedbackMipRegionDepth = 0) noexcept
1514 {
1515 return CD3DX12_RESOURCE_DESC1( D3D12_RESOURCE_DIMENSION_TEXTURE2D, alignment, width, height, arraySize,
1516 mipLevels, format, sampleCount, sampleQuality, layout, flags, samplerFeedbackMipRegionWidth,
1517 samplerFeedbackMipRegionHeight, samplerFeedbackMipRegionDepth );
1518 }
1519 static inline CD3DX12_RESOURCE_DESC1 Tex3D(
1520 DXGI_FORMAT format,
1521 UINT64 width,
1522 UINT height,
1523 UINT16 depth,
1524 UINT16 mipLevels = 0,
1525 D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
1526 D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
1527 UINT64 alignment = 0 ) noexcept
1528 {
1529 return CD3DX12_RESOURCE_DESC1( D3D12_RESOURCE_DIMENSION_TEXTURE3D, alignment, width, height, depth,
1530 mipLevels, format, 1, 0, layout, flags, 0, 0, 0 );
1531 }
1532 inline UINT16 Depth() const noexcept
1533 { return (Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize : 1u); }
1534 inline UINT16 ArraySize() const noexcept
1535 { return (Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize : 1u); }
1536 inline UINT8 PlaneCount(_In_ ID3D12Device* pDevice) const noexcept
1537 { return D3D12GetFormatPlaneCount(pDevice, Format); }
1538 inline UINT Subresources(_In_ ID3D12Device* pDevice) const noexcept
1539 { return static_cast<UINT>(MipLevels) * ArraySize() * PlaneCount(pDevice); }
1540 inline UINT CalcSubresource(UINT MipSlice, UINT ArraySlice, UINT PlaneSlice) noexcept
1541 { return D3D12CalcSubresource(MipSlice, ArraySlice, PlaneSlice, MipLevels, ArraySize()); }
1542};
1543inline bool operator==( const D3D12_RESOURCE_DESC1& l, const D3D12_RESOURCE_DESC1& r ) noexcept
1544{
1545 return l.Dimension == r.Dimension &&
1546 l.Alignment == r.Alignment &&
1547 l.Width == r.Width &&
1548 l.Height == r.Height &&
1549 l.DepthOrArraySize == r.DepthOrArraySize &&
1550 l.MipLevels == r.MipLevels &&
1551 l.Format == r.Format &&
1552 l.SampleDesc.Count == r.SampleDesc.Count &&
1553 l.SampleDesc.Quality == r.SampleDesc.Quality &&
1554 l.Layout == r.Layout &&
1555 l.Flags == r.Flags &&
1556 l.SamplerFeedbackMipRegion.Width == r.SamplerFeedbackMipRegion.Width &&
1557 l.SamplerFeedbackMipRegion.Height == r.SamplerFeedbackMipRegion.Height &&
1558 l.SamplerFeedbackMipRegion.Depth == r.SamplerFeedbackMipRegion.Depth;
1559}
1560inline bool operator!=( const D3D12_RESOURCE_DESC1& l, const D3D12_RESOURCE_DESC1& r ) noexcept
1561{ return !( l == r ); }
1562
1563//------------------------------------------------------------------------------------------------
1564// Fills in the mipmap and alignment values of pDesc when either members are zero
1565// Used to replace an implicit field to an explicit (0 mip map = max mip map level)
1566// If expansion has occured, returns LclDesc, else returns the original pDesc
1567inline const CD3DX12_RESOURCE_DESC1* D3DX12ConditionallyExpandAPIDesc(
1568 CD3DX12_RESOURCE_DESC1& LclDesc,
1569 const CD3DX12_RESOURCE_DESC1* pDesc,
1570 const bool tightAlignmentSupported = false,
1571 const bool alignAsCommitted = false)
1572{
1573 // Expand mip levels:
1574 if (pDesc->MipLevels == 0 || pDesc->Alignment == 0)
1575 {
1576 LclDesc = *pDesc;
1577 if (pDesc->MipLevels == 0)
1578 {
1579 auto MaxMipLevels = [](UINT64 uiMaxDimension) -> UINT16
1580 {
1581 UINT16 uiRet = 0;
1582 while (uiMaxDimension > 0)
1583 {
1584 uiRet++;
1585 uiMaxDimension >>= 1;
1586 }
1587 return uiRet;
1588 };
1589 auto Max = [](UINT64 const& a, UINT64 const& b)
1590 {
1591 return (a < b) ? b : a;
1592 };
1593
1594 LclDesc.MipLevels = MaxMipLevels(
1595 Max(LclDesc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? LclDesc.DepthOrArraySize : 1,
1596 Max(LclDesc.Width, LclDesc.Height)));
1597 }
1598 if (pDesc->Alignment == 0)
1599 {
1600 if (pDesc->Layout == D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE
1601 || pDesc->Layout == D3D12_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE
1602 )
1603 {
1604 LclDesc.Alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT;
1605 }
1606 else if (!(tightAlignmentSupported && (pDesc->Flags & D3D12_RESOURCE_FLAG_USE_TIGHT_ALIGNMENT))
1607 || (pDesc->Flags & D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER))
1608 {
1609 LclDesc.Alignment =
1610 (pDesc->SampleDesc.Count > 1 ? D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT : D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT);
1611 }
1612 else
1613 {
1614 // Tight alignment is supported and we aren't a cross adapter resource, now just need to set the alignment field to the minimum alignment for each type
1615 if(alignAsCommitted)
1616 LclDesc.Alignment = D3D12_TIGHT_ALIGNMENT_MIN_COMMITTED_RESOURCE_ALIGNMENT;
1617 else
1618 LclDesc.Alignment = D3D12_TIGHT_ALIGNMENT_MIN_PLACED_RESOURCE_ALIGNMENT;
1619 }
1620 }
1621 return &LclDesc;
1622 }
1623 else
1624 {
1625 return pDesc;
1626 }
1627}
1628
1629
1630//------------------------------------------------------------------------------------------------
1631struct CD3DX12_SHADER_RESOURCE_VIEW_DESC : public D3D12_SHADER_RESOURCE_VIEW_DESC
1632{
1633 CD3DX12_SHADER_RESOURCE_VIEW_DESC() = default;
1634 explicit CD3DX12_SHADER_RESOURCE_VIEW_DESC( const D3D12_SHADER_RESOURCE_VIEW_DESC& o ) noexcept :
1635 D3D12_SHADER_RESOURCE_VIEW_DESC(o)
1636 {}
1637
1638 static inline CD3DX12_SHADER_RESOURCE_VIEW_DESC StructuredBuffer(
1639 UINT NumElements,
1640 UINT StructureByteStride,
1641 UINT64 FirstElement = 0) noexcept
1642 {
1643 CD3DX12_SHADER_RESOURCE_VIEW_DESC desc;
1644 desc.Format = DXGI_FORMAT_UNKNOWN;
1645 desc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER;
1646 desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
1647 desc.Buffer.FirstElement = FirstElement;
1648 desc.Buffer.NumElements = NumElements;
1649 desc.Buffer.StructureByteStride = StructureByteStride;
1650 desc.Buffer.Flags = D3D12_BUFFER_SRV_FLAG_NONE;
1651 return desc;
1652 }
1653
1654 static inline CD3DX12_SHADER_RESOURCE_VIEW_DESC RawBuffer(
1655 UINT NumElements,
1656 UINT64 FirstElement = 0) noexcept
1657 {
1658 CD3DX12_SHADER_RESOURCE_VIEW_DESC desc;
1659 desc.Format = DXGI_FORMAT_R32_UINT;
1660 desc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER;
1661 desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
1662 desc.Buffer.FirstElement = FirstElement;
1663 desc.Buffer.NumElements = NumElements;
1664 desc.Buffer.StructureByteStride = 0;
1665 desc.Buffer.Flags = D3D12_BUFFER_SRV_FLAG_RAW;
1666 return desc;
1667 }
1668
1669 static inline CD3DX12_SHADER_RESOURCE_VIEW_DESC TypedBuffer(
1670 DXGI_FORMAT Format,
1671 UINT NumElements,
1672 UINT64 FirstElement = 0,
1673 UINT Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING) noexcept
1674 {
1675 CD3DX12_SHADER_RESOURCE_VIEW_DESC desc;
1676 desc.Format = Format;
1677 desc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER;
1678 desc.Shader4ComponentMapping = Shader4ComponentMapping;
1679 desc.Buffer.FirstElement = FirstElement;
1680 desc.Buffer.NumElements = NumElements;
1681 desc.Buffer.StructureByteStride = 0;
1682 desc.Buffer.Flags = D3D12_BUFFER_SRV_FLAG_NONE;
1683 return desc;
1684 }
1685
1686 static inline CD3DX12_SHADER_RESOURCE_VIEW_DESC Tex1D(
1687 DXGI_FORMAT Format,
1688 UINT MipLevels = -1,
1689 UINT MostDetailedMip = 0,
1690 FLOAT ResourceMinLODClamp = 0.0f,
1691 UINT Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING) noexcept
1692 {
1693 CD3DX12_SHADER_RESOURCE_VIEW_DESC desc;
1694 desc.Format = Format;
1695 desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE1D;
1696 desc.Shader4ComponentMapping = Shader4ComponentMapping;
1697 desc.Texture1D.MostDetailedMip = MostDetailedMip;
1698 desc.Texture1D.MipLevels = MipLevels;
1699 desc.Texture1D.ResourceMinLODClamp = ResourceMinLODClamp;
1700 return desc;
1701 }
1702
1703 static inline CD3DX12_SHADER_RESOURCE_VIEW_DESC Tex1DArray(
1704 DXGI_FORMAT Format,
1705 UINT ArraySize = -1,
1706 UINT MipLevels = -1,
1707 UINT FirstArraySlice = 0,
1708 UINT MostDetailedMip = 0,
1709 FLOAT ResourceMinLODClamp = 0.0f,
1710 UINT Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING) noexcept
1711 {
1712 CD3DX12_SHADER_RESOURCE_VIEW_DESC desc;
1713 desc.Format = Format;
1714 desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE1DARRAY;
1715 desc.Shader4ComponentMapping = Shader4ComponentMapping;
1716 desc.Texture1DArray.MostDetailedMip = MostDetailedMip;
1717 desc.Texture1DArray.MipLevels = MipLevels;
1718 desc.Texture1DArray.FirstArraySlice = FirstArraySlice;
1719 desc.Texture1DArray.ArraySize = ArraySize;
1720 desc.Texture1DArray.ResourceMinLODClamp = ResourceMinLODClamp;
1721 return desc;
1722 }
1723
1724 static inline CD3DX12_SHADER_RESOURCE_VIEW_DESC Tex2D(
1725 DXGI_FORMAT Format,
1726 UINT MipLevels = -1,
1727 UINT MostDetailedMip = 0,
1728 UINT PlaneSlice = 0,
1729 FLOAT ResourceMinLODClamp = 0.0f,
1730 UINT Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING) noexcept
1731 {
1732 CD3DX12_SHADER_RESOURCE_VIEW_DESC desc;
1733 desc.Format = Format;
1734 desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D;
1735 desc.Shader4ComponentMapping = Shader4ComponentMapping;
1736 desc.Texture2D.MostDetailedMip = MostDetailedMip;
1737 desc.Texture2D.MipLevels = MipLevels;
1738 desc.Texture2D.PlaneSlice = PlaneSlice;
1739 desc.Texture2D.ResourceMinLODClamp = ResourceMinLODClamp;
1740 return desc;
1741 }
1742
1743 static inline CD3DX12_SHADER_RESOURCE_VIEW_DESC Tex2DArray(
1744 DXGI_FORMAT Format,
1745 UINT ArraySize = -1,
1746 UINT MipLevels = -1,
1747 UINT FirstArraySlice = 0,
1748 UINT MostDetailedMip = 0,
1749 UINT PlaneSlice = 0,
1750 FLOAT ResourceMinLODClamp = 0.0f,
1751 UINT Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING) noexcept
1752 {
1753 CD3DX12_SHADER_RESOURCE_VIEW_DESC desc;
1754 desc.Format = Format;
1755 desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2DARRAY;
1756 desc.Shader4ComponentMapping = Shader4ComponentMapping;
1757 desc.Texture2DArray.MostDetailedMip = MostDetailedMip;
1758 desc.Texture2DArray.MipLevels = MipLevels;
1759 desc.Texture2DArray.FirstArraySlice = FirstArraySlice;
1760 desc.Texture2DArray.ArraySize = ArraySize;
1761 desc.Texture2DArray.PlaneSlice = PlaneSlice;
1762 desc.Texture2DArray.ResourceMinLODClamp = ResourceMinLODClamp;
1763 return desc;
1764 }
1765
1766 static inline CD3DX12_SHADER_RESOURCE_VIEW_DESC Tex2DMS(
1767 DXGI_FORMAT Format,
1768 UINT Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING) noexcept
1769 {
1770 CD3DX12_SHADER_RESOURCE_VIEW_DESC desc;
1771 desc.Format = Format;
1772 desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2DMS;
1773 desc.Shader4ComponentMapping = Shader4ComponentMapping;
1774 // desc.Texture2DMS.UnusedField_NothingToDefine = 0;
1775 return desc;
1776 }
1777
1778 static inline CD3DX12_SHADER_RESOURCE_VIEW_DESC Tex2DMSArray(
1779 DXGI_FORMAT Format,
1780 UINT ArraySize,
1781 UINT FirstArraySlice = 0,
1782 UINT Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING) noexcept
1783 {
1784 CD3DX12_SHADER_RESOURCE_VIEW_DESC desc;
1785 desc.Format = Format;
1786 desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY;
1787 desc.Shader4ComponentMapping = Shader4ComponentMapping;
1788 desc.Texture2DMSArray.ArraySize = ArraySize;
1789 desc.Texture2DMSArray.FirstArraySlice = FirstArraySlice;
1790 return desc;
1791 }
1792
1793 static inline CD3DX12_SHADER_RESOURCE_VIEW_DESC Tex3D(
1794 DXGI_FORMAT Format,
1795 UINT MipLevels = -1,
1796 UINT MostDetailedMip = 0,
1797 FLOAT ResourceMinLODClamp = 0.0f,
1798 UINT Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING) noexcept
1799 {
1800 CD3DX12_SHADER_RESOURCE_VIEW_DESC desc;
1801 desc.Format = Format;
1802 desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE3D;
1803 desc.Shader4ComponentMapping = Shader4ComponentMapping;
1804 desc.Texture3D.MostDetailedMip = MostDetailedMip;
1805 desc.Texture3D.MipLevels = MipLevels;
1806 desc.Texture3D.ResourceMinLODClamp = ResourceMinLODClamp;
1807 return desc;
1808 }
1809
1810 static inline CD3DX12_SHADER_RESOURCE_VIEW_DESC TexCube(
1811 DXGI_FORMAT Format,
1812 UINT MipLevels = -1,
1813 UINT MostDetailedMip = 0,
1814 FLOAT ResourceMinLODClamp = 0.0f,
1815 UINT Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING) noexcept
1816 {
1817 CD3DX12_SHADER_RESOURCE_VIEW_DESC desc;
1818 desc.Format = Format;
1819 desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBE;
1820 desc.Shader4ComponentMapping = Shader4ComponentMapping;
1821 desc.TextureCube.MostDetailedMip = MostDetailedMip;
1822 desc.TextureCube.MipLevels = MipLevels;
1823 desc.TextureCube.ResourceMinLODClamp = ResourceMinLODClamp;
1824 return desc;
1825 }
1826
1827 static inline CD3DX12_SHADER_RESOURCE_VIEW_DESC TexCubeArray(
1828 DXGI_FORMAT Format,
1829 UINT NumCubes,
1830 UINT MipLevels = -1,
1831 UINT First2DArrayFace = 0,
1832 UINT MostDetailedMip = 0,
1833 FLOAT ResourceMinLODClamp = 0.0f,
1834 UINT Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING) noexcept
1835 {
1836 CD3DX12_SHADER_RESOURCE_VIEW_DESC desc;
1837 desc.Format = Format;
1838 desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBEARRAY;
1839 desc.Shader4ComponentMapping = Shader4ComponentMapping;
1840 desc.TextureCubeArray.NumCubes = NumCubes;
1841 desc.TextureCubeArray.MostDetailedMip = MostDetailedMip;
1842 desc.TextureCubeArray.MipLevels = MipLevels;
1843 desc.TextureCubeArray.First2DArrayFace = First2DArrayFace;
1844 desc.TextureCubeArray.ResourceMinLODClamp = ResourceMinLODClamp;
1845 return desc;
1846 }
1847
1848 static inline CD3DX12_SHADER_RESOURCE_VIEW_DESC RaytracingAccelStruct(
1849 D3D12_GPU_VIRTUAL_ADDRESS Location) noexcept
1850 {
1851 CD3DX12_SHADER_RESOURCE_VIEW_DESC desc;
1852 desc.Format = DXGI_FORMAT_UNKNOWN;
1853 desc.ViewDimension = D3D12_SRV_DIMENSION_RAYTRACING_ACCELERATION_STRUCTURE;
1854 desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
1855 desc.RaytracingAccelerationStructure.Location = Location;
1856 return desc;
1857 }
1858};
1859
1860//------------------------------------------------------------------------------------------------
1861struct CD3DX12_UNORDERED_ACCESS_VIEW_DESC : public D3D12_UNORDERED_ACCESS_VIEW_DESC
1862{
1863 CD3DX12_UNORDERED_ACCESS_VIEW_DESC() = default;
1864 explicit CD3DX12_UNORDERED_ACCESS_VIEW_DESC( const D3D12_UNORDERED_ACCESS_VIEW_DESC& o ) noexcept :
1865 D3D12_UNORDERED_ACCESS_VIEW_DESC(o)
1866 {}
1867
1868 static inline CD3DX12_UNORDERED_ACCESS_VIEW_DESC StructuredBuffer(
1869 UINT NumElements,
1870 UINT StructureByteStride,
1871 UINT64 FirstElement = 0,
1872 UINT64 CounterOffsetInBytes = 0) noexcept
1873 {
1874 CD3DX12_UNORDERED_ACCESS_VIEW_DESC desc;
1875 desc.Format = DXGI_FORMAT_UNKNOWN;
1876 desc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER;
1877 desc.Buffer.FirstElement = FirstElement;
1878 desc.Buffer.NumElements = NumElements;
1879 desc.Buffer.StructureByteStride = StructureByteStride;
1880 desc.Buffer.Flags = D3D12_BUFFER_UAV_FLAG_NONE;
1881 desc.Buffer.CounterOffsetInBytes = CounterOffsetInBytes;
1882 return desc;
1883 }
1884
1885 static inline CD3DX12_UNORDERED_ACCESS_VIEW_DESC RawBuffer(
1886 UINT NumElements,
1887 UINT64 FirstElement = 0,
1888 UINT64 CounterOffsetInBytes = 0) noexcept
1889 {
1890 CD3DX12_UNORDERED_ACCESS_VIEW_DESC desc;
1891 desc.Format = DXGI_FORMAT_R32_UINT;
1892 desc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER;
1893 desc.Buffer.FirstElement = FirstElement;
1894 desc.Buffer.NumElements = NumElements;
1895 desc.Buffer.StructureByteStride = 0;
1896 desc.Buffer.Flags = D3D12_BUFFER_UAV_FLAG_RAW;
1897 desc.Buffer.CounterOffsetInBytes = CounterOffsetInBytes;
1898 return desc;
1899 }
1900
1901 static inline CD3DX12_UNORDERED_ACCESS_VIEW_DESC TypedBuffer(
1902 DXGI_FORMAT Format,
1903 UINT NumElements,
1904 UINT64 FirstElement = 0,
1905 UINT64 CounterOffsetInBytes = 0) noexcept
1906 {
1907 CD3DX12_UNORDERED_ACCESS_VIEW_DESC desc;
1908 desc.Format = Format;
1909 desc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER;
1910 desc.Buffer.FirstElement = FirstElement;
1911 desc.Buffer.NumElements = NumElements;
1912 desc.Buffer.StructureByteStride = 0;
1913 desc.Buffer.Flags = D3D12_BUFFER_UAV_FLAG_NONE;
1914 desc.Buffer.CounterOffsetInBytes = CounterOffsetInBytes;
1915 return desc;
1916 }
1917
1918 static inline CD3DX12_UNORDERED_ACCESS_VIEW_DESC Tex1D(
1919 DXGI_FORMAT Format,
1920 UINT MipSlice = 0) noexcept
1921 {
1922 CD3DX12_UNORDERED_ACCESS_VIEW_DESC desc;
1923 desc.Format = Format;
1924 desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE1D;
1925 desc.Texture1D.MipSlice = MipSlice;
1926 return desc;
1927 }
1928
1929 static inline CD3DX12_UNORDERED_ACCESS_VIEW_DESC Tex1DArray(
1930 DXGI_FORMAT Format,
1931 UINT ArraySize = -1,
1932 UINT FirstArraySlice = 0,
1933 UINT MipSlice = 0) noexcept
1934 {
1935 CD3DX12_UNORDERED_ACCESS_VIEW_DESC desc;
1936 desc.Format = Format;
1937 desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE1DARRAY;
1938 desc.Texture1DArray.MipSlice = MipSlice;
1939 desc.Texture1DArray.FirstArraySlice = FirstArraySlice;
1940 desc.Texture1DArray.ArraySize = ArraySize;
1941 return desc;
1942 }
1943
1944 static inline CD3DX12_UNORDERED_ACCESS_VIEW_DESC Tex2D(
1945 DXGI_FORMAT Format,
1946 UINT MipSlice = 0,
1947 UINT PlaneSlice = 0) noexcept
1948 {
1949 CD3DX12_UNORDERED_ACCESS_VIEW_DESC desc;
1950 desc.Format = Format;
1951 desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2D;
1952 desc.Texture2D.MipSlice = MipSlice;
1953 desc.Texture2D.PlaneSlice = PlaneSlice;
1954 return desc;
1955 }
1956
1957 static inline CD3DX12_UNORDERED_ACCESS_VIEW_DESC Tex2DArray(
1958 DXGI_FORMAT Format,
1959 UINT ArraySize = -1,
1960 UINT FirstArraySlice = 0,
1961 UINT MipSlice = 0,
1962 UINT PlaneSlice = 0) noexcept
1963 {
1964 CD3DX12_UNORDERED_ACCESS_VIEW_DESC desc;
1965 desc.Format = Format;
1966 desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2DARRAY;
1967 desc.Texture2DArray.MipSlice = MipSlice;
1968 desc.Texture2DArray.FirstArraySlice = FirstArraySlice;
1969 desc.Texture2DArray.ArraySize = ArraySize;
1970 desc.Texture2DArray.PlaneSlice = PlaneSlice;
1971 return desc;
1972 }
1973
1974 static inline CD3DX12_UNORDERED_ACCESS_VIEW_DESC Tex2DMS(
1975 DXGI_FORMAT Format) noexcept
1976 {
1977 CD3DX12_UNORDERED_ACCESS_VIEW_DESC desc;
1978 desc.Format = Format;
1979 desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2DMS;
1980 //desc.Texture2DMS.UnusedField_NothingToDefine = 0;
1981 return desc;
1982 }
1983
1984 static inline CD3DX12_UNORDERED_ACCESS_VIEW_DESC Tex2DMSArray(
1985 DXGI_FORMAT Format,
1986 UINT ArraySize = -1,
1987 UINT FirstArraySlice = 0) noexcept
1988 {
1989 CD3DX12_UNORDERED_ACCESS_VIEW_DESC desc;
1990 desc.Format = Format;
1991 desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2DMSARRAY;
1992 desc.Texture2DMSArray.FirstArraySlice = FirstArraySlice;
1993 desc.Texture2DMSArray.ArraySize = ArraySize;
1994 return desc;
1995 }
1996
1997 static inline CD3DX12_UNORDERED_ACCESS_VIEW_DESC Tex3D(
1998 DXGI_FORMAT Format,
1999 UINT WSize = -1,
2000 UINT FirstWSlice = 0,
2001 UINT MipSlice = 0) noexcept
2002 {
2003 CD3DX12_UNORDERED_ACCESS_VIEW_DESC desc;
2004 desc.Format = Format;
2005 desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE3D;
2006 desc.Texture3D.MipSlice = MipSlice;
2007 desc.Texture3D.FirstWSlice = FirstWSlice;
2008 desc.Texture3D.WSize = WSize;
2009 return desc;
2010 }
2011};
2012
2013//------------------------------------------------------------------------------------------------
2014struct CD3DX12_VIEW_INSTANCING_DESC : public D3D12_VIEW_INSTANCING_DESC
2015{
2016 CD3DX12_VIEW_INSTANCING_DESC() = default;
2017 explicit CD3DX12_VIEW_INSTANCING_DESC( const D3D12_VIEW_INSTANCING_DESC& o ) noexcept :
2018 D3D12_VIEW_INSTANCING_DESC( o )
2019 {}
2020 explicit CD3DX12_VIEW_INSTANCING_DESC( CD3DX12_DEFAULT ) noexcept
2021 {
2022 ViewInstanceCount = 0;
2023 pViewInstanceLocations = nullptr;
2024 Flags = D3D12_VIEW_INSTANCING_FLAG_NONE;
2025 }
2026 explicit CD3DX12_VIEW_INSTANCING_DESC(
2027 UINT InViewInstanceCount,
2028 const D3D12_VIEW_INSTANCE_LOCATION* InViewInstanceLocations,
2029 D3D12_VIEW_INSTANCING_FLAGS InFlags) noexcept
2030 {
2031 ViewInstanceCount = InViewInstanceCount;
2032 pViewInstanceLocations = InViewInstanceLocations;
2033 Flags = InFlags;
2034 }
2035};
2036
2037//------------------------------------------------------------------------------------------------
2038struct CD3DX12_RT_FORMAT_ARRAY : public D3D12_RT_FORMAT_ARRAY
2039{
2040 CD3DX12_RT_FORMAT_ARRAY() = default;
2041 explicit CD3DX12_RT_FORMAT_ARRAY(const D3D12_RT_FORMAT_ARRAY& o) noexcept
2042 : D3D12_RT_FORMAT_ARRAY(o)
2043 {}
2044 explicit CD3DX12_RT_FORMAT_ARRAY(_In_reads_(NumFormats) const DXGI_FORMAT* pFormats, UINT NumFormats) noexcept
2045 {
2046 NumRenderTargets = NumFormats;
2047 memcpy(RTFormats, pFormats, sizeof(RTFormats));
2048 // assumes ARRAY_SIZE(pFormats) == ARRAY_SIZE(RTFormats)
2049 }
2050};
2051
2052//------------------------------------------------------------------------------------------------
2053struct CD3DX12_SERIALIZED_ROOT_SIGNATURE_DESC : public D3D12_SERIALIZED_ROOT_SIGNATURE_DESC
2054{
2055 CD3DX12_SERIALIZED_ROOT_SIGNATURE_DESC() = default;
2056 explicit CD3DX12_SERIALIZED_ROOT_SIGNATURE_DESC(const D3D12_SERIALIZED_ROOT_SIGNATURE_DESC& o) noexcept :
2057 D3D12_SERIALIZED_ROOT_SIGNATURE_DESC(o)
2058 {
2059 }
2060 explicit CD3DX12_SERIALIZED_ROOT_SIGNATURE_DESC( CD3DX12_DEFAULT ) noexcept
2061 {
2062 pSerializedBlob = nullptr;
2063 SerializedBlobSizeInBytes = 0;
2064 }
2065 explicit CD3DX12_SERIALIZED_ROOT_SIGNATURE_DESC( const void* pData, SIZE_T size) noexcept
2066 {
2067 pSerializedBlob = pData;
2068 SerializedBlobSizeInBytes = size;
2069 }
2070};
2071
2072
generated by cgit v1.2.3 (git 2.25.1) at 2025-12-04 12:27:17 +0000