Core/d3dx12.h

   1 //*********************************************************
   2 //
   3 // Copyright (c) Microsoft. All rights reserved.
   4 // This code is licensed under the MIT License (MIT).
   5 // THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
   6 // ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
   7 // IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
   8 // PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
   9 //
  10 //*********************************************************
  11
  12 #ifndef __D3DX12_H__
  13 #define __D3DX12_H__
  14
  15 #include "vkd3d_d3d12.h"
  16
  17 #if defined( __cplusplus )
  18
  19 struct CD3DX12_DEFAULT {};
  20 extern const DECLSPEC_SELECTANY CD3DX12_DEFAULT D3D12_DEFAULT;
  21
  22 //------------------------------------------------------------------------------------------------
  23 inline bool operator==( const D3D12_VIEWPORT& l, const D3D12_VIEWPORT& r )
  24 {
  25     return l.TopLeftX == r.TopLeftX && l.TopLeftY == r.TopLeftY && l.Width == r.Width &&
  26         l.Height == r.Height && l.MinDepth == r.MinDepth && l.MaxDepth == r.MaxDepth;
  27 }
  28
  29 //------------------------------------------------------------------------------------------------
  30 inline bool operator!=( const D3D12_VIEWPORT& l, const D3D12_VIEWPORT& r )
  31 { return !( l == r ); }
  32
  33 //------------------------------------------------------------------------------------------------
  34 struct CD3DX12_RECT : public D3D12_RECT
  35 {
  36     CD3DX12_RECT()
  37     {}
  38     explicit CD3DX12_RECT( const D3D12_RECT& o ) :
  39         D3D12_RECT( o )
  40     {}
  41     explicit CD3DX12_RECT(
  42         LONG Left,
  43         LONG Top,
  44         LONG Right,
  45         LONG Bottom )
  46     {
  47         left = Left;
  48         top = Top;
  49         right = Right;
  50         bottom = Bottom;
  51     }
  52     ~CD3DX12_RECT() {}
  53     operator const D3D12_RECT&() const { return *this; }
  54 };
  55
  56 //------------------------------------------------------------------------------------------------
  57 struct CD3DX12_BOX : public D3D12_BOX
  58 {
  59     CD3DX12_BOX()
  60     {}
  61     explicit CD3DX12_BOX( const D3D12_BOX& o ) :
  62         D3D12_BOX( o )
  63     {}
  64     explicit CD3DX12_BOX(
  65         LONG Left,
  66         LONG Right )
  67     {
  68         left = Left;
  69         top = 0;
  70         front = 0;
  71         right = Right;
  72         bottom = 1;
  73         back = 1;
  74     }
  75     explicit CD3DX12_BOX(
  76         LONG Left,
  77         LONG Top,
  78         LONG Right,
  79         LONG Bottom )
  80     {
  81         left = Left;
  82         top = Top;
  83         front = 0;
  84         right = Right;
  85         bottom = Bottom;
  86         back = 1;
  87     }
  88     explicit CD3DX12_BOX(
  89         LONG Left,
  90         LONG Top,
  91         LONG Front,
  92         LONG Right,
  93         LONG Bottom,
  94         LONG Back )
  95     {
  96         left = Left;
  97         top = Top;
  98         front = Front;
  99         right = Right;
 100         bottom = Bottom;
 101         back = Back;
 102     }
 103     ~CD3DX12_BOX() {}
 104     operator const D3D12_BOX&() const { return *this; }
 105 };
 106 inline bool operator==( const D3D12_BOX& l, const D3D12_BOX& r )
 107 {
 108     return l.left == r.left && l.top == r.top && l.front == r.front &&
 109         l.right == r.right && l.bottom == r.bottom && l.back == r.back;
 110 }
 111 inline bool operator!=( const D3D12_BOX& l, const D3D12_BOX& r )
 112 { return !( l == r ); }
 113
 114 //------------------------------------------------------------------------------------------------
 115 struct CD3DX12_DEPTH_STENCIL_DESC : public D3D12_DEPTH_STENCIL_DESC
 116 {
 117     CD3DX12_DEPTH_STENCIL_DESC()
 118     {}
 119     explicit CD3DX12_DEPTH_STENCIL_DESC( const D3D12_DEPTH_STENCIL_DESC& o ) :
 120         D3D12_DEPTH_STENCIL_DESC( o )
 121     {}
 122     explicit CD3DX12_DEPTH_STENCIL_DESC( CD3DX12_DEFAULT )
 123     {
 124         DepthEnable = TRUE;
 125         DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL;
 126         DepthFunc = D3D12_COMPARISON_FUNC_LESS;
 127         StencilEnable = FALSE;
 128         StencilReadMask = D3D12_DEFAULT_STENCIL_READ_MASK;
 129         StencilWriteMask = D3D12_DEFAULT_STENCIL_WRITE_MASK;
 130         const D3D12_DEPTH_STENCILOP_DESC defaultStencilOp =
 131         { D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_COMPARISON_FUNC_ALWAYS };
 132         FrontFace = defaultStencilOp;
 133         BackFace = defaultStencilOp;
 134     }
 135     explicit CD3DX12_DEPTH_STENCIL_DESC(
 136         BOOL depthEnable,
 137         D3D12_DEPTH_WRITE_MASK depthWriteMask,
 138         D3D12_COMPARISON_FUNC depthFunc,
 139         BOOL stencilEnable,
 140         UINT8 stencilReadMask,
 141         UINT8 stencilWriteMask,
 142         D3D12_STENCIL_OP frontStencilFailOp,
 143         D3D12_STENCIL_OP frontStencilDepthFailOp,
 144         D3D12_STENCIL_OP frontStencilPassOp,
 145         D3D12_COMPARISON_FUNC frontStencilFunc,
 146         D3D12_STENCIL_OP backStencilFailOp,
 147         D3D12_STENCIL_OP backStencilDepthFailOp,
 148         D3D12_STENCIL_OP backStencilPassOp,
 149         D3D12_COMPARISON_FUNC backStencilFunc )
 150     {
 151         DepthEnable = depthEnable;
 152         DepthWriteMask = depthWriteMask;
 153         DepthFunc = depthFunc;
 154         StencilEnable = stencilEnable;
 155         StencilReadMask = stencilReadMask;
 156         StencilWriteMask = stencilWriteMask;
 157         FrontFace.StencilFailOp = frontStencilFailOp;
 158         FrontFace.StencilDepthFailOp = frontStencilDepthFailOp;
 159         FrontFace.StencilPassOp = frontStencilPassOp;
 160         FrontFace.StencilFunc = frontStencilFunc;
 161         BackFace.StencilFailOp = backStencilFailOp;
 162         BackFace.StencilDepthFailOp = backStencilDepthFailOp;
 163         BackFace.StencilPassOp = backStencilPassOp;
 164         BackFace.StencilFunc = backStencilFunc;
 165     }
 166     ~CD3DX12_DEPTH_STENCIL_DESC() {}
 167     operator const D3D12_DEPTH_STENCIL_DESC&() const { return *this; }
 168 };
 169
 170 //------------------------------------------------------------------------------------------------
 171 struct CD3DX12_BLEND_DESC : public D3D12_BLEND_DESC
 172 {
 173     CD3DX12_BLEND_DESC()
 174     {}
 175     explicit CD3DX12_BLEND_DESC( const D3D12_BLEND_DESC& o ) :
 176         D3D12_BLEND_DESC( o )
 177     {}
 178     explicit CD3DX12_BLEND_DESC( CD3DX12_DEFAULT )
 179     {
 180         AlphaToCoverageEnable = FALSE;
 181         IndependentBlendEnable = FALSE;
 182         const D3D12_RENDER_TARGET_BLEND_DESC defaultRenderTargetBlendDesc =
 183         {
 184             FALSE,FALSE,
 185             D3D12_BLEND_ONE, D3D12_BLEND_ZERO, D3D12_BLEND_OP_ADD,
 186             D3D12_BLEND_ONE, D3D12_BLEND_ZERO, D3D12_BLEND_OP_ADD,
 187             D3D12_LOGIC_OP_NOOP,
 188             D3D12_COLOR_WRITE_ENABLE_ALL,
 189         };
 190         for (UINT i = 0; i < D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
 191             RenderTarget[ i ] = defaultRenderTargetBlendDesc;
 192     }
 193     ~CD3DX12_BLEND_DESC() {}
 194     operator const D3D12_BLEND_DESC&() const { return *this; }
 195 };
 196
 197 //------------------------------------------------------------------------------------------------
 198 struct CD3DX12_RASTERIZER_DESC : public D3D12_RASTERIZER_DESC
 199 {
 200     CD3DX12_RASTERIZER_DESC()
 201     {}
 202     explicit CD3DX12_RASTERIZER_DESC( const D3D12_RASTERIZER_DESC& o ) :
 203         D3D12_RASTERIZER_DESC( o )
 204     {}
 205     explicit CD3DX12_RASTERIZER_DESC( CD3DX12_DEFAULT )
 206     {
 207         FillMode = D3D12_FILL_MODE_SOLID;
 208         CullMode = D3D12_CULL_MODE_BACK;
 209         FrontCounterClockwise = FALSE;
 210         DepthBias = D3D12_DEFAULT_DEPTH_BIAS;
 211         DepthBiasClamp = D3D12_DEFAULT_DEPTH_BIAS_CLAMP;
 212         SlopeScaledDepthBias = D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS;
 213         DepthClipEnable = TRUE;
 214         MultisampleEnable = FALSE;
 215         AntialiasedLineEnable = FALSE;
 216         ForcedSampleCount = 0;
 217         ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF;
 218     }
 219     explicit CD3DX12_RASTERIZER_DESC(
 220         D3D12_FILL_MODE fillMode,
 221         D3D12_CULL_MODE cullMode,
 222         BOOL frontCounterClockwise,
 223         INT depthBias,
 224         FLOAT depthBiasClamp,
 225         FLOAT slopeScaledDepthBias,
 226         BOOL depthClipEnable,
 227         BOOL multisampleEnable,
 228         BOOL antialiasedLineEnable,
 229         UINT forcedSampleCount,
 230         D3D12_CONSERVATIVE_RASTERIZATION_MODE conservativeRaster)
 231     {
 232         FillMode = fillMode;
 233         CullMode = cullMode;
 234         FrontCounterClockwise = frontCounterClockwise;
 235         DepthBias = depthBias;
 236         DepthBiasClamp = depthBiasClamp;
 237         SlopeScaledDepthBias = slopeScaledDepthBias;
 238         DepthClipEnable = depthClipEnable;
 239         MultisampleEnable = multisampleEnable;
 240         AntialiasedLineEnable = antialiasedLineEnable;
 241         ForcedSampleCount = forcedSampleCount;
 242         ConservativeRaster = conservativeRaster;
 243     }
 244     ~CD3DX12_RASTERIZER_DESC() {}
 245     operator const D3D12_RASTERIZER_DESC&() const { return *this; }
 246 };
 247
 248 //------------------------------------------------------------------------------------------------
 249 struct CD3DX12_RESOURCE_ALLOCATION_INFO : public D3D12_RESOURCE_ALLOCATION_INFO
 250 {
 251     CD3DX12_RESOURCE_ALLOCATION_INFO()
 252     {}
 253     explicit CD3DX12_RESOURCE_ALLOCATION_INFO( const D3D12_RESOURCE_ALLOCATION_INFO& o ) :
 254         D3D12_RESOURCE_ALLOCATION_INFO( o )
 255     {}
 256     CD3DX12_RESOURCE_ALLOCATION_INFO(
 257         UINT64 size,
 258         UINT64 alignment )
 259     {
 260         SizeInBytes = size;
 261         Alignment = alignment;
 262     }
 263     operator const D3D12_RESOURCE_ALLOCATION_INFO&() const { return *this; }
 264 };
 265
 266 //------------------------------------------------------------------------------------------------
 267 struct CD3DX12_HEAP_PROPERTIES : public D3D12_HEAP_PROPERTIES
 268 {
 269     CD3DX12_HEAP_PROPERTIES()
 270     {}
 271     explicit CD3DX12_HEAP_PROPERTIES(const D3D12_HEAP_PROPERTIES &o) :
 272         D3D12_HEAP_PROPERTIES(o)
 273     {}
 274     CD3DX12_HEAP_PROPERTIES(
 275         D3D12_CPU_PAGE_PROPERTY cpuPageProperty,
 276         D3D12_MEMORY_POOL memoryPoolPreference,
 277         UINT creationNodeMask = 1,
 278         UINT nodeMask = 1 )
 279     {
 280         Type = D3D12_HEAP_TYPE_CUSTOM;
 281         CPUPageProperty = cpuPageProperty;
 282         MemoryPoolPreference = memoryPoolPreference;
 283         CreationNodeMask = creationNodeMask;
 284         VisibleNodeMask = nodeMask;
 285     }
 286     explicit CD3DX12_HEAP_PROPERTIES(
 287         D3D12_HEAP_TYPE type,
 288         UINT creationNodeMask = 1,
 289         UINT nodeMask = 1 )
 290     {
 291         Type = type;
 292         CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
 293         MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
 294         CreationNodeMask = creationNodeMask;
 295         VisibleNodeMask = nodeMask;
 296     }
 297     operator const D3D12_HEAP_PROPERTIES&() const { return *this; }
 298     bool IsCPUAccessible() const
 299     {
 300         return Type == D3D12_HEAP_TYPE_UPLOAD || Type == D3D12_HEAP_TYPE_READBACK || (Type == D3D12_HEAP_TYPE_CUSTOM &&
 301             (CPUPageProperty == D3D12_CPU_PAGE_PROPERTY_WRITE_COMBINE || CPUPageProperty == D3D12_CPU_PAGE_PROPERTY_WRITE_BACK));
 302     }
 303 };
 304 inline bool operator==( const D3D12_HEAP_PROPERTIES& l, const D3D12_HEAP_PROPERTIES& r )
 305 {
 306     return l.Type == r.Type && l.CPUPageProperty == r.CPUPageProperty &&
 307         l.MemoryPoolPreference == r.MemoryPoolPreference &&
 308         l.CreationNodeMask == r.CreationNodeMask &&
 309         l.VisibleNodeMask == r.VisibleNodeMask;
 310 }
 311 inline bool operator!=( const D3D12_HEAP_PROPERTIES& l, const D3D12_HEAP_PROPERTIES& r )
 312 { return !( l == r ); }
 313
 314 //------------------------------------------------------------------------------------------------
 315 struct CD3DX12_HEAP_DESC : public D3D12_HEAP_DESC
 316 {
 317     CD3DX12_HEAP_DESC()
 318     {}
 319     explicit CD3DX12_HEAP_DESC(const D3D12_HEAP_DESC &o) :
 320         D3D12_HEAP_DESC(o)
 321     {}
 322     CD3DX12_HEAP_DESC(
 323         UINT64 size,
 324         D3D12_HEAP_PROPERTIES properties,
 325         UINT64 alignment = 0,
 326         D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE )
 327     {
 328         SizeInBytes = size;
 329         Properties = properties;
 330         Alignment = alignment;
 331         Flags = flags;
 332     }
 333     CD3DX12_HEAP_DESC(
 334         UINT64 size,
 335         D3D12_HEAP_TYPE type,
 336         UINT64 alignment = 0,
 337         D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE )
 338     {
 339         SizeInBytes = size;
 340         Properties = CD3DX12_HEAP_PROPERTIES( type );
 341         Alignment = alignment;
 342         Flags = flags;
 343     }
 344     CD3DX12_HEAP_DESC(
 345         UINT64 size,
 346         D3D12_CPU_PAGE_PROPERTY cpuPageProperty,
 347         D3D12_MEMORY_POOL memoryPoolPreference,
 348         UINT64 alignment = 0,
 349         D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE )
 350     {
 351         SizeInBytes = size;
 352         Properties = CD3DX12_HEAP_PROPERTIES( cpuPageProperty, memoryPoolPreference );
 353         Alignment = alignment;
 354         Flags = flags;
 355     }
 356     CD3DX12_HEAP_DESC(
 357         const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
 358         D3D12_HEAP_PROPERTIES properties,
 359         D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE )
 360     {
 361         SizeInBytes = resAllocInfo.SizeInBytes;
 362         Properties = properties;
 363         Alignment = resAllocInfo.Alignment;
 364         Flags = flags;
 365     }
 366     CD3DX12_HEAP_DESC(
 367         const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
 368         D3D12_HEAP_TYPE type,
 369         D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE )
 370     {
 371         SizeInBytes = resAllocInfo.SizeInBytes;
 372         Properties = CD3DX12_HEAP_PROPERTIES( type );
 373         Alignment = resAllocInfo.Alignment;
 374         Flags = flags;
 375     }
 376     CD3DX12_HEAP_DESC(
 377         const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
 378         D3D12_CPU_PAGE_PROPERTY cpuPageProperty,
 379         D3D12_MEMORY_POOL memoryPoolPreference,
 380         D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE )
 381     {
 382         SizeInBytes = resAllocInfo.SizeInBytes;
 383         Properties = CD3DX12_HEAP_PROPERTIES( cpuPageProperty, memoryPoolPreference );
 384         Alignment = resAllocInfo.Alignment;
 385         Flags = flags;
 386     }
 387     operator const D3D12_HEAP_DESC&() const { return *this; }
 388     bool IsCPUAccessible() const
 389     { return static_cast< const CD3DX12_HEAP_PROPERTIES* >( &Properties )->IsCPUAccessible(); }
 390 };
 391 inline bool operator==( const D3D12_HEAP_DESC& l, const D3D12_HEAP_DESC& r )
 392 {
 393     return l.SizeInBytes == r.SizeInBytes &&
 394         l.Properties == r.Properties &&
 395         l.Alignment == r.Alignment &&
 396         l.Flags == r.Flags;
 397 }
 398 inline bool operator!=( const D3D12_HEAP_DESC& l, const D3D12_HEAP_DESC& r )
 399 { return !( l == r ); }
 400
 401 //------------------------------------------------------------------------------------------------
 402 struct CD3DX12_CLEAR_VALUE : public D3D12_CLEAR_VALUE
 403 {
 404     CD3DX12_CLEAR_VALUE()
 405     {}
 406     explicit CD3DX12_CLEAR_VALUE(const D3D12_CLEAR_VALUE &o) :
 407         D3D12_CLEAR_VALUE(o)
 408     {}
 409     CD3DX12_CLEAR_VALUE(
 410         DXGI_FORMAT format,
 411         const FLOAT color[4] )
 412     {
 413         Format = format;
 414         memcpy( Color, color, sizeof( Color ) );
 415     }
 416     CD3DX12_CLEAR_VALUE(
 417         DXGI_FORMAT format,
 418         FLOAT depth,
 419         UINT8 stencil )
 420     {
 421         Format = format;
 422         /* Use memcpy to preserve NAN values */
 423         memcpy( &DepthStencil.Depth, &depth, sizeof( depth ) );
 424         DepthStencil.Stencil = stencil;
 425     }
 426     operator const D3D12_CLEAR_VALUE&() const { return *this; }
 427 };
 428
 429 //------------------------------------------------------------------------------------------------
 430 struct CD3DX12_RANGE : public D3D12_RANGE
 431 {
 432     CD3DX12_RANGE()
 433     {}
 434     explicit CD3DX12_RANGE(const D3D12_RANGE &o) :
 435         D3D12_RANGE(o)
 436     {}
 437     CD3DX12_RANGE(
 438         SIZE_T begin,
 439         SIZE_T end )
 440     {
 441         Begin = begin;
 442         End = end;
 443     }
 444     operator const D3D12_RANGE&() const { return *this; }
 445 };
 446
 447 //------------------------------------------------------------------------------------------------
 448 struct CD3DX12_SHADER_BYTECODE : public D3D12_SHADER_BYTECODE
 449 {
 450     CD3DX12_SHADER_BYTECODE()
 451     {}
 452     explicit CD3DX12_SHADER_BYTECODE(const D3D12_SHADER_BYTECODE &o) :
 453         D3D12_SHADER_BYTECODE(o)
 454     {}
 455     CD3DX12_SHADER_BYTECODE(
 456         ID3DBlob* pShaderBlob )
 457     {
 458         pShaderBytecode = pShaderBlob->GetBufferPointer();
 459         BytecodeLength = pShaderBlob->GetBufferSize();
 460     }
 461     CD3DX12_SHADER_BYTECODE(
 462         void* _pShaderBytecode,
 463         SIZE_T bytecodeLength )
 464     {
 465         pShaderBytecode = _pShaderBytecode;
 466         BytecodeLength = bytecodeLength;
 467     }
 468     operator const D3D12_SHADER_BYTECODE&() const { return *this; }
 469 };
 470
 471 //------------------------------------------------------------------------------------------------
 472 struct CD3DX12_TILED_RESOURCE_COORDINATE : public D3D12_TILED_RESOURCE_COORDINATE
 473 {
 474     CD3DX12_TILED_RESOURCE_COORDINATE()
 475     {}
 476     explicit CD3DX12_TILED_RESOURCE_COORDINATE(const D3D12_TILED_RESOURCE_COORDINATE &o) :
 477         D3D12_TILED_RESOURCE_COORDINATE(o)
 478     {}
 479     CD3DX12_TILED_RESOURCE_COORDINATE(
 480         UINT x,
 481         UINT y,
 482         UINT z,
 483         UINT subresource )
 484     {
 485         X = x;
 486         Y = y;
 487         Z = z;
 488         Subresource = subresource;
 489     }
 490     operator const D3D12_TILED_RESOURCE_COORDINATE&() const { return *this; }
 491 };
 492
 493 //------------------------------------------------------------------------------------------------
 494 struct CD3DX12_TILE_REGION_SIZE : public D3D12_TILE_REGION_SIZE
 495 {
 496     CD3DX12_TILE_REGION_SIZE()
 497     {}
 498     explicit CD3DX12_TILE_REGION_SIZE(const D3D12_TILE_REGION_SIZE &o) :
 499         D3D12_TILE_REGION_SIZE(o)
 500     {}
 501     CD3DX12_TILE_REGION_SIZE(
 502         UINT numTiles,
 503         BOOL useBox,
 504         UINT width,
 505         UINT16 height,
 506         UINT16 depth )
 507     {
 508         NumTiles = numTiles;
 509         UseBox = useBox;
 510         Width = width;
 511         Height = height;
 512         Depth = depth;
 513     }
 514     operator const D3D12_TILE_REGION_SIZE&() const { return *this; }
 515 };
 516
 517 //------------------------------------------------------------------------------------------------
 518 struct CD3DX12_SUBRESOURCE_TILING : public D3D12_SUBRESOURCE_TILING
 519 {
 520     CD3DX12_SUBRESOURCE_TILING()
 521     {}
 522     explicit CD3DX12_SUBRESOURCE_TILING(const D3D12_SUBRESOURCE_TILING &o) :
 523         D3D12_SUBRESOURCE_TILING(o)
 524     {}
 525     CD3DX12_SUBRESOURCE_TILING(
 526         UINT widthInTiles,
 527         UINT16 heightInTiles,
 528         UINT16 depthInTiles,
 529         UINT startTileIndexInOverallResource )
 530     {
 531         WidthInTiles = widthInTiles;
 532         HeightInTiles = heightInTiles;
 533         DepthInTiles = depthInTiles;
 534         StartTileIndexInOverallResource = startTileIndexInOverallResource;
 535     }
 536     operator const D3D12_SUBRESOURCE_TILING&() const { return *this; }
 537 };
 538
 539 //------------------------------------------------------------------------------------------------
 540 struct CD3DX12_TILE_SHAPE : public D3D12_TILE_SHAPE
 541 {
 542     CD3DX12_TILE_SHAPE()
 543     {}
 544     explicit CD3DX12_TILE_SHAPE(const D3D12_TILE_SHAPE &o) :
 545         D3D12_TILE_SHAPE(o)
 546     {}
 547     CD3DX12_TILE_SHAPE(
 548         UINT widthInTexels,
 549         UINT heightInTexels,
 550         UINT depthInTexels )
 551     {
 552         WidthInTexels = widthInTexels;
 553         HeightInTexels = heightInTexels;
 554         DepthInTexels = depthInTexels;
 555     }
 556     operator const D3D12_TILE_SHAPE&() const { return *this; }
 557 };
 558
 559 //------------------------------------------------------------------------------------------------
 560 struct CD3DX12_RESOURCE_BARRIER : public D3D12_RESOURCE_BARRIER
 561 {
 562     CD3DX12_RESOURCE_BARRIER()
 563     {}
 564     explicit CD3DX12_RESOURCE_BARRIER(const D3D12_RESOURCE_BARRIER &o) :
 565         D3D12_RESOURCE_BARRIER(o)
 566     {}
 567     static inline CD3DX12_RESOURCE_BARRIER Transition(
 568         _In_ ID3D12Resource* pResource,
 569         D3D12_RESOURCE_STATES stateBefore,
 570         D3D12_RESOURCE_STATES stateAfter,
 571         UINT subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES,
 572         D3D12_RESOURCE_BARRIER_FLAGS flags = D3D12_RESOURCE_BARRIER_FLAG_NONE)
 573     {
 574         CD3DX12_RESOURCE_BARRIER result;
 575         ZeroMemory(&result, sizeof(result));
 576         D3D12_RESOURCE_BARRIER &barrier = result;
 577         result.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
 578         result.Flags = flags;
 579         barrier.Transition.pResource = pResource;
 580         barrier.Transition.StateBefore = stateBefore;
 581         barrier.Transition.StateAfter = stateAfter;
 582         barrier.Transition.Subresource = subresource;
 583         return result;
 584     }
 585     static inline CD3DX12_RESOURCE_BARRIER Aliasing(
 586         _In_ ID3D12Resource* pResourceBefore,
 587         _In_ ID3D12Resource* pResourceAfter)
 588     {
 589         CD3DX12_RESOURCE_BARRIER result;
 590         ZeroMemory(&result, sizeof(result));
 591         D3D12_RESOURCE_BARRIER &barrier = result;
 592         result.Type = D3D12_RESOURCE_BARRIER_TYPE_ALIASING;
 593         barrier.Aliasing.pResourceBefore = pResourceBefore;
 594         barrier.Aliasing.pResourceAfter = pResourceAfter;
 595         return result;
 596     }
 597     static inline CD3DX12_RESOURCE_BARRIER UAV(
 598         _In_ ID3D12Resource* pResource)
 599     {
 600         CD3DX12_RESOURCE_BARRIER result;
 601         ZeroMemory(&result, sizeof(result));
 602         D3D12_RESOURCE_BARRIER &barrier = result;
 603         result.Type = D3D12_RESOURCE_BARRIER_TYPE_UAV;
 604         barrier.UAV.pResource = pResource;
 605         return result;
 606     }
 607     operator const D3D12_RESOURCE_BARRIER&() const { return *this; }
 608 };
 609
 610 //------------------------------------------------------------------------------------------------
 611 struct CD3DX12_PACKED_MIP_INFO : public D3D12_PACKED_MIP_INFO
 612 {
 613     CD3DX12_PACKED_MIP_INFO()
 614     {}
 615     explicit CD3DX12_PACKED_MIP_INFO(const D3D12_PACKED_MIP_INFO &o) :
 616         D3D12_PACKED_MIP_INFO(o)
 617     {}
 618     CD3DX12_PACKED_MIP_INFO(
 619         UINT8 numStandardMips,
 620         UINT8 numPackedMips,
 621         UINT numTilesForPackedMips,
 622         UINT startTileIndexInOverallResource )
 623     {
 624         NumStandardMips = numStandardMips;
 625         NumPackedMips = numPackedMips;
 626         NumTilesForPackedMips = numTilesForPackedMips;
 627         StartTileIndexInOverallResource = startTileIndexInOverallResource;
 628     }
 629     operator const D3D12_PACKED_MIP_INFO&() const { return *this; }
 630 };
 631
 632 //------------------------------------------------------------------------------------------------
 633 struct CD3DX12_SUBRESOURCE_FOOTPRINT : public D3D12_SUBRESOURCE_FOOTPRINT
 634 {
 635     CD3DX12_SUBRESOURCE_FOOTPRINT()
 636     {}
 637     explicit CD3DX12_SUBRESOURCE_FOOTPRINT(const D3D12_SUBRESOURCE_FOOTPRINT &o) :
 638         D3D12_SUBRESOURCE_FOOTPRINT(o)
 639     {}
 640     CD3DX12_SUBRESOURCE_FOOTPRINT(
 641         DXGI_FORMAT format,
 642         UINT width,
 643         UINT height,
 644         UINT depth,
 645         UINT rowPitch )
 646     {
 647         Format = format;
 648         Width = width;
 649         Height = height;
 650         Depth = depth;
 651         RowPitch = rowPitch;
 652     }
 653     explicit CD3DX12_SUBRESOURCE_FOOTPRINT(
 654         const D3D12_RESOURCE_DESC& resDesc,
 655         UINT rowPitch )
 656     {
 657         Format = resDesc.Format;
 658         Width = UINT( resDesc.Width );
 659         Height = resDesc.Height;
 660         Depth = (resDesc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? resDesc.DepthOrArraySize : 1);
 661         RowPitch = rowPitch;
 662     }
 663     operator const D3D12_SUBRESOURCE_FOOTPRINT&() const { return *this; }
 664 };
 665
 666 //------------------------------------------------------------------------------------------------
 667 struct CD3DX12_TEXTURE_COPY_LOCATION : public D3D12_TEXTURE_COPY_LOCATION
 668 {
 669     CD3DX12_TEXTURE_COPY_LOCATION()
 670     {}
 671     explicit CD3DX12_TEXTURE_COPY_LOCATION(const D3D12_TEXTURE_COPY_LOCATION &o) :
 672         D3D12_TEXTURE_COPY_LOCATION(o)
 673     {}
 674     CD3DX12_TEXTURE_COPY_LOCATION(ID3D12Resource* pRes) { pResource = pRes; }
 675     CD3DX12_TEXTURE_COPY_LOCATION(ID3D12Resource* pRes, D3D12_PLACED_SUBRESOURCE_FOOTPRINT const& Footprint)
 676     {
 677         pResource = pRes;
 678         Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
 679         PlacedFootprint = Footprint;
 680     }
 681     CD3DX12_TEXTURE_COPY_LOCATION(ID3D12Resource* pRes, UINT Sub)
 682     {
 683         pResource = pRes;
 684         Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
 685         SubresourceIndex = Sub;
 686     }
 687 };
 688
 689 //------------------------------------------------------------------------------------------------
 690 struct CD3DX12_DESCRIPTOR_RANGE : public D3D12_DESCRIPTOR_RANGE
 691 {
 692     CD3DX12_DESCRIPTOR_RANGE() { }
 693     explicit CD3DX12_DESCRIPTOR_RANGE(const D3D12_DESCRIPTOR_RANGE &o) :
 694         D3D12_DESCRIPTOR_RANGE(o)
 695     {}
 696     CD3DX12_DESCRIPTOR_RANGE(
 697         D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
 698         UINT numDescriptors,
 699         UINT baseShaderRegister,
 700         UINT registerSpace = 0,
 701         UINT offsetInDescriptorsFromTableStart =
 702         D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND)
 703     {
 704         Init(rangeType, numDescriptors, baseShaderRegister, registerSpace, offsetInDescriptorsFromTableStart);
 705     }
 706
 707     inline void Init(
 708         D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
 709         UINT numDescriptors,
 710         UINT baseShaderRegister,
 711         UINT registerSpace = 0,
 712         UINT offsetInDescriptorsFromTableStart =
 713         D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND)
 714     {
 715         Init(*this, rangeType, numDescriptors, baseShaderRegister, registerSpace, offsetInDescriptorsFromTableStart);
 716     }
 717
 718     static inline void Init(
 719         _Out_ D3D12_DESCRIPTOR_RANGE &range,
 720         D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
 721         UINT numDescriptors,
 722         UINT baseShaderRegister,
 723         UINT registerSpace = 0,
 724         UINT offsetInDescriptorsFromTableStart =
 725         D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND)
 726     {
 727         range.RangeType = rangeType;
 728         range.NumDescriptors = numDescriptors;
 729         range.BaseShaderRegister = baseShaderRegister;
 730         range.RegisterSpace = registerSpace;
 731         range.OffsetInDescriptorsFromTableStart = offsetInDescriptorsFromTableStart;
 732     }
 733 };
 734
 735 //------------------------------------------------------------------------------------------------
 736 struct CD3DX12_ROOT_DESCRIPTOR_TABLE : public D3D12_ROOT_DESCRIPTOR_TABLE
 737 {
 738     CD3DX12_ROOT_DESCRIPTOR_TABLE() {}
 739     explicit CD3DX12_ROOT_DESCRIPTOR_TABLE(const D3D12_ROOT_DESCRIPTOR_TABLE &o) :
 740         D3D12_ROOT_DESCRIPTOR_TABLE(o)
 741     {}
 742     CD3DX12_ROOT_DESCRIPTOR_TABLE(
 743         UINT numDescriptorRanges,
 744         _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges)
 745     {
 746         Init(numDescriptorRanges, _pDescriptorRanges);
 747     }
 748
 749     inline void Init(
 750         UINT numDescriptorRanges,
 751         _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges)
 752     {
 753         Init(*this, numDescriptorRanges, _pDescriptorRanges);
 754     }
 755
 756     static inline void Init(
 757         _Out_ D3D12_ROOT_DESCRIPTOR_TABLE &rootDescriptorTable,
 758         UINT numDescriptorRanges,
 759         _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges)
 760     {
 761         rootDescriptorTable.NumDescriptorRanges = numDescriptorRanges;
 762         rootDescriptorTable.pDescriptorRanges = _pDescriptorRanges;
 763     }
 764 };
 765
 766 //------------------------------------------------------------------------------------------------
 767 struct CD3DX12_ROOT_CONSTANTS : public D3D12_ROOT_CONSTANTS
 768 {
 769     CD3DX12_ROOT_CONSTANTS() {}
 770     explicit CD3DX12_ROOT_CONSTANTS(const D3D12_ROOT_CONSTANTS &o) :
 771         D3D12_ROOT_CONSTANTS(o)
 772     {}
 773     CD3DX12_ROOT_CONSTANTS(
 774         UINT num32BitValues,
 775         UINT shaderRegister,
 776         UINT registerSpace = 0)
 777     {
 778         Init(num32BitValues, shaderRegister, registerSpace);
 779     }
 780
 781     inline void Init(
 782         UINT num32BitValues,
 783         UINT shaderRegister,
 784         UINT registerSpace = 0)
 785     {
 786         Init(*this, num32BitValues, shaderRegister, registerSpace);
 787     }
 788
 789     static inline void Init(
 790         _Out_ D3D12_ROOT_CONSTANTS &rootConstants,
 791         UINT num32BitValues,
 792         UINT shaderRegister,
 793         UINT registerSpace = 0)
 794     {
 795         rootConstants.Num32BitValues = num32BitValues;
 796         rootConstants.ShaderRegister = shaderRegister;
 797         rootConstants.RegisterSpace = registerSpace;
 798     }
 799 };
 800
 801 //------------------------------------------------------------------------------------------------
 802 struct CD3DX12_ROOT_DESCRIPTOR : public D3D12_ROOT_DESCRIPTOR
 803 {
 804     CD3DX12_ROOT_DESCRIPTOR() {}
 805     explicit CD3DX12_ROOT_DESCRIPTOR(const D3D12_ROOT_DESCRIPTOR &o) :
 806         D3D12_ROOT_DESCRIPTOR(o)
 807     {}
 808     CD3DX12_ROOT_DESCRIPTOR(
 809         UINT shaderRegister,
 810         UINT registerSpace = 0)
 811     {
 812         Init(shaderRegister, registerSpace);
 813     }
 814
 815     inline void Init(
 816         UINT shaderRegister,
 817         UINT registerSpace = 0)
 818     {
 819         Init(*this, shaderRegister, registerSpace);
 820     }
 821
 822     static inline void Init(_Out_ D3D12_ROOT_DESCRIPTOR &table, UINT shaderRegister, UINT registerSpace = 0)
 823     {
 824         table.ShaderRegister = shaderRegister;
 825         table.RegisterSpace = registerSpace;
 826     }
 827 };
 828
 829 //------------------------------------------------------------------------------------------------
 830 struct CD3DX12_ROOT_PARAMETER : public D3D12_ROOT_PARAMETER
 831 {
 832     CD3DX12_ROOT_PARAMETER() {}
 833     explicit CD3DX12_ROOT_PARAMETER(const D3D12_ROOT_PARAMETER &o) :
 834         D3D12_ROOT_PARAMETER(o)
 835     {}
 836
 837     static inline void InitAsDescriptorTable(
 838         _Out_ D3D12_ROOT_PARAMETER &rootParam,
 839         UINT numDescriptorRanges,
 840         _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* pDescriptorRanges,
 841         D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
 842     {
 843         rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
 844         rootParam.ShaderVisibility = visibility;
 845         CD3DX12_ROOT_DESCRIPTOR_TABLE::Init(rootParam.DescriptorTable, numDescriptorRanges, pDescriptorRanges);
 846     }
 847
 848     static inline void InitAsConstants(
 849         _Out_ D3D12_ROOT_PARAMETER &rootParam,
 850         UINT num32BitValues,
 851         UINT shaderRegister,
 852         UINT registerSpace = 0,
 853         D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
 854     {
 855         rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS;
 856         rootParam.ShaderVisibility = visibility;
 857         CD3DX12_ROOT_CONSTANTS::Init(rootParam.Constants, num32BitValues, shaderRegister, registerSpace);
 858     }
 859
 860     static inline void InitAsConstantBufferView(
 861         _Out_ D3D12_ROOT_PARAMETER &rootParam,
 862         UINT shaderRegister,
 863         UINT registerSpace = 0,
 864         D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
 865     {
 866         rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
 867         rootParam.ShaderVisibility = visibility;
 868         CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister, registerSpace);
 869     }
 870
 871     static inline void InitAsShaderResourceView(
 872         _Out_ D3D12_ROOT_PARAMETER &rootParam,
 873         UINT shaderRegister,
 874         UINT registerSpace = 0,
 875         D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
 876     {
 877         rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_SRV;
 878         rootParam.ShaderVisibility = visibility;
 879         CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister, registerSpace);
 880     }
 881
 882     static inline void InitAsUnorderedAccessView(
 883         _Out_ D3D12_ROOT_PARAMETER &rootParam,
 884         UINT shaderRegister,
 885         UINT registerSpace = 0,
 886         D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
 887     {
 888         rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_UAV;
 889         rootParam.ShaderVisibility = visibility;
 890         CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister, registerSpace);
 891     }
 892
 893     inline void InitAsDescriptorTable(
 894         UINT numDescriptorRanges,
 895         _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* pDescriptorRanges,
 896         D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
 897     {
 898         InitAsDescriptorTable(*this, numDescriptorRanges, pDescriptorRanges, visibility);
 899     }
 900
 901     inline void InitAsConstants(
 902         UINT num32BitValues,
 903         UINT shaderRegister,
 904         UINT registerSpace = 0,
 905         D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
 906     {
 907         InitAsConstants(*this, num32BitValues, shaderRegister, registerSpace, visibility);
 908     }
 909
 910     inline void InitAsConstantBufferView(
 911         UINT shaderRegister,
 912         UINT registerSpace = 0,
 913         D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
 914     {
 915         InitAsConstantBufferView(*this, shaderRegister, registerSpace, visibility);
 916     }
 917
 918     inline void InitAsShaderResourceView(
 919         UINT shaderRegister,
 920         UINT registerSpace = 0,
 921         D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
 922     {
 923         InitAsShaderResourceView(*this, shaderRegister, registerSpace, visibility);
 924     }
 925
 926     inline void InitAsUnorderedAccessView(
 927         UINT shaderRegister,
 928         UINT registerSpace = 0,
 929         D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
 930     {
 931         InitAsUnorderedAccessView(*this, shaderRegister, registerSpace, visibility);
 932     }
 933 };
 934
 935 //------------------------------------------------------------------------------------------------
 936 struct CD3DX12_STATIC_SAMPLER_DESC : public D3D12_STATIC_SAMPLER_DESC
 937 {
 938     CD3DX12_STATIC_SAMPLER_DESC() {}
 939     explicit CD3DX12_STATIC_SAMPLER_DESC(const D3D12_STATIC_SAMPLER_DESC &o) :
 940         D3D12_STATIC_SAMPLER_DESC(o)
 941     {}
 942     CD3DX12_STATIC_SAMPLER_DESC(
 943          UINT shaderRegister,
 944          D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC,
 945          D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
 946          D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
 947          D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
 948          FLOAT mipLODBias = 0,
 949          UINT maxAnisotropy = 16,
 950          D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL,
 951          D3D12_STATIC_BORDER_COLOR borderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE,
 952          FLOAT minLOD = 0.f,
 953          FLOAT maxLOD = D3D12_FLOAT32_MAX,
 954          D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL,
 955          UINT registerSpace = 0)
 956     {
 957         Init(
 958             shaderRegister,
 959             filter,
 960             addressU,
 961             addressV,
 962             addressW,
 963             mipLODBias,
 964             maxAnisotropy,
 965             comparisonFunc,
 966             borderColor,
 967             minLOD,
 968             maxLOD,
 969             shaderVisibility,
 970             registerSpace);
 971     }
 972
 973     static inline void Init(
 974         _Out_ D3D12_STATIC_SAMPLER_DESC &samplerDesc,
 975          UINT shaderRegister,
 976          D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC,
 977          D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
 978          D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
 979          D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
 980          FLOAT mipLODBias = 0,
 981          UINT maxAnisotropy = 16,
 982          D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL,
 983          D3D12_STATIC_BORDER_COLOR borderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE,
 984          FLOAT minLOD = 0.f,
 985          FLOAT maxLOD = D3D12_FLOAT32_MAX,
 986          D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL,
 987          UINT registerSpace = 0)
 988     {
 989         samplerDesc.ShaderRegister = shaderRegister;
 990         samplerDesc.Filter = filter;
 991         samplerDesc.AddressU = addressU;
 992         samplerDesc.AddressV = addressV;
 993         samplerDesc.AddressW = addressW;
 994         samplerDesc.MipLODBias = mipLODBias;
 995         samplerDesc.MaxAnisotropy = maxAnisotropy;
 996         samplerDesc.ComparisonFunc = comparisonFunc;
 997         samplerDesc.BorderColor = borderColor;
 998         samplerDesc.MinLOD = minLOD;
 999         samplerDesc.MaxLOD = maxLOD;
1000         samplerDesc.ShaderVisibility = shaderVisibility;
1001         samplerDesc.RegisterSpace = registerSpace;
1002     }
1003     inline void Init(
1004          UINT shaderRegister,
1005          D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC,
1006          D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
1007          D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
1008          D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
1009          FLOAT mipLODBias = 0,
1010          UINT maxAnisotropy = 16,
1011          D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL,
1012          D3D12_STATIC_BORDER_COLOR borderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE,
1013          FLOAT minLOD = 0.f,
1014          FLOAT maxLOD = D3D12_FLOAT32_MAX,
1015          D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL,
1016          UINT registerSpace = 0)
1017     {
1018         Init(
1019             *this,
1020             shaderRegister,
1021             filter,
1022             addressU,
1023             addressV,
1024             addressW,
1025             mipLODBias,
1026             maxAnisotropy,
1027             comparisonFunc,
1028             borderColor,
1029             minLOD,
1030             maxLOD,
1031             shaderVisibility,
1032             registerSpace);
1033     }
1034
1035 };
1036
1037 //------------------------------------------------------------------------------------------------
1038 struct CD3DX12_ROOT_SIGNATURE_DESC : public D3D12_ROOT_SIGNATURE_DESC
1039 {
1040     CD3DX12_ROOT_SIGNATURE_DESC() {}
1041     explicit CD3DX12_ROOT_SIGNATURE_DESC(const D3D12_ROOT_SIGNATURE_DESC &o) :
1042         D3D12_ROOT_SIGNATURE_DESC(o)
1043     {}
1044     CD3DX12_ROOT_SIGNATURE_DESC(
1045         UINT numParameters,
1046         _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
1047         UINT numStaticSamplers = 0,
1048         _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = NULL,
1049         D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE)
1050     {
1051         Init(numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
1052     }
1053     CD3DX12_ROOT_SIGNATURE_DESC(CD3DX12_DEFAULT)
1054     {
1055         Init(0, NULL, 0, NULL, D3D12_ROOT_SIGNATURE_FLAG_NONE);
1056     }
1057
1058     inline void Init(
1059         UINT numParameters,
1060         _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
1061         UINT numStaticSamplers = 0,
1062         _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = NULL,
1063         D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE)
1064     {
1065         Init(*this, numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
1066     }
1067
1068     static inline void Init(
1069         _Out_ D3D12_ROOT_SIGNATURE_DESC &desc,
1070         UINT numParameters,
1071         _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
1072         UINT numStaticSamplers = 0,
1073         _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = NULL,
1074         D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE)
1075     {
1076         desc.NumParameters = numParameters;
1077         desc.pParameters = _pParameters;
1078         desc.NumStaticSamplers = numStaticSamplers;
1079         desc.pStaticSamplers = _pStaticSamplers;
1080         desc.Flags = flags;
1081     }
1082 };
1083
1084 //------------------------------------------------------------------------------------------------
1085 struct CD3DX12_DESCRIPTOR_RANGE1 : public D3D12_DESCRIPTOR_RANGE1
1086 {
1087     CD3DX12_DESCRIPTOR_RANGE1() { }
1088     explicit CD3DX12_DESCRIPTOR_RANGE1(const D3D12_DESCRIPTOR_RANGE1 &o) :
1089         D3D12_DESCRIPTOR_RANGE1(o)
1090     {}
1091     CD3DX12_DESCRIPTOR_RANGE1(
1092         D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
1093         UINT numDescriptors,
1094         UINT baseShaderRegister,
1095         UINT registerSpace = 0,
1096         D3D12_DESCRIPTOR_RANGE_FLAGS flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE,
1097         UINT offsetInDescriptorsFromTableStart =
1098         D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND)
1099     {
1100         Init(rangeType, numDescriptors, baseShaderRegister, registerSpace, flags, offsetInDescriptorsFromTableStart);
1101     }
1102
1103     inline void Init(
1104         D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
1105         UINT numDescriptors,
1106         UINT baseShaderRegister,
1107         UINT registerSpace = 0,
1108         D3D12_DESCRIPTOR_RANGE_FLAGS flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE,
1109         UINT offsetInDescriptorsFromTableStart =
1110         D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND)
1111     {
1112         Init(*this, rangeType, numDescriptors, baseShaderRegister, registerSpace, flags, offsetInDescriptorsFromTableStart);
1113     }
1114
1115     static inline void Init(
1116         _Out_ D3D12_DESCRIPTOR_RANGE1 &range,
1117         D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
1118         UINT numDescriptors,
1119         UINT baseShaderRegister,
1120         UINT registerSpace = 0,
1121         D3D12_DESCRIPTOR_RANGE_FLAGS flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE,
1122         UINT offsetInDescriptorsFromTableStart =
1123         D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND)
1124     {
1125         range.RangeType = rangeType;
1126         range.NumDescriptors = numDescriptors;
1127         range.BaseShaderRegister = baseShaderRegister;
1128         range.RegisterSpace = registerSpace;
1129         range.Flags = flags;
1130         range.OffsetInDescriptorsFromTableStart = offsetInDescriptorsFromTableStart;
1131     }
1132 };
1133
1134 //------------------------------------------------------------------------------------------------
1135 struct CD3DX12_ROOT_DESCRIPTOR_TABLE1 : public D3D12_ROOT_DESCRIPTOR_TABLE1
1136 {
1137     CD3DX12_ROOT_DESCRIPTOR_TABLE1() {}
1138     explicit CD3DX12_ROOT_DESCRIPTOR_TABLE1(const D3D12_ROOT_DESCRIPTOR_TABLE1 &o) :
1139         D3D12_ROOT_DESCRIPTOR_TABLE1(o)
1140     {}
1141     CD3DX12_ROOT_DESCRIPTOR_TABLE1(
1142         UINT numDescriptorRanges,
1143         _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* _pDescriptorRanges)
1144     {
1145         Init(numDescriptorRanges, _pDescriptorRanges);
1146     }
1147
1148     inline void Init(
1149         UINT numDescriptorRanges,
1150         _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* _pDescriptorRanges)
1151     {
1152         Init(*this, numDescriptorRanges, _pDescriptorRanges);
1153     }
1154
1155     static inline void Init(
1156         _Out_ D3D12_ROOT_DESCRIPTOR_TABLE1 &rootDescriptorTable,
1157         UINT numDescriptorRanges,
1158         _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* _pDescriptorRanges)
1159     {
1160         rootDescriptorTable.NumDescriptorRanges = numDescriptorRanges;
1161         rootDescriptorTable.pDescriptorRanges = _pDescriptorRanges;
1162     }
1163 };
1164
1165 //------------------------------------------------------------------------------------------------
1166 struct CD3DX12_ROOT_DESCRIPTOR1 : public D3D12_ROOT_DESCRIPTOR1
1167 {
1168     CD3DX12_ROOT_DESCRIPTOR1() {}
1169     explicit CD3DX12_ROOT_DESCRIPTOR1(const D3D12_ROOT_DESCRIPTOR1 &o) :
1170         D3D12_ROOT_DESCRIPTOR1(o)
1171     {}
1172     CD3DX12_ROOT_DESCRIPTOR1(
1173         UINT shaderRegister,
1174         UINT registerSpace = 0,
1175         D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE)
1176     {
1177         Init(shaderRegister, registerSpace, flags);
1178     }
1179
1180     inline void Init(
1181         UINT shaderRegister,
1182         UINT registerSpace = 0,
1183         D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE)
1184     {
1185         Init(*this, shaderRegister, registerSpace, flags);
1186     }
1187
1188     static inline void Init(
1189         _Out_ D3D12_ROOT_DESCRIPTOR1 &table,
1190         UINT shaderRegister,
1191         UINT registerSpace = 0,
1192         D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE)
1193     {
1194         table.ShaderRegister = shaderRegister;
1195         table.RegisterSpace = registerSpace;
1196         table.Flags = flags;
1197     }
1198 };
1199
1200 //------------------------------------------------------------------------------------------------
1201 struct CD3DX12_ROOT_PARAMETER1 : public D3D12_ROOT_PARAMETER1
1202 {
1203     CD3DX12_ROOT_PARAMETER1() {}
1204     explicit CD3DX12_ROOT_PARAMETER1(const D3D12_ROOT_PARAMETER1 &o) :
1205         D3D12_ROOT_PARAMETER1(o)
1206     {}
1207
1208     static inline void InitAsDescriptorTable(
1209         _Out_ D3D12_ROOT_PARAMETER1 &rootParam,
1210         UINT numDescriptorRanges,
1211         _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* pDescriptorRanges,
1212         D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
1213     {
1214         rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
1215         rootParam.ShaderVisibility = visibility;
1216         CD3DX12_ROOT_DESCRIPTOR_TABLE1::Init(rootParam.DescriptorTable, numDescriptorRanges, pDescriptorRanges);
1217     }
1218
1219     static inline void InitAsConstants(
1220         _Out_ D3D12_ROOT_PARAMETER1 &rootParam,
1221         UINT num32BitValues,
1222         UINT shaderRegister,
1223         UINT registerSpace = 0,
1224         D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
1225     {
1226         rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS;
1227         rootParam.ShaderVisibility = visibility;
1228         CD3DX12_ROOT_CONSTANTS::Init(rootParam.Constants, num32BitValues, shaderRegister, registerSpace);
1229     }
1230
1231     static inline void InitAsConstantBufferView(
1232         _Out_ D3D12_ROOT_PARAMETER1 &rootParam,
1233         UINT shaderRegister,
1234         UINT registerSpace = 0,
1235         D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
1236         D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
1237     {
1238         rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
1239         rootParam.ShaderVisibility = visibility;
1240         CD3DX12_ROOT_DESCRIPTOR1::Init(rootParam.Descriptor, shaderRegister, registerSpace, flags);
1241     }
1242
1243     static inline void InitAsShaderResourceView(
1244         _Out_ D3D12_ROOT_PARAMETER1 &rootParam,
1245         UINT shaderRegister,
1246         UINT registerSpace = 0,
1247         D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
1248         D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
1249     {
1250         rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_SRV;
1251         rootParam.ShaderVisibility = visibility;
1252         CD3DX12_ROOT_DESCRIPTOR1::Init(rootParam.Descriptor, shaderRegister, registerSpace, flags);
1253     }
1254
1255     static inline void InitAsUnorderedAccessView(
1256         _Out_ D3D12_ROOT_PARAMETER1 &rootParam,
1257         UINT shaderRegister,
1258         UINT registerSpace = 0,
1259         D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
1260         D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
1261     {
1262         rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_UAV;
1263         rootParam.ShaderVisibility = visibility;
1264         CD3DX12_ROOT_DESCRIPTOR1::Init(rootParam.Descriptor, shaderRegister, registerSpace, flags);
1265     }
1266
1267     inline void InitAsDescriptorTable(
1268         UINT numDescriptorRanges,
1269         _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* pDescriptorRanges,
1270         D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
1271     {
1272         InitAsDescriptorTable(*this, numDescriptorRanges, pDescriptorRanges, visibility);
1273     }
1274
1275     inline void InitAsConstants(
1276         UINT num32BitValues,
1277         UINT shaderRegister,
1278         UINT registerSpace = 0,
1279         D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
1280     {
1281         InitAsConstants(*this, num32BitValues, shaderRegister, registerSpace, visibility);
1282     }
1283
1284     inline void InitAsConstantBufferView(
1285         UINT shaderRegister,
1286         UINT registerSpace = 0,
1287         D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
1288         D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
1289     {
1290         InitAsConstantBufferView(*this, shaderRegister, registerSpace, flags, visibility);
1291     }
1292
1293     inline void InitAsShaderResourceView(
1294         UINT shaderRegister,
1295         UINT registerSpace = 0,
1296         D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
1297         D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
1298     {
1299         InitAsShaderResourceView(*this, shaderRegister, registerSpace, flags, visibility);
1300     }
1301
1302     inline void InitAsUnorderedAccessView(
1303         UINT shaderRegister,
1304         UINT registerSpace = 0,
1305         D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
1306         D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
1307     {
1308         InitAsUnorderedAccessView(*this, shaderRegister, registerSpace, flags, visibility);
1309     }
1310 };
1311
1312 //------------------------------------------------------------------------------------------------
1313 struct CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC : public D3D12_VERSIONED_ROOT_SIGNATURE_DESC
1314 {
1315     CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC() {}
1316     explicit CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC &o) :
1317         D3D12_VERSIONED_ROOT_SIGNATURE_DESC(o)
1318     {}
1319     explicit CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(const D3D12_ROOT_SIGNATURE_DESC &o)
1320     {
1321         Version = D3D_ROOT_SIGNATURE_VERSION_1_0;
1322         Desc_1_0 = o;
1323     }
1324     explicit CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(const D3D12_ROOT_SIGNATURE_DESC1 &o)
1325     {
1326         Version = D3D_ROOT_SIGNATURE_VERSION_1_1;
1327         Desc_1_1 = o;
1328     }
1329     CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(
1330         UINT numParameters,
1331         _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
1332         UINT numStaticSamplers = 0,
1333         _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = NULL,
1334         D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE)
1335     {
1336         Init_1_0(numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
1337     }
1338     CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(
1339         UINT numParameters,
1340         _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER1* _pParameters,
1341         UINT numStaticSamplers = 0,
1342         _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = NULL,
1343         D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE)
1344     {
1345         Init_1_1(numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
1346     }
1347     CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(CD3DX12_DEFAULT)
1348     {
1349         Init_1_1(0, NULL, 0, NULL, D3D12_ROOT_SIGNATURE_FLAG_NONE);
1350     }
1351
1352     inline void Init_1_0(
1353         UINT numParameters,
1354         _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
1355         UINT numStaticSamplers = 0,
1356         _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = NULL,
1357         D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE)
1358     {
1359         Init_1_0(*this, numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
1360     }
1361
1362     static inline void Init_1_0(
1363         _Out_ D3D12_VERSIONED_ROOT_SIGNATURE_DESC &desc,
1364         UINT numParameters,
1365         _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
1366         UINT numStaticSamplers = 0,
1367         _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = NULL,
1368         D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE)
1369     {
1370         desc.Version = D3D_ROOT_SIGNATURE_VERSION_1_0;
1371         desc.Desc_1_0.NumParameters = numParameters;
1372         desc.Desc_1_0.pParameters = _pParameters;
1373         desc.Desc_1_0.NumStaticSamplers = numStaticSamplers;
1374         desc.Desc_1_0.pStaticSamplers = _pStaticSamplers;
1375         desc.Desc_1_0.Flags = flags;
1376     }
1377
1378     inline void Init_1_1(
1379         UINT numParameters,
1380         _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER1* _pParameters,
1381         UINT numStaticSamplers = 0,
1382         _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = NULL,
1383         D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE)
1384     {
1385         Init_1_1(*this, numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
1386     }
1387
1388     static inline void Init_1_1(
1389         _Out_ D3D12_VERSIONED_ROOT_SIGNATURE_DESC &desc,
1390         UINT numParameters,
1391         _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER1* _pParameters,
1392         UINT numStaticSamplers = 0,
1393         _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = NULL,
1394         D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE)
1395     {
1396         desc.Version = D3D_ROOT_SIGNATURE_VERSION_1_1;
1397         desc.Desc_1_1.NumParameters = numParameters;
1398         desc.Desc_1_1.pParameters = _pParameters;
1399         desc.Desc_1_1.NumStaticSamplers = numStaticSamplers;
1400         desc.Desc_1_1.pStaticSamplers = _pStaticSamplers;
1401         desc.Desc_1_1.Flags = flags;
1402     }
1403 };
1404
1405 //------------------------------------------------------------------------------------------------
1406 struct CD3DX12_CPU_DESCRIPTOR_HANDLE : public D3D12_CPU_DESCRIPTOR_HANDLE
1407 {
1408     CD3DX12_CPU_DESCRIPTOR_HANDLE() {}
1409     explicit CD3DX12_CPU_DESCRIPTOR_HANDLE(const D3D12_CPU_DESCRIPTOR_HANDLE &o) :
1410         D3D12_CPU_DESCRIPTOR_HANDLE(o)
1411     {}
1412     CD3DX12_CPU_DESCRIPTOR_HANDLE(CD3DX12_DEFAULT) { ptr = 0; }
1413     CD3DX12_CPU_DESCRIPTOR_HANDLE(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &other, INT offsetScaledByIncrementSize)
1414     {
1415         InitOffsetted(other, offsetScaledByIncrementSize);
1416     }
1417     CD3DX12_CPU_DESCRIPTOR_HANDLE(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &other, INT offsetInDescriptors, UINT descriptorIncrementSize)
1418     {
1419         InitOffsetted(other, offsetInDescriptors, descriptorIncrementSize);
1420     }
1421     CD3DX12_CPU_DESCRIPTOR_HANDLE& Offset(INT offsetInDescriptors, UINT descriptorIncrementSize)
1422     {
1423         ptr += offsetInDescriptors * descriptorIncrementSize;
1424         return *this;
1425     }
1426     CD3DX12_CPU_DESCRIPTOR_HANDLE& Offset(INT offsetScaledByIncrementSize)
1427     {
1428         ptr += offsetScaledByIncrementSize;
1429         return *this;
1430     }
1431     bool operator==(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE& other) const
1432     {
1433         return (ptr == other.ptr);
1434     }
1435     bool operator!=(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE& other) const
1436     {
1437         return (ptr != other.ptr);
1438     }
1439     CD3DX12_CPU_DESCRIPTOR_HANDLE &operator=(const D3D12_CPU_DESCRIPTOR_HANDLE &other)
1440     {
1441         ptr = other.ptr;
1442         return *this;
1443     }
1444
1445     inline void InitOffsetted(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize)
1446     {
1447         InitOffsetted(*this, base, offsetScaledByIncrementSize);
1448     }
1449
1450     inline void InitOffsetted(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize)
1451     {
1452         InitOffsetted(*this, base, offsetInDescriptors, descriptorIncrementSize);
1453     }
1454
1455     static inline void InitOffsetted(_Out_ D3D12_CPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize)
1456     {
1457         handle.ptr = base.ptr + offsetScaledByIncrementSize;
1458     }
1459
1460     static inline void InitOffsetted(_Out_ D3D12_CPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize)
1461     {
1462         handle.ptr = base.ptr + offsetInDescriptors * descriptorIncrementSize;
1463     }
1464 };
1465
1466 //------------------------------------------------------------------------------------------------
1467 struct CD3DX12_GPU_DESCRIPTOR_HANDLE : public D3D12_GPU_DESCRIPTOR_HANDLE
1468 {
1469     CD3DX12_GPU_DESCRIPTOR_HANDLE() {}
1470     explicit CD3DX12_GPU_DESCRIPTOR_HANDLE(const D3D12_GPU_DESCRIPTOR_HANDLE &o) :
1471         D3D12_GPU_DESCRIPTOR_HANDLE(o)
1472     {}
1473     CD3DX12_GPU_DESCRIPTOR_HANDLE(CD3DX12_DEFAULT) { ptr = 0; }
1474     CD3DX12_GPU_DESCRIPTOR_HANDLE(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &other, INT offsetScaledByIncrementSize)
1475     {
1476         InitOffsetted(other, offsetScaledByIncrementSize);
1477     }
1478     CD3DX12_GPU_DESCRIPTOR_HANDLE(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &other, INT offsetInDescriptors, UINT descriptorIncrementSize)
1479     {
1480         InitOffsetted(other, offsetInDescriptors, descriptorIncrementSize);
1481     }
1482     CD3DX12_GPU_DESCRIPTOR_HANDLE& Offset(INT offsetInDescriptors, UINT descriptorIncrementSize)
1483     {
1484         ptr += offsetInDescriptors * descriptorIncrementSize;
1485         return *this;
1486     }
1487     CD3DX12_GPU_DESCRIPTOR_HANDLE& Offset(INT offsetScaledByIncrementSize)
1488     {
1489         ptr += offsetScaledByIncrementSize;
1490         return *this;
1491     }
1492     inline bool operator==(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE& other) const
1493     {
1494         return (ptr == other.ptr);
1495     }
1496     inline bool operator!=(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE& other) const
1497     {
1498         return (ptr != other.ptr);
1499     }
1500     CD3DX12_GPU_DESCRIPTOR_HANDLE &operator=(const D3D12_GPU_DESCRIPTOR_HANDLE &other)
1501     {
1502         ptr = other.ptr;
1503         return *this;
1504     }
1505
1506     inline void InitOffsetted(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize)
1507     {
1508         InitOffsetted(*this, base, offsetScaledByIncrementSize);
1509     }
1510
1511     inline void InitOffsetted(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize)
1512     {
1513         InitOffsetted(*this, base, offsetInDescriptors, descriptorIncrementSize);
1514     }
1515
1516     static inline void InitOffsetted(_Out_ D3D12_GPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize)
1517     {
1518         handle.ptr = base.ptr + offsetScaledByIncrementSize;
1519     }
1520
1521     static inline void InitOffsetted(_Out_ D3D12_GPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize)
1522     {
1523         handle.ptr = base.ptr + offsetInDescriptors * descriptorIncrementSize;
1524     }
1525 };
1526
1527 //------------------------------------------------------------------------------------------------
1528 inline UINT D3D12CalcSubresource( UINT MipSlice, UINT ArraySlice, UINT PlaneSlice, UINT MipLevels, UINT ArraySize )
1529 {
1530     return MipSlice + ArraySlice * MipLevels + PlaneSlice * MipLevels * ArraySize;
1531 }
1532
1533 //------------------------------------------------------------------------------------------------
1534 template <typename T, typename U, typename V>
1535 inline void D3D12DecomposeSubresource( UINT Subresource, UINT MipLevels, UINT ArraySize, _Out_ T& MipSlice, _Out_ U& ArraySlice, _Out_ V& PlaneSlice )
1536 {
1537     MipSlice = static_cast<T>(Subresource % MipLevels);
1538     ArraySlice = static_cast<U>((Subresource / MipLevels) % ArraySize);
1539     PlaneSlice = static_cast<V>(Subresource / (MipLevels * ArraySize));
1540 }
1541
1542 //------------------------------------------------------------------------------------------------
1543 inline UINT8 D3D12GetFormatPlaneCount(
1544     _In_ ID3D12Device* pDevice,
1545     DXGI_FORMAT Format
1546     )
1547 {
1548     D3D12_FEATURE_DATA_FORMAT_INFO formatInfo = {Format};
1549     if (FAILED(pDevice->CheckFeatureSupport(D3D12_FEATURE_FORMAT_INFO, &formatInfo, sizeof(formatInfo))))
1550     {
1551         return 0;
1552     }
1553     return formatInfo.PlaneCount;
1554 }
1555
1556 //------------------------------------------------------------------------------------------------
1557 struct CD3DX12_RESOURCE_DESC : public D3D12_RESOURCE_DESC
1558 {
1559     CD3DX12_RESOURCE_DESC()
1560     {}
1561     explicit CD3DX12_RESOURCE_DESC( const D3D12_RESOURCE_DESC& o ) :
1562         D3D12_RESOURCE_DESC( o )
1563     {}
1564     CD3DX12_RESOURCE_DESC(
1565         D3D12_RESOURCE_DIMENSION dimension,
1566         UINT64 alignment,
1567         UINT64 width,
1568         UINT height,
1569         UINT16 depthOrArraySize,
1570         UINT16 mipLevels,
1571         DXGI_FORMAT format,
1572         UINT sampleCount,
1573         UINT sampleQuality,
1574         D3D12_TEXTURE_LAYOUT layout,
1575         D3D12_RESOURCE_FLAGS flags )
1576     {
1577         Dimension = dimension;
1578         Alignment = alignment;
1579         Width = width;
1580         Height = height;
1581         DepthOrArraySize = depthOrArraySize;
1582         MipLevels = mipLevels;
1583         Format = format;
1584         SampleDesc.Count = sampleCount;
1585         SampleDesc.Quality = sampleQuality;
1586         Layout = layout;
1587         Flags = flags;
1588     }
1589     static inline CD3DX12_RESOURCE_DESC Buffer(
1590         const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
1591         D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE )
1592     {
1593         return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_BUFFER, resAllocInfo.Alignment, resAllocInfo.SizeInBytes,
1594             1, 1, 1, DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags );
1595     }
1596     static inline CD3DX12_RESOURCE_DESC Buffer(
1597         UINT64 width,
1598         D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
1599         UINT64 alignment = 0 )
1600     {
1601         return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_BUFFER, alignment, width, 1, 1, 1,
1602             DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags );
1603     }
1604     static inline CD3DX12_RESOURCE_DESC Tex1D(
1605         DXGI_FORMAT format,
1606         UINT64 width,
1607         UINT16 arraySize = 1,
1608         UINT16 mipLevels = 0,
1609         D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
1610         D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
1611         UINT64 alignment = 0 )
1612     {
1613         return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_TEXTURE1D, alignment, width, 1, arraySize,
1614             mipLevels, format, 1, 0, layout, flags );
1615     }
1616     static inline CD3DX12_RESOURCE_DESC Tex2D(
1617         DXGI_FORMAT format,
1618         UINT64 width,
1619         UINT height,
1620         UINT16 arraySize = 1,
1621         UINT16 mipLevels = 0,
1622         UINT sampleCount = 1,
1623         UINT sampleQuality = 0,
1624         D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
1625         D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
1626         UINT64 alignment = 0 )
1627     {
1628         return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_TEXTURE2D, alignment, width, height, arraySize,
1629             mipLevels, format, sampleCount, sampleQuality, layout, flags );
1630     }
1631     static inline CD3DX12_RESOURCE_DESC Tex3D(
1632         DXGI_FORMAT format,
1633         UINT64 width,
1634         UINT height,
1635         UINT16 depth,
1636         UINT16 mipLevels = 0,
1637         D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
1638         D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
1639         UINT64 alignment = 0 )
1640     {
1641         return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_TEXTURE3D, alignment, width, height, depth,
1642             mipLevels, format, 1, 0, layout, flags );
1643     }
1644     inline UINT16 Depth() const
1645     { return (Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize : 1); }
1646     inline UINT16 ArraySize() const
1647     { return (Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize : 1); }
1648     inline UINT8 PlaneCount(_In_ ID3D12Device* pDevice) const
1649     { return D3D12GetFormatPlaneCount(pDevice, Format); }
1650     inline UINT Subresources(_In_ ID3D12Device* pDevice) const
1651     { return MipLevels * ArraySize() * PlaneCount(pDevice); }
1652     inline UINT CalcSubresource(UINT MipSlice, UINT ArraySlice, UINT PlaneSlice)
1653     { return D3D12CalcSubresource(MipSlice, ArraySlice, PlaneSlice, MipLevels, ArraySize()); }
1654     operator const D3D12_RESOURCE_DESC&() const { return *this; }
1655 };
1656 inline bool operator==( const D3D12_RESOURCE_DESC& l, const D3D12_RESOURCE_DESC& r )
1657 {
1658     return l.Dimension == r.Dimension &&
1659         l.Alignment == r.Alignment &&
1660         l.Width == r.Width &&
1661         l.Height == r.Height &&
1662         l.DepthOrArraySize == r.DepthOrArraySize &&
1663         l.MipLevels == r.MipLevels &&
1664         l.Format == r.Format &&
1665         l.SampleDesc.Count == r.SampleDesc.Count &&
1666         l.SampleDesc.Quality == r.SampleDesc.Quality &&
1667         l.Layout == r.Layout &&
1668         l.Flags == r.Flags;
1669 }
1670 inline bool operator!=( const D3D12_RESOURCE_DESC& l, const D3D12_RESOURCE_DESC& r )
1671 { return !( l == r ); }
1672
1673 //------------------------------------------------------------------------------------------------
1674 // Row-by-row memcpy
1675 inline void MemcpySubresource(
1676     _In_ const D3D12_MEMCPY_DEST* pDest,
1677     _In_ const D3D12_SUBRESOURCE_DATA* pSrc,
1678     SIZE_T RowSizeInBytes,
1679     UINT NumRows,
1680     UINT NumSlices)
1681 {
1682     for (UINT z = 0; z < NumSlices; ++z)
1683     {
1684         BYTE* pDestSlice = reinterpret_cast<BYTE*>(pDest->pData) + pDest->SlicePitch * z;
1685         const BYTE* pSrcSlice = reinterpret_cast<const BYTE*>(pSrc->pData) + pSrc->SlicePitch * z;
1686         for (UINT y = 0; y < NumRows; ++y)
1687         {
1688             memcpy(pDestSlice + pDest->RowPitch * y,
1689                    pSrcSlice + pSrc->RowPitch * y,
1690                    RowSizeInBytes);
1691         }
1692     }
1693 }
1694
1695 //------------------------------------------------------------------------------------------------
1696 // Returns required size of a buffer to be used for data upload
1697 inline UINT64 GetRequiredIntermediateSize(
1698     _In_ ID3D12Resource* pDestinationResource,
1699     _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
1700     _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources)
1701 {
1702     D3D12_RESOURCE_DESC Desc = pDestinationResource->GetDesc();
1703     UINT64 RequiredSize = 0;
1704
1705     ID3D12Device* pDevice;
1706     pDestinationResource->GetDevice(__uuidof(*pDevice), reinterpret_cast<void**>(&pDevice));
1707     pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, 0, nullptr, nullptr, nullptr, &RequiredSize);
1708     pDevice->Release();
1709
1710     return RequiredSize;
1711 }
1712
1713 //------------------------------------------------------------------------------------------------
1714 // All arrays must be populated (e.g. by calling GetCopyableFootprints)
1715 inline UINT64 UpdateSubresources(
1716     _In_ ID3D12GraphicsCommandList* pCmdList,
1717     _In_ ID3D12Resource* pDestinationResource,
1718     _In_ ID3D12Resource* pIntermediate,
1719     _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
1720     _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources,
1721     UINT64 RequiredSize,
1722     _In_reads_(NumSubresources) const D3D12_PLACED_SUBRESOURCE_FOOTPRINT* pLayouts,
1723     _In_reads_(NumSubresources) const UINT* pNumRows,
1724     _In_reads_(NumSubresources) const UINT64* pRowSizesInBytes,
1725     _In_reads_(NumSubresources) const D3D12_SUBRESOURCE_DATA* pSrcData)
1726 {
1727     // Minor validation
1728     D3D12_RESOURCE_DESC IntermediateDesc = pIntermediate->GetDesc();
1729     D3D12_RESOURCE_DESC DestinationDesc = pDestinationResource->GetDesc();
1730     if (IntermediateDesc.Dimension != D3D12_RESOURCE_DIMENSION_BUFFER ||
1731         IntermediateDesc.Width < RequiredSize + pLayouts[0].Offset ||
1732         RequiredSize > (SIZE_T)-1 ||
1733         (DestinationDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER &&
1734             (FirstSubresource != 0 || NumSubresources != 1)))
1735     {
1736         return 0;
1737     }
1738
1739     BYTE* pData;
1740     HRESULT hr = pIntermediate->Map(0, NULL, reinterpret_cast<void**>(&pData));
1741     if (FAILED(hr))
1742     {
1743         return 0;
1744     }
1745
1746     for (UINT i = 0; i < NumSubresources; ++i)
1747     {
1748         if (pRowSizesInBytes[i] > (SIZE_T)-1) return 0;
1749         D3D12_MEMCPY_DEST DestData = { pData + pLayouts[i].Offset, pLayouts[i].Footprint.RowPitch, pLayouts[i].Footprint.RowPitch * pNumRows[i] };
1750         MemcpySubresource(&DestData, &pSrcData[i], (SIZE_T)pRowSizesInBytes[i], pNumRows[i], pLayouts[i].Footprint.Depth);
1751     }
1752     pIntermediate->Unmap(0, NULL);
1753
1754     if (DestinationDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER)
1755     {
1756         CD3DX12_BOX SrcBox( UINT( pLayouts[0].Offset ), UINT( pLayouts[0].Offset + pLayouts[0].Footprint.Width ) );
1757         pCmdList->CopyBufferRegion(
1758             pDestinationResource, 0, pIntermediate, pLayouts[0].Offset, pLayouts[0].Footprint.Width);
1759     }
1760     else
1761     {
1762         for (UINT i = 0; i < NumSubresources; ++i)
1763         {
1764             CD3DX12_TEXTURE_COPY_LOCATION Dst(pDestinationResource, i + FirstSubresource);
1765             CD3DX12_TEXTURE_COPY_LOCATION Src(pIntermediate, pLayouts[i]);
1766             pCmdList->CopyTextureRegion(&Dst, 0, 0, 0, &Src, nullptr);
1767         }
1768     }
1769     return RequiredSize;
1770 }
1771
1772 //------------------------------------------------------------------------------------------------
1773 // Heap-allocating UpdateSubresources implementation
1774 inline UINT64 UpdateSubresources(
1775     _In_ ID3D12GraphicsCommandList* pCmdList,
1776     _In_ ID3D12Resource* pDestinationResource,
1777     _In_ ID3D12Resource* pIntermediate,
1778     UINT64 IntermediateOffset,
1779     _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
1780     _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources,
1781     _In_reads_(NumSubresources) D3D12_SUBRESOURCE_DATA* pSrcData)
1782 {
1783     UINT64 RequiredSize = 0;
1784     UINT64 MemToAlloc = static_cast<UINT64>(sizeof(D3D12_PLACED_SUBRESOURCE_FOOTPRINT) + sizeof(UINT) + sizeof(UINT64)) * NumSubresources;
1785     if (MemToAlloc > SIZE_MAX)
1786     {
1787        return 0;
1788     }
1789     void* pMem = HeapAlloc(GetProcessHeap(), 0, static_cast<SIZE_T>(MemToAlloc));
1790     if (pMem == NULL)
1791     {
1792        return 0;
1793     }
1794     D3D12_PLACED_SUBRESOURCE_FOOTPRINT* pLayouts = reinterpret_cast<D3D12_PLACED_SUBRESOURCE_FOOTPRINT*>(pMem);
1795     UINT64* pRowSizesInBytes = reinterpret_cast<UINT64*>(pLayouts + NumSubresources);
1796     UINT* pNumRows = reinterpret_cast<UINT*>(pRowSizesInBytes + NumSubresources);
1797
1798     D3D12_RESOURCE_DESC Desc = pDestinationResource->GetDesc();
1799     ID3D12Device* pDevice;
1800     pDestinationResource->GetDevice(__uuidof(*pDevice), reinterpret_cast<void**>(&pDevice));
1801     pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, IntermediateOffset, pLayouts, pNumRows, pRowSizesInBytes, &RequiredSize);
1802     pDevice->Release();
1803
1804     UINT64 Result = UpdateSubresources(pCmdList, pDestinationResource, pIntermediate, FirstSubresource, NumSubresources, RequiredSize, pLayouts, pNumRows, pRowSizesInBytes, pSrcData);
1805     HeapFree(GetProcessHeap(), 0, pMem);
1806     return Result;
1807 }
1808
1809 //------------------------------------------------------------------------------------------------
1810 // Stack-allocating UpdateSubresources implementation
1811 template <UINT MaxSubresources>
1812 inline UINT64 UpdateSubresources(
1813     _In_ ID3D12GraphicsCommandList* pCmdList,
1814     _In_ ID3D12Resource* pDestinationResource,
1815     _In_ ID3D12Resource* pIntermediate,
1816     UINT64 IntermediateOffset,
1817     _In_range_(0, MaxSubresources) UINT FirstSubresource,
1818     _In_range_(1, MaxSubresources - FirstSubresource) UINT NumSubresources,
1819     _In_reads_(NumSubresources) D3D12_SUBRESOURCE_DATA* pSrcData)
1820 {
1821     UINT64 RequiredSize = 0;
1822     D3D12_PLACED_SUBRESOURCE_FOOTPRINT Layouts[MaxSubresources];
1823     UINT NumRows[MaxSubresources];
1824     UINT64 RowSizesInBytes[MaxSubresources];
1825
1826     D3D12_RESOURCE_DESC Desc = pDestinationResource->GetDesc();
1827     ID3D12Device* pDevice;
1828     pDestinationResource->GetDevice(__uuidof(*pDevice), reinterpret_cast<void**>(&pDevice));
1829     pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, IntermediateOffset, Layouts, NumRows, RowSizesInBytes, &RequiredSize);
1830     pDevice->Release();
1831
1832     return UpdateSubresources(pCmdList, pDestinationResource, pIntermediate, FirstSubresource, NumSubresources, RequiredSize, Layouts, NumRows, RowSizesInBytes, pSrcData);
1833 }
1834
1835 //------------------------------------------------------------------------------------------------
1836 inline bool D3D12IsLayoutOpaque( D3D12_TEXTURE_LAYOUT Layout )
1837 { return Layout == D3D12_TEXTURE_LAYOUT_UNKNOWN || Layout == D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE; }
1838
1839 //------------------------------------------------------------------------------------------------
1840 inline ID3D12CommandList * const * CommandListCast(ID3D12GraphicsCommandList * const * pp)
1841 {
1842     // This cast is useful for passing strongly typed command list pointers into
1843     // ExecuteCommandLists.
1844     // This cast is valid as long as the const-ness is respected. D3D12 APIs do
1845     // respect the const-ness of their arguments.
1846     return reinterpret_cast<ID3D12CommandList * const *>(pp);
1847 }
1848
1849 //------------------------------------------------------------------------------------------------
1850 // D3D12 exports a new method for serializing root signatures in the Windows 10 Anniversary Update.
1851 // To help enable root signature 1.1 features when they are available and not require maintaining
1852 // two code paths for building root signatures, this helper method reconstructs a 1.0 signature when
1853 // 1.1 is not supported.
1854 inline HRESULT D3DX12SerializeVersionedRootSignature(
1855     _In_ const D3D12_VERSIONED_ROOT_SIGNATURE_DESC* pRootSignatureDesc,
1856     D3D_ROOT_SIGNATURE_VERSION MaxVersion,
1857     _Outptr_ ID3DBlob** ppBlob,
1858     _Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorBlob)
1859 {
1860     switch (MaxVersion)
1861     {
1862         case D3D_ROOT_SIGNATURE_VERSION_1_0:
1863             switch (pRootSignatureDesc->Version)
1864             {
1865                 case D3D_ROOT_SIGNATURE_VERSION_1_0:
1866                     return D3D12SerializeRootSignature(&pRootSignatureDesc->Desc_1_0, D3D_ROOT_SIGNATURE_VERSION_1, ppBlob, ppErrorBlob);
1867
1868                 case D3D_ROOT_SIGNATURE_VERSION_1_1:
1869                 {
1870                     const D3D12_ROOT_SIGNATURE_DESC1& desc_1_1 = pRootSignatureDesc->Desc_1_1;
1871
1872                     SIZE_T ParametersSize = sizeof(D3D12_ROOT_PARAMETER) * desc_1_1.NumParameters;
1873                     void* pParameters = (ParametersSize > 0) ? HeapAlloc(GetProcessHeap(), 0, ParametersSize) : NULL;
1874                     D3D12_ROOT_PARAMETER* pParameters_1_0 = reinterpret_cast<D3D12_ROOT_PARAMETER*>(pParameters);
1875
1876                     for (UINT n = 0; n < desc_1_1.NumParameters; n++)
1877                     {
1878                         pParameters_1_0[n].ParameterType = desc_1_1.pParameters[n].ParameterType;
1879                         pParameters_1_0[n].ShaderVisibility = desc_1_1.pParameters[n].ShaderVisibility;
1880
1881                         switch (desc_1_1.pParameters[n].ParameterType)
1882                         {
1883                         case D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS:
1884                             pParameters_1_0[n].Constants.Num32BitValues = desc_1_1.pParameters[n].Constants.Num32BitValues;
1885                             pParameters_1_0[n].Constants.RegisterSpace = desc_1_1.pParameters[n].Constants.RegisterSpace;
1886                             pParameters_1_0[n].Constants.ShaderRegister = desc_1_1.pParameters[n].Constants.ShaderRegister;
1887                             break;
1888
1889                         case D3D12_ROOT_PARAMETER_TYPE_CBV:
1890                         case D3D12_ROOT_PARAMETER_TYPE_SRV:
1891                         case D3D12_ROOT_PARAMETER_TYPE_UAV:
1892                             pParameters_1_0[n].Descriptor.RegisterSpace = desc_1_1.pParameters[n].Descriptor.RegisterSpace;
1893                             pParameters_1_0[n].Descriptor.ShaderRegister = desc_1_1.pParameters[n].Descriptor.ShaderRegister;
1894                             break;
1895
1896                         case D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE:
1897                             const D3D12_ROOT_DESCRIPTOR_TABLE1& table_1_1 = desc_1_1.pParameters[n].DescriptorTable;
1898
1899                             SIZE_T DescriptorRangesSize = sizeof(D3D12_DESCRIPTOR_RANGE) * table_1_1.NumDescriptorRanges;
1900                             void* pDescriptorRanges = (DescriptorRangesSize > 0) ? HeapAlloc(GetProcessHeap(), 0, DescriptorRangesSize) : NULL;
1901                             D3D12_DESCRIPTOR_RANGE* pDescriptorRanges_1_0 = reinterpret_cast<D3D12_DESCRIPTOR_RANGE*>(pDescriptorRanges);
1902
1903                             for (UINT x = 0; x < table_1_1.NumDescriptorRanges; x++)
1904                             {
1905                                 pDescriptorRanges_1_0[x].BaseShaderRegister = table_1_1.pDescriptorRanges[x].BaseShaderRegister;
1906                                 pDescriptorRanges_1_0[x].NumDescriptors = table_1_1.pDescriptorRanges[x].NumDescriptors;
1907                                 pDescriptorRanges_1_0[x].OffsetInDescriptorsFromTableStart = table_1_1.pDescriptorRanges[x].OffsetInDescriptorsFromTableStart;
1908                                 pDescriptorRanges_1_0[x].RangeType = table_1_1.pDescriptorRanges[x].RangeType;
1909                                 pDescriptorRanges_1_0[x].RegisterSpace = table_1_1.pDescriptorRanges[x].RegisterSpace;
1910                             }
1911
1912                             D3D12_ROOT_DESCRIPTOR_TABLE& table_1_0 = pParameters_1_0[n].DescriptorTable;
1913                             table_1_0.NumDescriptorRanges = table_1_1.NumDescriptorRanges;
1914                             table_1_0.pDescriptorRanges = pDescriptorRanges_1_0;
1915                         }
1916                     }
1917
1918                     CD3DX12_ROOT_SIGNATURE_DESC desc_1_0(desc_1_1.NumParameters, pParameters_1_0, desc_1_1.NumStaticSamplers, desc_1_1.pStaticSamplers, desc_1_1.Flags);
1919                     HRESULT hr = D3D12SerializeRootSignature(&desc_1_0, D3D_ROOT_SIGNATURE_VERSION_1, ppBlob, ppErrorBlob);
1920
1921                     for (UINT n = 0; n < desc_1_0.NumParameters; n++)
1922                     {
1923                         if (desc_1_0.pParameters[n].ParameterType == D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE)
1924                         {
1925                             HeapFree(GetProcessHeap(), 0, reinterpret_cast<void*>(const_cast<D3D12_DESCRIPTOR_RANGE*>(pParameters_1_0[n].DescriptorTable.pDescriptorRanges)));
1926                         }
1927                     }
1928                     HeapFree(GetProcessHeap(), 0, pParameters);
1929                     return hr;
1930                 }
1931             }
1932             break;
1933
1934         case D3D_ROOT_SIGNATURE_VERSION_1_1:
1935             return D3D12SerializeVersionedRootSignature(pRootSignatureDesc, ppBlob, ppErrorBlob);
1936     }
1937
1938     return E_INVALIDARG;
1939 }
1940
1941 #endif // defined( __cplusplus )
1942
1943 #endif //__D3DX12_H__
1944
1945
1946