//*********************************************************
//
// Copyright (c) Microsoft. All rights reserved.
// This code is licensed under the MIT License (MIT).
// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
//
//*********************************************************

#ifndef __D3DX12_H__
#define __D3DX12_H__

#include "d3d12.h"

#if defined(__cplusplus)

struct CD3DX12_DEFAULT {};
extern const DECLSPEC_SELECTANY CD3DX12_DEFAULT D3D12_DEFAULT;

//------------------------------------------------------------------------------------------------
inline bool operator==(const D3D12_VIEWPORT &l, const D3D12_VIEWPORT &r) {
  return l.TopLeftX == r.TopLeftX && l.TopLeftY == r.TopLeftY &&
         l.Width == r.Width && l.Height == r.Height &&
         l.MinDepth == r.MinDepth && l.MaxDepth == r.MaxDepth;
}

//------------------------------------------------------------------------------------------------
inline bool operator!=(const D3D12_VIEWPORT &l, const D3D12_VIEWPORT &r) {
  return !(l == r);
}

//------------------------------------------------------------------------------------------------
struct CD3DX12_RECT : public D3D12_RECT {
  CD3DX12_RECT() = default;
  explicit CD3DX12_RECT(const D3D12_RECT &o) : D3D12_RECT(o) {}
  explicit CD3DX12_RECT(LONG Left, LONG Top, LONG Right, LONG Bottom) {
    left = Left;
    top = Top;
    right = Right;
    bottom = Bottom;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_VIEWPORT : public D3D12_VIEWPORT {
  CD3DX12_VIEWPORT() = default;
  explicit CD3DX12_VIEWPORT(const D3D12_VIEWPORT &o) : D3D12_VIEWPORT(o) {}
  explicit CD3DX12_VIEWPORT(FLOAT topLeftX, FLOAT topLeftY, FLOAT width,
                            FLOAT height, FLOAT minDepth = D3D12_MIN_DEPTH,
                            FLOAT maxDepth = D3D12_MAX_DEPTH) {
    TopLeftX = topLeftX;
    TopLeftY = topLeftY;
    Width = width;
    Height = height;
    MinDepth = minDepth;
    MaxDepth = maxDepth;
  }
  explicit CD3DX12_VIEWPORT(_In_ ID3D12Resource *pResource, UINT mipSlice = 0,
                            FLOAT topLeftX = 0.0f, FLOAT topLeftY = 0.0f,
                            FLOAT minDepth = D3D12_MIN_DEPTH,
                            FLOAT maxDepth = D3D12_MAX_DEPTH) {
    auto Desc = pResource->GetDesc();
    const UINT64 SubresourceWidth = Desc.Width >> mipSlice;
    const UINT64 SubresourceHeight = Desc.Height >> mipSlice;
    switch (Desc.Dimension) {
    case D3D12_RESOURCE_DIMENSION_BUFFER:
      TopLeftX = topLeftX;
      TopLeftY = 0.0f;
      Width = Desc.Width - topLeftX;
      Height = 1.0f;
      break;
    case D3D12_RESOURCE_DIMENSION_TEXTURE1D:
      TopLeftX = topLeftX;
      TopLeftY = 0.0f;
      Width = (SubresourceWidth ? SubresourceWidth : 1.0f) - topLeftX;
      Height = 1.0f;
      break;
    case D3D12_RESOURCE_DIMENSION_TEXTURE2D:
    case D3D12_RESOURCE_DIMENSION_TEXTURE3D:
      TopLeftX = topLeftX;
      TopLeftY = topLeftY;
      Width = (SubresourceWidth ? SubresourceWidth : 1.0f) - topLeftX;
      Height = (SubresourceHeight ? SubresourceHeight : 1.0f) - topLeftY;
      break;
    default:
      break;
    }

    MinDepth = minDepth;
    MaxDepth = maxDepth;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_BOX : public D3D12_BOX {
  CD3DX12_BOX() = default;
  explicit CD3DX12_BOX(const D3D12_BOX &o) : D3D12_BOX(o) {}
  explicit CD3DX12_BOX(LONG Left, LONG Right) {
    left = static_cast<UINT>(Left);
    top = 0;
    front = 0;
    right = static_cast<UINT>(Right);
    bottom = 1;
    back = 1;
  }
  explicit CD3DX12_BOX(LONG Left, LONG Top, LONG Right, LONG Bottom) {
    left = static_cast<UINT>(Left);
    top = static_cast<UINT>(Top);
    front = 0;
    right = static_cast<UINT>(Right);
    bottom = static_cast<UINT>(Bottom);
    back = 1;
  }
  explicit CD3DX12_BOX(LONG Left, LONG Top, LONG Front, LONG Right, LONG Bottom,
                       LONG Back) {
    left = static_cast<UINT>(Left);
    top = static_cast<UINT>(Top);
    front = static_cast<UINT>(Front);
    right = static_cast<UINT>(Right);
    bottom = static_cast<UINT>(Bottom);
    back = static_cast<UINT>(Back);
  }
};
inline bool operator==(const D3D12_BOX &l, const D3D12_BOX &r) {
  return l.left == r.left && l.top == r.top && l.front == r.front &&
         l.right == r.right && l.bottom == r.bottom && l.back == r.back;
}
inline bool operator!=(const D3D12_BOX &l, const D3D12_BOX &r) {
  return !(l == r);
}

//------------------------------------------------------------------------------------------------
struct CD3DX12_DEPTH_STENCIL_DESC : public D3D12_DEPTH_STENCIL_DESC {
  CD3DX12_DEPTH_STENCIL_DESC() = default;
  explicit CD3DX12_DEPTH_STENCIL_DESC(const D3D12_DEPTH_STENCIL_DESC &o)
      : D3D12_DEPTH_STENCIL_DESC(o) {}
  explicit CD3DX12_DEPTH_STENCIL_DESC(CD3DX12_DEFAULT) {
    DepthEnable = TRUE;
    DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL;
    DepthFunc = D3D12_COMPARISON_FUNC_LESS;
    StencilEnable = FALSE;
    StencilReadMask = D3D12_DEFAULT_STENCIL_READ_MASK;
    StencilWriteMask = D3D12_DEFAULT_STENCIL_WRITE_MASK;
    const D3D12_DEPTH_STENCILOP_DESC defaultStencilOp = {
        D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP,
        D3D12_COMPARISON_FUNC_ALWAYS};
    FrontFace = defaultStencilOp;
    BackFace = defaultStencilOp;
  }
  explicit CD3DX12_DEPTH_STENCIL_DESC(BOOL depthEnable,
                                      D3D12_DEPTH_WRITE_MASK depthWriteMask,
                                      D3D12_COMPARISON_FUNC depthFunc,
                                      BOOL stencilEnable, UINT8 stencilReadMask,
                                      UINT8 stencilWriteMask,
                                      D3D12_STENCIL_OP frontStencilFailOp,
                                      D3D12_STENCIL_OP frontStencilDepthFailOp,
                                      D3D12_STENCIL_OP frontStencilPassOp,
                                      D3D12_COMPARISON_FUNC frontStencilFunc,
                                      D3D12_STENCIL_OP backStencilFailOp,
                                      D3D12_STENCIL_OP backStencilDepthFailOp,
                                      D3D12_STENCIL_OP backStencilPassOp,
                                      D3D12_COMPARISON_FUNC backStencilFunc) {
    DepthEnable = depthEnable;
    DepthWriteMask = depthWriteMask;
    DepthFunc = depthFunc;
    StencilEnable = stencilEnable;
    StencilReadMask = stencilReadMask;
    StencilWriteMask = stencilWriteMask;
    FrontFace.StencilFailOp = frontStencilFailOp;
    FrontFace.StencilDepthFailOp = frontStencilDepthFailOp;
    FrontFace.StencilPassOp = frontStencilPassOp;
    FrontFace.StencilFunc = frontStencilFunc;
    BackFace.StencilFailOp = backStencilFailOp;
    BackFace.StencilDepthFailOp = backStencilDepthFailOp;
    BackFace.StencilPassOp = backStencilPassOp;
    BackFace.StencilFunc = backStencilFunc;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_DEPTH_STENCIL_DESC1 : public D3D12_DEPTH_STENCIL_DESC1 {
  CD3DX12_DEPTH_STENCIL_DESC1() = default;
  explicit CD3DX12_DEPTH_STENCIL_DESC1(const D3D12_DEPTH_STENCIL_DESC1 &o)
      : D3D12_DEPTH_STENCIL_DESC1(o) {}
  explicit CD3DX12_DEPTH_STENCIL_DESC1(const D3D12_DEPTH_STENCIL_DESC &o) {
    DepthEnable = o.DepthEnable;
    DepthWriteMask = o.DepthWriteMask;
    DepthFunc = o.DepthFunc;
    StencilEnable = o.StencilEnable;
    StencilReadMask = o.StencilReadMask;
    StencilWriteMask = o.StencilWriteMask;
    FrontFace.StencilFailOp = o.FrontFace.StencilFailOp;
    FrontFace.StencilDepthFailOp = o.FrontFace.StencilDepthFailOp;
    FrontFace.StencilPassOp = o.FrontFace.StencilPassOp;
    FrontFace.StencilFunc = o.FrontFace.StencilFunc;
    BackFace.StencilFailOp = o.BackFace.StencilFailOp;
    BackFace.StencilDepthFailOp = o.BackFace.StencilDepthFailOp;
    BackFace.StencilPassOp = o.BackFace.StencilPassOp;
    BackFace.StencilFunc = o.BackFace.StencilFunc;
    DepthBoundsTestEnable = FALSE;
  }
  explicit CD3DX12_DEPTH_STENCIL_DESC1(CD3DX12_DEFAULT) {
    DepthEnable = TRUE;
    DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL;
    DepthFunc = D3D12_COMPARISON_FUNC_LESS;
    StencilEnable = FALSE;
    StencilReadMask = D3D12_DEFAULT_STENCIL_READ_MASK;
    StencilWriteMask = D3D12_DEFAULT_STENCIL_WRITE_MASK;
    const D3D12_DEPTH_STENCILOP_DESC defaultStencilOp = {
        D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP,
        D3D12_COMPARISON_FUNC_ALWAYS};
    FrontFace = defaultStencilOp;
    BackFace = defaultStencilOp;
    DepthBoundsTestEnable = FALSE;
  }
  explicit CD3DX12_DEPTH_STENCIL_DESC1(
      BOOL depthEnable, D3D12_DEPTH_WRITE_MASK depthWriteMask,
      D3D12_COMPARISON_FUNC depthFunc, BOOL stencilEnable,
      UINT8 stencilReadMask, UINT8 stencilWriteMask,
      D3D12_STENCIL_OP frontStencilFailOp,
      D3D12_STENCIL_OP frontStencilDepthFailOp,
      D3D12_STENCIL_OP frontStencilPassOp,
      D3D12_COMPARISON_FUNC frontStencilFunc,
      D3D12_STENCIL_OP backStencilFailOp,
      D3D12_STENCIL_OP backStencilDepthFailOp,
      D3D12_STENCIL_OP backStencilPassOp, D3D12_COMPARISON_FUNC backStencilFunc,
      BOOL depthBoundsTestEnable) {
    DepthEnable = depthEnable;
    DepthWriteMask = depthWriteMask;
    DepthFunc = depthFunc;
    StencilEnable = stencilEnable;
    StencilReadMask = stencilReadMask;
    StencilWriteMask = stencilWriteMask;
    FrontFace.StencilFailOp = frontStencilFailOp;
    FrontFace.StencilDepthFailOp = frontStencilDepthFailOp;
    FrontFace.StencilPassOp = frontStencilPassOp;
    FrontFace.StencilFunc = frontStencilFunc;
    BackFace.StencilFailOp = backStencilFailOp;
    BackFace.StencilDepthFailOp = backStencilDepthFailOp;
    BackFace.StencilPassOp = backStencilPassOp;
    BackFace.StencilFunc = backStencilFunc;
    DepthBoundsTestEnable = depthBoundsTestEnable;
  }
  operator D3D12_DEPTH_STENCIL_DESC() const {
    D3D12_DEPTH_STENCIL_DESC D;
    D.DepthEnable = DepthEnable;
    D.DepthWriteMask = DepthWriteMask;
    D.DepthFunc = DepthFunc;
    D.StencilEnable = StencilEnable;
    D.StencilReadMask = StencilReadMask;
    D.StencilWriteMask = StencilWriteMask;
    D.FrontFace.StencilFailOp = FrontFace.StencilFailOp;
    D.FrontFace.StencilDepthFailOp = FrontFace.StencilDepthFailOp;
    D.FrontFace.StencilPassOp = FrontFace.StencilPassOp;
    D.FrontFace.StencilFunc = FrontFace.StencilFunc;
    D.BackFace.StencilFailOp = BackFace.StencilFailOp;
    D.BackFace.StencilDepthFailOp = BackFace.StencilDepthFailOp;
    D.BackFace.StencilPassOp = BackFace.StencilPassOp;
    D.BackFace.StencilFunc = BackFace.StencilFunc;
    return D;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_BLEND_DESC : public D3D12_BLEND_DESC {
  CD3DX12_BLEND_DESC() = default;
  explicit CD3DX12_BLEND_DESC(const D3D12_BLEND_DESC &o)
      : D3D12_BLEND_DESC(o) {}
  explicit CD3DX12_BLEND_DESC(CD3DX12_DEFAULT) {
    AlphaToCoverageEnable = FALSE;
    IndependentBlendEnable = FALSE;
    const D3D12_RENDER_TARGET_BLEND_DESC defaultRenderTargetBlendDesc = {
        FALSE,
        FALSE,
        D3D12_BLEND_ONE,
        D3D12_BLEND_ZERO,
        D3D12_BLEND_OP_ADD,
        D3D12_BLEND_ONE,
        D3D12_BLEND_ZERO,
        D3D12_BLEND_OP_ADD,
        D3D12_LOGIC_OP_NOOP,
        D3D12_COLOR_WRITE_ENABLE_ALL,
    };
    for (UINT i = 0; i < D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
      RenderTarget[i] = defaultRenderTargetBlendDesc;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_RASTERIZER_DESC : public D3D12_RASTERIZER_DESC {
  CD3DX12_RASTERIZER_DESC() = default;
  explicit CD3DX12_RASTERIZER_DESC(const D3D12_RASTERIZER_DESC &o)
      : D3D12_RASTERIZER_DESC(o) {}
  explicit CD3DX12_RASTERIZER_DESC(CD3DX12_DEFAULT) {
    FillMode = D3D12_FILL_MODE_SOLID;
    CullMode = D3D12_CULL_MODE_BACK;
    FrontCounterClockwise = FALSE;
    DepthBias = D3D12_DEFAULT_DEPTH_BIAS;
    DepthBiasClamp = D3D12_DEFAULT_DEPTH_BIAS_CLAMP;
    SlopeScaledDepthBias = D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS;
    DepthClipEnable = TRUE;
    MultisampleEnable = FALSE;
    AntialiasedLineEnable = FALSE;
    ForcedSampleCount = 0;
    ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF;
  }
  explicit CD3DX12_RASTERIZER_DESC(
      D3D12_FILL_MODE fillMode, D3D12_CULL_MODE cullMode,
      BOOL frontCounterClockwise, INT depthBias, FLOAT depthBiasClamp,
      FLOAT slopeScaledDepthBias, BOOL depthClipEnable, BOOL multisampleEnable,
      BOOL antialiasedLineEnable, UINT forcedSampleCount,
      D3D12_CONSERVATIVE_RASTERIZATION_MODE conservativeRaster) {
    FillMode = fillMode;
    CullMode = cullMode;
    FrontCounterClockwise = frontCounterClockwise;
    DepthBias = depthBias;
    DepthBiasClamp = depthBiasClamp;
    SlopeScaledDepthBias = slopeScaledDepthBias;
    DepthClipEnable = depthClipEnable;
    MultisampleEnable = multisampleEnable;
    AntialiasedLineEnable = antialiasedLineEnable;
    ForcedSampleCount = forcedSampleCount;
    ConservativeRaster = conservativeRaster;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_RESOURCE_ALLOCATION_INFO
    : public D3D12_RESOURCE_ALLOCATION_INFO {
  CD3DX12_RESOURCE_ALLOCATION_INFO() = default;
  explicit CD3DX12_RESOURCE_ALLOCATION_INFO(
      const D3D12_RESOURCE_ALLOCATION_INFO &o)
      : D3D12_RESOURCE_ALLOCATION_INFO(o) {}
  CD3DX12_RESOURCE_ALLOCATION_INFO(UINT64 size, UINT64 alignment) {
    SizeInBytes = size;
    Alignment = alignment;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_HEAP_PROPERTIES : public D3D12_HEAP_PROPERTIES {
  CD3DX12_HEAP_PROPERTIES() = default;
  explicit CD3DX12_HEAP_PROPERTIES(const D3D12_HEAP_PROPERTIES &o)
      : D3D12_HEAP_PROPERTIES(o) {}
  CD3DX12_HEAP_PROPERTIES(D3D12_CPU_PAGE_PROPERTY cpuPageProperty,
                          D3D12_MEMORY_POOL memoryPoolPreference,
                          UINT creationNodeMask = 1, UINT nodeMask = 1) {
    Type = D3D12_HEAP_TYPE_CUSTOM;
    CPUPageProperty = cpuPageProperty;
    MemoryPoolPreference = memoryPoolPreference;
    CreationNodeMask = creationNodeMask;
    VisibleNodeMask = nodeMask;
  }
  explicit CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE type,
                                   UINT creationNodeMask = 1,
                                   UINT nodeMask = 1) {
    Type = type;
    CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
    MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
    CreationNodeMask = creationNodeMask;
    VisibleNodeMask = nodeMask;
  }
  bool IsCPUAccessible() const {
    return Type == D3D12_HEAP_TYPE_UPLOAD || Type == D3D12_HEAP_TYPE_READBACK ||
           (Type == D3D12_HEAP_TYPE_CUSTOM &&
            (CPUPageProperty == D3D12_CPU_PAGE_PROPERTY_WRITE_COMBINE ||
             CPUPageProperty == D3D12_CPU_PAGE_PROPERTY_WRITE_BACK));
  }
};
inline bool operator==(const D3D12_HEAP_PROPERTIES &l,
                       const D3D12_HEAP_PROPERTIES &r) {
  return l.Type == r.Type && l.CPUPageProperty == r.CPUPageProperty &&
         l.MemoryPoolPreference == r.MemoryPoolPreference &&
         l.CreationNodeMask == r.CreationNodeMask &&
         l.VisibleNodeMask == r.VisibleNodeMask;
}
inline bool operator!=(const D3D12_HEAP_PROPERTIES &l,
                       const D3D12_HEAP_PROPERTIES &r) {
  return !(l == r);
}

//------------------------------------------------------------------------------------------------
struct CD3DX12_HEAP_DESC : public D3D12_HEAP_DESC {
  CD3DX12_HEAP_DESC() = default;
  explicit CD3DX12_HEAP_DESC(const D3D12_HEAP_DESC &o) : D3D12_HEAP_DESC(o) {}
  CD3DX12_HEAP_DESC(UINT64 size, D3D12_HEAP_PROPERTIES properties,
                    UINT64 alignment = 0,
                    D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE) {
    SizeInBytes = size;
    Properties = properties;
    Alignment = alignment;
    Flags = flags;
  }
  CD3DX12_HEAP_DESC(UINT64 size, D3D12_HEAP_TYPE type, UINT64 alignment = 0,
                    D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE) {
    SizeInBytes = size;
    Properties = CD3DX12_HEAP_PROPERTIES(type);
    Alignment = alignment;
    Flags = flags;
  }
  CD3DX12_HEAP_DESC(UINT64 size, D3D12_CPU_PAGE_PROPERTY cpuPageProperty,
                    D3D12_MEMORY_POOL memoryPoolPreference,
                    UINT64 alignment = 0,
                    D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE) {
    SizeInBytes = size;
    Properties = CD3DX12_HEAP_PROPERTIES(cpuPageProperty, memoryPoolPreference);
    Alignment = alignment;
    Flags = flags;
  }
  CD3DX12_HEAP_DESC(const D3D12_RESOURCE_ALLOCATION_INFO &resAllocInfo,
                    D3D12_HEAP_PROPERTIES properties,
                    D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE) {
    SizeInBytes = resAllocInfo.SizeInBytes;
    Properties = properties;
    Alignment = resAllocInfo.Alignment;
    Flags = flags;
  }
  CD3DX12_HEAP_DESC(const D3D12_RESOURCE_ALLOCATION_INFO &resAllocInfo,
                    D3D12_HEAP_TYPE type,
                    D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE) {
    SizeInBytes = resAllocInfo.SizeInBytes;
    Properties = CD3DX12_HEAP_PROPERTIES(type);
    Alignment = resAllocInfo.Alignment;
    Flags = flags;
  }
  CD3DX12_HEAP_DESC(const D3D12_RESOURCE_ALLOCATION_INFO &resAllocInfo,
                    D3D12_CPU_PAGE_PROPERTY cpuPageProperty,
                    D3D12_MEMORY_POOL memoryPoolPreference,
                    D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE) {
    SizeInBytes = resAllocInfo.SizeInBytes;
    Properties = CD3DX12_HEAP_PROPERTIES(cpuPageProperty, memoryPoolPreference);
    Alignment = resAllocInfo.Alignment;
    Flags = flags;
  }
  bool IsCPUAccessible() const {
    return static_cast<const CD3DX12_HEAP_PROPERTIES *>(&Properties)
        ->IsCPUAccessible();
  }
};
inline bool operator==(const D3D12_HEAP_DESC &l, const D3D12_HEAP_DESC &r) {
  return l.SizeInBytes == r.SizeInBytes && l.Properties == r.Properties &&
         l.Alignment == r.Alignment && l.Flags == r.Flags;
}
inline bool operator!=(const D3D12_HEAP_DESC &l, const D3D12_HEAP_DESC &r) {
  return !(l == r);
}

//------------------------------------------------------------------------------------------------
struct CD3DX12_CLEAR_VALUE : public D3D12_CLEAR_VALUE {
  CD3DX12_CLEAR_VALUE() = default;
  explicit CD3DX12_CLEAR_VALUE(const D3D12_CLEAR_VALUE &o)
      : D3D12_CLEAR_VALUE(o) {}
  CD3DX12_CLEAR_VALUE(DXGI_FORMAT format, const FLOAT color[4]) {
    Format = format;
    memcpy(Color, color, sizeof(Color));
  }
  CD3DX12_CLEAR_VALUE(DXGI_FORMAT format, FLOAT depth, UINT8 stencil) {
    Format = format;
    memset(&Color, 0, sizeof(Color));
    /* Use memcpy to preserve NAN values */
    memcpy(&DepthStencil.Depth, &depth, sizeof(depth));
    DepthStencil.Stencil = stencil;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_RANGE : public D3D12_RANGE {
  CD3DX12_RANGE() = default;
  explicit CD3DX12_RANGE(const D3D12_RANGE &o) : D3D12_RANGE(o) {}
  CD3DX12_RANGE(SIZE_T begin, SIZE_T end) {
    Begin = begin;
    End = end;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_RANGE_UINT64 : public D3D12_RANGE_UINT64 {
  CD3DX12_RANGE_UINT64() = default;
  explicit CD3DX12_RANGE_UINT64(const D3D12_RANGE_UINT64 &o)
      : D3D12_RANGE_UINT64(o) {}
  CD3DX12_RANGE_UINT64(UINT64 begin, UINT64 end) {
    Begin = begin;
    End = end;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_SUBRESOURCE_RANGE_UINT64
    : public D3D12_SUBRESOURCE_RANGE_UINT64 {
  CD3DX12_SUBRESOURCE_RANGE_UINT64() = default;
  explicit CD3DX12_SUBRESOURCE_RANGE_UINT64(
      const D3D12_SUBRESOURCE_RANGE_UINT64 &o)
      : D3D12_SUBRESOURCE_RANGE_UINT64(o) {}
  CD3DX12_SUBRESOURCE_RANGE_UINT64(UINT subresource,
                                   const D3D12_RANGE_UINT64 &range) {
    Subresource = subresource;
    Range = range;
  }
  CD3DX12_SUBRESOURCE_RANGE_UINT64(UINT subresource, UINT64 begin, UINT64 end) {
    Subresource = subresource;
    Range.Begin = begin;
    Range.End = end;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_SHADER_BYTECODE : public D3D12_SHADER_BYTECODE {
  CD3DX12_SHADER_BYTECODE() = default;
  explicit CD3DX12_SHADER_BYTECODE(const D3D12_SHADER_BYTECODE &o)
      : D3D12_SHADER_BYTECODE(o) {}
  CD3DX12_SHADER_BYTECODE(_In_ ID3DBlob *pShaderBlob) {
    pShaderBytecode = pShaderBlob->GetBufferPointer();
    BytecodeLength = pShaderBlob->GetBufferSize();
  }
  CD3DX12_SHADER_BYTECODE(const void *_pShaderBytecode, SIZE_T bytecodeLength) {
    pShaderBytecode = _pShaderBytecode;
    BytecodeLength = bytecodeLength;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_TILED_RESOURCE_COORDINATE
    : public D3D12_TILED_RESOURCE_COORDINATE {
  CD3DX12_TILED_RESOURCE_COORDINATE() = default;
  explicit CD3DX12_TILED_RESOURCE_COORDINATE(
      const D3D12_TILED_RESOURCE_COORDINATE &o)
      : D3D12_TILED_RESOURCE_COORDINATE(o) {}
  CD3DX12_TILED_RESOURCE_COORDINATE(UINT x, UINT y, UINT z, UINT subresource) {
    X = x;
    Y = y;
    Z = z;
    Subresource = subresource;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_TILE_REGION_SIZE : public D3D12_TILE_REGION_SIZE {
  CD3DX12_TILE_REGION_SIZE() = default;
  explicit CD3DX12_TILE_REGION_SIZE(const D3D12_TILE_REGION_SIZE &o)
      : D3D12_TILE_REGION_SIZE(o) {}
  CD3DX12_TILE_REGION_SIZE(UINT numTiles, BOOL useBox, UINT width,
                           UINT16 height, UINT16 depth) {
    NumTiles = numTiles;
    UseBox = useBox;
    Width = width;
    Height = height;
    Depth = depth;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_SUBRESOURCE_TILING : public D3D12_SUBRESOURCE_TILING {
  CD3DX12_SUBRESOURCE_TILING() = default;
  explicit CD3DX12_SUBRESOURCE_TILING(const D3D12_SUBRESOURCE_TILING &o)
      : D3D12_SUBRESOURCE_TILING(o) {}
  CD3DX12_SUBRESOURCE_TILING(UINT widthInTiles, UINT16 heightInTiles,
                             UINT16 depthInTiles,
                             UINT startTileIndexInOverallResource) {
    WidthInTiles = widthInTiles;
    HeightInTiles = heightInTiles;
    DepthInTiles = depthInTiles;
    StartTileIndexInOverallResource = startTileIndexInOverallResource;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_TILE_SHAPE : public D3D12_TILE_SHAPE {
  CD3DX12_TILE_SHAPE() = default;
  explicit CD3DX12_TILE_SHAPE(const D3D12_TILE_SHAPE &o)
      : D3D12_TILE_SHAPE(o) {}
  CD3DX12_TILE_SHAPE(UINT widthInTexels, UINT heightInTexels,
                     UINT depthInTexels) {
    WidthInTexels = widthInTexels;
    HeightInTexels = heightInTexels;
    DepthInTexels = depthInTexels;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_RESOURCE_BARRIER : public D3D12_RESOURCE_BARRIER {
  CD3DX12_RESOURCE_BARRIER() = default;
  explicit CD3DX12_RESOURCE_BARRIER(const D3D12_RESOURCE_BARRIER &o)
      : D3D12_RESOURCE_BARRIER(o) {}
  static inline CD3DX12_RESOURCE_BARRIER Transition(
      _In_ ID3D12Resource *pResource, D3D12_RESOURCE_STATES stateBefore,
      D3D12_RESOURCE_STATES stateAfter,
      UINT subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES,
      D3D12_RESOURCE_BARRIER_FLAGS flags = D3D12_RESOURCE_BARRIER_FLAG_NONE) {
    CD3DX12_RESOURCE_BARRIER result = {};
    D3D12_RESOURCE_BARRIER &barrier = result;
    result.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
    result.Flags = flags;
    barrier.Transition.pResource = pResource;
    barrier.Transition.StateBefore = stateBefore;
    barrier.Transition.StateAfter = stateAfter;
    barrier.Transition.Subresource = subresource;
    return result;
  }
  static inline CD3DX12_RESOURCE_BARRIER
  Aliasing(_In_ ID3D12Resource *pResourceBefore,
           _In_ ID3D12Resource *pResourceAfter) {
    CD3DX12_RESOURCE_BARRIER result = {};
    D3D12_RESOURCE_BARRIER &barrier = result;
    result.Type = D3D12_RESOURCE_BARRIER_TYPE_ALIASING;
    barrier.Aliasing.pResourceBefore = pResourceBefore;
    barrier.Aliasing.pResourceAfter = pResourceAfter;
    return result;
  }
  static inline CD3DX12_RESOURCE_BARRIER UAV(_In_ ID3D12Resource *pResource) {
    CD3DX12_RESOURCE_BARRIER result = {};
    D3D12_RESOURCE_BARRIER &barrier = result;
    result.Type = D3D12_RESOURCE_BARRIER_TYPE_UAV;
    barrier.UAV.pResource = pResource;
    return result;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_PACKED_MIP_INFO : public D3D12_PACKED_MIP_INFO {
  CD3DX12_PACKED_MIP_INFO() = default;
  explicit CD3DX12_PACKED_MIP_INFO(const D3D12_PACKED_MIP_INFO &o)
      : D3D12_PACKED_MIP_INFO(o) {}
  CD3DX12_PACKED_MIP_INFO(UINT8 numStandardMips, UINT8 numPackedMips,
                          UINT numTilesForPackedMips,
                          UINT startTileIndexInOverallResource) {
    NumStandardMips = numStandardMips;
    NumPackedMips = numPackedMips;
    NumTilesForPackedMips = numTilesForPackedMips;
    StartTileIndexInOverallResource = startTileIndexInOverallResource;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_SUBRESOURCE_FOOTPRINT : public D3D12_SUBRESOURCE_FOOTPRINT {
  CD3DX12_SUBRESOURCE_FOOTPRINT() = default;
  explicit CD3DX12_SUBRESOURCE_FOOTPRINT(const D3D12_SUBRESOURCE_FOOTPRINT &o)
      : D3D12_SUBRESOURCE_FOOTPRINT(o) {}
  CD3DX12_SUBRESOURCE_FOOTPRINT(DXGI_FORMAT format, UINT width, UINT height,
                                UINT depth, UINT rowPitch) {
    Format = format;
    Width = width;
    Height = height;
    Depth = depth;
    RowPitch = rowPitch;
  }
  explicit CD3DX12_SUBRESOURCE_FOOTPRINT(const D3D12_RESOURCE_DESC &resDesc,
                                         UINT rowPitch) {
    Format = resDesc.Format;
    Width = UINT(resDesc.Width);
    Height = resDesc.Height;
    Depth = (resDesc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D
                 ? resDesc.DepthOrArraySize
                 : 1);
    RowPitch = rowPitch;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_TEXTURE_COPY_LOCATION : public D3D12_TEXTURE_COPY_LOCATION {
  CD3DX12_TEXTURE_COPY_LOCATION() = default;
  explicit CD3DX12_TEXTURE_COPY_LOCATION(const D3D12_TEXTURE_COPY_LOCATION &o)
      : D3D12_TEXTURE_COPY_LOCATION(o) {}
  CD3DX12_TEXTURE_COPY_LOCATION(_In_ ID3D12Resource *pRes) {
    pResource = pRes;
    Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
    PlacedFootprint = {};
  }
  CD3DX12_TEXTURE_COPY_LOCATION(
      _In_ ID3D12Resource *pRes,
      D3D12_PLACED_SUBRESOURCE_FOOTPRINT const &Footprint) {
    pResource = pRes;
    Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
    PlacedFootprint = Footprint;
  }
  CD3DX12_TEXTURE_COPY_LOCATION(_In_ ID3D12Resource *pRes, UINT Sub) {
    pResource = pRes;
    Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
    PlacedFootprint = {};
    SubresourceIndex = Sub;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_DESCRIPTOR_RANGE : public D3D12_DESCRIPTOR_RANGE {
  CD3DX12_DESCRIPTOR_RANGE() = default;
  explicit CD3DX12_DESCRIPTOR_RANGE(const D3D12_DESCRIPTOR_RANGE &o)
      : D3D12_DESCRIPTOR_RANGE(o) {}
  CD3DX12_DESCRIPTOR_RANGE(D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
                           UINT numDescriptors, UINT baseShaderRegister,
                           UINT registerSpace = 0,
                           UINT offsetInDescriptorsFromTableStart =
                               D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) {
    Init(rangeType, numDescriptors, baseShaderRegister, registerSpace,
         offsetInDescriptorsFromTableStart);
  }

  inline void Init(D3D12_DESCRIPTOR_RANGE_TYPE rangeType, UINT numDescriptors,
                   UINT baseShaderRegister, UINT registerSpace = 0,
                   UINT offsetInDescriptorsFromTableStart =
                       D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) {
    Init(*this, rangeType, numDescriptors, baseShaderRegister, registerSpace,
         offsetInDescriptorsFromTableStart);
  }

  static inline void Init(_Out_ D3D12_DESCRIPTOR_RANGE &range,
                          D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
                          UINT numDescriptors, UINT baseShaderRegister,
                          UINT registerSpace = 0,
                          UINT offsetInDescriptorsFromTableStart =
                              D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) {
    range.RangeType = rangeType;
    range.NumDescriptors = numDescriptors;
    range.BaseShaderRegister = baseShaderRegister;
    range.RegisterSpace = registerSpace;
    range.OffsetInDescriptorsFromTableStart = offsetInDescriptorsFromTableStart;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_ROOT_DESCRIPTOR_TABLE : public D3D12_ROOT_DESCRIPTOR_TABLE {
  CD3DX12_ROOT_DESCRIPTOR_TABLE() = default;
  explicit CD3DX12_ROOT_DESCRIPTOR_TABLE(const D3D12_ROOT_DESCRIPTOR_TABLE &o)
      : D3D12_ROOT_DESCRIPTOR_TABLE(o) {}
  CD3DX12_ROOT_DESCRIPTOR_TABLE(
      UINT numDescriptorRanges,
      _In_reads_opt_(numDescriptorRanges)
          const D3D12_DESCRIPTOR_RANGE *_pDescriptorRanges) {
    Init(numDescriptorRanges, _pDescriptorRanges);
  }

  inline void Init(UINT numDescriptorRanges,
                   _In_reads_opt_(numDescriptorRanges)
                       const D3D12_DESCRIPTOR_RANGE *_pDescriptorRanges) {
    Init(*this, numDescriptorRanges, _pDescriptorRanges);
  }

  static inline void
  Init(_Out_ D3D12_ROOT_DESCRIPTOR_TABLE &rootDescriptorTable,
       UINT numDescriptorRanges,
       _In_reads_opt_(numDescriptorRanges)
           const D3D12_DESCRIPTOR_RANGE *_pDescriptorRanges) {
    rootDescriptorTable.NumDescriptorRanges = numDescriptorRanges;
    rootDescriptorTable.pDescriptorRanges = _pDescriptorRanges;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_ROOT_CONSTANTS : public D3D12_ROOT_CONSTANTS {
  CD3DX12_ROOT_CONSTANTS() = default;
  explicit CD3DX12_ROOT_CONSTANTS(const D3D12_ROOT_CONSTANTS &o)
      : D3D12_ROOT_CONSTANTS(o) {}
  CD3DX12_ROOT_CONSTANTS(UINT num32BitValues, UINT shaderRegister,
                         UINT registerSpace = 0) {
    Init(num32BitValues, shaderRegister, registerSpace);
  }

  inline void Init(UINT num32BitValues, UINT shaderRegister,
                   UINT registerSpace = 0) {
    Init(*this, num32BitValues, shaderRegister, registerSpace);
  }

  static inline void Init(_Out_ D3D12_ROOT_CONSTANTS &rootConstants,
                          UINT num32BitValues, UINT shaderRegister,
                          UINT registerSpace = 0) {
    rootConstants.Num32BitValues = num32BitValues;
    rootConstants.ShaderRegister = shaderRegister;
    rootConstants.RegisterSpace = registerSpace;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_ROOT_DESCRIPTOR : public D3D12_ROOT_DESCRIPTOR {
  CD3DX12_ROOT_DESCRIPTOR() = default;
  explicit CD3DX12_ROOT_DESCRIPTOR(const D3D12_ROOT_DESCRIPTOR &o)
      : D3D12_ROOT_DESCRIPTOR(o) {}
  CD3DX12_ROOT_DESCRIPTOR(UINT shaderRegister, UINT registerSpace = 0) {
    Init(shaderRegister, registerSpace);
  }

  inline void Init(UINT shaderRegister, UINT registerSpace = 0) {
    Init(*this, shaderRegister, registerSpace);
  }

  static inline void Init(_Out_ D3D12_ROOT_DESCRIPTOR &table,
                          UINT shaderRegister, UINT registerSpace = 0) {
    table.ShaderRegister = shaderRegister;
    table.RegisterSpace = registerSpace;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_ROOT_PARAMETER : public D3D12_ROOT_PARAMETER {
  CD3DX12_ROOT_PARAMETER() = default;
  explicit CD3DX12_ROOT_PARAMETER(const D3D12_ROOT_PARAMETER &o)
      : D3D12_ROOT_PARAMETER(o) {}

  static inline void InitAsDescriptorTable(
      _Out_ D3D12_ROOT_PARAMETER &rootParam, UINT numDescriptorRanges,
      _In_reads_(numDescriptorRanges)
          const D3D12_DESCRIPTOR_RANGE *pDescriptorRanges,
      D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) {
    rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
    rootParam.ShaderVisibility = visibility;
    CD3DX12_ROOT_DESCRIPTOR_TABLE::Init(rootParam.DescriptorTable,
                                        numDescriptorRanges, pDescriptorRanges);
  }

  static inline void InitAsConstants(
      _Out_ D3D12_ROOT_PARAMETER &rootParam, UINT num32BitValues,
      UINT shaderRegister, UINT registerSpace = 0,
      D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) {
    rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS;
    rootParam.ShaderVisibility = visibility;
    CD3DX12_ROOT_CONSTANTS::Init(rootParam.Constants, num32BitValues,
                                 shaderRegister, registerSpace);
  }

  static inline void InitAsConstantBufferView(
      _Out_ D3D12_ROOT_PARAMETER &rootParam, UINT shaderRegister,
      UINT registerSpace = 0,
      D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) {
    rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
    rootParam.ShaderVisibility = visibility;
    CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister,
                                  registerSpace);
  }

  static inline void InitAsShaderResourceView(
      _Out_ D3D12_ROOT_PARAMETER &rootParam, UINT shaderRegister,
      UINT registerSpace = 0,
      D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) {
    rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_SRV;
    rootParam.ShaderVisibility = visibility;
    CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister,
                                  registerSpace);
  }

  static inline void InitAsUnorderedAccessView(
      _Out_ D3D12_ROOT_PARAMETER &rootParam, UINT shaderRegister,
      UINT registerSpace = 0,
      D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) {
    rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_UAV;
    rootParam.ShaderVisibility = visibility;
    CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister,
                                  registerSpace);
  }

  inline void InitAsDescriptorTable(
      UINT numDescriptorRanges,
      _In_reads_(numDescriptorRanges)
          const D3D12_DESCRIPTOR_RANGE *pDescriptorRanges,
      D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) {
    InitAsDescriptorTable(*this, numDescriptorRanges, pDescriptorRanges,
                          visibility);
  }

  inline void InitAsConstants(
      UINT num32BitValues, UINT shaderRegister, UINT registerSpace = 0,
      D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) {
    InitAsConstants(*this, num32BitValues, shaderRegister, registerSpace,
                    visibility);
  }

  inline void InitAsConstantBufferView(
      UINT shaderRegister, UINT registerSpace = 0,
      D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) {
    InitAsConstantBufferView(*this, shaderRegister, registerSpace, visibility);
  }

  inline void InitAsShaderResourceView(
      UINT shaderRegister, UINT registerSpace = 0,
      D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) {
    InitAsShaderResourceView(*this, shaderRegister, registerSpace, visibility);
  }

  inline void InitAsUnorderedAccessView(
      UINT shaderRegister, UINT registerSpace = 0,
      D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) {
    InitAsUnorderedAccessView(*this, shaderRegister, registerSpace, visibility);
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_STATIC_SAMPLER_DESC : public D3D12_STATIC_SAMPLER_DESC {
  CD3DX12_STATIC_SAMPLER_DESC() = default;
  explicit CD3DX12_STATIC_SAMPLER_DESC(const D3D12_STATIC_SAMPLER_DESC &o)
      : D3D12_STATIC_SAMPLER_DESC(o) {}
  CD3DX12_STATIC_SAMPLER_DESC(
      UINT shaderRegister, D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC,
      D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
      D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
      D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
      FLOAT mipLODBias = 0, UINT maxAnisotropy = 16,
      D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL,
      D3D12_STATIC_BORDER_COLOR borderColor =
          D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE,
      FLOAT minLOD = 0.f, FLOAT maxLOD = D3D12_FLOAT32_MAX,
      D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL,
      UINT registerSpace = 0) {
    Init(shaderRegister, filter, addressU, addressV, addressW, mipLODBias,
         maxAnisotropy, comparisonFunc, borderColor, minLOD, maxLOD,
         shaderVisibility, registerSpace);
  }

  static inline void
  Init(_Out_ D3D12_STATIC_SAMPLER_DESC &samplerDesc, UINT shaderRegister,
       D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC,
       D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
       D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
       D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
       FLOAT mipLODBias = 0, UINT maxAnisotropy = 16,
       D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL,
       D3D12_STATIC_BORDER_COLOR borderColor =
           D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE,
       FLOAT minLOD = 0.f, FLOAT maxLOD = D3D12_FLOAT32_MAX,
       D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL,
       UINT registerSpace = 0) {
    samplerDesc.ShaderRegister = shaderRegister;
    samplerDesc.Filter = filter;
    samplerDesc.AddressU = addressU;
    samplerDesc.AddressV = addressV;
    samplerDesc.AddressW = addressW;
    samplerDesc.MipLODBias = mipLODBias;
    samplerDesc.MaxAnisotropy = maxAnisotropy;
    samplerDesc.ComparisonFunc = comparisonFunc;
    samplerDesc.BorderColor = borderColor;
    samplerDesc.MinLOD = minLOD;
    samplerDesc.MaxLOD = maxLOD;
    samplerDesc.ShaderVisibility = shaderVisibility;
    samplerDesc.RegisterSpace = registerSpace;
  }
  inline void
  Init(UINT shaderRegister, D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC,
       D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
       D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
       D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
       FLOAT mipLODBias = 0, UINT maxAnisotropy = 16,
       D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL,
       D3D12_STATIC_BORDER_COLOR borderColor =
           D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE,
       FLOAT minLOD = 0.f, FLOAT maxLOD = D3D12_FLOAT32_MAX,
       D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL,
       UINT registerSpace = 0) {
    Init(*this, shaderRegister, filter, addressU, addressV, addressW,
         mipLODBias, maxAnisotropy, comparisonFunc, borderColor, minLOD, maxLOD,
         shaderVisibility, registerSpace);
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_ROOT_SIGNATURE_DESC : public D3D12_ROOT_SIGNATURE_DESC {
  CD3DX12_ROOT_SIGNATURE_DESC() = default;
  explicit CD3DX12_ROOT_SIGNATURE_DESC(const D3D12_ROOT_SIGNATURE_DESC &o)
      : D3D12_ROOT_SIGNATURE_DESC(o) {}
  CD3DX12_ROOT_SIGNATURE_DESC(
      UINT numParameters,
      _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER *_pParameters,
      UINT numStaticSamplers = 0,
      _In_reads_opt_(numStaticSamplers)
          const D3D12_STATIC_SAMPLER_DESC *_pStaticSamplers = nullptr,
      D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) {
    Init(numParameters, _pParameters, numStaticSamplers, _pStaticSamplers,
         flags);
  }
  CD3DX12_ROOT_SIGNATURE_DESC(CD3DX12_DEFAULT) {
    Init(0, nullptr, 0, nullptr, D3D12_ROOT_SIGNATURE_FLAG_NONE);
  }

  inline void
  Init(UINT numParameters,
       _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER *_pParameters,
       UINT numStaticSamplers = 0,
       _In_reads_opt_(numStaticSamplers)
           const D3D12_STATIC_SAMPLER_DESC *_pStaticSamplers = nullptr,
       D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) {
    Init(*this, numParameters, _pParameters, numStaticSamplers,
         _pStaticSamplers, flags);
  }

  static inline void
  Init(_Out_ D3D12_ROOT_SIGNATURE_DESC &desc, UINT numParameters,
       _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER *_pParameters,
       UINT numStaticSamplers = 0,
       _In_reads_opt_(numStaticSamplers)
           const D3D12_STATIC_SAMPLER_DESC *_pStaticSamplers = nullptr,
       D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) {
    desc.NumParameters = numParameters;
    desc.pParameters = _pParameters;
    desc.NumStaticSamplers = numStaticSamplers;
    desc.pStaticSamplers = _pStaticSamplers;
    desc.Flags = flags;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_DESCRIPTOR_RANGE1 : public D3D12_DESCRIPTOR_RANGE1 {
  CD3DX12_DESCRIPTOR_RANGE1() = default;
  explicit CD3DX12_DESCRIPTOR_RANGE1(const D3D12_DESCRIPTOR_RANGE1 &o)
      : D3D12_DESCRIPTOR_RANGE1(o) {}
  CD3DX12_DESCRIPTOR_RANGE1(
      D3D12_DESCRIPTOR_RANGE_TYPE rangeType, UINT numDescriptors,
      UINT baseShaderRegister, UINT registerSpace = 0,
      D3D12_DESCRIPTOR_RANGE_FLAGS flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE,
      UINT offsetInDescriptorsFromTableStart =
          D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) {
    Init(rangeType, numDescriptors, baseShaderRegister, registerSpace, flags,
         offsetInDescriptorsFromTableStart);
  }

  inline void
  Init(D3D12_DESCRIPTOR_RANGE_TYPE rangeType, UINT numDescriptors,
       UINT baseShaderRegister, UINT registerSpace = 0,
       D3D12_DESCRIPTOR_RANGE_FLAGS flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE,
       UINT offsetInDescriptorsFromTableStart =
           D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) {
    Init(*this, rangeType, numDescriptors, baseShaderRegister, registerSpace,
         flags, offsetInDescriptorsFromTableStart);
  }

  static inline void
  Init(_Out_ D3D12_DESCRIPTOR_RANGE1 &range,
       D3D12_DESCRIPTOR_RANGE_TYPE rangeType, UINT numDescriptors,
       UINT baseShaderRegister, UINT registerSpace = 0,
       D3D12_DESCRIPTOR_RANGE_FLAGS flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE,
       UINT offsetInDescriptorsFromTableStart =
           D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) {
    range.RangeType = rangeType;
    range.NumDescriptors = numDescriptors;
    range.BaseShaderRegister = baseShaderRegister;
    range.RegisterSpace = registerSpace;
    range.Flags = flags;
    range.OffsetInDescriptorsFromTableStart = offsetInDescriptorsFromTableStart;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_ROOT_DESCRIPTOR_TABLE1 : public D3D12_ROOT_DESCRIPTOR_TABLE1 {
  CD3DX12_ROOT_DESCRIPTOR_TABLE1() = default;
  explicit CD3DX12_ROOT_DESCRIPTOR_TABLE1(const D3D12_ROOT_DESCRIPTOR_TABLE1 &o)
      : D3D12_ROOT_DESCRIPTOR_TABLE1(o) {}
  CD3DX12_ROOT_DESCRIPTOR_TABLE1(
      UINT numDescriptorRanges,
      _In_reads_opt_(numDescriptorRanges)
          const D3D12_DESCRIPTOR_RANGE1 *_pDescriptorRanges) {
    Init(numDescriptorRanges, _pDescriptorRanges);
  }

  inline void Init(UINT numDescriptorRanges,
                   _In_reads_opt_(numDescriptorRanges)
                       const D3D12_DESCRIPTOR_RANGE1 *_pDescriptorRanges) {
    Init(*this, numDescriptorRanges, _pDescriptorRanges);
  }

  static inline void
  Init(_Out_ D3D12_ROOT_DESCRIPTOR_TABLE1 &rootDescriptorTable,
       UINT numDescriptorRanges,
       _In_reads_opt_(numDescriptorRanges)
           const D3D12_DESCRIPTOR_RANGE1 *_pDescriptorRanges) {
    rootDescriptorTable.NumDescriptorRanges = numDescriptorRanges;
    rootDescriptorTable.pDescriptorRanges = _pDescriptorRanges;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_ROOT_DESCRIPTOR1 : public D3D12_ROOT_DESCRIPTOR1 {
  CD3DX12_ROOT_DESCRIPTOR1() = default;
  explicit CD3DX12_ROOT_DESCRIPTOR1(const D3D12_ROOT_DESCRIPTOR1 &o)
      : D3D12_ROOT_DESCRIPTOR1(o) {}
  CD3DX12_ROOT_DESCRIPTOR1(
      UINT shaderRegister, UINT registerSpace = 0,
      D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE) {
    Init(shaderRegister, registerSpace, flags);
  }

  inline void
  Init(UINT shaderRegister, UINT registerSpace = 0,
       D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE) {
    Init(*this, shaderRegister, registerSpace, flags);
  }

  static inline void
  Init(_Out_ D3D12_ROOT_DESCRIPTOR1 &table, UINT shaderRegister,
       UINT registerSpace = 0,
       D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE) {
    table.ShaderRegister = shaderRegister;
    table.RegisterSpace = registerSpace;
    table.Flags = flags;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_ROOT_PARAMETER1 : public D3D12_ROOT_PARAMETER1 {
  CD3DX12_ROOT_PARAMETER1() = default;
  explicit CD3DX12_ROOT_PARAMETER1(const D3D12_ROOT_PARAMETER1 &o)
      : D3D12_ROOT_PARAMETER1(o) {}

  static inline void InitAsDescriptorTable(
      _Out_ D3D12_ROOT_PARAMETER1 &rootParam, UINT numDescriptorRanges,
      _In_reads_(numDescriptorRanges)
          const D3D12_DESCRIPTOR_RANGE1 *pDescriptorRanges,
      D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) {
    rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
    rootParam.ShaderVisibility = visibility;
    CD3DX12_ROOT_DESCRIPTOR_TABLE1::Init(
        rootParam.DescriptorTable, numDescriptorRanges, pDescriptorRanges);
  }

  static inline void InitAsConstants(
      _Out_ D3D12_ROOT_PARAMETER1 &rootParam, UINT num32BitValues,
      UINT shaderRegister, UINT registerSpace = 0,
      D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) {
    rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS;
    rootParam.ShaderVisibility = visibility;
    CD3DX12_ROOT_CONSTANTS::Init(rootParam.Constants, num32BitValues,
                                 shaderRegister, registerSpace);
  }

  static inline void InitAsConstantBufferView(
      _Out_ D3D12_ROOT_PARAMETER1 &rootParam, UINT shaderRegister,
      UINT registerSpace = 0,
      D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
      D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) {
    rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
    rootParam.ShaderVisibility = visibility;
    CD3DX12_ROOT_DESCRIPTOR1::Init(rootParam.Descriptor, shaderRegister,
                                   registerSpace, flags);
  }

  static inline void InitAsShaderResourceView(
      _Out_ D3D12_ROOT_PARAMETER1 &rootParam, UINT shaderRegister,
      UINT registerSpace = 0,
      D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
      D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) {
    rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_SRV;
    rootParam.ShaderVisibility = visibility;
    CD3DX12_ROOT_DESCRIPTOR1::Init(rootParam.Descriptor, shaderRegister,
                                   registerSpace, flags);
  }

  static inline void InitAsUnorderedAccessView(
      _Out_ D3D12_ROOT_PARAMETER1 &rootParam, UINT shaderRegister,
      UINT registerSpace = 0,
      D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
      D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) {
    rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_UAV;
    rootParam.ShaderVisibility = visibility;
    CD3DX12_ROOT_DESCRIPTOR1::Init(rootParam.Descriptor, shaderRegister,
                                   registerSpace, flags);
  }

  inline void InitAsDescriptorTable(
      UINT numDescriptorRanges,
      _In_reads_(numDescriptorRanges)
          const D3D12_DESCRIPTOR_RANGE1 *pDescriptorRanges,
      D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) {
    InitAsDescriptorTable(*this, numDescriptorRanges, pDescriptorRanges,
                          visibility);
  }

  inline void InitAsConstants(
      UINT num32BitValues, UINT shaderRegister, UINT registerSpace = 0,
      D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) {
    InitAsConstants(*this, num32BitValues, shaderRegister, registerSpace,
                    visibility);
  }

  inline void InitAsConstantBufferView(
      UINT shaderRegister, UINT registerSpace = 0,
      D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
      D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) {
    InitAsConstantBufferView(*this, shaderRegister, registerSpace, flags,
                             visibility);
  }

  inline void InitAsShaderResourceView(
      UINT shaderRegister, UINT registerSpace = 0,
      D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
      D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) {
    InitAsShaderResourceView(*this, shaderRegister, registerSpace, flags,
                             visibility);
  }

  inline void InitAsUnorderedAccessView(
      UINT shaderRegister, UINT registerSpace = 0,
      D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE,
      D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) {
    InitAsUnorderedAccessView(*this, shaderRegister, registerSpace, flags,
                              visibility);
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC
    : public D3D12_VERSIONED_ROOT_SIGNATURE_DESC {
  CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC() = default;
  explicit CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(
      const D3D12_VERSIONED_ROOT_SIGNATURE_DESC &o)
      : D3D12_VERSIONED_ROOT_SIGNATURE_DESC(o) {}
  explicit CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(
      const D3D12_ROOT_SIGNATURE_DESC &o) {
    Version = D3D_ROOT_SIGNATURE_VERSION_1_0;
    Desc_1_0 = o;
  }
  explicit CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(
      const D3D12_ROOT_SIGNATURE_DESC1 &o) {
    Version = D3D_ROOT_SIGNATURE_VERSION_1_1;
    Desc_1_1 = o;
  }
  CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(
      UINT numParameters,
      _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER *_pParameters,
      UINT numStaticSamplers = 0,
      _In_reads_opt_(numStaticSamplers)
          const D3D12_STATIC_SAMPLER_DESC *_pStaticSamplers = nullptr,
      D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) {
    Init_1_0(numParameters, _pParameters, numStaticSamplers, _pStaticSamplers,
             flags);
  }
  CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(
      UINT numParameters,
      _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER1 *_pParameters,
      UINT numStaticSamplers = 0,
      _In_reads_opt_(numStaticSamplers)
          const D3D12_STATIC_SAMPLER_DESC *_pStaticSamplers = nullptr,
      D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) {
    Init_1_1(numParameters, _pParameters, numStaticSamplers, _pStaticSamplers,
             flags);
  }
  CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(CD3DX12_DEFAULT) {
    Init_1_1(0, nullptr, 0, nullptr, D3D12_ROOT_SIGNATURE_FLAG_NONE);
  }

  inline void
  Init_1_0(UINT numParameters,
           _In_reads_opt_(numParameters)
               const D3D12_ROOT_PARAMETER *_pParameters,
           UINT numStaticSamplers = 0,
           _In_reads_opt_(numStaticSamplers)
               const D3D12_STATIC_SAMPLER_DESC *_pStaticSamplers = nullptr,
           D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) {
    Init_1_0(*this, numParameters, _pParameters, numStaticSamplers,
             _pStaticSamplers, flags);
  }

  static inline void
  Init_1_0(_Out_ D3D12_VERSIONED_ROOT_SIGNATURE_DESC &desc, UINT numParameters,
           _In_reads_opt_(numParameters)
               const D3D12_ROOT_PARAMETER *_pParameters,
           UINT numStaticSamplers = 0,
           _In_reads_opt_(numStaticSamplers)
               const D3D12_STATIC_SAMPLER_DESC *_pStaticSamplers = nullptr,
           D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) {
    desc.Version = D3D_ROOT_SIGNATURE_VERSION_1_0;
    desc.Desc_1_0.NumParameters = numParameters;
    desc.Desc_1_0.pParameters = _pParameters;
    desc.Desc_1_0.NumStaticSamplers = numStaticSamplers;
    desc.Desc_1_0.pStaticSamplers = _pStaticSamplers;
    desc.Desc_1_0.Flags = flags;
  }

  inline void
  Init_1_1(UINT numParameters,
           _In_reads_opt_(numParameters)
               const D3D12_ROOT_PARAMETER1 *_pParameters,
           UINT numStaticSamplers = 0,
           _In_reads_opt_(numStaticSamplers)
               const D3D12_STATIC_SAMPLER_DESC *_pStaticSamplers = nullptr,
           D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) {
    Init_1_1(*this, numParameters, _pParameters, numStaticSamplers,
             _pStaticSamplers, flags);
  }

  static inline void
  Init_1_1(_Out_ D3D12_VERSIONED_ROOT_SIGNATURE_DESC &desc, UINT numParameters,
           _In_reads_opt_(numParameters)
               const D3D12_ROOT_PARAMETER1 *_pParameters,
           UINT numStaticSamplers = 0,
           _In_reads_opt_(numStaticSamplers)
               const D3D12_STATIC_SAMPLER_DESC *_pStaticSamplers = nullptr,
           D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) {
    desc.Version = D3D_ROOT_SIGNATURE_VERSION_1_1;
    desc.Desc_1_1.NumParameters = numParameters;
    desc.Desc_1_1.pParameters = _pParameters;
    desc.Desc_1_1.NumStaticSamplers = numStaticSamplers;
    desc.Desc_1_1.pStaticSamplers = _pStaticSamplers;
    desc.Desc_1_1.Flags = flags;
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_CPU_DESCRIPTOR_HANDLE : public D3D12_CPU_DESCRIPTOR_HANDLE {
  CD3DX12_CPU_DESCRIPTOR_HANDLE() = default;
  explicit CD3DX12_CPU_DESCRIPTOR_HANDLE(const D3D12_CPU_DESCRIPTOR_HANDLE &o)
      : D3D12_CPU_DESCRIPTOR_HANDLE(o) {}
  CD3DX12_CPU_DESCRIPTOR_HANDLE(CD3DX12_DEFAULT) { ptr = 0; }
  CD3DX12_CPU_DESCRIPTOR_HANDLE(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &other,
                                INT offsetScaledByIncrementSize) {
    InitOffsetted(other, offsetScaledByIncrementSize);
  }
  CD3DX12_CPU_DESCRIPTOR_HANDLE(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &other,
                                INT offsetInDescriptors,
                                UINT descriptorIncrementSize) {
    InitOffsetted(other, offsetInDescriptors, descriptorIncrementSize);
  }
  CD3DX12_CPU_DESCRIPTOR_HANDLE &Offset(INT offsetInDescriptors,
                                        UINT descriptorIncrementSize) {
    ptr = SIZE_T(INT64(ptr) +
                 INT64(offsetInDescriptors) * INT64(descriptorIncrementSize));
    return *this;
  }
  CD3DX12_CPU_DESCRIPTOR_HANDLE &Offset(INT offsetScaledByIncrementSize) {
    ptr = SIZE_T(INT64(ptr) + INT64(offsetScaledByIncrementSize));
    return *this;
  }
  bool operator==(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &other) const {
    return (ptr == other.ptr);
  }
  bool operator!=(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &other) const {
    return (ptr != other.ptr);
  }
  CD3DX12_CPU_DESCRIPTOR_HANDLE &
  operator=(const D3D12_CPU_DESCRIPTOR_HANDLE &other) {
    ptr = other.ptr;
    return *this;
  }

  inline void InitOffsetted(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base,
                            INT offsetScaledByIncrementSize) {
    InitOffsetted(*this, base, offsetScaledByIncrementSize);
  }

  inline void InitOffsetted(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base,
                            INT offsetInDescriptors,
                            UINT descriptorIncrementSize) {
    InitOffsetted(*this, base, offsetInDescriptors, descriptorIncrementSize);
  }

  static inline void InitOffsetted(_Out_ D3D12_CPU_DESCRIPTOR_HANDLE &handle,
                                   _In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base,
                                   INT offsetScaledByIncrementSize) {
    handle.ptr = SIZE_T(INT64(base.ptr) + INT64(offsetScaledByIncrementSize));
  }

  static inline void InitOffsetted(_Out_ D3D12_CPU_DESCRIPTOR_HANDLE &handle,
                                   _In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base,
                                   INT offsetInDescriptors,
                                   UINT descriptorIncrementSize) {
    handle.ptr = SIZE_T(INT64(base.ptr) + INT64(offsetInDescriptors) *
                                              INT64(descriptorIncrementSize));
  }
};

//------------------------------------------------------------------------------------------------
struct CD3DX12_GPU_DESCRIPTOR_HANDLE : public D3D12_GPU_DESCRIPTOR_HANDLE {
  CD3DX12_GPU_DESCRIPTOR_HANDLE() = default;
  explicit CD3DX12_GPU_DESCRIPTOR_HANDLE(const D3D12_GPU_DESCRIPTOR_HANDLE &o)
      : D3D12_GPU_DESCRIPTOR_HANDLE(o) {}
  CD3DX12_GPU_DESCRIPTOR_HANDLE(CD3DX12_DEFAULT) { ptr = 0; }
  CD3DX12_GPU_DESCRIPTOR_HANDLE(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &other,
                                INT offsetScaledByIncrementSize) {
    InitOffsetted(other, offsetScaledByIncrementSize);
  }
  CD3DX12_GPU_DESCRIPTOR_HANDLE(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &other,
                                INT offsetInDescriptors,
                                UINT descriptorIncrementSize) {
    InitOffsetted(other, offsetInDescriptors, descriptorIncrementSize);
  }
  CD3DX12_GPU_DESCRIPTOR_HANDLE &Offset(INT offsetInDescriptors,
                                        UINT descriptorIncrementSize) {
    ptr = UINT64(INT64(ptr) +
                 INT64(offsetInDescriptors) * INT64(descriptorIncrementSize));
    return *this;
  }
  CD3DX12_GPU_DESCRIPTOR_HANDLE &Offset(INT offsetScaledByIncrementSize) {
    ptr = UINT64(INT64(ptr) + INT64(offsetScaledByIncrementSize));
    return *this;
  }
  inline bool operator==(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &other) const {
    return (ptr == other.ptr);
  }
  inline bool operator!=(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &other) const {
    return (ptr != other.ptr);
  }
  CD3DX12_GPU_DESCRIPTOR_HANDLE &
  operator=(const D3D12_GPU_DESCRIPTOR_HANDLE &other) {
    ptr = other.ptr;
    return *this;
  }

  inline void InitOffsetted(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base,
                            INT offsetScaledByIncrementSize) {
    InitOffsetted(*this, base, offsetScaledByIncrementSize);
  }

  inline void InitOffsetted(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base,
                            INT offsetInDescriptors,
                            UINT descriptorIncrementSize) {
    InitOffsetted(*this, base, offsetInDescriptors, descriptorIncrementSize);
  }

  static inline void InitOffsetted(_Out_ D3D12_GPU_DESCRIPTOR_HANDLE &handle,
                                   _In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base,
                                   INT offsetScaledByIncrementSize) {
    handle.ptr = UINT64(INT64(base.ptr) + INT64(offsetScaledByIncrementSize));
  }

  static inline void InitOffsetted(_Out_ D3D12_GPU_DESCRIPTOR_HANDLE &handle,
                                   _In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base,
                                   INT offsetInDescriptors,
                                   UINT descriptorIncrementSize) {
    handle.ptr = UINT64(INT64(base.ptr) + INT64(offsetInDescriptors) *
                                              INT64(descriptorIncrementSize));
  }
};

//------------------------------------------------------------------------------------------------
inline UINT D3D12CalcSubresource(UINT MipSlice, UINT ArraySlice,
                                 UINT PlaneSlice, UINT MipLevels,
                                 UINT ArraySize) {
  return MipSlice + ArraySlice * MipLevels + PlaneSlice * MipLevels * ArraySize;
}

//------------------------------------------------------------------------------------------------
template <typename T, typename U, typename V>
inline void D3D12DecomposeSubresource(UINT Subresource, UINT MipLevels,
                                      UINT ArraySize, _Out_ T &MipSlice,
                                      _Out_ U &ArraySlice,
                                      _Out_ V &PlaneSlice) {
  MipSlice = static_cast<T>(Subresource % MipLevels);
  ArraySlice = static_cast<U>((Subresource / MipLevels) % ArraySize);
  PlaneSlice = static_cast<V>(Subresource / (MipLevels * ArraySize));
}

//------------------------------------------------------------------------------------------------
inline UINT8 D3D12GetFormatPlaneCount(_In_ ID3D12Device *pDevice,
                                      DXGI_FORMAT Format) {
  D3D12_FEATURE_DATA_FORMAT_INFO formatInfo = {Format, 0};
  if (FAILED(pDevice->CheckFeatureSupport(D3D12_FEATURE_FORMAT_INFO,
                                          &formatInfo, sizeof(formatInfo)))) {
    return 0;
  }
  return formatInfo.PlaneCount;
}

//------------------------------------------------------------------------------------------------
struct CD3DX12_RESOURCE_DESC : public D3D12_RESOURCE_DESC {
  CD3DX12_RESOURCE_DESC() = default;
  explicit CD3DX12_RESOURCE_DESC(const D3D12_RESOURCE_DESC &o)
      : D3D12_RESOURCE_DESC(o) {}
  CD3DX12_RESOURCE_DESC(D3D12_RESOURCE_DIMENSION dimension, UINT64 alignment,
                        UINT64 width, UINT height, UINT16 depthOrArraySize,
                        UINT16 mipLevels, DXGI_FORMAT format, UINT sampleCount,
                        UINT sampleQuality, D3D12_TEXTURE_LAYOUT layout,
                        D3D12_RESOURCE_FLAGS flags) {
    Dimension = dimension;
    Alignment = alignment;
    Width = width;
    Height = height;
    DepthOrArraySize = depthOrArraySize;
    MipLevels = mipLevels;
    Format = format;
    SampleDesc.Count = sampleCount;
    SampleDesc.Quality = sampleQuality;
    Layout = layout;
    Flags = flags;
  }
  static inline CD3DX12_RESOURCE_DESC
  Buffer(const D3D12_RESOURCE_ALLOCATION_INFO &resAllocInfo,
         D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE) {
    return CD3DX12_RESOURCE_DESC(
        D3D12_RESOURCE_DIMENSION_BUFFER, resAllocInfo.Alignment,
        resAllocInfo.SizeInBytes, 1, 1, 1, DXGI_FORMAT_UNKNOWN, 1, 0,
        D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags);
  }
  static inline CD3DX12_RESOURCE_DESC
  Buffer(UINT64 width, D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
         UINT64 alignment = 0) {
    return CD3DX12_RESOURCE_DESC(D3D12_RESOURCE_DIMENSION_BUFFER, alignment,
                                 width, 1, 1, 1, DXGI_FORMAT_UNKNOWN, 1, 0,
                                 D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags);
  }
  static inline CD3DX12_RESOURCE_DESC
  Tex1D(DXGI_FORMAT format, UINT64 width, UINT16 arraySize = 1,
        UINT16 mipLevels = 0,
        D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
        D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
        UINT64 alignment = 0) {
    return CD3DX12_RESOURCE_DESC(D3D12_RESOURCE_DIMENSION_TEXTURE1D, alignment,
                                 width, 1, arraySize, mipLevels, format, 1, 0,
                                 layout, flags);
  }
  static inline CD3DX12_RESOURCE_DESC
  Tex2D(DXGI_FORMAT format, UINT64 width, UINT height, UINT16 arraySize = 1,
        UINT16 mipLevels = 0, UINT sampleCount = 1, UINT sampleQuality = 0,
        D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
        D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
        UINT64 alignment = 0) {
    return CD3DX12_RESOURCE_DESC(D3D12_RESOURCE_DIMENSION_TEXTURE2D, alignment,
                                 width, height, arraySize, mipLevels, format,
                                 sampleCount, sampleQuality, layout, flags);
  }
  static inline CD3DX12_RESOURCE_DESC
  Tex3D(DXGI_FORMAT format, UINT64 width, UINT height, UINT16 depth,
        UINT16 mipLevels = 0,
        D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
        D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
        UINT64 alignment = 0) {
    return CD3DX12_RESOURCE_DESC(D3D12_RESOURCE_DIMENSION_TEXTURE3D, alignment,
                                 width, height, depth, mipLevels, format, 1, 0,
                                 layout, flags);
  }
  inline UINT16 Depth() const {
    return (Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize
                                                            : 1);
  }
  inline UINT16 ArraySize() const {
    return (Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize
                                                            : 1);
  }
  inline UINT8 PlaneCount(_In_ ID3D12Device *pDevice) const {
    return D3D12GetFormatPlaneCount(pDevice, Format);
  }
  inline UINT Subresources(_In_ ID3D12Device *pDevice) const {
    return MipLevels * ArraySize() * PlaneCount(pDevice);
  }
  inline UINT CalcSubresource(UINT MipSlice, UINT ArraySlice, UINT PlaneSlice) {
    return D3D12CalcSubresource(MipSlice, ArraySlice, PlaneSlice, MipLevels,
                                ArraySize());
  }
};
inline bool operator==(const D3D12_RESOURCE_DESC &l,
                       const D3D12_RESOURCE_DESC &r) {
  return l.Dimension == r.Dimension && l.Alignment == r.Alignment &&
         l.Width == r.Width && l.Height == r.Height &&
         l.DepthOrArraySize == r.DepthOrArraySize &&
         l.MipLevels == r.MipLevels && l.Format == r.Format &&
         l.SampleDesc.Count == r.SampleDesc.Count &&
         l.SampleDesc.Quality == r.SampleDesc.Quality && l.Layout == r.Layout &&
         l.Flags == r.Flags;
}
inline bool operator!=(const D3D12_RESOURCE_DESC &l,
                       const D3D12_RESOURCE_DESC &r) {
  return !(l == r);
}

//------------------------------------------------------------------------------------------------
struct CD3DX12_VIEW_INSTANCING_DESC : public D3D12_VIEW_INSTANCING_DESC {
  CD3DX12_VIEW_INSTANCING_DESC() = default;
  explicit CD3DX12_VIEW_INSTANCING_DESC(const D3D12_VIEW_INSTANCING_DESC &o)
      : D3D12_VIEW_INSTANCING_DESC(o) {}
  explicit CD3DX12_VIEW_INSTANCING_DESC(CD3DX12_DEFAULT) {
    ViewInstanceCount = 0;
    pViewInstanceLocations = nullptr;
    Flags = D3D12_VIEW_INSTANCING_FLAG_NONE;
  }
  explicit CD3DX12_VIEW_INSTANCING_DESC(
      UINT InViewInstanceCount,
      const D3D12_VIEW_INSTANCE_LOCATION *InViewInstanceLocations,
      D3D12_VIEW_INSTANCING_FLAGS InFlags) {
    ViewInstanceCount = InViewInstanceCount;
    pViewInstanceLocations = InViewInstanceLocations;
    Flags = InFlags;
  }
};

//------------------------------------------------------------------------------------------------
// Row-by-row memcpy
inline void MemcpySubresource(_In_ const D3D12_MEMCPY_DEST *pDest,
                              _In_ const D3D12_SUBRESOURCE_DATA *pSrc,
                              SIZE_T RowSizeInBytes, UINT NumRows,
                              UINT NumSlices) {
  for (UINT z = 0; z < NumSlices; ++z) {
    auto pDestSlice =
        reinterpret_cast<BYTE *>(pDest->pData) + pDest->SlicePitch * z;
    auto pSrcSlice = reinterpret_cast<const BYTE *>(pSrc->pData) +
                     pSrc->SlicePitch * LONG_PTR(z);
    for (UINT y = 0; y < NumRows; ++y) {
      memcpy(pDestSlice + pDest->RowPitch * y,
             pSrcSlice + pSrc->RowPitch * LONG_PTR(y), RowSizeInBytes);
    }
  }
}

//------------------------------------------------------------------------------------------------
// Returns required size of a buffer to be used for data upload
inline UINT64 GetRequiredIntermediateSize(
    _In_ ID3D12Resource *pDestinationResource,
    _In_range_(0, D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
    _In_range_(0, D3D12_REQ_SUBRESOURCES - FirstSubresource)
        UINT NumSubresources) {
  auto Desc = pDestinationResource->GetDesc();
  UINT64 RequiredSize = 0;

  ID3D12Device *pDevice = nullptr;
  pDestinationResource->GetDevice(IID_ID3D12Device,
                                  reinterpret_cast<void **>(&pDevice));
  pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, 0,
                                 nullptr, nullptr, nullptr, &RequiredSize);
  pDevice->Release();

  return RequiredSize;
}

//------------------------------------------------------------------------------------------------
// All arrays must be populated (e.g. by calling GetCopyableFootprints)
inline UINT64
UpdateSubresources(_In_ ID3D12GraphicsCommandList *pCmdList,
                   _In_ ID3D12Resource *pDestinationResource,
                   _In_ ID3D12Resource *pIntermediate,
                   _In_range_(0, D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
                   _In_range_(0, D3D12_REQ_SUBRESOURCES - FirstSubresource)
                       UINT NumSubresources,
                   UINT64 RequiredSize,
                   _In_reads_(NumSubresources)
                       const D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts,
                   _In_reads_(NumSubresources) const UINT *pNumRows,
                   _In_reads_(NumSubresources) const UINT64 *pRowSizesInBytes,
                   _In_reads_(NumSubresources)
                       const D3D12_SUBRESOURCE_DATA *pSrcData) {
  // Minor validation
  auto IntermediateDesc = pIntermediate->GetDesc();
  auto DestinationDesc = pDestinationResource->GetDesc();
  if (IntermediateDesc.Dimension != D3D12_RESOURCE_DIMENSION_BUFFER ||
      IntermediateDesc.Width < RequiredSize + pLayouts[0].Offset ||
      RequiredSize > SIZE_T(-1) ||
      (DestinationDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER &&
       (FirstSubresource != 0 || NumSubresources != 1))) {
    return 0;
  }

  BYTE *pData;
  HRESULT hr =
      pIntermediate->Map(0, nullptr, reinterpret_cast<void **>(&pData));
  if (FAILED(hr)) {
    return 0;
  }

  for (UINT i = 0; i < NumSubresources; ++i) {
    if (pRowSizesInBytes[i] > SIZE_T(-1))
      return 0;
    D3D12_MEMCPY_DEST DestData = {
        pData + pLayouts[i].Offset, pLayouts[i].Footprint.RowPitch,
        SIZE_T(pLayouts[i].Footprint.RowPitch) * SIZE_T(pNumRows[i])};
    MemcpySubresource(&DestData, &pSrcData[i],
                      static_cast<SIZE_T>(pRowSizesInBytes[i]), pNumRows[i],
                      pLayouts[i].Footprint.Depth);
  }
  pIntermediate->Unmap(0, nullptr);

  if (DestinationDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER) {
    pCmdList->CopyBufferRegion(pDestinationResource, 0, pIntermediate,
                               pLayouts[0].Offset, pLayouts[0].Footprint.Width);
  } else {
    for (UINT i = 0; i < NumSubresources; ++i) {
      CD3DX12_TEXTURE_COPY_LOCATION Dst(pDestinationResource,
                                        i + FirstSubresource);
      CD3DX12_TEXTURE_COPY_LOCATION Src(pIntermediate, pLayouts[i]);
      pCmdList->CopyTextureRegion(&Dst, 0, 0, 0, &Src, nullptr);
    }
  }
  return RequiredSize;
}

//------------------------------------------------------------------------------------------------
// Heap-allocating UpdateSubresources implementation
inline UINT64 UpdateSubresources(
    _In_ ID3D12GraphicsCommandList *pCmdList,
    _In_ ID3D12Resource *pDestinationResource,
    _In_ ID3D12Resource *pIntermediate, UINT64 IntermediateOffset,
    _In_range_(0, D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
    _In_range_(0, D3D12_REQ_SUBRESOURCES - FirstSubresource)
        UINT NumSubresources,
    _In_reads_(NumSubresources) D3D12_SUBRESOURCE_DATA *pSrcData) {
  UINT64 RequiredSize = 0;
  UINT64 MemToAlloc =
      static_cast<UINT64>(sizeof(D3D12_PLACED_SUBRESOURCE_FOOTPRINT) +
                          sizeof(UINT) + sizeof(UINT64)) *
      NumSubresources;
  if (MemToAlloc > SIZE_MAX) {
    return 0;
  }
  void *pMem = HeapAlloc(GetProcessHeap(), 0, static_cast<SIZE_T>(MemToAlloc));
  if (pMem == nullptr) {
    return 0;
  }
  auto pLayouts = reinterpret_cast<D3D12_PLACED_SUBRESOURCE_FOOTPRINT *>(pMem);
  UINT64 *pRowSizesInBytes =
      reinterpret_cast<UINT64 *>(pLayouts + NumSubresources);
  UINT *pNumRows = reinterpret_cast<UINT *>(pRowSizesInBytes + NumSubresources);

  auto Desc = pDestinationResource->GetDesc();
  ID3D12Device *pDevice = nullptr;
  pDestinationResource->GetDevice(IID_ID3D12Device,
                                  reinterpret_cast<void **>(&pDevice));
  pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources,
                                 IntermediateOffset, pLayouts, pNumRows,
                                 pRowSizesInBytes, &RequiredSize);
  pDevice->Release();

  UINT64 Result =
      UpdateSubresources(pCmdList, pDestinationResource, pIntermediate,
                         FirstSubresource, NumSubresources, RequiredSize,
                         pLayouts, pNumRows, pRowSizesInBytes, pSrcData);
  HeapFree(GetProcessHeap(), 0, pMem);
  return Result;
}

//------------------------------------------------------------------------------------------------
// Stack-allocating UpdateSubresources implementation
template <UINT MaxSubresources>
inline UINT64 UpdateSubresources(
    _In_ ID3D12GraphicsCommandList *pCmdList,
    _In_ ID3D12Resource *pDestinationResource,
    _In_ ID3D12Resource *pIntermediate, UINT64 IntermediateOffset,
    _In_range_(0, MaxSubresources) UINT FirstSubresource,
    _In_range_(1, MaxSubresources - FirstSubresource) UINT NumSubresources,
    _In_reads_(NumSubresources) D3D12_SUBRESOURCE_DATA *pSrcData) {
  UINT64 RequiredSize = 0;
  D3D12_PLACED_SUBRESOURCE_FOOTPRINT Layouts[MaxSubresources];
  UINT NumRows[MaxSubresources];
  UINT64 RowSizesInBytes[MaxSubresources];

  auto Desc = pDestinationResource->GetDesc();
  ID3D12Device *pDevice = nullptr;
  pDestinationResource->GetDevice(IID_ID3D12Device,
                                  reinterpret_cast<void **>(&pDevice));
  pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources,
                                 IntermediateOffset, Layouts, NumRows,
                                 RowSizesInBytes, &RequiredSize);
  pDevice->Release();

  return UpdateSubresources(pCmdList, pDestinationResource, pIntermediate,
                            FirstSubresource, NumSubresources, RequiredSize,
                            Layouts, NumRows, RowSizesInBytes, pSrcData);
}

//------------------------------------------------------------------------------------------------
inline bool D3D12IsLayoutOpaque(D3D12_TEXTURE_LAYOUT Layout) {
  return Layout == D3D12_TEXTURE_LAYOUT_UNKNOWN ||
         Layout == D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE;
}

//------------------------------------------------------------------------------------------------
template <typename t_CommandListType>
inline ID3D12CommandList *const *CommandListCast(t_CommandListType *const *pp) {
  // This cast is useful for passing strongly typed command list pointers into
  // ExecuteCommandLists.
  // This cast is valid as long as the const-ness is respected. D3D12 APIs do
  // respect the const-ness of their arguments.
  return reinterpret_cast<ID3D12CommandList *const *>(pp);
}

//------------------------------------------------------------------------------------------------
// D3D12 exports a new method for serializing root signatures in the Windows 10
// Anniversary Update. To help enable root signature 1.1 features when they are
// available and not require maintaining two code paths for building root
// signatures, this helper method reconstructs a 1.0 signature when 1.1 is not
// supported.
inline HRESULT D3DX12SerializeVersionedRootSignature(
    _In_ const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *pRootSignatureDesc,
    D3D_ROOT_SIGNATURE_VERSION MaxVersion, _Outptr_ ID3DBlob **ppBlob,
    _Always_(_Outptr_opt_result_maybenull_) ID3DBlob **ppErrorBlob) {
  if (ppErrorBlob != nullptr) {
    *ppErrorBlob = nullptr;
  }

  switch (MaxVersion) {
  case D3D_ROOT_SIGNATURE_VERSION_1_0:
    switch (pRootSignatureDesc->Version) {
    case D3D_ROOT_SIGNATURE_VERSION_1_0:
      return D3D12SerializeRootSignature(&pRootSignatureDesc->Desc_1_0,
                                         D3D_ROOT_SIGNATURE_VERSION_1, ppBlob,
                                         ppErrorBlob);

    case D3D_ROOT_SIGNATURE_VERSION_1_1: {
      HRESULT hr = S_OK;
      const D3D12_ROOT_SIGNATURE_DESC1 &desc_1_1 = pRootSignatureDesc->Desc_1_1;

      const SIZE_T ParametersSize =
          sizeof(D3D12_ROOT_PARAMETER) * desc_1_1.NumParameters;
      void *pParameters = (ParametersSize > 0)
                              ? HeapAlloc(GetProcessHeap(), 0, ParametersSize)
                              : nullptr;
      if (ParametersSize > 0 && pParameters == nullptr) {
        hr = E_OUTOFMEMORY;
      }
      auto pParameters_1_0 =
          reinterpret_cast<D3D12_ROOT_PARAMETER *>(pParameters);

      if (SUCCEEDED(hr)) {
        for (UINT n = 0; n < desc_1_1.NumParameters; n++) {
          __analysis_assume(ParametersSize == sizeof(D3D12_ROOT_PARAMETER) *
                                                  desc_1_1.NumParameters);
          pParameters_1_0[n].ParameterType =
              desc_1_1.pParameters[n].ParameterType;
          pParameters_1_0[n].ShaderVisibility =
              desc_1_1.pParameters[n].ShaderVisibility;

          switch (desc_1_1.pParameters[n].ParameterType) {
          case D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS:
            pParameters_1_0[n].Constants.Num32BitValues =
                desc_1_1.pParameters[n].Constants.Num32BitValues;
            pParameters_1_0[n].Constants.RegisterSpace =
                desc_1_1.pParameters[n].Constants.RegisterSpace;
            pParameters_1_0[n].Constants.ShaderRegister =
                desc_1_1.pParameters[n].Constants.ShaderRegister;
            break;

          case D3D12_ROOT_PARAMETER_TYPE_CBV:
          case D3D12_ROOT_PARAMETER_TYPE_SRV:
          case D3D12_ROOT_PARAMETER_TYPE_UAV:
            pParameters_1_0[n].Descriptor.RegisterSpace =
                desc_1_1.pParameters[n].Descriptor.RegisterSpace;
            pParameters_1_0[n].Descriptor.ShaderRegister =
                desc_1_1.pParameters[n].Descriptor.ShaderRegister;
            break;

          case D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE:
            const D3D12_ROOT_DESCRIPTOR_TABLE1 &table_1_1 =
                desc_1_1.pParameters[n].DescriptorTable;

            const SIZE_T DescriptorRangesSize =
                sizeof(D3D12_DESCRIPTOR_RANGE) * table_1_1.NumDescriptorRanges;
            void *pDescriptorRanges =
                (DescriptorRangesSize > 0 && SUCCEEDED(hr))
                    ? HeapAlloc(GetProcessHeap(), 0, DescriptorRangesSize)
                    : nullptr;
            if (DescriptorRangesSize > 0 && pDescriptorRanges == nullptr) {
              hr = E_OUTOFMEMORY;
            }
            auto pDescriptorRanges_1_0 =
                reinterpret_cast<D3D12_DESCRIPTOR_RANGE *>(pDescriptorRanges);

            if (SUCCEEDED(hr)) {
              for (UINT x = 0; x < table_1_1.NumDescriptorRanges; x++) {
                __analysis_assume(DescriptorRangesSize ==
                                  sizeof(D3D12_DESCRIPTOR_RANGE) *
                                      table_1_1.NumDescriptorRanges);
                pDescriptorRanges_1_0[x].BaseShaderRegister =
                    table_1_1.pDescriptorRanges[x].BaseShaderRegister;
                pDescriptorRanges_1_0[x].NumDescriptors =
                    table_1_1.pDescriptorRanges[x].NumDescriptors;
                pDescriptorRanges_1_0[x].OffsetInDescriptorsFromTableStart =
                    table_1_1.pDescriptorRanges[x]
                        .OffsetInDescriptorsFromTableStart;
                pDescriptorRanges_1_0[x].RangeType =
                    table_1_1.pDescriptorRanges[x].RangeType;
                pDescriptorRanges_1_0[x].RegisterSpace =
                    table_1_1.pDescriptorRanges[x].RegisterSpace;
              }
            }

            D3D12_ROOT_DESCRIPTOR_TABLE &table_1_0 =
                pParameters_1_0[n].DescriptorTable;
            table_1_0.NumDescriptorRanges = table_1_1.NumDescriptorRanges;
            table_1_0.pDescriptorRanges = pDescriptorRanges_1_0;
          }
        }
      }

      if (SUCCEEDED(hr)) {
        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);
        hr = D3D12SerializeRootSignature(
            &desc_1_0, D3D_ROOT_SIGNATURE_VERSION_1, ppBlob, ppErrorBlob);
      }

      if (pParameters) {
        for (UINT n = 0; n < desc_1_1.NumParameters; n++) {
          if (desc_1_1.pParameters[n].ParameterType ==
              D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE) {
            HeapFree(
                GetProcessHeap(), 0,
                reinterpret_cast<void *>(const_cast<D3D12_DESCRIPTOR_RANGE *>(
                    pParameters_1_0[n].DescriptorTable.pDescriptorRanges)));
          }
        }
        HeapFree(GetProcessHeap(), 0, pParameters);
      }
      return hr;
    }
    }
    break;

  case D3D_ROOT_SIGNATURE_VERSION_1_1:
    return D3D12SerializeVersionedRootSignature(pRootSignatureDesc, ppBlob,
                                                ppErrorBlob);
  }

  return E_INVALIDARG;
}

//------------------------------------------------------------------------------------------------
struct CD3DX12_RT_FORMAT_ARRAY : public D3D12_RT_FORMAT_ARRAY {
  CD3DX12_RT_FORMAT_ARRAY() = default;
  explicit CD3DX12_RT_FORMAT_ARRAY(const D3D12_RT_FORMAT_ARRAY &o)
      : D3D12_RT_FORMAT_ARRAY(o) {}
  explicit CD3DX12_RT_FORMAT_ARRAY(_In_reads_(NumFormats)
                                       const DXGI_FORMAT *pFormats,
                                   UINT NumFormats) {
    NumRenderTargets = NumFormats;
    memcpy(RTFormats, pFormats, sizeof(RTFormats));
    // assumes ARRAY_SIZE(pFormats) == ARRAY_SIZE(RTFormats)
  }
};

//------------------------------------------------------------------------------------------------
// Pipeline State Stream Helpers
//------------------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------------------
// Stream Subobjects, i.e. elements of a stream

struct DefaultSampleMask {
  operator UINT() { return UINT_MAX; }
};
struct DefaultSampleDesc {
  operator DXGI_SAMPLE_DESC() { return DXGI_SAMPLE_DESC{1, 0}; }
};

#pragma warning(push)
#pragma warning(disable : 4324)
template <typename InnerStructType, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE Type,
          typename DefaultArg = InnerStructType>
class alignas(void *) CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT {
private:
  D3D12_PIPELINE_STATE_SUBOBJECT_TYPE _Type;
  InnerStructType _Inner;

public:
  CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT()
  noexcept : _Type(Type), _Inner(DefaultArg()) {}
  CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT(InnerStructType const &i)
      : _Type(Type), _Inner(i) {}
  CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT &operator=(InnerStructType const &i) {
    _Type = Type;
    _Inner = i;
    return *this;
  }
  operator InnerStructType const &() const { return _Inner; }
  operator InnerStructType &() { return _Inner; }
  InnerStructType *operator&() { return &_Inner; }
  InnerStructType const *operator&() const { return &_Inner; }
};
#pragma warning(pop)
typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT<
    D3D12_PIPELINE_STATE_FLAGS, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS>
    CD3DX12_PIPELINE_STATE_STREAM_FLAGS;
typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT<
    UINT, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_NODE_MASK>
    CD3DX12_PIPELINE_STATE_STREAM_NODE_MASK;
typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT<
    ID3D12RootSignature *, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE>
    CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE;
typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT<
    D3D12_INPUT_LAYOUT_DESC, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT>
    CD3DX12_PIPELINE_STATE_STREAM_INPUT_LAYOUT;
typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT<
    D3D12_INDEX_BUFFER_STRIP_CUT_VALUE,
    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE>
    CD3DX12_PIPELINE_STATE_STREAM_IB_STRIP_CUT_VALUE;
typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT<
    D3D12_PRIMITIVE_TOPOLOGY_TYPE,
    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY>
    CD3DX12_PIPELINE_STATE_STREAM_PRIMITIVE_TOPOLOGY;
typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT<
    D3D12_SHADER_BYTECODE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VS>
    CD3DX12_PIPELINE_STATE_STREAM_VS;
typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT<
    D3D12_SHADER_BYTECODE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_GS>
    CD3DX12_PIPELINE_STATE_STREAM_GS;
typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT<
    D3D12_STREAM_OUTPUT_DESC, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT>
    CD3DX12_PIPELINE_STATE_STREAM_STREAM_OUTPUT;
typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT<
    D3D12_SHADER_BYTECODE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_HS>
    CD3DX12_PIPELINE_STATE_STREAM_HS;
typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT<
    D3D12_SHADER_BYTECODE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DS>
    CD3DX12_PIPELINE_STATE_STREAM_DS;
typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT<
    D3D12_SHADER_BYTECODE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PS>
    CD3DX12_PIPELINE_STATE_STREAM_PS;
typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT<
    D3D12_SHADER_BYTECODE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CS>
    CD3DX12_PIPELINE_STATE_STREAM_CS;
typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT<
    CD3DX12_BLEND_DESC, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_BLEND,
    CD3DX12_DEFAULT>
    CD3DX12_PIPELINE_STATE_STREAM_BLEND_DESC;
typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT<
    CD3DX12_DEPTH_STENCIL_DESC,
    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL, CD3DX12_DEFAULT>
    CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL;
typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT<
    CD3DX12_DEPTH_STENCIL_DESC1,
    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1, CD3DX12_DEFAULT>
    CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL1;
typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT<
    DXGI_FORMAT, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT>
    CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL_FORMAT;
typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT<
    CD3DX12_RASTERIZER_DESC, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER,
    CD3DX12_DEFAULT>
    CD3DX12_PIPELINE_STATE_STREAM_RASTERIZER;
typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT<
    D3D12_RT_FORMAT_ARRAY,
    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS>
    CD3DX12_PIPELINE_STATE_STREAM_RENDER_TARGET_FORMATS;
typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT<
    DXGI_SAMPLE_DESC, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_DESC,
    DefaultSampleDesc>
    CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_DESC;
typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT<
    UINT, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_MASK, DefaultSampleMask>
    CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_MASK;
typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT<
    D3D12_CACHED_PIPELINE_STATE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CACHED_PSO>
    CD3DX12_PIPELINE_STATE_STREAM_CACHED_PSO;
typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT<
    CD3DX12_VIEW_INSTANCING_DESC,
    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING, CD3DX12_DEFAULT>
    CD3DX12_PIPELINE_STATE_STREAM_VIEW_INSTANCING;

//------------------------------------------------------------------------------------------------
// Stream Parser Helpers

struct ID3DX12PipelineParserCallbacks {
  // Subobject Callbacks
  virtual void FlagsCb(D3D12_PIPELINE_STATE_FLAGS) {}
  virtual void NodeMaskCb(UINT) {}
  virtual void RootSignatureCb(ID3D12RootSignature *) {}
  virtual void InputLayoutCb(const D3D12_INPUT_LAYOUT_DESC &) {}
  virtual void IBStripCutValueCb(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE) {}
  virtual void PrimitiveTopologyTypeCb(D3D12_PRIMITIVE_TOPOLOGY_TYPE) {}
  virtual void VSCb(const D3D12_SHADER_BYTECODE &) {}
  virtual void GSCb(const D3D12_SHADER_BYTECODE &) {}
  virtual void StreamOutputCb(const D3D12_STREAM_OUTPUT_DESC &) {}
  virtual void HSCb(const D3D12_SHADER_BYTECODE &) {}
  virtual void DSCb(const D3D12_SHADER_BYTECODE &) {}
  virtual void PSCb(const D3D12_SHADER_BYTECODE &) {}
  virtual void CSCb(const D3D12_SHADER_BYTECODE &) {}
  virtual void BlendStateCb(const D3D12_BLEND_DESC &) {}
  virtual void DepthStencilStateCb(const D3D12_DEPTH_STENCIL_DESC &) {}
  virtual void DepthStencilState1Cb(const D3D12_DEPTH_STENCIL_DESC1 &) {}
  virtual void DSVFormatCb(DXGI_FORMAT) {}
  virtual void RasterizerStateCb(const D3D12_RASTERIZER_DESC &) {}
  virtual void RTVFormatsCb(const D3D12_RT_FORMAT_ARRAY &) {}
  virtual void SampleDescCb(const DXGI_SAMPLE_DESC &) {}
  virtual void SampleMaskCb(UINT) {}
  virtual void ViewInstancingCb(const D3D12_VIEW_INSTANCING_DESC &) {}
  virtual void CachedPSOCb(const D3D12_CACHED_PIPELINE_STATE &) {}

  // Error Callbacks
  virtual void ErrorBadInputParameter(UINT /*ParameterIndex*/) {}
  virtual void ErrorDuplicateSubobject(
      D3D12_PIPELINE_STATE_SUBOBJECT_TYPE /*DuplicateType*/) {}
  virtual void ErrorUnknownSubobject(UINT /*UnknownTypeValue*/) {}

  virtual ~ID3DX12PipelineParserCallbacks() = default;
};

// CD3DX12_PIPELINE_STATE_STREAM1 Works on RS3+ (where there is a new view
// instancing subobject). Use CD3DX12_PIPELINE_STATE_STREAM for RS2+ support.
struct CD3DX12_PIPELINE_STATE_STREAM1 {
  CD3DX12_PIPELINE_STATE_STREAM1() = default;
  CD3DX12_PIPELINE_STATE_STREAM1(const D3D12_GRAPHICS_PIPELINE_STATE_DESC &Desc)
      : Flags(Desc.Flags), NodeMask(Desc.NodeMask),
        pRootSignature(Desc.pRootSignature), InputLayout(Desc.InputLayout),
        IBStripCutValue(Desc.IBStripCutValue),
        PrimitiveTopologyType(Desc.PrimitiveTopologyType), VS(Desc.VS),
        GS(Desc.GS), StreamOutput(Desc.StreamOutput), HS(Desc.HS), DS(Desc.DS),
        PS(Desc.PS), BlendState(CD3DX12_BLEND_DESC(Desc.BlendState)),
        DepthStencilState(CD3DX12_DEPTH_STENCIL_DESC1(Desc.DepthStencilState)),
        DSVFormat(Desc.DSVFormat),
        RasterizerState(CD3DX12_RASTERIZER_DESC(Desc.RasterizerState)),
        RTVFormats(
            CD3DX12_RT_FORMAT_ARRAY(Desc.RTVFormats, Desc.NumRenderTargets)),
        SampleDesc(Desc.SampleDesc), SampleMask(Desc.SampleMask),
        CachedPSO(Desc.CachedPSO),
        ViewInstancingDesc(CD3DX12_VIEW_INSTANCING_DESC(CD3DX12_DEFAULT())) {}
  CD3DX12_PIPELINE_STATE_STREAM1(const D3D12_COMPUTE_PIPELINE_STATE_DESC &Desc)
      : Flags(Desc.Flags), NodeMask(Desc.NodeMask),
        pRootSignature(Desc.pRootSignature),
        CS(CD3DX12_SHADER_BYTECODE(Desc.CS)), CachedPSO(Desc.CachedPSO) {
    static_cast<D3D12_DEPTH_STENCIL_DESC1 &>(DepthStencilState).DepthEnable =
        false;
  }
  CD3DX12_PIPELINE_STATE_STREAM_FLAGS Flags;
  CD3DX12_PIPELINE_STATE_STREAM_NODE_MASK NodeMask;
  CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE pRootSignature;
  CD3DX12_PIPELINE_STATE_STREAM_INPUT_LAYOUT InputLayout;
  CD3DX12_PIPELINE_STATE_STREAM_IB_STRIP_CUT_VALUE IBStripCutValue;
  CD3DX12_PIPELINE_STATE_STREAM_PRIMITIVE_TOPOLOGY PrimitiveTopologyType;
  CD3DX12_PIPELINE_STATE_STREAM_VS VS;
  CD3DX12_PIPELINE_STATE_STREAM_GS GS;
  CD3DX12_PIPELINE_STATE_STREAM_STREAM_OUTPUT StreamOutput;
  CD3DX12_PIPELINE_STATE_STREAM_HS HS;
  CD3DX12_PIPELINE_STATE_STREAM_DS DS;
  CD3DX12_PIPELINE_STATE_STREAM_PS PS;
  CD3DX12_PIPELINE_STATE_STREAM_CS CS;
  CD3DX12_PIPELINE_STATE_STREAM_BLEND_DESC BlendState;
  CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL1 DepthStencilState;
  CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL_FORMAT DSVFormat;
  CD3DX12_PIPELINE_STATE_STREAM_RASTERIZER RasterizerState;
  CD3DX12_PIPELINE_STATE_STREAM_RENDER_TARGET_FORMATS RTVFormats;
  CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_DESC SampleDesc;
  CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_MASK SampleMask;
  CD3DX12_PIPELINE_STATE_STREAM_CACHED_PSO CachedPSO;
  CD3DX12_PIPELINE_STATE_STREAM_VIEW_INSTANCING ViewInstancingDesc;
  D3D12_GRAPHICS_PIPELINE_STATE_DESC GraphicsDescV0() const {
    D3D12_GRAPHICS_PIPELINE_STATE_DESC D;
    D.Flags = this->Flags;
    D.NodeMask = this->NodeMask;
    D.pRootSignature = this->pRootSignature;
    D.InputLayout = this->InputLayout;
    D.IBStripCutValue = this->IBStripCutValue;
    D.PrimitiveTopologyType = this->PrimitiveTopologyType;
    D.VS = this->VS;
    D.GS = this->GS;
    D.StreamOutput = this->StreamOutput;
    D.HS = this->HS;
    D.DS = this->DS;
    D.PS = this->PS;
    D.BlendState = this->BlendState;
    D.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC1(
        D3D12_DEPTH_STENCIL_DESC1(this->DepthStencilState));
    D.DSVFormat = this->DSVFormat;
    D.RasterizerState = this->RasterizerState;
    D.NumRenderTargets =
        D3D12_RT_FORMAT_ARRAY(this->RTVFormats).NumRenderTargets;
    memcpy(D.RTVFormats, D3D12_RT_FORMAT_ARRAY(this->RTVFormats).RTFormats,
           sizeof(D.RTVFormats));
    D.SampleDesc = this->SampleDesc;
    D.SampleMask = this->SampleMask;
    D.CachedPSO = this->CachedPSO;
    return D;
  }
  D3D12_COMPUTE_PIPELINE_STATE_DESC ComputeDescV0() const {
    D3D12_COMPUTE_PIPELINE_STATE_DESC D;
    D.Flags = this->Flags;
    D.NodeMask = this->NodeMask;
    D.pRootSignature = this->pRootSignature;
    D.CS = this->CS;
    D.CachedPSO = this->CachedPSO;
    return D;
  }
};

// CD3DX12_PIPELINE_STATE_STREAM works on RS2+ but does not support new
// subobject(s) added in RS3+. See CD3DX12_PIPELINE_STATE_STREAM1 for instance.
struct CD3DX12_PIPELINE_STATE_STREAM {
  CD3DX12_PIPELINE_STATE_STREAM() = default;
  CD3DX12_PIPELINE_STATE_STREAM(const D3D12_GRAPHICS_PIPELINE_STATE_DESC &Desc)
      : Flags(Desc.Flags), NodeMask(Desc.NodeMask),
        pRootSignature(Desc.pRootSignature), InputLayout(Desc.InputLayout),
        IBStripCutValue(Desc.IBStripCutValue),
        PrimitiveTopologyType(Desc.PrimitiveTopologyType), VS(Desc.VS),
        GS(Desc.GS), StreamOutput(Desc.StreamOutput), HS(Desc.HS), DS(Desc.DS),
        PS(Desc.PS), BlendState(CD3DX12_BLEND_DESC(Desc.BlendState)),
        DepthStencilState(CD3DX12_DEPTH_STENCIL_DESC1(Desc.DepthStencilState)),
        DSVFormat(Desc.DSVFormat),
        RasterizerState(CD3DX12_RASTERIZER_DESC(Desc.RasterizerState)),
        RTVFormats(
            CD3DX12_RT_FORMAT_ARRAY(Desc.RTVFormats, Desc.NumRenderTargets)),
        SampleDesc(Desc.SampleDesc), SampleMask(Desc.SampleMask),
        CachedPSO(Desc.CachedPSO) {}
  CD3DX12_PIPELINE_STATE_STREAM(const D3D12_COMPUTE_PIPELINE_STATE_DESC &Desc)
      : Flags(Desc.Flags), NodeMask(Desc.NodeMask),
        pRootSignature(Desc.pRootSignature),
        CS(CD3DX12_SHADER_BYTECODE(Desc.CS)), CachedPSO(Desc.CachedPSO) {}
  CD3DX12_PIPELINE_STATE_STREAM_FLAGS Flags;
  CD3DX12_PIPELINE_STATE_STREAM_NODE_MASK NodeMask;
  CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE pRootSignature;
  CD3DX12_PIPELINE_STATE_STREAM_INPUT_LAYOUT InputLayout;
  CD3DX12_PIPELINE_STATE_STREAM_IB_STRIP_CUT_VALUE IBStripCutValue;
  CD3DX12_PIPELINE_STATE_STREAM_PRIMITIVE_TOPOLOGY PrimitiveTopologyType;
  CD3DX12_PIPELINE_STATE_STREAM_VS VS;
  CD3DX12_PIPELINE_STATE_STREAM_GS GS;
  CD3DX12_PIPELINE_STATE_STREAM_STREAM_OUTPUT StreamOutput;
  CD3DX12_PIPELINE_STATE_STREAM_HS HS;
  CD3DX12_PIPELINE_STATE_STREAM_DS DS;
  CD3DX12_PIPELINE_STATE_STREAM_PS PS;
  CD3DX12_PIPELINE_STATE_STREAM_CS CS;
  CD3DX12_PIPELINE_STATE_STREAM_BLEND_DESC BlendState;
  CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL1 DepthStencilState;
  CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL_FORMAT DSVFormat;
  CD3DX12_PIPELINE_STATE_STREAM_RASTERIZER RasterizerState;
  CD3DX12_PIPELINE_STATE_STREAM_RENDER_TARGET_FORMATS RTVFormats;
  CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_DESC SampleDesc;
  CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_MASK SampleMask;
  CD3DX12_PIPELINE_STATE_STREAM_CACHED_PSO CachedPSO;
  D3D12_GRAPHICS_PIPELINE_STATE_DESC GraphicsDescV0() const {
    D3D12_GRAPHICS_PIPELINE_STATE_DESC D;
    D.Flags = this->Flags;
    D.NodeMask = this->NodeMask;
    D.pRootSignature = this->pRootSignature;
    D.InputLayout = this->InputLayout;
    D.IBStripCutValue = this->IBStripCutValue;
    D.PrimitiveTopologyType = this->PrimitiveTopologyType;
    D.VS = this->VS;
    D.GS = this->GS;
    D.StreamOutput = this->StreamOutput;
    D.HS = this->HS;
    D.DS = this->DS;
    D.PS = this->PS;
    D.BlendState = this->BlendState;
    D.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC1(
        D3D12_DEPTH_STENCIL_DESC1(this->DepthStencilState));
    D.DSVFormat = this->DSVFormat;
    D.RasterizerState = this->RasterizerState;
    D.NumRenderTargets =
        D3D12_RT_FORMAT_ARRAY(this->RTVFormats).NumRenderTargets;
    memcpy(D.RTVFormats, D3D12_RT_FORMAT_ARRAY(this->RTVFormats).RTFormats,
           sizeof(D.RTVFormats));
    D.SampleDesc = this->SampleDesc;
    D.SampleMask = this->SampleMask;
    D.CachedPSO = this->CachedPSO;
    return D;
  }
  D3D12_COMPUTE_PIPELINE_STATE_DESC ComputeDescV0() const {
    D3D12_COMPUTE_PIPELINE_STATE_DESC D;
    D.Flags = this->Flags;
    D.NodeMask = this->NodeMask;
    D.pRootSignature = this->pRootSignature;
    D.CS = this->CS;
    D.CachedPSO = this->CachedPSO;
    return D;
  }
};

struct CD3DX12_PIPELINE_STATE_STREAM_PARSE_HELPER
    : public ID3DX12PipelineParserCallbacks {
  CD3DX12_PIPELINE_STATE_STREAM1 PipelineStream;
  CD3DX12_PIPELINE_STATE_STREAM_PARSE_HELPER() noexcept : SeenDSS(false) {
    // Adjust defaults to account for absent members.
    PipelineStream.PrimitiveTopologyType =
        D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;

    // Depth disabled if no DSV format specified.
    static_cast<D3D12_DEPTH_STENCIL_DESC1 &>(PipelineStream.DepthStencilState)
        .DepthEnable = false;
  }

  // ID3DX12PipelineParserCallbacks
  void FlagsCb(D3D12_PIPELINE_STATE_FLAGS Flags) override {
    PipelineStream.Flags = Flags;
  }
  void NodeMaskCb(UINT NodeMask) override {
    PipelineStream.NodeMask = NodeMask;
  }
  void RootSignatureCb(ID3D12RootSignature *pRootSignature) override {
    PipelineStream.pRootSignature = pRootSignature;
  }
  void InputLayoutCb(const D3D12_INPUT_LAYOUT_DESC &InputLayout) override {
    PipelineStream.InputLayout = InputLayout;
  }
  void IBStripCutValueCb(
      D3D12_INDEX_BUFFER_STRIP_CUT_VALUE IBStripCutValue) override {
    PipelineStream.IBStripCutValue = IBStripCutValue;
  }
  void PrimitiveTopologyTypeCb(
      D3D12_PRIMITIVE_TOPOLOGY_TYPE PrimitiveTopologyType) override {
    PipelineStream.PrimitiveTopologyType = PrimitiveTopologyType;
  }
  void VSCb(const D3D12_SHADER_BYTECODE &VS) override {
    PipelineStream.VS = VS;
  }
  void GSCb(const D3D12_SHADER_BYTECODE &GS) override {
    PipelineStream.GS = GS;
  }
  void StreamOutputCb(const D3D12_STREAM_OUTPUT_DESC &StreamOutput) override {
    PipelineStream.StreamOutput = StreamOutput;
  }
  void HSCb(const D3D12_SHADER_BYTECODE &HS) override {
    PipelineStream.HS = HS;
  }
  void DSCb(const D3D12_SHADER_BYTECODE &DS) override {
    PipelineStream.DS = DS;
  }
  void PSCb(const D3D12_SHADER_BYTECODE &PS) override {
    PipelineStream.PS = PS;
  }
  void CSCb(const D3D12_SHADER_BYTECODE &CS) override {
    PipelineStream.CS = CS;
  }
  void BlendStateCb(const D3D12_BLEND_DESC &BlendState) override {
    PipelineStream.BlendState = CD3DX12_BLEND_DESC(BlendState);
  }
  void DepthStencilStateCb(
      const D3D12_DEPTH_STENCIL_DESC &DepthStencilState) override {
    PipelineStream.DepthStencilState =
        CD3DX12_DEPTH_STENCIL_DESC1(DepthStencilState);
    SeenDSS = true;
  }
  void DepthStencilState1Cb(
      const D3D12_DEPTH_STENCIL_DESC1 &DepthStencilState) override {
    PipelineStream.DepthStencilState =
        CD3DX12_DEPTH_STENCIL_DESC1(DepthStencilState);
    SeenDSS = true;
  }
  void DSVFormatCb(DXGI_FORMAT DSVFormat) override {
    PipelineStream.DSVFormat = DSVFormat;
    if (!SeenDSS && DSVFormat != DXGI_FORMAT_UNKNOWN) {
      // Re-enable depth for the default state.
      static_cast<D3D12_DEPTH_STENCIL_DESC1 &>(PipelineStream.DepthStencilState)
          .DepthEnable = true;
    }
  }
  void
  RasterizerStateCb(const D3D12_RASTERIZER_DESC &RasterizerState) override {
    PipelineStream.RasterizerState = CD3DX12_RASTERIZER_DESC(RasterizerState);
  }
  void RTVFormatsCb(const D3D12_RT_FORMAT_ARRAY &RTVFormats) override {
    PipelineStream.RTVFormats = RTVFormats;
  }
  void SampleDescCb(const DXGI_SAMPLE_DESC &SampleDesc) override {
    PipelineStream.SampleDesc = SampleDesc;
  }
  void SampleMaskCb(UINT SampleMask) override {
    PipelineStream.SampleMask = SampleMask;
  }
  void ViewInstancingCb(
      const D3D12_VIEW_INSTANCING_DESC &ViewInstancingDesc) override {
    PipelineStream.ViewInstancingDesc =
        CD3DX12_VIEW_INSTANCING_DESC(ViewInstancingDesc);
  }
  void CachedPSOCb(const D3D12_CACHED_PIPELINE_STATE &CachedPSO) override {
    PipelineStream.CachedPSO = CachedPSO;
  }

private:
  bool SeenDSS;
};

inline D3D12_PIPELINE_STATE_SUBOBJECT_TYPE
D3DX12GetBaseSubobjectType(D3D12_PIPELINE_STATE_SUBOBJECT_TYPE SubobjectType) {
  switch (SubobjectType) {
  case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1:
    return D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL;
  default:
    return SubobjectType;
  }
}

inline HRESULT
D3DX12ParsePipelineStream(const D3D12_PIPELINE_STATE_STREAM_DESC &Desc,
                          ID3DX12PipelineParserCallbacks *pCallbacks) {
  if (pCallbacks == nullptr) {
    return E_INVALIDARG;
  }

  if (Desc.SizeInBytes == 0 || Desc.pPipelineStateSubobjectStream == nullptr) {
    pCallbacks->ErrorBadInputParameter(1); // first parameter issue
    return E_INVALIDARG;
  }

  bool SubobjectSeen[D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MAX_VALID] = {};
  for (SIZE_T CurOffset = 0, SizeOfSubobject = 0; CurOffset < Desc.SizeInBytes;
       CurOffset += SizeOfSubobject) {
    BYTE *pStream =
        static_cast<BYTE *>(Desc.pPipelineStateSubobjectStream) + CurOffset;
    auto SubobjectType =
        *reinterpret_cast<D3D12_PIPELINE_STATE_SUBOBJECT_TYPE *>(pStream);
    if (SubobjectType < 0 ||
        SubobjectType >= D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MAX_VALID) {
      pCallbacks->ErrorUnknownSubobject(SubobjectType);
      return E_INVALIDARG;
    }
    if (SubobjectSeen[D3DX12GetBaseSubobjectType(SubobjectType)]) {
      pCallbacks->ErrorDuplicateSubobject(SubobjectType);
      return E_INVALIDARG; // disallow subobject duplicates in a stream
    }
    SubobjectSeen[SubobjectType] = true;
    switch (SubobjectType) {
    case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE:
      pCallbacks->RootSignatureCb(
          *reinterpret_cast<
              decltype(CD3DX12_PIPELINE_STATE_STREAM::pRootSignature) *>(
              pStream));
      SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::pRootSignature);
      break;
    case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VS:
      pCallbacks->VSCb(
          *reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::VS) *>(
              pStream));
      SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::VS);
      break;
    case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PS:
      pCallbacks->PSCb(
          *reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::PS) *>(
              pStream));
      SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::PS);
      break;
    case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DS:
      pCallbacks->DSCb(
          *reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::DS) *>(
              pStream));
      SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::DS);
      break;
    case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_HS:
      pCallbacks->HSCb(
          *reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::HS) *>(
              pStream));
      SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::HS);
      break;
    case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_GS:
      pCallbacks->GSCb(
          *reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::GS) *>(
              pStream));
      SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::GS);
      break;
    case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CS:
      pCallbacks->CSCb(
          *reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::CS) *>(
              pStream));
      SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::CS);
      break;
    case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT:
      pCallbacks->StreamOutputCb(
          *reinterpret_cast<
              decltype(CD3DX12_PIPELINE_STATE_STREAM::StreamOutput) *>(
              pStream));
      SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::StreamOutput);
      break;
    case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_BLEND:
      pCallbacks->BlendStateCb(
          *reinterpret_cast<
              decltype(CD3DX12_PIPELINE_STATE_STREAM::BlendState) *>(pStream));
      SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::BlendState);
      break;
    case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_MASK:
      pCallbacks->SampleMaskCb(
          *reinterpret_cast<
              decltype(CD3DX12_PIPELINE_STATE_STREAM::SampleMask) *>(pStream));
      SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::SampleMask);
      break;
    case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER:
      pCallbacks->RasterizerStateCb(
          *reinterpret_cast<
              decltype(CD3DX12_PIPELINE_STATE_STREAM::RasterizerState) *>(
              pStream));
      SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::RasterizerState);
      break;
    case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL:
      pCallbacks->DepthStencilStateCb(
          *reinterpret_cast<CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL *>(
              pStream));
      SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL);
      break;
    case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1:
      pCallbacks->DepthStencilState1Cb(
          *reinterpret_cast<
              decltype(CD3DX12_PIPELINE_STATE_STREAM::DepthStencilState) *>(
              pStream));
      SizeOfSubobject =
          sizeof(CD3DX12_PIPELINE_STATE_STREAM::DepthStencilState);
      break;
    case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT:
      pCallbacks->InputLayoutCb(
          *reinterpret_cast<
              decltype(CD3DX12_PIPELINE_STATE_STREAM::InputLayout) *>(pStream));
      SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::InputLayout);
      break;
    case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE:
      pCallbacks->IBStripCutValueCb(
          *reinterpret_cast<
              decltype(CD3DX12_PIPELINE_STATE_STREAM::IBStripCutValue) *>(
              pStream));
      SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::IBStripCutValue);
      break;
    case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY:
      pCallbacks->PrimitiveTopologyTypeCb(
          *reinterpret_cast<
              decltype(CD3DX12_PIPELINE_STATE_STREAM::PrimitiveTopologyType) *>(
              pStream));
      SizeOfSubobject =
          sizeof(CD3DX12_PIPELINE_STATE_STREAM::PrimitiveTopologyType);
      break;
    case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS:
      pCallbacks->RTVFormatsCb(
          *reinterpret_cast<
              decltype(CD3DX12_PIPELINE_STATE_STREAM::RTVFormats) *>(pStream));
      SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::RTVFormats);
      break;
    case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT:
      pCallbacks->DSVFormatCb(
          *reinterpret_cast<
              decltype(CD3DX12_PIPELINE_STATE_STREAM::DSVFormat) *>(pStream));
      SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::DSVFormat);
      break;
    case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_DESC:
      pCallbacks->SampleDescCb(
          *reinterpret_cast<
              decltype(CD3DX12_PIPELINE_STATE_STREAM::SampleDesc) *>(pStream));
      SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::SampleDesc);
      break;
    case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_NODE_MASK:
      pCallbacks->NodeMaskCb(
          *reinterpret_cast<
              decltype(CD3DX12_PIPELINE_STATE_STREAM::NodeMask) *>(pStream));
      SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::NodeMask);
      break;
    case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CACHED_PSO:
      pCallbacks->CachedPSOCb(
          *reinterpret_cast<
              decltype(CD3DX12_PIPELINE_STATE_STREAM::CachedPSO) *>(pStream));
      SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::CachedPSO);
      break;
    case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS:
      pCallbacks->FlagsCb(
          *reinterpret_cast<decltype(CD3DX12_PIPELINE_STATE_STREAM::Flags) *>(
              pStream));
      SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::Flags);
      break;
    case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING:
      pCallbacks->ViewInstancingCb(
          *reinterpret_cast<
              decltype(CD3DX12_PIPELINE_STATE_STREAM1::ViewInstancingDesc) *>(
              pStream));
      SizeOfSubobject =
          sizeof(CD3DX12_PIPELINE_STATE_STREAM1::ViewInstancingDesc);
      break;
    default:
      pCallbacks->ErrorUnknownSubobject(SubobjectType);
      return E_INVALIDARG;
      break;
    }
  }

  return S_OK;
}

//------------------------------------------------------------------------------------------------
inline bool operator==(const D3D12_CLEAR_VALUE &a, const D3D12_CLEAR_VALUE &b) {
  if (a.Format != b.Format)
    return false;
  if (a.Format == DXGI_FORMAT_D24_UNORM_S8_UINT ||
      a.Format == DXGI_FORMAT_D16_UNORM || a.Format == DXGI_FORMAT_D32_FLOAT ||
      a.Format == DXGI_FORMAT_D32_FLOAT_S8X24_UINT) {
    return (a.DepthStencil.Depth == b.DepthStencil.Depth) &&
           (a.DepthStencil.Stencil == b.DepthStencil.Stencil);
  } else {
    return (a.Color[0] == b.Color[0]) && (a.Color[1] == b.Color[1]) &&
           (a.Color[2] == b.Color[2]) && (a.Color[3] == b.Color[3]);
  }
}
inline bool
operator==(const D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS &a,
           const D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS &b) {
  return a.ClearValue == b.ClearValue;
}
inline bool
operator==(const D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS &a,
           const D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS &b) {
  if (a.pSrcResource != b.pSrcResource)
    return false;
  if (a.pDstResource != b.pDstResource)
    return false;
  if (a.SubresourceCount != b.SubresourceCount)
    return false;
  if (a.Format != b.Format)
    return false;
  if (a.ResolveMode != b.ResolveMode)
    return false;
  if (a.PreserveResolveSource != b.PreserveResolveSource)
    return false;
  return true;
}
inline bool operator==(const D3D12_RENDER_PASS_BEGINNING_ACCESS &a,
                       const D3D12_RENDER_PASS_BEGINNING_ACCESS &b) {
  if (a.Type != b.Type)
    return false;
  if (a.Type == D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR &&
      !(a.Clear == b.Clear))
    return false;
  return true;
}
inline bool operator==(const D3D12_RENDER_PASS_ENDING_ACCESS &a,
                       const D3D12_RENDER_PASS_ENDING_ACCESS &b) {
  if (a.Type != b.Type)
    return false;
  if (a.Type == D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE &&
      !(a.Resolve == b.Resolve))
    return false;
  return true;
}
inline bool operator==(const D3D12_RENDER_PASS_RENDER_TARGET_DESC &a,
                       const D3D12_RENDER_PASS_RENDER_TARGET_DESC &b) {
  if (a.cpuDescriptor.ptr != b.cpuDescriptor.ptr)
    return false;
  if (!(a.BeginningAccess == b.BeginningAccess))
    return false;
  if (!(a.EndingAccess == b.EndingAccess))
    return false;
  return true;
}
inline bool operator==(const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC &a,
                       const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC &b) {
  if (a.cpuDescriptor.ptr != b.cpuDescriptor.ptr)
    return false;
  if (!(a.DepthBeginningAccess == b.DepthBeginningAccess))
    return false;
  if (!(a.StencilBeginningAccess == b.StencilBeginningAccess))
    return false;
  if (!(a.DepthEndingAccess == b.DepthEndingAccess))
    return false;
  if (!(a.StencilEndingAccess == b.StencilEndingAccess))
    return false;
  return true;
}

#ifndef D3DX12_NO_STATE_OBJECT_HELPERS

//================================================================================================
// D3DX12 State Object Creation Helpers
//
// Helper classes for creating new style state objects out of an arbitrary set
// of subobjects. Uses STL
//
// Start by instantiating CD3DX12_STATE_OBJECT_DESC (see it's public methods).
// One of its methods is CreateSubobject(), which has a comment showing a couple
// of options for defining subobjects using the helper classes for each
// subobject (CD3DX12_DXIL_LIBRARY_SUBOBJECT etc.). The subobject helpers each
// have methods specific to the subobject for configuring it's contents.
//
//================================================================================================
#include <list>
#include <memory>
#include <string>
#include <vector>
#include <wrl/client.h>

//------------------------------------------------------------------------------------------------
class CD3DX12_STATE_OBJECT_DESC {
public:
  CD3DX12_STATE_OBJECT_DESC() { Init(D3D12_STATE_OBJECT_TYPE_COLLECTION); }
  CD3DX12_STATE_OBJECT_DESC(D3D12_STATE_OBJECT_TYPE Type) { Init(Type); }
  void SetStateObjectType(D3D12_STATE_OBJECT_TYPE Type) { m_Desc.Type = Type; }
  operator const D3D12_STATE_OBJECT_DESC &() {
    // Do final preparation work
    m_RepointedAssociations.clear();
    m_SubobjectArray.clear();
    m_SubobjectArray.reserve(m_Desc.NumSubobjects);
    // Flatten subobjects into an array (each flattened subobject still has a
    // member that's a pointer to it's desc that's not flattened)
    for (auto Iter = m_SubobjectList.begin(); Iter != m_SubobjectList.end();
         Iter++) {
      m_SubobjectArray.push_back(*Iter);
      // Store new location in array so we can redirect pointers contained in
      // subobjects
      Iter->pSubobjectArrayLocation = &m_SubobjectArray.back();
    }
    // For subobjects with pointer fields, create a new copy of those subobject
    // definitions with fixed pointers
    for (UINT i = 0; i < m_Desc.NumSubobjects; i++) {
      if (m_SubobjectArray[i].Type ==
          D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION) {
        auto pOriginalSubobjectAssociation =
            reinterpret_cast<const D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION *>(
                m_SubobjectArray[i].pDesc);
        D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION Repointed =
            *pOriginalSubobjectAssociation;
        auto pWrapper = static_cast<const SUBOBJECT_WRAPPER *>(
            pOriginalSubobjectAssociation->pSubobjectToAssociate);
        Repointed.pSubobjectToAssociate = pWrapper->pSubobjectArrayLocation;
        m_RepointedAssociations.push_back(Repointed);
        m_SubobjectArray[i].pDesc = &m_RepointedAssociations.back();
      }
    }
    // Below: using ugly way to get pointer in case .data() is not defined
    m_Desc.pSubobjects = m_Desc.NumSubobjects ? &m_SubobjectArray[0] : nullptr;
    return m_Desc;
  }
  operator const D3D12_STATE_OBJECT_DESC *() {
    // Cast calls the above final preparation work
    return &static_cast<const D3D12_STATE_OBJECT_DESC &>(*this);
  }

  // CreateSubobject creates a sububject helper (e.g.
  // CD3DX12_HIT_GROUP_SUBOBJECT) whose lifetime is owned by this class. e.g.
  //
  //    CD3DX12_STATE_OBJECT_DESC
  //    Collection1(D3D12_STATE_OBJECT_TYPE_COLLECTION); auto Lib0 =
  //    Collection1.CreateSubobject<CD3DX12_DXIL_LIBRARY_SUBOBJECT>();
  //    Lib0->SetDXILLibrary(&pMyAppDxilLibs[0]);
  //    Lib0->DefineExport(L"rayGenShader0"); // in practice these export
  //    listings might be
  //                                          // data/engine driven
  //    etc.
  //
  // Alternatively, users can instantiate sububject helpers explicitly, such as
  // via local variables instead, passing the state object desc that should
  // point to it into the helper constructor (or call
  // mySubobjectHelper.AddToStateObject(Collection1)). In this alternative
  // scenario, the user must keep the subobject alive as long as the state
  // object it is associated with is alive, else it's pointer references will be
  // stale. e.g.
  //
  //    CD3DX12_STATE_OBJECT_DESC
  //    RaytracingState2(D3D12_STATE_OBJECT_TYPE_RAYTRACING_PIPELINE);
  //    CD3DX12_DXIL_LIBRARY_SUBOBJECT LibA(RaytracingState2);
  //    LibA.SetDXILLibrary(&pMyAppDxilLibs[4]); // not manually specifying
  //    exports
  //                                             // - meaning all exports in the
  //                                             libraries
  //                                             // are exported
  //    etc.

  template <typename T> T *CreateSubobject() {
    T *pSubobject = new T(*this);
    m_OwnedSubobjectHelpers.emplace_back(pSubobject);
    return pSubobject;
  }

private:
  D3D12_STATE_SUBOBJECT *TrackSubobject(D3D12_STATE_SUBOBJECT_TYPE Type,
                                        void *pDesc) {
    SUBOBJECT_WRAPPER Subobject;
    Subobject.pSubobjectArrayLocation = nullptr;
    Subobject.Type = Type;
    Subobject.pDesc = pDesc;
    m_SubobjectList.push_back(Subobject);
    m_Desc.NumSubobjects++;
    return &m_SubobjectList.back();
  }
  void Init(D3D12_STATE_OBJECT_TYPE Type) {
    SetStateObjectType(Type);
    m_Desc.pSubobjects = nullptr;
    m_Desc.NumSubobjects = 0;
    m_SubobjectList.clear();
    m_SubobjectArray.clear();
    m_RepointedAssociations.clear();
  }
  typedef struct SUBOBJECT_WRAPPER : public D3D12_STATE_SUBOBJECT {
    D3D12_STATE_SUBOBJECT
        *pSubobjectArrayLocation; // new location when flattened into array
                                  // for repointing pointers in subobjects
  } SUBOBJECT_WRAPPER;
  D3D12_STATE_OBJECT_DESC m_Desc;
  std::list<SUBOBJECT_WRAPPER>
      m_SubobjectList; // Pointers to list nodes handed out so
                       // these can be edited live
  std::vector<D3D12_STATE_SUBOBJECT>
      m_SubobjectArray; // Built at the end, copying list contents

  std::list<D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION>
      m_RepointedAssociations; // subobject type that contains pointers to other
                               // subobjects, repointed to flattened array

  class StringContainer {
  public:
    LPCWSTR LocalCopy(LPCWSTR string, bool bSingleString = false) {
      if (string) {
        if (bSingleString) {
          m_Strings.clear();
          m_Strings.push_back(string);
        } else {
          m_Strings.push_back(string);
        }
        return m_Strings.back().c_str();
      } else {
        return nullptr;
      }
    }
    void clear() { m_Strings.clear(); }

  private:
    std::list<std::wstring> m_Strings;
  };

  class SUBOBJECT_HELPER_BASE {
  public:
    SUBOBJECT_HELPER_BASE() { Init(); }
    virtual ~SUBOBJECT_HELPER_BASE() {}
    virtual D3D12_STATE_SUBOBJECT_TYPE Type() const = 0;
    void AddToStateObject(CD3DX12_STATE_OBJECT_DESC &ContainingStateObject) {
      m_pSubobject = ContainingStateObject.TrackSubobject(Type(), Data());
    }

  protected:
    virtual void *Data() = 0;
    void Init() { m_pSubobject = nullptr; }
    D3D12_STATE_SUBOBJECT *m_pSubobject;
  };

#if (__cplusplus >= 201103L)
  std::list<std::unique_ptr<const SUBOBJECT_HELPER_BASE>>
      m_OwnedSubobjectHelpers;
#else
  class OWNED_HELPER {
  public:
    OWNED_HELPER(const SUBOBJECT_HELPER_BASE *pHelper) { m_pHelper = pHelper; }
    ~OWNED_HELPER() { delete m_pHelper; }
    const SUBOBJECT_HELPER_BASE *m_pHelper;
  };

  std::list<OWNED_HELPER> m_OwnedSubobjectHelpers;
#endif

  friend class CD3DX12_DXIL_LIBRARY_SUBOBJECT;
  friend class CD3DX12_EXISTING_COLLECTION_SUBOBJECT;
  friend class CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT;
  friend class CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
  friend class CD3DX12_HIT_GROUP_SUBOBJECT;
  friend class CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT;
  friend class CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT;
  friend class CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT;
  friend class CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT;
  friend class CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT;
  friend class CD3DX12_NODE_MASK_SUBOBJECT;
};

//------------------------------------------------------------------------------------------------
class CD3DX12_DXIL_LIBRARY_SUBOBJECT
    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE {
public:
  CD3DX12_DXIL_LIBRARY_SUBOBJECT() { Init(); }
  CD3DX12_DXIL_LIBRARY_SUBOBJECT(
      CD3DX12_STATE_OBJECT_DESC &ContainingStateObject) {
    Init();
    AddToStateObject(ContainingStateObject);
  }
  void SetDXILLibrary(D3D12_SHADER_BYTECODE *pCode) {
    static const D3D12_SHADER_BYTECODE Default = {};
    m_Desc.DXILLibrary = pCode ? *pCode : Default;
  }
  void DefineExport(LPCWSTR Name, LPCWSTR ExportToRename = nullptr,
                    D3D12_EXPORT_FLAGS Flags = D3D12_EXPORT_FLAG_NONE) {
    D3D12_EXPORT_DESC Export;
    Export.Name = m_Strings.LocalCopy(Name);
    Export.ExportToRename = m_Strings.LocalCopy(ExportToRename);
    Export.Flags = Flags;
    m_Exports.push_back(Export);
    m_Desc.pExports = &m_Exports[0]; // using ugly way to get pointer in case
                                     // .data() is not defined
    m_Desc.NumExports = static_cast<UINT>(m_Exports.size());
  }
  template <size_t N> void DefineExports(LPCWSTR (&Exports)[N]) {
    for (UINT i = 0; i < N; i++) {
      DefineExport(Exports[i]);
    }
  }
  void DefineExports(LPCWSTR *Exports, UINT N) {
    for (UINT i = 0; i < N; i++) {
      DefineExport(Exports[i]);
    }
  }
  D3D12_STATE_SUBOBJECT_TYPE Type() const {
    return D3D12_STATE_SUBOBJECT_TYPE_DXIL_LIBRARY;
  }
  operator const D3D12_STATE_SUBOBJECT &() const { return *m_pSubobject; }
  operator const D3D12_DXIL_LIBRARY_DESC &() const { return m_Desc; }

private:
  void Init() {
    SUBOBJECT_HELPER_BASE::Init();
    m_Desc = {};
    m_Strings.clear();
    m_Exports.clear();
  }
  void *Data() { return &m_Desc; }
  D3D12_DXIL_LIBRARY_DESC m_Desc;
  CD3DX12_STATE_OBJECT_DESC::StringContainer m_Strings;
  std::vector<D3D12_EXPORT_DESC> m_Exports;
};

//------------------------------------------------------------------------------------------------
class CD3DX12_EXISTING_COLLECTION_SUBOBJECT
    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE {
public:
  CD3DX12_EXISTING_COLLECTION_SUBOBJECT() { Init(); }
  CD3DX12_EXISTING_COLLECTION_SUBOBJECT(
      CD3DX12_STATE_OBJECT_DESC &ContainingStateObject) {
    Init();
    AddToStateObject(ContainingStateObject);
  }
  void SetExistingCollection(ID3D12StateObject *pExistingCollection) {
    m_Desc.pExistingCollection = pExistingCollection;
    m_CollectionRef = pExistingCollection;
  }
  void DefineExport(LPCWSTR Name, LPCWSTR ExportToRename = nullptr,
                    D3D12_EXPORT_FLAGS Flags = D3D12_EXPORT_FLAG_NONE) {
    D3D12_EXPORT_DESC Export;
    Export.Name = m_Strings.LocalCopy(Name);
    Export.ExportToRename = m_Strings.LocalCopy(ExportToRename);
    Export.Flags = Flags;
    m_Exports.push_back(Export);
    m_Desc.pExports = &m_Exports[0]; // using ugly way to get pointer in case
                                     // .data() is not defined
    m_Desc.NumExports = static_cast<UINT>(m_Exports.size());
  }
  template <size_t N> void DefineExports(LPCWSTR (&Exports)[N]) {
    for (UINT i = 0; i < N; i++) {
      DefineExport(Exports[i]);
    }
  }
  void DefineExports(LPCWSTR *Exports, UINT N) {
    for (UINT i = 0; i < N; i++) {
      DefineExport(Exports[i]);
    }
  }
  D3D12_STATE_SUBOBJECT_TYPE Type() const {
    return D3D12_STATE_SUBOBJECT_TYPE_EXISTING_COLLECTION;
  }
  operator const D3D12_STATE_SUBOBJECT &() const { return *m_pSubobject; }
  operator const D3D12_EXISTING_COLLECTION_DESC &() const { return m_Desc; }

private:
  void Init() {
    SUBOBJECT_HELPER_BASE::Init();
    m_Desc = {};
    m_CollectionRef = nullptr;
    m_Strings.clear();
    m_Exports.clear();
  }
  void *Data() { return &m_Desc; }
  D3D12_EXISTING_COLLECTION_DESC m_Desc;
  Microsoft::WRL::ComPtr<ID3D12StateObject> m_CollectionRef;
  CD3DX12_STATE_OBJECT_DESC::StringContainer m_Strings;
  std::vector<D3D12_EXPORT_DESC> m_Exports;
};

//------------------------------------------------------------------------------------------------
class CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT
    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE {
public:
  CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT() { Init(); }
  CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT(
      CD3DX12_STATE_OBJECT_DESC &ContainingStateObject) {
    Init();
    AddToStateObject(ContainingStateObject);
  }
  void
  SetSubobjectToAssociate(const D3D12_STATE_SUBOBJECT &SubobjectToAssociate) {
    m_Desc.pSubobjectToAssociate = &SubobjectToAssociate;
  }
  void AddExport(LPCWSTR Export) {
    m_Desc.NumExports++;
    m_Exports.push_back(m_Strings.LocalCopy(Export));
    m_Desc.pExports = &m_Exports[0]; // using ugly way to get pointer in case
                                     // .data() is not defined
  }
  template <size_t N> void AddExports(LPCWSTR (&Exports)[N]) {
    for (UINT i = 0; i < N; i++) {
      AddExport(Exports[i]);
    }
  }
  void AddExports(LPCWSTR *Exports, UINT N) {
    for (UINT i = 0; i < N; i++) {
      AddExport(Exports[i]);
    }
  }
  D3D12_STATE_SUBOBJECT_TYPE Type() const {
    return D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
  }
  operator const D3D12_STATE_SUBOBJECT &() const { return *m_pSubobject; }
  operator const D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION &() const {
    return m_Desc;
  }

private:
  void Init() {
    SUBOBJECT_HELPER_BASE::Init();
    m_Desc = {};
    m_Strings.clear();
    m_Exports.clear();
  }
  void *Data() { return &m_Desc; }
  D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION m_Desc;
  CD3DX12_STATE_OBJECT_DESC::StringContainer m_Strings;
  std::vector<LPCWSTR> m_Exports;
};

//------------------------------------------------------------------------------------------------
class CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION
    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE {
public:
  CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION() { Init(); }
  CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION(
      CD3DX12_STATE_OBJECT_DESC &ContainingStateObject) {
    Init();
    AddToStateObject(ContainingStateObject);
  }
  void SetSubobjectNameToAssociate(LPCWSTR SubobjectToAssociate) {
    m_Desc.SubobjectToAssociate =
        m_SubobjectName.LocalCopy(SubobjectToAssociate, true);
  }
  void AddExport(LPCWSTR Export) {
    m_Desc.NumExports++;
    m_Exports.push_back(m_Strings.LocalCopy(Export));
    m_Desc.pExports = &m_Exports[0]; // using ugly way to get pointer in case
                                     // .data() is not defined
  }
  template <size_t N> void AddExports(LPCWSTR (&Exports)[N]) {
    for (UINT i = 0; i < N; i++) {
      AddExport(Exports[i]);
    }
  }
  void AddExports(LPCWSTR *Exports, UINT N) {
    for (UINT i = 0; i < N; i++) {
      AddExport(Exports[i]);
    }
  }
  D3D12_STATE_SUBOBJECT_TYPE Type() const {
    return D3D12_STATE_SUBOBJECT_TYPE_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
  }
  operator const D3D12_STATE_SUBOBJECT &() const { return *m_pSubobject; }
  operator const D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION &() const {
    return m_Desc;
  }

private:
  void Init() {
    SUBOBJECT_HELPER_BASE::Init();
    m_Desc = {};
    m_Strings.clear();
    m_SubobjectName.clear();
    m_Exports.clear();
  }
  void *Data() { return &m_Desc; }
  D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION m_Desc;
  CD3DX12_STATE_OBJECT_DESC::StringContainer m_Strings;
  CD3DX12_STATE_OBJECT_DESC::StringContainer m_SubobjectName;
  std::vector<LPCWSTR> m_Exports;
};

//------------------------------------------------------------------------------------------------
class CD3DX12_HIT_GROUP_SUBOBJECT
    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE {
public:
  CD3DX12_HIT_GROUP_SUBOBJECT() { Init(); }
  CD3DX12_HIT_GROUP_SUBOBJECT(
      CD3DX12_STATE_OBJECT_DESC &ContainingStateObject) {
    Init();
    AddToStateObject(ContainingStateObject);
  }
  void SetHitGroupExport(LPCWSTR exportName) {
    m_Desc.HitGroupExport = m_Strings[0].LocalCopy(exportName, true);
  }
  void SetHitGroupType(D3D12_HIT_GROUP_TYPE Type) { m_Desc.Type = Type; }
  void SetAnyHitShaderImport(LPCWSTR importName) {
    m_Desc.AnyHitShaderImport = m_Strings[1].LocalCopy(importName, true);
  }
  void SetClosestHitShaderImport(LPCWSTR importName) {
    m_Desc.ClosestHitShaderImport = m_Strings[2].LocalCopy(importName, true);
  }
  void SetIntersectionShaderImport(LPCWSTR importName) {
    m_Desc.IntersectionShaderImport = m_Strings[3].LocalCopy(importName, true);
  }
  D3D12_STATE_SUBOBJECT_TYPE Type() const {
    return D3D12_STATE_SUBOBJECT_TYPE_HIT_GROUP;
  }
  operator const D3D12_STATE_SUBOBJECT &() const { return *m_pSubobject; }
  operator const D3D12_HIT_GROUP_DESC &() const { return m_Desc; }

private:
  void Init() {
    SUBOBJECT_HELPER_BASE::Init();
    m_Desc = {};
    for (UINT i = 0; i < m_NumStrings; i++) {
      m_Strings[i].clear();
    }
  }
  void *Data() { return &m_Desc; }
  D3D12_HIT_GROUP_DESC m_Desc;
  static const UINT m_NumStrings = 4;
  CD3DX12_STATE_OBJECT_DESC::StringContainer
      m_Strings[m_NumStrings]; // one string for every entrypoint name
};

//------------------------------------------------------------------------------------------------
class CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT
    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE {
public:
  CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT() { Init(); }
  CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT(
      CD3DX12_STATE_OBJECT_DESC &ContainingStateObject) {
    Init();
    AddToStateObject(ContainingStateObject);
  }
  void Config(UINT MaxPayloadSizeInBytes, UINT MaxAttributeSizeInBytes) {
    m_Desc.MaxPayloadSizeInBytes = MaxPayloadSizeInBytes;
    m_Desc.MaxAttributeSizeInBytes = MaxAttributeSizeInBytes;
  }
  D3D12_STATE_SUBOBJECT_TYPE Type() const {
    return D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_SHADER_CONFIG;
  }
  operator const D3D12_STATE_SUBOBJECT &() const { return *m_pSubobject; }
  operator const D3D12_RAYTRACING_SHADER_CONFIG &() const { return m_Desc; }

private:
  void Init() {
    SUBOBJECT_HELPER_BASE::Init();
    m_Desc = {};
  }
  void *Data() { return &m_Desc; }
  D3D12_RAYTRACING_SHADER_CONFIG m_Desc;
};

//------------------------------------------------------------------------------------------------
class CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT
    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE {
public:
  CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT() { Init(); }
  CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT(
      CD3DX12_STATE_OBJECT_DESC &ContainingStateObject) {
    Init();
    AddToStateObject(ContainingStateObject);
  }
  void Config(UINT MaxTraceRecursionDepth) {
    m_Desc.MaxTraceRecursionDepth = MaxTraceRecursionDepth;
  }
  D3D12_STATE_SUBOBJECT_TYPE Type() const {
    return D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG;
  }
  operator const D3D12_STATE_SUBOBJECT &() const { return *m_pSubobject; }
  operator const D3D12_RAYTRACING_PIPELINE_CONFIG &() const { return m_Desc; }

private:
  void Init() {
    SUBOBJECT_HELPER_BASE::Init();
    m_Desc = {};
  }
  void *Data() { return &m_Desc; }
  D3D12_RAYTRACING_PIPELINE_CONFIG m_Desc;
};

//------------------------------------------------------------------------------------------------
class CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT
    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE {
public:
  CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT() { Init(); }
  CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT(
      CD3DX12_STATE_OBJECT_DESC &ContainingStateObject) {
    Init();
    AddToStateObject(ContainingStateObject);
  }
  void SetRootSignature(ID3D12RootSignature *pRootSig) {
    m_pRootSig = pRootSig;
  }
  D3D12_STATE_SUBOBJECT_TYPE Type() const {
    return D3D12_STATE_SUBOBJECT_TYPE_GLOBAL_ROOT_SIGNATURE;
  }
  operator const D3D12_STATE_SUBOBJECT &() const { return *m_pSubobject; }
  operator ID3D12RootSignature *() const { return m_pRootSig.Get(); }

private:
  void Init() {
    SUBOBJECT_HELPER_BASE::Init();
    m_pRootSig = nullptr;
  }
  void *Data() { return m_pRootSig.GetAddressOf(); }
  Microsoft::WRL::ComPtr<ID3D12RootSignature> m_pRootSig;
};

//------------------------------------------------------------------------------------------------
class CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT
    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE {
public:
  CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT() { Init(); }
  CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT(
      CD3DX12_STATE_OBJECT_DESC &ContainingStateObject) {
    Init();
    AddToStateObject(ContainingStateObject);
  }
  void SetRootSignature(ID3D12RootSignature *pRootSig) {
    m_pRootSig = pRootSig;
  }
  D3D12_STATE_SUBOBJECT_TYPE Type() const {
    return D3D12_STATE_SUBOBJECT_TYPE_LOCAL_ROOT_SIGNATURE;
  }
  operator const D3D12_STATE_SUBOBJECT &() const { return *m_pSubobject; }
  operator ID3D12RootSignature *() const { return m_pRootSig.Get(); }

private:
  void Init() {
    SUBOBJECT_HELPER_BASE::Init();
    m_pRootSig = nullptr;
  }
  void *Data() { return m_pRootSig.GetAddressOf(); }
  Microsoft::WRL::ComPtr<ID3D12RootSignature> m_pRootSig;
};

//------------------------------------------------------------------------------------------------
class CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT
    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE {
public:
  CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT() { Init(); }
  CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT(
      CD3DX12_STATE_OBJECT_DESC &ContainingStateObject) {
    Init();
    AddToStateObject(ContainingStateObject);
  }
  void SetFlags(D3D12_STATE_OBJECT_FLAGS Flags) { m_Desc.Flags = Flags; }
  D3D12_STATE_SUBOBJECT_TYPE Type() const {
    return D3D12_STATE_SUBOBJECT_TYPE_STATE_OBJECT_CONFIG;
  }
  operator const D3D12_STATE_SUBOBJECT &() const { return *m_pSubobject; }
  operator const D3D12_STATE_OBJECT_CONFIG &() const { return m_Desc; }

private:
  void Init() {
    SUBOBJECT_HELPER_BASE::Init();
    m_Desc = {};
  }
  void *Data() { return &m_Desc; }
  D3D12_STATE_OBJECT_CONFIG m_Desc;
};

//------------------------------------------------------------------------------------------------
class CD3DX12_NODE_MASK_SUBOBJECT
    : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE {
public:
  CD3DX12_NODE_MASK_SUBOBJECT() { Init(); }
  CD3DX12_NODE_MASK_SUBOBJECT(
      CD3DX12_STATE_OBJECT_DESC &ContainingStateObject) {
    Init();
    AddToStateObject(ContainingStateObject);
  }
  void SetNodeMask(UINT NodeMask) { m_Desc.NodeMask = NodeMask; }
  D3D12_STATE_SUBOBJECT_TYPE Type() const {
    return D3D12_STATE_SUBOBJECT_TYPE_NODE_MASK;
  }
  operator const D3D12_STATE_SUBOBJECT &() const { return *m_pSubobject; }
  operator const D3D12_NODE_MASK &() const { return m_Desc; }

private:
  void Init() {
    SUBOBJECT_HELPER_BASE::Init();
    m_Desc = {};
  }
  void *Data() { return &m_Desc; }
  D3D12_NODE_MASK m_Desc;
};

#endif // #ifndef D3DX12_NO_STATE_OBJECT_HELPERS

#endif // defined( __cplusplus )

#endif //__D3DX12_H__