HatchitGraphics
d3dx12.h
1 //
3 // Copyright (C) Microsoft Corporation. All Rights Reserved.
4 //
5 // File: d3dx12.h
6 // Content: D3DX12 utility library
7 //
9 
10 #ifndef __D3DX12_H__
11 #define __D3DX12_H__
12 
13 #include "d3d12.h"
14 
15 #if defined( __cplusplus )
16 
17 struct CD3DX12_DEFAULT {};
18 extern const DECLSPEC_SELECTANY CD3DX12_DEFAULT D3D12_DEFAULT;
19 
20 //------------------------------------------------------------------------------------------------
21 inline bool operator==( const D3D12_VIEWPORT& l, const D3D12_VIEWPORT& r )
22 {
23  return l.TopLeftX == r.TopLeftX && l.TopLeftY == r.TopLeftY && l.Width == r.Width &&
24  l.Height == r.Height && l.MinDepth == r.MinDepth && l.MaxDepth == r.MaxDepth;
25 }
26 
27 //------------------------------------------------------------------------------------------------
28 inline bool operator!=( const D3D12_VIEWPORT& l, const D3D12_VIEWPORT& r )
29 { return !( l == r ); }
30 
31 //------------------------------------------------------------------------------------------------
32 struct CD3DX12_RECT : public D3D12_RECT
33 {
34  CD3DX12_RECT()
35  {}
36  explicit CD3DX12_RECT( const D3D12_RECT& o ) :
37  D3D12_RECT( o )
38  {}
39  explicit CD3DX12_RECT(
40  LONG Left,
41  LONG Top,
42  LONG Right,
43  LONG Bottom )
44  {
45  left = Left;
46  top = Top;
47  right = Right;
48  bottom = Bottom;
49  }
50  ~CD3DX12_RECT() {}
51  operator const D3D12_RECT&() const { return *this; }
52 };
53 
54 //------------------------------------------------------------------------------------------------
55 struct CD3DX12_BOX : public D3D12_BOX
56 {
57  CD3DX12_BOX()
58  {}
59  explicit CD3DX12_BOX( const D3D12_BOX& o ) :
60  D3D12_BOX( o )
61  {}
62  explicit CD3DX12_BOX(
63  LONG Left,
64  LONG Right )
65  {
66  left = Left;
67  top = 0;
68  front = 0;
69  right = Right;
70  bottom = 1;
71  back = 1;
72  }
73  explicit CD3DX12_BOX(
74  LONG Left,
75  LONG Top,
76  LONG Right,
77  LONG Bottom )
78  {
79  left = Left;
80  top = Top;
81  front = 0;
82  right = Right;
83  bottom = Bottom;
84  back = 1;
85  }
86  explicit CD3DX12_BOX(
87  LONG Left,
88  LONG Top,
89  LONG Front,
90  LONG Right,
91  LONG Bottom,
92  LONG Back )
93  {
94  left = Left;
95  top = Top;
96  front = Front;
97  right = Right;
98  bottom = Bottom;
99  back = Back;
100  }
101  ~CD3DX12_BOX() {}
102  operator const D3D12_BOX&() const { return *this; }
103 };
104 inline bool operator==( const D3D12_BOX& l, const D3D12_BOX& r )
105 {
106  return l.left == r.left && l.top == r.top && l.front == r.front &&
107  l.right == r.right && l.bottom == r.bottom && l.back == r.back;
108 }
109 inline bool operator!=( const D3D12_BOX& l, const D3D12_BOX& r )
110 { return !( l == r ); }
111 
112 //------------------------------------------------------------------------------------------------
113 struct CD3DX12_DEPTH_STENCIL_DESC : public D3D12_DEPTH_STENCIL_DESC
114 {
115  CD3DX12_DEPTH_STENCIL_DESC()
116  {}
117  explicit CD3DX12_DEPTH_STENCIL_DESC( const D3D12_DEPTH_STENCIL_DESC& o ) :
118  D3D12_DEPTH_STENCIL_DESC( o )
119  {}
120  explicit CD3DX12_DEPTH_STENCIL_DESC( CD3DX12_DEFAULT )
121  {
122  DepthEnable = TRUE;
123  DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL;
124  DepthFunc = D3D12_COMPARISON_FUNC_LESS;
125  StencilEnable = FALSE;
126  StencilReadMask = D3D12_DEFAULT_STENCIL_READ_MASK;
127  StencilWriteMask = D3D12_DEFAULT_STENCIL_WRITE_MASK;
128  const D3D12_DEPTH_STENCILOP_DESC defaultStencilOp =
129  { D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_COMPARISON_FUNC_ALWAYS };
130  FrontFace = defaultStencilOp;
131  BackFace = defaultStencilOp;
132  }
133  explicit CD3DX12_DEPTH_STENCIL_DESC(
134  BOOL depthEnable,
135  D3D12_DEPTH_WRITE_MASK depthWriteMask,
136  D3D12_COMPARISON_FUNC depthFunc,
137  BOOL stencilEnable,
138  UINT8 stencilReadMask,
139  UINT8 stencilWriteMask,
140  D3D12_STENCIL_OP frontStencilFailOp,
141  D3D12_STENCIL_OP frontStencilDepthFailOp,
142  D3D12_STENCIL_OP frontStencilPassOp,
143  D3D12_COMPARISON_FUNC frontStencilFunc,
144  D3D12_STENCIL_OP backStencilFailOp,
145  D3D12_STENCIL_OP backStencilDepthFailOp,
146  D3D12_STENCIL_OP backStencilPassOp,
147  D3D12_COMPARISON_FUNC backStencilFunc )
148  {
149  DepthEnable = depthEnable;
150  DepthWriteMask = depthWriteMask;
151  DepthFunc = depthFunc;
152  StencilEnable = stencilEnable;
153  StencilReadMask = stencilReadMask;
154  StencilWriteMask = stencilWriteMask;
155  FrontFace.StencilFailOp = frontStencilFailOp;
156  FrontFace.StencilDepthFailOp = frontStencilDepthFailOp;
157  FrontFace.StencilPassOp = frontStencilPassOp;
158  FrontFace.StencilFunc = frontStencilFunc;
159  BackFace.StencilFailOp = backStencilFailOp;
160  BackFace.StencilDepthFailOp = backStencilDepthFailOp;
161  BackFace.StencilPassOp = backStencilPassOp;
162  BackFace.StencilFunc = backStencilFunc;
163  }
164  ~CD3DX12_DEPTH_STENCIL_DESC() {}
165  operator const D3D12_DEPTH_STENCIL_DESC&() const { return *this; }
166 };
167 
168 //------------------------------------------------------------------------------------------------
169 struct CD3DX12_BLEND_DESC : public D3D12_BLEND_DESC
170 {
171  CD3DX12_BLEND_DESC()
172  {}
173  explicit CD3DX12_BLEND_DESC( const D3D12_BLEND_DESC& o ) :
174  D3D12_BLEND_DESC( o )
175  {}
176  explicit CD3DX12_BLEND_DESC( CD3DX12_DEFAULT )
177  {
178  AlphaToCoverageEnable = FALSE;
179  IndependentBlendEnable = FALSE;
180  const D3D12_RENDER_TARGET_BLEND_DESC defaultRenderTargetBlendDesc =
181  {
182  FALSE,FALSE,
183  D3D12_BLEND_ONE, D3D12_BLEND_ZERO, D3D12_BLEND_OP_ADD,
184  D3D12_BLEND_ONE, D3D12_BLEND_ZERO, D3D12_BLEND_OP_ADD,
185  D3D12_LOGIC_OP_NOOP,
186  D3D12_COLOR_WRITE_ENABLE_ALL,
187  };
188  for (UINT i = 0; i < D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
189  RenderTarget[ i ] = defaultRenderTargetBlendDesc;
190  }
191  ~CD3DX12_BLEND_DESC() {}
192  operator const D3D12_BLEND_DESC&() const { return *this; }
193 };
194 
195 //------------------------------------------------------------------------------------------------
196 struct CD3DX12_RASTERIZER_DESC : public D3D12_RASTERIZER_DESC
197 {
198  CD3DX12_RASTERIZER_DESC()
199  {}
200  explicit CD3DX12_RASTERIZER_DESC( const D3D12_RASTERIZER_DESC& o ) :
201  D3D12_RASTERIZER_DESC( o )
202  {}
203  explicit CD3DX12_RASTERIZER_DESC( CD3DX12_DEFAULT )
204  {
205  FillMode = D3D12_FILL_MODE_SOLID;
206  CullMode = D3D12_CULL_MODE_BACK;
207  FrontCounterClockwise = FALSE;
208  DepthBias = D3D12_DEFAULT_DEPTH_BIAS;
209  DepthBiasClamp = D3D12_DEFAULT_DEPTH_BIAS_CLAMP;
210  SlopeScaledDepthBias = D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS;
211  DepthClipEnable = TRUE;
212  MultisampleEnable = FALSE;
213  AntialiasedLineEnable = FALSE;
214  ForcedSampleCount = 0;
215  ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF;
216  }
217  explicit CD3DX12_RASTERIZER_DESC(
218  D3D12_FILL_MODE fillMode,
219  D3D12_CULL_MODE cullMode,
220  BOOL frontCounterClockwise,
221  INT depthBias,
222  FLOAT depthBiasClamp,
223  FLOAT slopeScaledDepthBias,
224  BOOL depthClipEnable,
225  BOOL multisampleEnable,
226  BOOL antialiasedLineEnable,
227  UINT forcedSampleCount,
228  D3D12_CONSERVATIVE_RASTERIZATION_MODE conservativeRaster)
229  {
230  FillMode = fillMode;
231  CullMode = cullMode;
232  FrontCounterClockwise = frontCounterClockwise;
233  DepthBias = depthBias;
234  DepthBiasClamp = depthBiasClamp;
235  SlopeScaledDepthBias = slopeScaledDepthBias;
236  DepthClipEnable = depthClipEnable;
237  MultisampleEnable = multisampleEnable;
238  AntialiasedLineEnable = antialiasedLineEnable;
239  ForcedSampleCount = forcedSampleCount;
240  ConservativeRaster = conservativeRaster;
241  }
242  ~CD3DX12_RASTERIZER_DESC() {}
243  operator const D3D12_RASTERIZER_DESC&() const { return *this; }
244 };
245 
246 //------------------------------------------------------------------------------------------------
247 struct CD3DX12_RESOURCE_ALLOCATION_INFO : public D3D12_RESOURCE_ALLOCATION_INFO
248 {
249  CD3DX12_RESOURCE_ALLOCATION_INFO()
250  {}
251  explicit CD3DX12_RESOURCE_ALLOCATION_INFO( const D3D12_RESOURCE_ALLOCATION_INFO& o ) :
252  D3D12_RESOURCE_ALLOCATION_INFO( o )
253  {}
254  CD3DX12_RESOURCE_ALLOCATION_INFO(
255  UINT64 size,
256  UINT64 alignment )
257  {
258  SizeInBytes = size;
259  Alignment = alignment;
260  }
261  operator const D3D12_RESOURCE_ALLOCATION_INFO&() const { return *this; }
262 };
263 
264 //------------------------------------------------------------------------------------------------
265 struct CD3DX12_HEAP_PROPERTIES : public D3D12_HEAP_PROPERTIES
266 {
267  CD3DX12_HEAP_PROPERTIES()
268  {}
269  explicit CD3DX12_HEAP_PROPERTIES(const D3D12_HEAP_PROPERTIES &o) :
270  D3D12_HEAP_PROPERTIES(o)
271  {}
272  CD3DX12_HEAP_PROPERTIES(
273  D3D12_CPU_PAGE_PROPERTY cpuPageProperty,
274  D3D12_MEMORY_POOL memoryPoolPreference,
275  UINT creationNodeMask = 1,
276  UINT nodeMask = 1 )
277  {
278  Type = D3D12_HEAP_TYPE_CUSTOM;
279  CPUPageProperty = cpuPageProperty;
280  MemoryPoolPreference = memoryPoolPreference;
281  CreationNodeMask = creationNodeMask;
282  VisibleNodeMask = nodeMask;
283  }
284  explicit CD3DX12_HEAP_PROPERTIES(
285  D3D12_HEAP_TYPE type,
286  UINT creationNodeMask = 1,
287  UINT nodeMask = 1 )
288  {
289  Type = type;
290  CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
291  MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
292  CreationNodeMask = creationNodeMask;
293  VisibleNodeMask = nodeMask;
294  }
295  operator const D3D12_HEAP_PROPERTIES&() const { return *this; }
296  bool IsCPUAccessible() const
297  {
298  return Type == D3D12_HEAP_TYPE_UPLOAD || Type == D3D12_HEAP_TYPE_READBACK || (Type == D3D12_HEAP_TYPE_CUSTOM &&
299  (CPUPageProperty == D3D12_CPU_PAGE_PROPERTY_WRITE_COMBINE || CPUPageProperty == D3D12_CPU_PAGE_PROPERTY_WRITE_BACK));
300  }
301 };
302 inline bool operator==( const D3D12_HEAP_PROPERTIES& l, const D3D12_HEAP_PROPERTIES& r )
303 {
304  return l.Type == r.Type && l.CPUPageProperty == r.CPUPageProperty &&
305  l.MemoryPoolPreference == r.MemoryPoolPreference &&
306  l.CreationNodeMask == r.CreationNodeMask &&
307  l.VisibleNodeMask == r.VisibleNodeMask;
308 }
309 inline bool operator!=( const D3D12_HEAP_PROPERTIES& l, const D3D12_HEAP_PROPERTIES& r )
310 { return !( l == r ); }
311 
312 //------------------------------------------------------------------------------------------------
313 struct CD3DX12_HEAP_DESC : public D3D12_HEAP_DESC
314 {
315  CD3DX12_HEAP_DESC()
316  {}
317  explicit CD3DX12_HEAP_DESC(const D3D12_HEAP_DESC &o) :
318  D3D12_HEAP_DESC(o)
319  {}
320  CD3DX12_HEAP_DESC(
321  UINT64 size,
322  D3D12_HEAP_PROPERTIES properties,
323  UINT64 alignment = 0,
324  D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE )
325  {
326  SizeInBytes = size;
327  Properties = properties;
328  Alignment = alignment;
329  Flags = flags;
330  }
331  CD3DX12_HEAP_DESC(
332  UINT64 size,
333  D3D12_HEAP_TYPE type,
334  UINT64 alignment = 0,
335  D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE )
336  {
337  SizeInBytes = size;
338  Properties = CD3DX12_HEAP_PROPERTIES( type );
339  Alignment = alignment;
340  Flags = flags;
341  }
342  CD3DX12_HEAP_DESC(
343  UINT64 size,
344  D3D12_CPU_PAGE_PROPERTY cpuPageProperty,
345  D3D12_MEMORY_POOL memoryPoolPreference,
346  UINT64 alignment = 0,
347  D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE )
348  {
349  SizeInBytes = size;
350  Properties = CD3DX12_HEAP_PROPERTIES( cpuPageProperty, memoryPoolPreference );
351  Alignment = alignment;
352  Flags = flags;
353  }
354  CD3DX12_HEAP_DESC(
355  const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
356  D3D12_HEAP_PROPERTIES properties,
357  D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE )
358  {
359  SizeInBytes = resAllocInfo.SizeInBytes;
360  Properties = properties;
361  Alignment = resAllocInfo.Alignment;
362  Flags = flags;
363  }
364  CD3DX12_HEAP_DESC(
365  const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
366  D3D12_HEAP_TYPE type,
367  D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE )
368  {
369  SizeInBytes = resAllocInfo.SizeInBytes;
370  Properties = CD3DX12_HEAP_PROPERTIES( type );
371  Alignment = resAllocInfo.Alignment;
372  Flags = flags;
373  }
374  CD3DX12_HEAP_DESC(
375  const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
376  D3D12_CPU_PAGE_PROPERTY cpuPageProperty,
377  D3D12_MEMORY_POOL memoryPoolPreference,
378  D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE )
379  {
380  SizeInBytes = resAllocInfo.SizeInBytes;
381  Properties = CD3DX12_HEAP_PROPERTIES( cpuPageProperty, memoryPoolPreference );
382  Alignment = resAllocInfo.Alignment;
383  Flags = flags;
384  }
385  operator const D3D12_HEAP_DESC&() const { return *this; }
386  bool IsCPUAccessible() const
387  { return static_cast< const CD3DX12_HEAP_PROPERTIES* >( &Properties )->IsCPUAccessible(); }
388 };
389 inline bool operator==( const D3D12_HEAP_DESC& l, const D3D12_HEAP_DESC& r )
390 {
391  return l.SizeInBytes == r.SizeInBytes &&
392  l.Properties == r.Properties &&
393  l.Alignment == r.Alignment &&
394  l.Flags == r.Flags;
395 }
396 inline bool operator!=( const D3D12_HEAP_DESC& l, const D3D12_HEAP_DESC& r )
397 { return !( l == r ); }
398 
399 //------------------------------------------------------------------------------------------------
400 struct CD3DX12_CLEAR_VALUE : public D3D12_CLEAR_VALUE
401 {
402  CD3DX12_CLEAR_VALUE()
403  {}
404  explicit CD3DX12_CLEAR_VALUE(const D3D12_CLEAR_VALUE &o) :
405  D3D12_CLEAR_VALUE(o)
406  {}
407  CD3DX12_CLEAR_VALUE(
408  DXGI_FORMAT format,
409  const FLOAT color[4] )
410  {
411  Format = format;
412  memcpy( Color, color, sizeof( Color ) );
413  }
414  CD3DX12_CLEAR_VALUE(
415  DXGI_FORMAT format,
416  FLOAT depth,
417  UINT8 stencil )
418  {
419  Format = format;
420  /* Use memcpy to preserve NAN values */
421  memcpy( &DepthStencil.Depth, &depth, sizeof( depth ) );
422  DepthStencil.Stencil = stencil;
423  }
424  operator const D3D12_CLEAR_VALUE&() const { return *this; }
425 };
426 
427 //------------------------------------------------------------------------------------------------
428 struct CD3DX12_RANGE : public D3D12_RANGE
429 {
430  CD3DX12_RANGE()
431  {}
432  explicit CD3DX12_RANGE(const D3D12_RANGE &o) :
433  D3D12_RANGE(o)
434  {}
435  CD3DX12_RANGE(
436  SIZE_T begin,
437  SIZE_T end )
438  {
439  Begin = begin;
440  End = end;
441  }
442  operator const D3D12_RANGE&() const { return *this; }
443 };
444 
445 //------------------------------------------------------------------------------------------------
446 struct CD3DX12_SHADER_BYTECODE : public D3D12_SHADER_BYTECODE
447 {
448  CD3DX12_SHADER_BYTECODE()
449  {}
450  explicit CD3DX12_SHADER_BYTECODE(const D3D12_SHADER_BYTECODE &o) :
451  D3D12_SHADER_BYTECODE(o)
452  {}
453  CD3DX12_SHADER_BYTECODE(
454  ID3DBlob* pShaderBlob )
455  {
456  pShaderBytecode = pShaderBlob->GetBufferPointer();
457  BytecodeLength = pShaderBlob->GetBufferSize();
458  }
459  CD3DX12_SHADER_BYTECODE(
460  void* _pShaderBytecode,
461  SIZE_T bytecodeLength )
462  {
463  pShaderBytecode = _pShaderBytecode;
464  BytecodeLength = bytecodeLength;
465  }
466  operator const D3D12_SHADER_BYTECODE&() const { return *this; }
467 };
468 
469 //------------------------------------------------------------------------------------------------
470 struct CD3DX12_TILED_RESOURCE_COORDINATE : public D3D12_TILED_RESOURCE_COORDINATE
471 {
472  CD3DX12_TILED_RESOURCE_COORDINATE()
473  {}
474  explicit CD3DX12_TILED_RESOURCE_COORDINATE(const D3D12_TILED_RESOURCE_COORDINATE &o) :
475  D3D12_TILED_RESOURCE_COORDINATE(o)
476  {}
477  CD3DX12_TILED_RESOURCE_COORDINATE(
478  UINT x,
479  UINT y,
480  UINT z,
481  UINT subresource )
482  {
483  X = x;
484  Y = y;
485  Z = z;
486  Subresource = subresource;
487  }
488  operator const D3D12_TILED_RESOURCE_COORDINATE&() const { return *this; }
489 };
490 
491 //------------------------------------------------------------------------------------------------
492 struct CD3DX12_TILE_REGION_SIZE : public D3D12_TILE_REGION_SIZE
493 {
494  CD3DX12_TILE_REGION_SIZE()
495  {}
496  explicit CD3DX12_TILE_REGION_SIZE(const D3D12_TILE_REGION_SIZE &o) :
497  D3D12_TILE_REGION_SIZE(o)
498  {}
499  CD3DX12_TILE_REGION_SIZE(
500  UINT numTiles,
501  BOOL useBox,
502  UINT width,
503  UINT16 height,
504  UINT16 depth )
505  {
506  NumTiles = numTiles;
507  UseBox = useBox;
508  Width = width;
509  Height = height;
510  Depth = depth;
511  }
512  operator const D3D12_TILE_REGION_SIZE&() const { return *this; }
513 };
514 
515 //------------------------------------------------------------------------------------------------
516 struct CD3DX12_SUBRESOURCE_TILING : public D3D12_SUBRESOURCE_TILING
517 {
518  CD3DX12_SUBRESOURCE_TILING()
519  {}
520  explicit CD3DX12_SUBRESOURCE_TILING(const D3D12_SUBRESOURCE_TILING &o) :
521  D3D12_SUBRESOURCE_TILING(o)
522  {}
523  CD3DX12_SUBRESOURCE_TILING(
524  UINT widthInTiles,
525  UINT16 heightInTiles,
526  UINT16 depthInTiles,
527  UINT startTileIndexInOverallResource )
528  {
529  WidthInTiles = widthInTiles;
530  HeightInTiles = heightInTiles;
531  DepthInTiles = depthInTiles;
532  StartTileIndexInOverallResource = startTileIndexInOverallResource;
533  }
534  operator const D3D12_SUBRESOURCE_TILING&() const { return *this; }
535 };
536 
537 //------------------------------------------------------------------------------------------------
538 struct CD3DX12_TILE_SHAPE : public D3D12_TILE_SHAPE
539 {
540  CD3DX12_TILE_SHAPE()
541  {}
542  explicit CD3DX12_TILE_SHAPE(const D3D12_TILE_SHAPE &o) :
543  D3D12_TILE_SHAPE(o)
544  {}
545  CD3DX12_TILE_SHAPE(
546  UINT widthInTexels,
547  UINT heightInTexels,
548  UINT depthInTexels )
549  {
550  WidthInTexels = widthInTexels;
551  HeightInTexels = heightInTexels;
552  DepthInTexels = depthInTexels;
553  }
554  operator const D3D12_TILE_SHAPE&() const { return *this; }
555 };
556 
557 //------------------------------------------------------------------------------------------------
558 struct CD3DX12_RESOURCE_BARRIER : public D3D12_RESOURCE_BARRIER
559 {
560  CD3DX12_RESOURCE_BARRIER()
561  {}
562  explicit CD3DX12_RESOURCE_BARRIER(const D3D12_RESOURCE_BARRIER &o) :
563  D3D12_RESOURCE_BARRIER(o)
564  {}
565  static inline CD3DX12_RESOURCE_BARRIER Transition(
566  _In_ ID3D12Resource* pResource,
567  D3D12_RESOURCE_STATES stateBefore,
568  D3D12_RESOURCE_STATES stateAfter,
569  UINT subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES,
570  D3D12_RESOURCE_BARRIER_FLAGS flags = D3D12_RESOURCE_BARRIER_FLAG_NONE)
571  {
572  CD3DX12_RESOURCE_BARRIER result;
573  ZeroMemory(&result, sizeof(result));
574  D3D12_RESOURCE_BARRIER &barrier = result;
575  result.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
576  result.Flags = flags;
577  barrier.Transition.pResource = pResource;
578  barrier.Transition.StateBefore = stateBefore;
579  barrier.Transition.StateAfter = stateAfter;
580  barrier.Transition.Subresource = subresource;
581  return result;
582  }
583  static inline CD3DX12_RESOURCE_BARRIER Aliasing(
584  _In_ ID3D12Resource* pResourceBefore,
585  _In_ ID3D12Resource* pResourceAfter)
586  {
587  CD3DX12_RESOURCE_BARRIER result;
588  ZeroMemory(&result, sizeof(result));
589  D3D12_RESOURCE_BARRIER &barrier = result;
590  result.Type = D3D12_RESOURCE_BARRIER_TYPE_ALIASING;
591  barrier.Aliasing.pResourceBefore = pResourceBefore;
592  barrier.Aliasing.pResourceAfter = pResourceAfter;
593  return result;
594  }
595  static inline CD3DX12_RESOURCE_BARRIER UAV(
596  _In_ ID3D12Resource* pResource)
597  {
598  CD3DX12_RESOURCE_BARRIER result;
599  ZeroMemory(&result, sizeof(result));
600  D3D12_RESOURCE_BARRIER &barrier = result;
601  result.Type = D3D12_RESOURCE_BARRIER_TYPE_UAV;
602  barrier.UAV.pResource = pResource;
603  return result;
604  }
605  operator const D3D12_RESOURCE_BARRIER&() const { return *this; }
606 };
607 
608 //------------------------------------------------------------------------------------------------
609 struct CD3DX12_PACKED_MIP_INFO : public D3D12_PACKED_MIP_INFO
610 {
611  CD3DX12_PACKED_MIP_INFO()
612  {}
613  explicit CD3DX12_PACKED_MIP_INFO(const D3D12_PACKED_MIP_INFO &o) :
614  D3D12_PACKED_MIP_INFO(o)
615  {}
616  CD3DX12_PACKED_MIP_INFO(
617  UINT8 numStandardMips,
618  UINT8 numPackedMips,
619  UINT numTilesForPackedMips,
620  UINT startTileIndexInOverallResource )
621  {
622  NumStandardMips = numStandardMips;
623  NumPackedMips = numPackedMips;
624  NumTilesForPackedMips = numTilesForPackedMips;
625  StartTileIndexInOverallResource = startTileIndexInOverallResource;
626  }
627  operator const D3D12_PACKED_MIP_INFO&() const { return *this; }
628 };
629 
630 //------------------------------------------------------------------------------------------------
631 struct CD3DX12_SUBRESOURCE_FOOTPRINT : public D3D12_SUBRESOURCE_FOOTPRINT
632 {
633  CD3DX12_SUBRESOURCE_FOOTPRINT()
634  {}
635  explicit CD3DX12_SUBRESOURCE_FOOTPRINT(const D3D12_SUBRESOURCE_FOOTPRINT &o) :
636  D3D12_SUBRESOURCE_FOOTPRINT(o)
637  {}
638  CD3DX12_SUBRESOURCE_FOOTPRINT(
639  DXGI_FORMAT format,
640  UINT width,
641  UINT height,
642  UINT depth,
643  UINT rowPitch )
644  {
645  Format = format;
646  Width = width;
647  Height = height;
648  Depth = depth;
649  RowPitch = rowPitch;
650  }
651  explicit CD3DX12_SUBRESOURCE_FOOTPRINT(
652  const D3D12_RESOURCE_DESC& resDesc,
653  UINT rowPitch )
654  {
655  Format = resDesc.Format;
656  Width = UINT( resDesc.Width );
657  Height = resDesc.Height;
658  Depth = (resDesc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? resDesc.DepthOrArraySize : 1);
659  RowPitch = rowPitch;
660  }
661  operator const D3D12_SUBRESOURCE_FOOTPRINT&() const { return *this; }
662 };
663 
664 //------------------------------------------------------------------------------------------------
665 struct CD3DX12_TEXTURE_COPY_LOCATION : public D3D12_TEXTURE_COPY_LOCATION
666 {
667  CD3DX12_TEXTURE_COPY_LOCATION()
668  {}
669  explicit CD3DX12_TEXTURE_COPY_LOCATION(const D3D12_TEXTURE_COPY_LOCATION &o) :
670  D3D12_TEXTURE_COPY_LOCATION(o)
671  {}
672  CD3DX12_TEXTURE_COPY_LOCATION(ID3D12Resource* pRes) { pResource = pRes; }
673  CD3DX12_TEXTURE_COPY_LOCATION(ID3D12Resource* pRes, D3D12_PLACED_SUBRESOURCE_FOOTPRINT const& Footprint)
674  {
675  pResource = pRes;
676  Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
677  PlacedFootprint = Footprint;
678  }
679  CD3DX12_TEXTURE_COPY_LOCATION(ID3D12Resource* pRes, UINT Sub)
680  {
681  pResource = pRes;
682  Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
683  SubresourceIndex = Sub;
684  }
685 };
686 
687 //------------------------------------------------------------------------------------------------
688 struct CD3DX12_DESCRIPTOR_RANGE : public D3D12_DESCRIPTOR_RANGE
689 {
690  CD3DX12_DESCRIPTOR_RANGE() { }
691  explicit CD3DX12_DESCRIPTOR_RANGE(const D3D12_DESCRIPTOR_RANGE &o) :
692  D3D12_DESCRIPTOR_RANGE(o)
693  {}
694  CD3DX12_DESCRIPTOR_RANGE(
695  D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
696  UINT numDescriptors,
697  UINT baseShaderRegister,
698  UINT registerSpace = 0,
699  UINT offsetInDescriptorsFromTableStart =
700  D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND)
701  {
702  Init(rangeType, numDescriptors, baseShaderRegister, registerSpace, offsetInDescriptorsFromTableStart);
703  }
704 
705  inline void Init(
706  D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
707  UINT numDescriptors,
708  UINT baseShaderRegister,
709  UINT registerSpace = 0,
710  UINT offsetInDescriptorsFromTableStart =
711  D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND)
712  {
713  Init(*this, rangeType, numDescriptors, baseShaderRegister, registerSpace, offsetInDescriptorsFromTableStart);
714  }
715 
716  static inline void Init(
717  _Out_ D3D12_DESCRIPTOR_RANGE &range,
718  D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
719  UINT numDescriptors,
720  UINT baseShaderRegister,
721  UINT registerSpace = 0,
722  UINT offsetInDescriptorsFromTableStart =
723  D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND)
724  {
725  range.RangeType = rangeType;
726  range.NumDescriptors = numDescriptors;
727  range.BaseShaderRegister = baseShaderRegister;
728  range.RegisterSpace = registerSpace;
729  range.OffsetInDescriptorsFromTableStart = offsetInDescriptorsFromTableStart;
730  }
731 };
732 
733 //------------------------------------------------------------------------------------------------
734 struct CD3DX12_ROOT_DESCRIPTOR_TABLE : public D3D12_ROOT_DESCRIPTOR_TABLE
735 {
736  CD3DX12_ROOT_DESCRIPTOR_TABLE() {}
737  explicit CD3DX12_ROOT_DESCRIPTOR_TABLE(const D3D12_ROOT_DESCRIPTOR_TABLE &o) :
738  D3D12_ROOT_DESCRIPTOR_TABLE(o)
739  {}
740  CD3DX12_ROOT_DESCRIPTOR_TABLE(
741  UINT numDescriptorRanges,
742  _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges)
743  {
744  Init(numDescriptorRanges, _pDescriptorRanges);
745  }
746 
747  inline void Init(
748  UINT numDescriptorRanges,
749  _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges)
750  {
751  Init(*this, numDescriptorRanges, _pDescriptorRanges);
752  }
753 
754  static inline void Init(
755  _Out_ D3D12_ROOT_DESCRIPTOR_TABLE &rootDescriptorTable,
756  UINT numDescriptorRanges,
757  _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges)
758  {
759  rootDescriptorTable.NumDescriptorRanges = numDescriptorRanges;
760  rootDescriptorTable.pDescriptorRanges = _pDescriptorRanges;
761  }
762 };
763 
764 //------------------------------------------------------------------------------------------------
765 struct CD3DX12_ROOT_CONSTANTS : public D3D12_ROOT_CONSTANTS
766 {
767  CD3DX12_ROOT_CONSTANTS() {}
768  explicit CD3DX12_ROOT_CONSTANTS(const D3D12_ROOT_CONSTANTS &o) :
769  D3D12_ROOT_CONSTANTS(o)
770  {}
771  CD3DX12_ROOT_CONSTANTS(
772  UINT num32BitValues,
773  UINT shaderRegister,
774  UINT registerSpace = 0)
775  {
776  Init(num32BitValues, shaderRegister, registerSpace);
777  }
778 
779  inline void Init(
780  UINT num32BitValues,
781  UINT shaderRegister,
782  UINT registerSpace = 0)
783  {
784  Init(*this, num32BitValues, shaderRegister, registerSpace);
785  }
786 
787  static inline void Init(
788  _Out_ D3D12_ROOT_CONSTANTS &rootConstants,
789  UINT num32BitValues,
790  UINT shaderRegister,
791  UINT registerSpace = 0)
792  {
793  rootConstants.Num32BitValues = num32BitValues;
794  rootConstants.ShaderRegister = shaderRegister;
795  rootConstants.RegisterSpace = registerSpace;
796  }
797 };
798 
799 //------------------------------------------------------------------------------------------------
800 struct CD3DX12_ROOT_DESCRIPTOR : public D3D12_ROOT_DESCRIPTOR
801 {
802  CD3DX12_ROOT_DESCRIPTOR() {}
803  explicit CD3DX12_ROOT_DESCRIPTOR(const D3D12_ROOT_DESCRIPTOR &o) :
804  D3D12_ROOT_DESCRIPTOR(o)
805  {}
806  CD3DX12_ROOT_DESCRIPTOR(
807  UINT shaderRegister,
808  UINT registerSpace = 0)
809  {
810  Init(shaderRegister, registerSpace);
811  }
812 
813  inline void Init(
814  UINT shaderRegister,
815  UINT registerSpace = 0)
816  {
817  Init(*this, shaderRegister, registerSpace);
818  }
819 
820  static inline void Init(_Out_ D3D12_ROOT_DESCRIPTOR &table, UINT shaderRegister, UINT registerSpace = 0)
821  {
822  table.ShaderRegister = shaderRegister;
823  table.RegisterSpace = registerSpace;
824  }
825 };
826 
827 //------------------------------------------------------------------------------------------------
828 struct CD3DX12_ROOT_PARAMETER : public D3D12_ROOT_PARAMETER
829 {
830  CD3DX12_ROOT_PARAMETER() {}
831  explicit CD3DX12_ROOT_PARAMETER(const D3D12_ROOT_PARAMETER &o) :
832  D3D12_ROOT_PARAMETER(o)
833  {}
834 
835  static inline void InitAsDescriptorTable(
836  _Out_ D3D12_ROOT_PARAMETER &rootParam,
837  UINT numDescriptorRanges,
838  _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* pDescriptorRanges,
839  D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
840  {
841  rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
842  rootParam.ShaderVisibility = visibility;
843  CD3DX12_ROOT_DESCRIPTOR_TABLE::Init(rootParam.DescriptorTable, numDescriptorRanges, pDescriptorRanges);
844  }
845 
846  static inline void InitAsConstants(
847  _Out_ D3D12_ROOT_PARAMETER &rootParam,
848  UINT num32BitValues,
849  UINT shaderRegister,
850  UINT registerSpace = 0,
851  D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
852  {
853  rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS;
854  rootParam.ShaderVisibility = visibility;
855  CD3DX12_ROOT_CONSTANTS::Init(rootParam.Constants, num32BitValues, shaderRegister, registerSpace);
856  }
857 
858  static inline void InitAsConstantBufferView(
859  _Out_ D3D12_ROOT_PARAMETER &rootParam,
860  UINT shaderRegister,
861  UINT registerSpace = 0,
862  D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
863  {
864  rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
865  rootParam.ShaderVisibility = visibility;
866  CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister, registerSpace);
867  }
868 
869  static inline void InitAsShaderResourceView(
870  _Out_ D3D12_ROOT_PARAMETER &rootParam,
871  UINT shaderRegister,
872  UINT registerSpace = 0,
873  D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
874  {
875  rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_SRV;
876  rootParam.ShaderVisibility = visibility;
877  CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister, registerSpace);
878  }
879 
880  static inline void InitAsUnorderedAccessView(
881  _Out_ D3D12_ROOT_PARAMETER &rootParam,
882  UINT shaderRegister,
883  UINT registerSpace = 0,
884  D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
885  {
886  rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_UAV;
887  rootParam.ShaderVisibility = visibility;
888  CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister, registerSpace);
889  }
890 
891  inline void InitAsDescriptorTable(
892  UINT numDescriptorRanges,
893  _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* pDescriptorRanges,
894  D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
895  {
896  InitAsDescriptorTable(*this, numDescriptorRanges, pDescriptorRanges, visibility);
897  }
898 
899  inline void InitAsConstants(
900  UINT num32BitValues,
901  UINT shaderRegister,
902  UINT registerSpace = 0,
903  D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
904  {
905  InitAsConstants(*this, num32BitValues, shaderRegister, registerSpace, visibility);
906  }
907 
908  inline void InitAsConstantBufferView(
909  UINT shaderRegister,
910  UINT registerSpace = 0,
911  D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
912  {
913  InitAsConstantBufferView(*this, shaderRegister, registerSpace, visibility);
914  }
915 
916  inline void InitAsShaderResourceView(
917  UINT shaderRegister,
918  UINT registerSpace = 0,
919  D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
920  {
921  InitAsShaderResourceView(*this, shaderRegister, registerSpace, visibility);
922  }
923 
924  inline void InitAsUnorderedAccessView(
925  UINT shaderRegister,
926  UINT registerSpace = 0,
927  D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
928  {
929  InitAsUnorderedAccessView(*this, shaderRegister, registerSpace, visibility);
930  }
931 };
932 
933 //------------------------------------------------------------------------------------------------
934 struct CD3DX12_STATIC_SAMPLER_DESC : public D3D12_STATIC_SAMPLER_DESC
935 {
936  CD3DX12_STATIC_SAMPLER_DESC() {}
937  explicit CD3DX12_STATIC_SAMPLER_DESC(const D3D12_STATIC_SAMPLER_DESC &o) :
938  D3D12_STATIC_SAMPLER_DESC(o)
939  {}
940  CD3DX12_STATIC_SAMPLER_DESC(
941  UINT shaderRegister,
942  D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC,
943  D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
944  D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
945  D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
946  FLOAT mipLODBias = 0,
947  UINT maxAnisotropy = 16,
948  D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL,
949  D3D12_STATIC_BORDER_COLOR borderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE,
950  FLOAT minLOD = 0.f,
951  FLOAT maxLOD = D3D12_FLOAT32_MAX,
952  D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL,
953  UINT registerSpace = 0)
954  {
955  Init(
956  shaderRegister,
957  filter,
958  addressU,
959  addressV,
960  addressW,
961  mipLODBias,
962  maxAnisotropy,
963  comparisonFunc,
964  borderColor,
965  minLOD,
966  maxLOD,
967  shaderVisibility,
968  registerSpace);
969  }
970 
971  static inline void Init(
972  _Out_ D3D12_STATIC_SAMPLER_DESC &samplerDesc,
973  UINT shaderRegister,
974  D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC,
975  D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
976  D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
977  D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
978  FLOAT mipLODBias = 0,
979  UINT maxAnisotropy = 16,
980  D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL,
981  D3D12_STATIC_BORDER_COLOR borderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE,
982  FLOAT minLOD = 0.f,
983  FLOAT maxLOD = D3D12_FLOAT32_MAX,
984  D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL,
985  UINT registerSpace = 0)
986  {
987  samplerDesc.ShaderRegister = shaderRegister;
988  samplerDesc.Filter = filter;
989  samplerDesc.AddressU = addressU;
990  samplerDesc.AddressV = addressV;
991  samplerDesc.AddressW = addressW;
992  samplerDesc.MipLODBias = mipLODBias;
993  samplerDesc.MaxAnisotropy = maxAnisotropy;
994  samplerDesc.ComparisonFunc = comparisonFunc;
995  samplerDesc.BorderColor = borderColor;
996  samplerDesc.MinLOD = minLOD;
997  samplerDesc.MaxLOD = maxLOD;
998  samplerDesc.ShaderVisibility = shaderVisibility;
999  samplerDesc.RegisterSpace = registerSpace;
1000  }
1001  inline void Init(
1002  UINT shaderRegister,
1003  D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC,
1004  D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
1005  D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
1006  D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
1007  FLOAT mipLODBias = 0,
1008  UINT maxAnisotropy = 16,
1009  D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL,
1010  D3D12_STATIC_BORDER_COLOR borderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE,
1011  FLOAT minLOD = 0.f,
1012  FLOAT maxLOD = D3D12_FLOAT32_MAX,
1013  D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL,
1014  UINT registerSpace = 0)
1015  {
1016  Init(
1017  *this,
1018  shaderRegister,
1019  filter,
1020  addressU,
1021  addressV,
1022  addressW,
1023  mipLODBias,
1024  maxAnisotropy,
1025  comparisonFunc,
1026  borderColor,
1027  minLOD,
1028  maxLOD,
1029  shaderVisibility,
1030  registerSpace);
1031  }
1032 
1033 };
1034 
1035 //------------------------------------------------------------------------------------------------
1036 struct CD3DX12_ROOT_SIGNATURE_DESC : public D3D12_ROOT_SIGNATURE_DESC
1037 {
1038  CD3DX12_ROOT_SIGNATURE_DESC() {}
1039  explicit CD3DX12_ROOT_SIGNATURE_DESC(const D3D12_ROOT_SIGNATURE_DESC &o) :
1040  D3D12_ROOT_SIGNATURE_DESC(o)
1041  {}
1042  CD3DX12_ROOT_SIGNATURE_DESC(
1043  UINT numParameters,
1044  _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
1045  UINT numStaticSamplers = 0,
1046  _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = NULL,
1047  D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE)
1048  {
1049  Init(numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
1050  }
1051  CD3DX12_ROOT_SIGNATURE_DESC(CD3DX12_DEFAULT)
1052  {
1053  Init(0, NULL, 0, NULL, D3D12_ROOT_SIGNATURE_FLAG_NONE);
1054  }
1055 
1056  inline void Init(
1057  UINT numParameters,
1058  _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
1059  UINT numStaticSamplers = 0,
1060  _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = NULL,
1061  D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE)
1062  {
1063  Init(*this, numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
1064  }
1065 
1066  static inline void Init(
1067  _Out_ D3D12_ROOT_SIGNATURE_DESC &desc,
1068  UINT numParameters,
1069  _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
1070  UINT numStaticSamplers = 0,
1071  _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = NULL,
1072  D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE)
1073  {
1074  desc.NumParameters = numParameters;
1075  desc.pParameters = _pParameters;
1076  desc.NumStaticSamplers = numStaticSamplers;
1077  desc.pStaticSamplers = _pStaticSamplers;
1078  desc.Flags = flags;
1079  }
1080 };
1081 
1082 //------------------------------------------------------------------------------------------------
1083 struct CD3DX12_CPU_DESCRIPTOR_HANDLE : public D3D12_CPU_DESCRIPTOR_HANDLE
1084 {
1085  CD3DX12_CPU_DESCRIPTOR_HANDLE() {}
1086  explicit CD3DX12_CPU_DESCRIPTOR_HANDLE(const D3D12_CPU_DESCRIPTOR_HANDLE &o) :
1087  D3D12_CPU_DESCRIPTOR_HANDLE(o)
1088  {}
1089  CD3DX12_CPU_DESCRIPTOR_HANDLE(CD3DX12_DEFAULT) { ptr = 0; }
1090  CD3DX12_CPU_DESCRIPTOR_HANDLE(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &other, INT offsetScaledByIncrementSize)
1091  {
1092  InitOffsetted(other, offsetScaledByIncrementSize);
1093  }
1094  CD3DX12_CPU_DESCRIPTOR_HANDLE(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &other, INT offsetInDescriptors, UINT descriptorIncrementSize)
1095  {
1096  InitOffsetted(other, offsetInDescriptors, descriptorIncrementSize);
1097  }
1098  CD3DX12_CPU_DESCRIPTOR_HANDLE& Offset(INT offsetInDescriptors, UINT descriptorIncrementSize)
1099  {
1100  ptr += offsetInDescriptors * descriptorIncrementSize;
1101  return *this;
1102  }
1103  CD3DX12_CPU_DESCRIPTOR_HANDLE& Offset(INT offsetScaledByIncrementSize)
1104  {
1105  ptr += offsetScaledByIncrementSize;
1106  return *this;
1107  }
1108  bool operator==(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE& other)
1109  {
1110  return (ptr == other.ptr);
1111  }
1112  bool operator!=(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE& other)
1113  {
1114  return (ptr != other.ptr);
1115  }
1116  CD3DX12_CPU_DESCRIPTOR_HANDLE &operator=(const D3D12_CPU_DESCRIPTOR_HANDLE &other)
1117  {
1118  ptr = other.ptr;
1119  return *this;
1120  }
1121 
1122  inline void InitOffsetted(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize)
1123  {
1124  InitOffsetted(*this, base, offsetScaledByIncrementSize);
1125  }
1126 
1127  inline void InitOffsetted(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize)
1128  {
1129  InitOffsetted(*this, base, offsetInDescriptors, descriptorIncrementSize);
1130  }
1131 
1132  static inline void InitOffsetted(_Out_ D3D12_CPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize)
1133  {
1134  handle.ptr = base.ptr + offsetScaledByIncrementSize;
1135  }
1136 
1137  static inline void InitOffsetted(_Out_ D3D12_CPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize)
1138  {
1139  handle.ptr = base.ptr + offsetInDescriptors * descriptorIncrementSize;
1140  }
1141 };
1142 
1143 //------------------------------------------------------------------------------------------------
1144 struct CD3DX12_GPU_DESCRIPTOR_HANDLE : public D3D12_GPU_DESCRIPTOR_HANDLE
1145 {
1146  CD3DX12_GPU_DESCRIPTOR_HANDLE() {}
1147  explicit CD3DX12_GPU_DESCRIPTOR_HANDLE(const D3D12_GPU_DESCRIPTOR_HANDLE &o) :
1148  D3D12_GPU_DESCRIPTOR_HANDLE(o)
1149  {}
1150  CD3DX12_GPU_DESCRIPTOR_HANDLE(CD3DX12_DEFAULT) { ptr = 0; }
1151  CD3DX12_GPU_DESCRIPTOR_HANDLE(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &other, INT offsetScaledByIncrementSize)
1152  {
1153  InitOffsetted(other, offsetScaledByIncrementSize);
1154  }
1155  CD3DX12_GPU_DESCRIPTOR_HANDLE(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &other, INT offsetInDescriptors, UINT descriptorIncrementSize)
1156  {
1157  InitOffsetted(other, offsetInDescriptors, descriptorIncrementSize);
1158  }
1159  CD3DX12_GPU_DESCRIPTOR_HANDLE& Offset(INT offsetInDescriptors, UINT descriptorIncrementSize)
1160  {
1161  ptr += offsetInDescriptors * descriptorIncrementSize;
1162  return *this;
1163  }
1164  CD3DX12_GPU_DESCRIPTOR_HANDLE& Offset(INT offsetScaledByIncrementSize)
1165  {
1166  ptr += offsetScaledByIncrementSize;
1167  return *this;
1168  }
1169  inline bool operator==(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE& other)
1170  {
1171  return (ptr == other.ptr);
1172  }
1173  inline bool operator!=(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE& other)
1174  {
1175  return (ptr != other.ptr);
1176  }
1177  CD3DX12_GPU_DESCRIPTOR_HANDLE &operator=(const D3D12_GPU_DESCRIPTOR_HANDLE &other)
1178  {
1179  ptr = other.ptr;
1180  return *this;
1181  }
1182 
1183  inline void InitOffsetted(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize)
1184  {
1185  InitOffsetted(*this, base, offsetScaledByIncrementSize);
1186  }
1187 
1188  inline void InitOffsetted(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize)
1189  {
1190  InitOffsetted(*this, base, offsetInDescriptors, descriptorIncrementSize);
1191  }
1192 
1193  static inline void InitOffsetted(_Out_ D3D12_GPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize)
1194  {
1195  handle.ptr = base.ptr + offsetScaledByIncrementSize;
1196  }
1197 
1198  static inline void InitOffsetted(_Out_ D3D12_GPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize)
1199  {
1200  handle.ptr = base.ptr + offsetInDescriptors * descriptorIncrementSize;
1201  }
1202 };
1203 
1204 //------------------------------------------------------------------------------------------------
1205 inline UINT D3D12CalcSubresource( UINT MipSlice, UINT ArraySlice, UINT PlaneSlice, UINT MipLevels, UINT ArraySize )
1206 {
1207  return MipSlice + ArraySlice * MipLevels + PlaneSlice * MipLevels * ArraySize;
1208 }
1209 
1210 //------------------------------------------------------------------------------------------------
1211 template <typename T, typename U, typename V>
1212 inline void D3D12DecomposeSubresource( UINT Subresource, UINT MipLevels, UINT ArraySize, _Out_ T& MipSlice, _Out_ U& ArraySlice, _Out_ V& PlaneSlice )
1213 {
1214  MipSlice = static_cast<T>(Subresource % MipLevels);
1215  ArraySlice = static_cast<U>((Subresource / MipLevels) % ArraySize);
1216  PlaneSlice = static_cast<V>(Subresource / (MipLevels * ArraySize));
1217 }
1218 
1219 //------------------------------------------------------------------------------------------------
1220 inline UINT8 D3D12GetFormatPlaneCount(
1221  _In_ ID3D12Device* pDevice,
1222  DXGI_FORMAT Format
1223  )
1224 {
1225  D3D12_FEATURE_DATA_FORMAT_INFO formatInfo = {Format};
1226  if (FAILED(pDevice->CheckFeatureSupport(D3D12_FEATURE_FORMAT_INFO, &formatInfo, sizeof(formatInfo))))
1227  {
1228  return 0;
1229  }
1230  return formatInfo.PlaneCount;
1231 }
1232 
1233 //------------------------------------------------------------------------------------------------
1234 struct CD3DX12_RESOURCE_DESC : public D3D12_RESOURCE_DESC
1235 {
1236  CD3DX12_RESOURCE_DESC()
1237  {}
1238  explicit CD3DX12_RESOURCE_DESC( const D3D12_RESOURCE_DESC& o ) :
1239  D3D12_RESOURCE_DESC( o )
1240  {}
1241  CD3DX12_RESOURCE_DESC(
1242  D3D12_RESOURCE_DIMENSION dimension,
1243  UINT64 alignment,
1244  UINT64 width,
1245  UINT height,
1246  UINT16 depthOrArraySize,
1247  UINT16 mipLevels,
1248  DXGI_FORMAT format,
1249  UINT sampleCount,
1250  UINT sampleQuality,
1251  D3D12_TEXTURE_LAYOUT layout,
1252  D3D12_RESOURCE_FLAGS flags )
1253  {
1254  Dimension = dimension;
1255  Alignment = alignment;
1256  Width = width;
1257  Height = height;
1258  DepthOrArraySize = depthOrArraySize;
1259  MipLevels = mipLevels;
1260  Format = format;
1261  SampleDesc.Count = sampleCount;
1262  SampleDesc.Quality = sampleQuality;
1263  Layout = layout;
1264  Flags = flags;
1265  }
1266  static inline CD3DX12_RESOURCE_DESC Buffer(
1267  const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
1268  D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE )
1269  {
1270  return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_BUFFER, resAllocInfo.Alignment, resAllocInfo.SizeInBytes,
1271  1, 1, 1, DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags );
1272  }
1273  static inline CD3DX12_RESOURCE_DESC Buffer(
1274  UINT64 width,
1275  D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
1276  UINT64 alignment = 0 )
1277  {
1278  return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_BUFFER, alignment, width, 1, 1, 1,
1279  DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags );
1280  }
1281  static inline CD3DX12_RESOURCE_DESC Tex1D(
1282  DXGI_FORMAT format,
1283  UINT64 width,
1284  UINT16 arraySize = 1,
1285  UINT16 mipLevels = 0,
1286  D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
1287  D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
1288  UINT64 alignment = 0 )
1289  {
1290  return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_TEXTURE1D, alignment, width, 1, arraySize,
1291  mipLevels, format, 1, 0, layout, flags );
1292  }
1293  static inline CD3DX12_RESOURCE_DESC Tex2D(
1294  DXGI_FORMAT format,
1295  UINT64 width,
1296  UINT height,
1297  UINT16 arraySize = 1,
1298  UINT16 mipLevels = 0,
1299  UINT sampleCount = 1,
1300  UINT sampleQuality = 0,
1301  D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
1302  D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
1303  UINT64 alignment = 0 )
1304  {
1305  return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_TEXTURE2D, alignment, width, height, arraySize,
1306  mipLevels, format, sampleCount, sampleQuality, layout, flags );
1307  }
1308  static inline CD3DX12_RESOURCE_DESC Tex3D(
1309  DXGI_FORMAT format,
1310  UINT64 width,
1311  UINT height,
1312  UINT16 depth,
1313  UINT16 mipLevels = 0,
1314  D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
1315  D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
1316  UINT64 alignment = 0 )
1317  {
1318  return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_TEXTURE3D, alignment, width, height, depth,
1319  mipLevels, format, 1, 0, layout, flags );
1320  }
1321  inline UINT16 Depth() const
1322  { return (Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize : 1); }
1323  inline UINT16 ArraySize() const
1324  { return (Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize : 1); }
1325  inline UINT8 PlaneCount(_In_ ID3D12Device* pDevice) const
1326  { return D3D12GetFormatPlaneCount(pDevice, Format); }
1327  inline UINT Subresources(_In_ ID3D12Device* pDevice) const
1328  { return MipLevels * ArraySize() * PlaneCount(pDevice); }
1329  inline UINT CalcSubresource(UINT MipSlice, UINT ArraySlice, UINT PlaneSlice)
1330  { return D3D12CalcSubresource(MipSlice, ArraySlice, PlaneSlice, MipLevels, ArraySize()); }
1331  operator const D3D12_RESOURCE_DESC&() const { return *this; }
1332 };
1333 inline bool operator==( const D3D12_RESOURCE_DESC& l, const D3D12_RESOURCE_DESC& r )
1334 {
1335  return l.Dimension == r.Dimension &&
1336  l.Alignment == r.Alignment &&
1337  l.Width == r.Width &&
1338  l.Height == r.Height &&
1339  l.DepthOrArraySize == r.DepthOrArraySize &&
1340  l.MipLevels == r.MipLevels &&
1341  l.Format == r.Format &&
1342  l.SampleDesc.Count == r.SampleDesc.Count &&
1343  l.SampleDesc.Quality == r.SampleDesc.Quality &&
1344  l.Layout == r.Layout &&
1345  l.Flags == r.Flags;
1346 }
1347 inline bool operator!=( const D3D12_RESOURCE_DESC& l, const D3D12_RESOURCE_DESC& r )
1348 { return !( l == r ); }
1349 
1350 //------------------------------------------------------------------------------------------------
1351 // Row-by-row memcpy
1352 inline void MemcpySubresource(
1353  _In_ const D3D12_MEMCPY_DEST* pDest,
1354  _In_ const D3D12_SUBRESOURCE_DATA* pSrc,
1355  SIZE_T RowSizeInBytes,
1356  UINT NumRows,
1357  UINT NumSlices)
1358 {
1359  for (UINT z = 0; z < NumSlices; ++z)
1360  {
1361  BYTE* pDestSlice = reinterpret_cast<BYTE*>(pDest->pData) + pDest->SlicePitch * z;
1362  const BYTE* pSrcSlice = reinterpret_cast<const BYTE*>(pSrc->pData) + pSrc->SlicePitch * z;
1363  for (UINT y = 0; y < NumRows; ++y)
1364  {
1365  memcpy(pDestSlice + pDest->RowPitch * y,
1366  pSrcSlice + pSrc->RowPitch * y,
1367  RowSizeInBytes);
1368  }
1369  }
1370 }
1371 
1372 //------------------------------------------------------------------------------------------------
1373 // Returns required size of a buffer to be used for data upload
1374 inline UINT64 GetRequiredIntermediateSize(
1375  _In_ ID3D12Resource* pDestinationResource,
1376  _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
1377  _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources)
1378 {
1379  D3D12_RESOURCE_DESC Desc = pDestinationResource->GetDesc();
1380  UINT64 RequiredSize = 0;
1381 
1382  ID3D12Device* pDevice;
1383  pDestinationResource->GetDevice(__uuidof(*pDevice), reinterpret_cast<void**>(&pDevice));
1384  pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, 0, nullptr, nullptr, nullptr, &RequiredSize);
1385  pDevice->Release();
1386 
1387  return RequiredSize;
1388 }
1389 
1390 //------------------------------------------------------------------------------------------------
1391 // All arrays must be populated (e.g. by calling GetCopyableFootprints)
1392 inline UINT64 UpdateSubresources(
1393  _In_ ID3D12GraphicsCommandList* pCmdList,
1394  _In_ ID3D12Resource* pDestinationResource,
1395  _In_ ID3D12Resource* pIntermediate,
1396  _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
1397  _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources,
1398  UINT64 RequiredSize,
1399  _In_reads_(NumSubresources) const D3D12_PLACED_SUBRESOURCE_FOOTPRINT* pLayouts,
1400  _In_reads_(NumSubresources) const UINT* pNumRows,
1401  _In_reads_(NumSubresources) const UINT64* pRowSizesInBytes,
1402  _In_reads_(NumSubresources) const D3D12_SUBRESOURCE_DATA* pSrcData)
1403 {
1404  // Minor validation
1405  D3D12_RESOURCE_DESC IntermediateDesc = pIntermediate->GetDesc();
1406  D3D12_RESOURCE_DESC DestinationDesc = pDestinationResource->GetDesc();
1407  if (IntermediateDesc.Dimension != D3D12_RESOURCE_DIMENSION_BUFFER ||
1408  IntermediateDesc.Width < RequiredSize + pLayouts[0].Offset ||
1409  RequiredSize > (SIZE_T)-1 ||
1410  (DestinationDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER &&
1411  (FirstSubresource != 0 || NumSubresources != 1)))
1412  {
1413  return 0;
1414  }
1415 
1416  BYTE* pData;
1417  HRESULT hr = pIntermediate->Map(0, NULL, reinterpret_cast<void**>(&pData));
1418  if (FAILED(hr))
1419  {
1420  return 0;
1421  }
1422 
1423  for (UINT i = 0; i < NumSubresources; ++i)
1424  {
1425  if (pRowSizesInBytes[i] > (SIZE_T)-1) return 0;
1426  D3D12_MEMCPY_DEST DestData = { pData + pLayouts[i].Offset, pLayouts[i].Footprint.RowPitch, pLayouts[i].Footprint.RowPitch * pNumRows[i] };
1427  MemcpySubresource(&DestData, &pSrcData[i], (SIZE_T)pRowSizesInBytes[i], pNumRows[i], pLayouts[i].Footprint.Depth);
1428  }
1429  pIntermediate->Unmap(0, NULL);
1430 
1431  if (DestinationDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER)
1432  {
1433  CD3DX12_BOX SrcBox( UINT( pLayouts[0].Offset ), UINT( pLayouts[0].Offset + pLayouts[0].Footprint.Width ) );
1434  pCmdList->CopyBufferRegion(
1435  pDestinationResource, 0, pIntermediate, pLayouts[0].Offset, pLayouts[0].Footprint.Width);
1436  }
1437  else
1438  {
1439  for (UINT i = 0; i < NumSubresources; ++i)
1440  {
1441  CD3DX12_TEXTURE_COPY_LOCATION Dst(pDestinationResource, i + FirstSubresource);
1442  CD3DX12_TEXTURE_COPY_LOCATION Src(pIntermediate, pLayouts[i]);
1443  pCmdList->CopyTextureRegion(&Dst, 0, 0, 0, &Src, nullptr);
1444  }
1445  }
1446  return RequiredSize;
1447 }
1448 
1449 //------------------------------------------------------------------------------------------------
1450 // Heap-allocating UpdateSubresources implementation
1451 inline UINT64 UpdateSubresources(
1452  _In_ ID3D12GraphicsCommandList* pCmdList,
1453  _In_ ID3D12Resource* pDestinationResource,
1454  _In_ ID3D12Resource* pIntermediate,
1455  UINT64 IntermediateOffset,
1456  _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
1457  _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources,
1458  _In_reads_(NumSubresources) D3D12_SUBRESOURCE_DATA* pSrcData)
1459 {
1460  UINT64 RequiredSize = 0;
1461  UINT64 MemToAlloc = static_cast<UINT64>(sizeof(D3D12_PLACED_SUBRESOURCE_FOOTPRINT) + sizeof(UINT) + sizeof(UINT64)) * NumSubresources;
1462  if (MemToAlloc > SIZE_MAX)
1463  {
1464  return 0;
1465  }
1466  void* pMem = HeapAlloc(GetProcessHeap(), 0, static_cast<SIZE_T>(MemToAlloc));
1467  if (pMem == NULL)
1468  {
1469  return 0;
1470  }
1471  D3D12_PLACED_SUBRESOURCE_FOOTPRINT* pLayouts = reinterpret_cast<D3D12_PLACED_SUBRESOURCE_FOOTPRINT*>(pMem);
1472  UINT64* pRowSizesInBytes = reinterpret_cast<UINT64*>(pLayouts + NumSubresources);
1473  UINT* pNumRows = reinterpret_cast<UINT*>(pRowSizesInBytes + NumSubresources);
1474 
1475  D3D12_RESOURCE_DESC Desc = pDestinationResource->GetDesc();
1476  ID3D12Device* pDevice;
1477  pDestinationResource->GetDevice(__uuidof(*pDevice), reinterpret_cast<void**>(&pDevice));
1478  pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, IntermediateOffset, pLayouts, pNumRows, pRowSizesInBytes, &RequiredSize);
1479  pDevice->Release();
1480 
1481  UINT64 Result = UpdateSubresources(pCmdList, pDestinationResource, pIntermediate, FirstSubresource, NumSubresources, RequiredSize, pLayouts, pNumRows, pRowSizesInBytes, pSrcData);
1482  HeapFree(GetProcessHeap(), 0, pMem);
1483  return Result;
1484 }
1485 
1486 //------------------------------------------------------------------------------------------------
1487 // Stack-allocating UpdateSubresources implementation
1488 template <UINT MaxSubresources>
1489 inline UINT64 UpdateSubresources(
1490  _In_ ID3D12GraphicsCommandList* pCmdList,
1491  _In_ ID3D12Resource* pDestinationResource,
1492  _In_ ID3D12Resource* pIntermediate,
1493  UINT64 IntermediateOffset,
1494  _In_range_(0, MaxSubresources) UINT FirstSubresource,
1495  _In_range_(1, MaxSubresources - FirstSubresource) UINT NumSubresources,
1496  _In_reads_(NumSubresources) D3D12_SUBRESOURCE_DATA* pSrcData)
1497 {
1498  UINT64 RequiredSize = 0;
1499  D3D12_PLACED_SUBRESOURCE_FOOTPRINT Layouts[MaxSubresources];
1500  UINT NumRows[MaxSubresources];
1501  UINT64 RowSizesInBytes[MaxSubresources];
1502 
1503  D3D12_RESOURCE_DESC Desc = pDestinationResource->GetDesc();
1504  ID3D12Device* pDevice;
1505  pDestinationResource->GetDevice(__uuidof(*pDevice), reinterpret_cast<void**>(&pDevice));
1506  pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, IntermediateOffset, Layouts, NumRows, RowSizesInBytes, &RequiredSize);
1507  pDevice->Release();
1508 
1509  return UpdateSubresources(pCmdList, pDestinationResource, pIntermediate, FirstSubresource, NumSubresources, RequiredSize, Layouts, NumRows, RowSizesInBytes, pSrcData);
1510 }
1511 
1512 //------------------------------------------------------------------------------------------------
1513 inline bool D3D12IsLayoutOpaque( D3D12_TEXTURE_LAYOUT Layout )
1514 { return Layout == D3D12_TEXTURE_LAYOUT_UNKNOWN || Layout == D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE; }
1515 
1516 //------------------------------------------------------------------------------------------------
1517 inline ID3D12CommandList * const * CommandListCast(ID3D12GraphicsCommandList * const * pp)
1518 {
1519  // This cast is useful for passing strongly typed command list pointers into
1520  // ExecuteCommandLists.
1521  // This cast is valid as long as the const-ness is respected. D3D12 APIs do
1522  // respect the const-ness of their arguments.
1523  return reinterpret_cast<ID3D12CommandList * const *>(pp);
1524 }
1525 
1526 
1527 #endif // defined( __cplusplus )
1528 
1529 #endif //__D3DX12_H__
1530 
1531 
1532 
RenderTarget
Hatchit Engine Copyright(c) 2015-2016 Third-Degree.
Generated by   doxygen 1.8.11