//*********************************************************
//
// 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.
//
//*********************************************************
// changes made for dynamic linking of dx12.dll
// - all occurrences of "IID_ID3D12Device" were replaced by "__uuidof(*pDevice)"
// - the function D3DX12SerializeVersionedRootSignature has two additional
// functionpointer arguments pointing to the dynamically loaded fuctions of type
// PFN_D3D12_SERIALIZE_VERSIONED_ROOT_SIGNATURE and
// PFN_D3D12_SERIALIZE_ROOT_SIGNATURE
#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) noexcept
{
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) noexcept
{
return !(l == r);
}
//------------------------------------------------------------------------------------------------
struct CD3DX12_RECT : public D3D12_RECT
{
CD3DX12_RECT() = default;
explicit CD3DX12_RECT(const D3D12_RECT& o) noexcept
: D3D12_RECT(o)
{}
explicit CD3DX12_RECT(LONG Left, LONG Top, LONG Right, LONG Bottom) noexcept
{
left = Left;
top = Top;
right = Right;
bottom = Bottom;
}
};
//------------------------------------------------------------------------------------------------
struct CD3DX12_VIEWPORT : public D3D12_VIEWPORT
{
CD3DX12_VIEWPORT() = default;
explicit CD3DX12_VIEWPORT(const D3D12_VIEWPORT& o) noexcept
: D3D12_VIEWPORT(o)
{}
explicit CD3DX12_VIEWPORT(FLOAT topLeftX,
FLOAT topLeftY,
FLOAT width,
FLOAT height,
FLOAT minDepth = D3D12_MIN_DEPTH,
FLOAT maxDepth = D3D12_MAX_DEPTH) noexcept
{
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) noexcept
{
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 = float(Desc.Width) - topLeftX;
Height = 1.0f;
break;
case D3D12_RESOURCE_DIMENSION_TEXTURE1D:
TopLeftX = topLeftX;
TopLeftY = 0.0f;
Width = (SubresourceWidth ? float(SubresourceWidth) : 1.0f)
- topLeftX;
Height = 1.0f;
break;
case D3D12_RESOURCE_DIMENSION_TEXTURE2D:
case D3D12_RESOURCE_DIMENSION_TEXTURE3D:
TopLeftX = topLeftX;
TopLeftY = topLeftY;
Width = (SubresourceWidth ? float(SubresourceWidth) : 1.0f)
- topLeftX;
Height = (SubresourceHeight ? float(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) noexcept
: D3D12_BOX(o)
{}
explicit CD3DX12_BOX(LONG Left, LONG Right) noexcept
{
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) noexcept
{
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) noexcept
{
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) noexcept
{
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) noexcept
{
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) noexcept
: D3D12_DEPTH_STENCIL_DESC(o)
{}
explicit CD3DX12_DEPTH_STENCIL_DESC(CD3DX12_DEFAULT) noexcept
{
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) noexcept
{
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) noexcept
: D3D12_DEPTH_STENCIL_DESC1(o)
{}
explicit CD3DX12_DEPTH_STENCIL_DESC1(
const D3D12_DEPTH_STENCIL_DESC& o) noexcept
{
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) noexcept
{
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) noexcept
{
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 noexcept
{
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) noexcept
: D3D12_BLEND_DESC(o)
{}
explicit CD3DX12_BLEND_DESC(CD3DX12_DEFAULT) noexcept
{
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) noexcept
: D3D12_RASTERIZER_DESC(o)
{}
explicit CD3DX12_RASTERIZER_DESC(CD3DX12_DEFAULT) noexcept
{
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) noexcept
{
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) noexcept
: D3D12_RESOURCE_ALLOCATION_INFO(o)
{}
CD3DX12_RESOURCE_ALLOCATION_INFO(UINT64 size, UINT64 alignment) noexcept
{
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) noexcept
: D3D12_HEAP_PROPERTIES(o)
{}
CD3DX12_HEAP_PROPERTIES(D3D12_CPU_PAGE_PROPERTY cpuPageProperty,
D3D12_MEMORY_POOL memoryPoolPreference,
UINT creationNodeMask = 1,
UINT nodeMask = 1)
noexcept
{
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) noexcept
{
Type = type;
CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
CreationNodeMask = creationNodeMask;
VisibleNodeMask = nodeMask;
}
bool IsCPUAccessible() const noexcept
{
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) noexcept
{
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) noexcept
{
return !(l == r);
}
//------------------------------------------------------------------------------------------------
struct CD3DX12_HEAP_DESC : public D3D12_HEAP_DESC
{
CD3DX12_HEAP_DESC() = default;
explicit CD3DX12_HEAP_DESC(const D3D12_HEAP_DESC& o) noexcept
: D3D12_HEAP_DESC(o)
{}
CD3DX12_HEAP_DESC(UINT64 size,
D3D12_HEAP_PROPERTIES properties,
UINT64 alignment = 0,
D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE)
noexcept
{
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)
noexcept
{
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)
noexcept
{
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)
noexcept
{
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)
noexcept
{
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)
noexcept
{
SizeInBytes = resAllocInfo.SizeInBytes;
Properties
= CD3DX12_HEAP_PROPERTIES(cpuPageProperty, memoryPoolPreference);
Alignment = resAllocInfo.Alignment;
Flags = flags;
}
bool IsCPUAccessible() const noexcept
{
return static_cast<const CD3DX12_HEAP_PROPERTIES*>(&Properties)
->IsCPUAccessible();
}
};
inline bool operator==(
const D3D12_HEAP_DESC& l, const D3D12_HEAP_DESC& r) noexcept
{
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) noexcept
{
return !(l == r);
}
//------------------------------------------------------------------------------------------------
struct CD3DX12_CLEAR_VALUE : public D3D12_CLEAR_VALUE
{
CD3DX12_CLEAR_VALUE() = default;
explicit CD3DX12_CLEAR_VALUE(const D3D12_CLEAR_VALUE& o) noexcept
: D3D12_CLEAR_VALUE(o)
{}
CD3DX12_CLEAR_VALUE(DXGI_FORMAT format, const FLOAT color[4]) noexcept
{
Format = format;
memcpy(Color, color, sizeof(Color));
}
CD3DX12_CLEAR_VALUE(DXGI_FORMAT format, FLOAT depth, UINT8 stencil) noexcept
{
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) noexcept
: D3D12_RANGE(o)
{}
CD3DX12_RANGE(SIZE_T begin, SIZE_T end) noexcept
{
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) noexcept
: D3D12_RANGE_UINT64(o)
{}
CD3DX12_RANGE_UINT64(UINT64 begin, UINT64 end) noexcept
{
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) noexcept
: D3D12_SUBRESOURCE_RANGE_UINT64(o)
{}
CD3DX12_SUBRESOURCE_RANGE_UINT64(
UINT subresource, const D3D12_RANGE_UINT64& range)
noexcept
{
Subresource = subresource;
Range = range;
}
CD3DX12_SUBRESOURCE_RANGE_UINT64(UINT subresource, UINT64 begin, UINT64 end)
noexcept
{
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) noexcept
: D3D12_SHADER_BYTECODE(o)
{}
CD3DX12_SHADER_BYTECODE(_In_ ID3DBlob* pShaderBlob) noexcept
{
pShaderBytecode = pShaderBlob->GetBufferPointer();
BytecodeLength = pShaderBlob->GetBufferSize();
}
CD3DX12_SHADER_BYTECODE(const void* _pShaderBytecode, SIZE_T bytecodeLength)
noexcept
{
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) noexcept
: D3D12_TILED_RESOURCE_COORDINATE(o)
{}
CD3DX12_TILED_RESOURCE_COORDINATE(UINT x, UINT y, UINT z, UINT subresource)
noexcept
{
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) noexcept
: D3D12_TILE_REGION_SIZE(o)
{}
CD3DX12_TILE_REGION_SIZE(
UINT numTiles, BOOL useBox, UINT width, UINT16 height, UINT16 depth)
noexcept
{
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) noexcept
: D3D12_SUBRESOURCE_TILING(o)
{}
CD3DX12_SUBRESOURCE_TILING(UINT widthInTiles,
UINT16 heightInTiles,
UINT16 depthInTiles,
UINT startTileIndexInOverallResource)
noexcept
{
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) noexcept
: D3D12_TILE_SHAPE(o)
{}
CD3DX12_TILE_SHAPE(
UINT widthInTexels, UINT heightInTexels, UINT depthInTexels)
noexcept
{
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) noexcept
: D3D12_RESOURCE_BARRIER(o)
{}
inline static 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) noexcept
{
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;
}
inline static CD3DX12_RESOURCE_BARRIER Aliasing(
_In_ ID3D12Resource* pResourceBefore,
_In_ ID3D12Resource* pResourceAfter) noexcept
{
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;
}
inline static CD3DX12_RESOURCE_BARRIER UAV(
_In_ ID3D12Resource* pResource) noexcept
{
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) noexcept
: D3D12_PACKED_MIP_INFO(o)
{}
CD3DX12_PACKED_MIP_INFO(UINT8 numStandardMips,
UINT8 numPackedMips,
UINT numTilesForPackedMips,
UINT startTileIndexInOverallResource)
noexcept
{
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) noexcept
: D3D12_SUBRESOURCE_FOOTPRINT(o)
{}
CD3DX12_SUBRESOURCE_FOOTPRINT(
DXGI_FORMAT format, UINT width, UINT height, UINT depth, UINT rowPitch)
noexcept
{
Format = format;
Width = width;
Height = height;
Depth = depth;
RowPitch = rowPitch;
}
explicit CD3DX12_SUBRESOURCE_FOOTPRINT(
const D3D12_RESOURCE_DESC& resDesc, UINT rowPitch) noexcept
{
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) noexcept
: D3D12_TEXTURE_COPY_LOCATION(o)
{}
CD3DX12_TEXTURE_COPY_LOCATION(_In_ ID3D12Resource* pRes) noexcept
{
pResource = pRes;
Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
PlacedFootprint = {};
}
CD3DX12_TEXTURE_COPY_LOCATION(_In_ ID3D12Resource* pRes,
D3D12_PLACED_SUBRESOURCE_FOOTPRINT const& Footprint)
noexcept
{
pResource = pRes;
Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
PlacedFootprint = Footprint;
}
CD3DX12_TEXTURE_COPY_LOCATION(_In_ ID3D12Resource* pRes, UINT Sub) noexcept
{
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) noexcept
: 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)
noexcept
{
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) noexcept
{
Init(*this,
rangeType,
numDescriptors,
baseShaderRegister,
registerSpace,
offsetInDescriptorsFromTableStart);
}
inline static 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) noexcept
{
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) noexcept
: D3D12_ROOT_DESCRIPTOR_TABLE(o)
{}
CD3DX12_ROOT_DESCRIPTOR_TABLE(UINT numDescriptorRanges,
_In_reads_opt_(numDescriptorRanges)
const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges)
noexcept
{
Init(numDescriptorRanges, _pDescriptorRanges);
}
inline void Init(UINT numDescriptorRanges,
_In_reads_opt_(numDescriptorRanges)
const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges) noexcept
{
Init(*this, numDescriptorRanges, _pDescriptorRanges);
}
inline static void Init(
_Out_ D3D12_ROOT_DESCRIPTOR_TABLE& rootDescriptorTable,
UINT numDescriptorRanges,
_In_reads_opt_(numDescriptorRanges)
const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges) noexcept
{
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) noexcept
: D3D12_ROOT_CONSTANTS(o)
{}
CD3DX12_ROOT_CONSTANTS(
UINT num32BitValues, UINT shaderRegister, UINT registerSpace = 0)
noexcept
{
Init(num32BitValues, shaderRegister, registerSpace);
}
inline void Init(UINT num32BitValues,
UINT shaderRegister,
UINT registerSpace = 0) noexcept
{
Init(*this, num32BitValues, shaderRegister, registerSpace);
}
inline static void Init(_Out_ D3D12_ROOT_CONSTANTS& rootConstants,
UINT num32BitValues,
UINT shaderRegister,
UINT registerSpace = 0) noexcept
{
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) noexcept
: D3D12_ROOT_DESCRIPTOR(o)
{}
CD3DX12_ROOT_DESCRIPTOR(UINT shaderRegister, UINT registerSpace = 0)
noexcept
{
Init(shaderRegister, registerSpace);
}
inline void Init(UINT shaderRegister, UINT registerSpace = 0) noexcept
{
Init(*this, shaderRegister, registerSpace);
}
inline static void Init(_Out_ D3D12_ROOT_DESCRIPTOR& table,
UINT shaderRegister,
UINT registerSpace = 0) noexcept
{
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) noexcept
: D3D12_ROOT_PARAMETER(o)
{}
inline static 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) noexcept
{
rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
rootParam.ShaderVisibility = visibility;
CD3DX12_ROOT_DESCRIPTOR_TABLE::Init(
rootParam.DescriptorTable, numDescriptorRanges, pDescriptorRanges);
}
inline static void InitAsConstants(_Out_ D3D12_ROOT_PARAMETER& rootParam,
UINT num32BitValues,
UINT shaderRegister,
UINT registerSpace = 0,
D3D12_SHADER_VISIBILITY visibility
= D3D12_SHADER_VISIBILITY_ALL) noexcept
{
rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS;
rootParam.ShaderVisibility = visibility;
CD3DX12_ROOT_CONSTANTS::Init(
rootParam.Constants, num32BitValues, shaderRegister, registerSpace);
}
inline static void InitAsConstantBufferView(
_Out_ D3D12_ROOT_PARAMETER& rootParam,
UINT shaderRegister,
UINT registerSpace = 0,
D3D12_SHADER_VISIBILITY visibility
= D3D12_SHADER_VISIBILITY_ALL) noexcept
{
rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
rootParam.ShaderVisibility = visibility;
CD3DX12_ROOT_DESCRIPTOR::Init(
rootParam.Descriptor, shaderRegister, registerSpace);
}
inline static void InitAsShaderResourceView(
_Out_ D3D12_ROOT_PARAMETER& rootParam,
UINT shaderRegister,
UINT registerSpace = 0,
D3D12_SHADER_VISIBILITY visibility
= D3D12_SHADER_VISIBILITY_ALL) noexcept
{
rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_SRV;
rootParam.ShaderVisibility = visibility;
CD3DX12_ROOT_DESCRIPTOR::Init(
rootParam.Descriptor, shaderRegister, registerSpace);
}
inline static void InitAsUnorderedAccessView(
_Out_ D3D12_ROOT_PARAMETER& rootParam,
UINT shaderRegister,
UINT registerSpace = 0,
D3D12_SHADER_VISIBILITY visibility
= D3D12_SHADER_VISIBILITY_ALL) noexcept
{
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) noexcept
{
InitAsDescriptorTable(
*this, numDescriptorRanges, pDescriptorRanges, visibility);
}
inline void InitAsConstants(UINT num32BitValues,
UINT shaderRegister,
UINT registerSpace = 0,
D3D12_SHADER_VISIBILITY visibility
= D3D12_SHADER_VISIBILITY_ALL) noexcept
{
InitAsConstants(
*this, num32BitValues, shaderRegister, registerSpace, visibility);
}
inline void InitAsConstantBufferView(UINT shaderRegister,
UINT registerSpace = 0,
D3D12_SHADER_VISIBILITY visibility
= D3D12_SHADER_VISIBILITY_ALL) noexcept
{
InitAsConstantBufferView(
*this, shaderRegister, registerSpace, visibility);
}
inline void InitAsShaderResourceView(UINT shaderRegister,
UINT registerSpace = 0,
D3D12_SHADER_VISIBILITY visibility
= D3D12_SHADER_VISIBILITY_ALL) noexcept
{
InitAsShaderResourceView(
*this, shaderRegister, registerSpace, visibility);
}
inline void InitAsUnorderedAccessView(UINT shaderRegister,
UINT registerSpace = 0,
D3D12_SHADER_VISIBILITY visibility
= D3D12_SHADER_VISIBILITY_ALL) noexcept
{
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) noexcept
: 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)
noexcept
{
Init(shaderRegister,
filter,
addressU,
addressV,
addressW,
mipLODBias,
maxAnisotropy,
comparisonFunc,
borderColor,
minLOD,
maxLOD,
shaderVisibility,
registerSpace);
}
inline static 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) noexcept
{
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) noexcept
{
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) noexcept
: 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)
noexcept
{
Init(numParameters,
_pParameters,
numStaticSamplers,
_pStaticSamplers,
flags);
}
CD3DX12_ROOT_SIGNATURE_DESC(CD3DX12_DEFAULT) noexcept
{
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) noexcept
{
Init(*this,
numParameters,
_pParameters,
numStaticSamplers,
_pStaticSamplers,
flags);
}
inline static 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) noexcept
{
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) noexcept
: 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)
noexcept
{
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) noexcept
{
Init(*this,
rangeType,
numDescriptors,
baseShaderRegister,
registerSpace,
flags,
offsetInDescriptorsFromTableStart);
}
inline static 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) noexcept
{
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) noexcept
: D3D12_ROOT_DESCRIPTOR_TABLE1(o)
{}
CD3DX12_ROOT_DESCRIPTOR_TABLE1(UINT numDescriptorRanges,
_In_reads_opt_(numDescriptorRanges)
const D3D12_DESCRIPTOR_RANGE1* _pDescriptorRanges)
noexcept
{
Init(numDescriptorRanges, _pDescriptorRanges);
}
inline void Init(UINT numDescriptorRanges,
_In_reads_opt_(numDescriptorRanges)
const D3D12_DESCRIPTOR_RANGE1* _pDescriptorRanges) noexcept
{
Init(*this, numDescriptorRanges, _pDescriptorRanges);
}
inline static void Init(
_Out_ D3D12_ROOT_DESCRIPTOR_TABLE1& rootDescriptorTable,
UINT numDescriptorRanges,
_In_reads_opt_(numDescriptorRanges)
const D3D12_DESCRIPTOR_RANGE1* _pDescriptorRanges) noexcept
{
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) noexcept
: D3D12_ROOT_DESCRIPTOR1(o)
{}
CD3DX12_ROOT_DESCRIPTOR1(UINT shaderRegister,
UINT registerSpace = 0,
D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE)
noexcept
{
Init(shaderRegister, registerSpace, flags);
}
inline void Init(UINT shaderRegister,
UINT registerSpace = 0,
D3D12_ROOT_DESCRIPTOR_FLAGS flags
= D3D12_ROOT_DESCRIPTOR_FLAG_NONE) noexcept
{
Init(*this, shaderRegister, registerSpace, flags);
}
inline static void Init(_Out_ D3D12_ROOT_DESCRIPTOR1& table,
UINT shaderRegister,
UINT registerSpace = 0,
D3D12_ROOT_DESCRIPTOR_FLAGS flags
= D3D12_ROOT_DESCRIPTOR_FLAG_NONE) noexcept
{
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) noexcept
: D3D12_ROOT_PARAMETER1(o)
{}
inline static 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) noexcept
{
rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
rootParam.ShaderVisibility = visibility;
CD3DX12_ROOT_DESCRIPTOR_TABLE1::Init(
rootParam.DescriptorTable, numDescriptorRanges, pDescriptorRanges);
}
inline static void InitAsConstants(_Out_ D3D12_ROOT_PARAMETER1& rootParam,
UINT num32BitValues,
UINT shaderRegister,
UINT registerSpace = 0,
D3D12_SHADER_VISIBILITY visibility
= D3D12_SHADER_VISIBILITY_ALL) noexcept
{
rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS;
rootParam.ShaderVisibility = visibility;
CD3DX12_ROOT_CONSTANTS::Init(
rootParam.Constants, num32BitValues, shaderRegister, registerSpace);
}
inline static 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) noexcept
{
rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
rootParam.ShaderVisibility = visibility;
CD3DX12_ROOT_DESCRIPTOR1::Init(
rootParam.Descriptor, shaderRegister, registerSpace, flags);
}
inline static 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) noexcept
{
rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_SRV;
rootParam.ShaderVisibility = visibility;
CD3DX12_ROOT_DESCRIPTOR1::Init(
rootParam.Descriptor, shaderRegister, registerSpace, flags);
}
inline static 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) noexcept
{
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) noexcept
{
InitAsDescriptorTable(
*this, numDescriptorRanges, pDescriptorRanges, visibility);
}
inline void InitAsConstants(UINT num32BitValues,
UINT shaderRegister,
UINT registerSpace = 0,
D3D12_SHADER_VISIBILITY visibility
= D3D12_SHADER_VISIBILITY_ALL) noexcept
{
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) noexcept
{
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) noexcept
{
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) noexcept
{
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) noexcept
: D3D12_VERSIONED_ROOT_SIGNATURE_DESC(o)
{}
explicit CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(
const D3D12_ROOT_SIGNATURE_DESC& o) noexcept
{
Version = D3D_ROOT_SIGNATURE_VERSION_1_0;
Desc_1_0 = o;
}
explicit CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(
const D3D12_ROOT_SIGNATURE_DESC1& o) noexcept
{
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)
noexcept
{
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)
noexcept
{
Init_1_1(numParameters,
_pParameters,
numStaticSamplers,
_pStaticSamplers,
flags);
}
CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(CD3DX12_DEFAULT) noexcept
{
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) noexcept
{
Init_1_0(*this,
numParameters,
_pParameters,
numStaticSamplers,
_pStaticSamplers,
flags);
}
inline static 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) noexcept
{
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) noexcept
{
Init_1_1(*this,
numParameters,
_pParameters,
numStaticSamplers,
_pStaticSamplers,
flags);
}
inline static 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) noexcept
{
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) noexcept
: D3D12_CPU_DESCRIPTOR_HANDLE(o)
{}
CD3DX12_CPU_DESCRIPTOR_HANDLE(CD3DX12_DEFAULT) noexcept
{
ptr = 0;
}
CD3DX12_CPU_DESCRIPTOR_HANDLE(const _In_ D3D12_CPU_DESCRIPTOR_HANDLE& other,
INT offsetScaledByIncrementSize)
noexcept
{
InitOffsetted(other, offsetScaledByIncrementSize);
}
CD3DX12_CPU_DESCRIPTOR_HANDLE(const _In_ D3D12_CPU_DESCRIPTOR_HANDLE& other,
INT offsetInDescriptors,
UINT descriptorIncrementSize)
noexcept
{
InitOffsetted(other, offsetInDescriptors, descriptorIncrementSize);
}
CD3DX12_CPU_DESCRIPTOR_HANDLE& Offset(
INT offsetInDescriptors, UINT descriptorIncrementSize) noexcept
{
ptr = SIZE_T(
INT64(ptr)
+ INT64(offsetInDescriptors) * INT64(descriptorIncrementSize));
return *this;
}
CD3DX12_CPU_DESCRIPTOR_HANDLE& Offset(
INT offsetScaledByIncrementSize) noexcept
{
ptr = SIZE_T(INT64(ptr) + INT64(offsetScaledByIncrementSize));
return *this;
}
bool operator==(
const _In_ D3D12_CPU_DESCRIPTOR_HANDLE& other) const noexcept
{
return (ptr == other.ptr);
}
bool operator!=(
const _In_ D3D12_CPU_DESCRIPTOR_HANDLE& other) const noexcept
{
return (ptr != other.ptr);
}
CD3DX12_CPU_DESCRIPTOR_HANDLE& operator=(
const D3D12_CPU_DESCRIPTOR_HANDLE& other) noexcept
{
ptr = other.ptr;
return *this;
}
inline void InitOffsetted(const _In_ D3D12_CPU_DESCRIPTOR_HANDLE& base,
INT offsetScaledByIncrementSize) noexcept
{
InitOffsetted(*this, base, offsetScaledByIncrementSize);
}
inline void InitOffsetted(const _In_ D3D12_CPU_DESCRIPTOR_HANDLE& base,
INT offsetInDescriptors,
UINT descriptorIncrementSize) noexcept
{
InitOffsetted(
*this, base, offsetInDescriptors, descriptorIncrementSize);
}
inline static void InitOffsetted(_Out_ D3D12_CPU_DESCRIPTOR_HANDLE& handle,
const _In_ D3D12_CPU_DESCRIPTOR_HANDLE& base,
INT offsetScaledByIncrementSize) noexcept
{
handle.ptr
= SIZE_T(INT64(base.ptr) + INT64(offsetScaledByIncrementSize));
}
inline static void InitOffsetted(_Out_ D3D12_CPU_DESCRIPTOR_HANDLE& handle,
const _In_ D3D12_CPU_DESCRIPTOR_HANDLE& base,
INT offsetInDescriptors,
UINT descriptorIncrementSize) noexcept
{
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) noexcept
: D3D12_GPU_DESCRIPTOR_HANDLE(o)
{}
CD3DX12_GPU_DESCRIPTOR_HANDLE(CD3DX12_DEFAULT) noexcept
{
ptr = 0;
}
CD3DX12_GPU_DESCRIPTOR_HANDLE(const _In_ D3D12_GPU_DESCRIPTOR_HANDLE& other,
INT offsetScaledByIncrementSize)
noexcept
{
InitOffsetted(other, offsetScaledByIncrementSize);
}
CD3DX12_GPU_DESCRIPTOR_HANDLE(const _In_ D3D12_GPU_DESCRIPTOR_HANDLE& other,
INT offsetInDescriptors,
UINT descriptorIncrementSize)
noexcept
{
InitOffsetted(other, offsetInDescriptors, descriptorIncrementSize);
}
CD3DX12_GPU_DESCRIPTOR_HANDLE& Offset(
INT offsetInDescriptors, UINT descriptorIncrementSize) noexcept
{
ptr = UINT64(
INT64(ptr)
+ INT64(offsetInDescriptors) * INT64(descriptorIncrementSize));
return *this;
}
CD3DX12_GPU_DESCRIPTOR_HANDLE& Offset(
INT offsetScaledByIncrementSize) noexcept
{
ptr = UINT64(INT64(ptr) + INT64(offsetScaledByIncrementSize));
return *this;
}
inline bool operator==(
const _In_ D3D12_GPU_DESCRIPTOR_HANDLE& other) const noexcept
{
return (ptr == other.ptr);
}
inline bool operator!=(
const _In_ D3D12_GPU_DESCRIPTOR_HANDLE& other) const noexcept
{
return (ptr != other.ptr);
}
CD3DX12_GPU_DESCRIPTOR_HANDLE& operator=(
const D3D12_GPU_DESCRIPTOR_HANDLE& other) noexcept
{
ptr = other.ptr;
return *this;
}
inline void InitOffsetted(const _In_ D3D12_GPU_DESCRIPTOR_HANDLE& base,
INT offsetScaledByIncrementSize) noexcept
{
InitOffsetted(*this, base, offsetScaledByIncrementSize);
}
inline void InitOffsetted(const _In_ D3D12_GPU_DESCRIPTOR_HANDLE& base,
INT offsetInDescriptors,
UINT descriptorIncrementSize) noexcept
{
InitOffsetted(
*this, base, offsetInDescriptors, descriptorIncrementSize);
}
inline static void InitOffsetted(_Out_ D3D12_GPU_DESCRIPTOR_HANDLE& handle,
const _In_ D3D12_GPU_DESCRIPTOR_HANDLE& base,
INT offsetScaledByIncrementSize) noexcept
{
handle.ptr
= UINT64(INT64(base.ptr) + INT64(offsetScaledByIncrementSize));
}
inline static void InitOffsetted(_Out_ D3D12_GPU_DESCRIPTOR_HANDLE& handle,
const _In_ D3D12_GPU_DESCRIPTOR_HANDLE& base,
INT offsetInDescriptors,
UINT descriptorIncrementSize) noexcept
{
handle.ptr = UINT64(
INT64(base.ptr)
+ INT64(offsetInDescriptors) * INT64(descriptorIncrementSize));
}
};
//------------------------------------------------------------------------------------------------
inline constexpr UINT D3D12CalcSubresource(UINT MipSlice,
UINT ArraySlice,
UINT PlaneSlice,
UINT MipLevels,
UINT ArraySize) noexcept
{
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) noexcept
{
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) noexcept
{
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) noexcept
: 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)
noexcept
{
Dimension = dimension;
Alignment = alignment;
Width = width;
Height = height;
DepthOrArraySize = depthOrArraySize;
MipLevels = mipLevels;
Format = format;
SampleDesc.Count = sampleCount;
SampleDesc.Quality = sampleQuality;
Layout = layout;
Flags = flags;
}
inline static CD3DX12_RESOURCE_DESC Buffer(
const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE) noexcept
{
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);
}
inline static CD3DX12_RESOURCE_DESC Buffer(UINT64 width,
D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
UINT64 alignment = 0) noexcept
{
return CD3DX12_RESOURCE_DESC(D3D12_RESOURCE_DIMENSION_BUFFER,
alignment,
width,
1,
1,
1,
DXGI_FORMAT_UNKNOWN,
1,
0,
D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
flags);
}
inline static 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) noexcept
{
return CD3DX12_RESOURCE_DESC(D3D12_RESOURCE_DIMENSION_TEXTURE1D,
alignment,
width,
1,
arraySize,
mipLevels,
format,
1,
0,
layout,
flags);
}
inline static 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) noexcept
{
return CD3DX12_RESOURCE_DESC(D3D12_RESOURCE_DIMENSION_TEXTURE2D,
alignment,
width,
height,
arraySize,
mipLevels,
format,
sampleCount,
sampleQuality,
layout,
flags);
}
inline static 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) noexcept
{
return CD3DX12_RESOURCE_DESC(D3D12_RESOURCE_DIMENSION_TEXTURE3D,
alignment,
width,
height,
depth,
mipLevels,
format,
1,
0,
layout,
flags);
}
inline UINT16 Depth() const noexcept
{
return (Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D
? DepthOrArraySize
: 1);
}
inline UINT16 ArraySize() const noexcept
{
return (Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE3D
? DepthOrArraySize
: 1);
}
inline UINT8 PlaneCount(_In_ ID3D12Device* pDevice) const noexcept
{
return D3D12GetFormatPlaneCount(pDevice, Format);
}
inline UINT Subresources(_In_ ID3D12Device* pDevice) const noexcept
{
return MipLevels * ArraySize() * PlaneCount(pDevice);
}
inline UINT CalcSubresource(
UINT MipSlice, UINT ArraySlice, UINT PlaneSlice) noexcept
{
return D3D12CalcSubresource(
MipSlice, ArraySlice, PlaneSlice, MipLevels, ArraySize());
}
};
inline bool operator==(
const D3D12_RESOURCE_DESC& l, const D3D12_RESOURCE_DESC& r) noexcept
{
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) noexcept
{
return !(l == r);
}
//------------------------------------------------------------------------------------------------
struct CD3DX12_RESOURCE_DESC1 : public D3D12_RESOURCE_DESC1
{
CD3DX12_RESOURCE_DESC1() = default;
explicit CD3DX12_RESOURCE_DESC1(const D3D12_RESOURCE_DESC1& o) noexcept
: D3D12_RESOURCE_DESC1(o)
{}
CD3DX12_RESOURCE_DESC1(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,
UINT samplerFeedbackMipRegionWidth = 0,
UINT samplerFeedbackMipRegionHeight = 0,
UINT samplerFeedbackMipRegionDepth = 0)
noexcept
{
Dimension = dimension;
Alignment = alignment;
Width = width;
Height = height;
DepthOrArraySize = depthOrArraySize;
MipLevels = mipLevels;
Format = format;
SampleDesc.Count = sampleCount;
SampleDesc.Quality = sampleQuality;
Layout = layout;
Flags = flags;
SamplerFeedbackMipRegion.Width = samplerFeedbackMipRegionWidth;
SamplerFeedbackMipRegion.Height = samplerFeedbackMipRegionHeight;
SamplerFeedbackMipRegion.Depth = samplerFeedbackMipRegionDepth;
}
inline static CD3DX12_RESOURCE_DESC1 Buffer(
const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE) noexcept
{
return CD3DX12_RESOURCE_DESC1(D3D12_RESOURCE_DIMENSION_BUFFER,
resAllocInfo.Alignment,
resAllocInfo.SizeInBytes,
1,
1,
1,
DXGI_FORMAT_UNKNOWN,
1,
0,
D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
flags,
0,
0,
0);
}
inline static CD3DX12_RESOURCE_DESC1 Buffer(UINT64 width,
D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
UINT64 alignment = 0) noexcept
{
return CD3DX12_RESOURCE_DESC1(D3D12_RESOURCE_DIMENSION_BUFFER,
alignment,
width,
1,
1,
1,
DXGI_FORMAT_UNKNOWN,
1,
0,
D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
flags,
0,
0,
0);
}
inline static CD3DX12_RESOURCE_DESC1 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) noexcept
{
return CD3DX12_RESOURCE_DESC1(D3D12_RESOURCE_DIMENSION_TEXTURE1D,
alignment,
width,
1,
arraySize,
mipLevels,
format,
1,
0,
layout,
flags,
0,
0,
0);
}
inline static CD3DX12_RESOURCE_DESC1 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,
UINT samplerFeedbackMipRegionWidth = 0,
UINT samplerFeedbackMipRegionHeight = 0,
UINT samplerFeedbackMipRegionDepth = 0) noexcept
{
return CD3DX12_RESOURCE_DESC1(D3D12_RESOURCE_DIMENSION_TEXTURE2D,
alignment,
width,
height,
arraySize,
mipLevels,
format,
sampleCount,
sampleQuality,
layout,
flags,
samplerFeedbackMipRegionWidth,
samplerFeedbackMipRegionHeight,
samplerFeedbackMipRegionDepth);
}
inline static CD3DX12_RESOURCE_DESC1 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) noexcept
{
return CD3DX12_RESOURCE_DESC1(D3D12_RESOURCE_DIMENSION_TEXTURE3D,
alignment,
width,
height,
depth,
mipLevels,
format,
1,
0,
layout,
flags,
0,
0,
0);
}
inline UINT16 Depth() const noexcept
{
return (Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D
? DepthOrArraySize
: 1);
}
inline UINT16 ArraySize() const noexcept
{
return (Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE3D
? DepthOrArraySize
: 1);
}
inline UINT8 PlaneCount(_In_ ID3D12Device* pDevice) const noexcept
{
return D3D12GetFormatPlaneCount(pDevice, Format);
}
inline UINT Subresources(_In_ ID3D12Device* pDevice) const noexcept
{
return MipLevels * ArraySize() * PlaneCount(pDevice);
}
inline UINT CalcSubresource(
UINT MipSlice, UINT ArraySlice, UINT PlaneSlice) noexcept
{
return D3D12CalcSubresource(
MipSlice, ArraySlice, PlaneSlice, MipLevels, ArraySize());
}
};
inline bool operator==(
const D3D12_RESOURCE_DESC1& l, const D3D12_RESOURCE_DESC1& r) noexcept
{
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
&& l.SamplerFeedbackMipRegion.Width == r.SamplerFeedbackMipRegion.Width
&& l.SamplerFeedbackMipRegion.Height
== r.SamplerFeedbackMipRegion.Height
&& l.SamplerFeedbackMipRegion.Depth == r.SamplerFeedbackMipRegion.Depth;
}
inline bool operator!=(
const D3D12_RESOURCE_DESC1& l, const D3D12_RESOURCE_DESC1& r) noexcept
{
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) noexcept
: D3D12_VIEW_INSTANCING_DESC(o)
{}
explicit CD3DX12_VIEW_INSTANCING_DESC(CD3DX12_DEFAULT) noexcept
{
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) noexcept
{
ViewInstanceCount = InViewInstanceCount;
pViewInstanceLocations = InViewInstanceLocations;
Flags = InFlags;
}
};
//------------------------------------------------------------------------------------------------
// Row-by-row memcpy
inline void MemcpySubresource(const _In_ D3D12_MEMCPY_DEST* pDest,
const _In_ D3D12_SUBRESOURCE_DATA* pSrc,
SIZE_T RowSizeInBytes,
UINT NumRows,
UINT NumSlices) noexcept
{
for (UINT z = 0; z < NumSlices; ++z)
{
auto pDestSlice
= static_cast<BYTE*>(pDest->pData) + pDest->SlicePitch * z;
auto pSrcSlice = static_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);
}
}
}
//------------------------------------------------------------------------------------------------
// Row-by-row memcpy
inline void MemcpySubresource(const _In_ D3D12_MEMCPY_DEST* pDest,
_In_ const void* pResourceData,
const _In_ D3D12_SUBRESOURCE_INFO* pSrc,
SIZE_T RowSizeInBytes,
UINT NumRows,
UINT NumSlices) noexcept
{
for (UINT z = 0; z < NumSlices; ++z)
{
auto pDestSlice
= static_cast<BYTE*>(pDest->pData) + pDest->SlicePitch * z;
auto pSrcSlice
= (static_cast<const BYTE*>(pResourceData) + pSrc->Offset)
+ pSrc->DepthPitch * ULONG_PTR(z);
for (UINT y = 0; y < NumRows; ++y)
{
memcpy(pDestSlice + pDest->RowPitch * y,
pSrcSlice + pSrc->RowPitch * ULONG_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) noexcept
{
auto Desc = pDestinationResource->GetDesc();
UINT64 RequiredSize = 0;
ID3D12Device* pDevice = nullptr;
pDestinationResource->GetDevice(
__uuidof(*pDevice), 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) noexcept
{
// 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;
}
//------------------------------------------------------------------------------------------------
// 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_ const void* pResourceData,
_In_reads_(NumSubresources) const D3D12_SUBRESOURCE_INFO* pSrcData) noexcept
{
// 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,
pResourceData,
&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) const D3D12_SUBRESOURCE_DATA* pSrcData) noexcept
{
UINT64 RequiredSize = 0;
auto 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 = static_cast<D3D12_PLACED_SUBRESOURCE_FOOTPRINT*>(pMem);
auto pRowSizesInBytes
= reinterpret_cast<UINT64*>(pLayouts + NumSubresources);
auto pNumRows = reinterpret_cast<UINT*>(pRowSizesInBytes + NumSubresources);
auto Desc = pDestinationResource->GetDesc();
ID3D12Device* pDevice = nullptr;
pDestinationResource->GetDevice(
__uuidof(*pDevice), 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;
}
//------------------------------------------------------------------------------------------------
// 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_ const void* pResourceData,
_In_reads_(NumSubresources) D3D12_SUBRESOURCE_INFO* pSrcData) noexcept
{
UINT64 RequiredSize = 0;
auto 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);
auto pRowSizesInBytes
= reinterpret_cast<UINT64*>(pLayouts + NumSubresources);
auto pNumRows = reinterpret_cast<UINT*>(pRowSizesInBytes + NumSubresources);
auto Desc = pDestinationResource->GetDesc();
ID3D12Device* pDevice = nullptr;
pDestinationResource->GetDevice(
__uuidof(*pDevice), 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,
pResourceData,
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) const D3D12_SUBRESOURCE_DATA* pSrcData) noexcept
{
UINT64 RequiredSize = 0;
D3D12_PLACED_SUBRESOURCE_FOOTPRINT Layouts[MaxSubresources];
UINT NumRows[MaxSubresources];
UINT64 RowSizesInBytes[MaxSubresources];
auto Desc = pDestinationResource->GetDesc();
ID3D12Device* pDevice = nullptr;
pDestinationResource->GetDevice(
__uuidof(*pDevice), 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);
}
//------------------------------------------------------------------------------------------------
// 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_ const void* pResourceData,
_In_reads_(NumSubresources) D3D12_SUBRESOURCE_INFO* pSrcData) noexcept
{
UINT64 RequiredSize = 0;
D3D12_PLACED_SUBRESOURCE_FOOTPRINT Layouts[MaxSubresources];
UINT NumRows[MaxSubresources];
UINT64 RowSizesInBytes[MaxSubresources];
auto Desc = pDestinationResource->GetDesc();
ID3D12Device* pDevice = nullptr;
pDestinationResource->GetDevice(
__uuidof(*pDevice), 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,
pResourceData,
pSrcData);
}
//------------------------------------------------------------------------------------------------
inline constexpr bool D3D12IsLayoutOpaque(D3D12_TEXTURE_LAYOUT Layout) noexcept
{
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) noexcept
{
// 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(
const _In_ D3D12_VERSIONED_ROOT_SIGNATURE_DESC* pRootSignatureDesc,
D3D_ROOT_SIGNATURE_VERSION MaxVersion,
_Outptr_ ID3DBlob** ppBlob,
_Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorBlob,
PFN_D3D12_SERIALIZE_VERSIONED_ROOT_SIGNATURE
D3D12SerializeVersionedRootSignature,
PFN_D3D12_SERIALIZE_ROOT_SIGNATURE D3D12SerializeRootSignature) noexcept
{
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
= static_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
= static_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) noexcept
: D3D12_RT_FORMAT_ARRAY(o)
{}
explicit CD3DX12_RT_FORMAT_ARRAY(_In_reads_(NumFormats)
const DXGI_FORMAT* pFormats,
UINT NumFormats) noexcept
{
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() noexcept
{
return UINT_MAX;
}
};
struct DefaultSampleDesc
{
operator DXGI_SAMPLE_DESC() noexcept
{
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(const InnerStructType& i)
noexcept
: _Type(Type),
_Inner(i)
{}
CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT& operator=(
const InnerStructType& i) noexcept
{
_Type = Type;
_Inner = i;
return *this;
}
operator const InnerStructType&() const noexcept
{
return _Inner;
}
operator InnerStructType&() noexcept
{
return _Inner;
}
InnerStructType* operator&() noexcept
{
return &_Inner;
}
const InnerStructType* operator&() const noexcept
{
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_AS>
CD3DX12_PIPELINE_STATE_STREAM_AS;
typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT<D3D12_SHADER_BYTECODE,
D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MS>
CD3DX12_PIPELINE_STATE_STREAM_MS;
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 ASCb(const D3D12_SHADER_BYTECODE&) {}
virtual void MSCb(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;
};
struct D3DX12_MESH_SHADER_PIPELINE_STATE_DESC
{
ID3D12RootSignature* pRootSignature;
D3D12_SHADER_BYTECODE AS;
D3D12_SHADER_BYTECODE MS;
D3D12_SHADER_BYTECODE PS;
D3D12_BLEND_DESC BlendState;
UINT SampleMask;
D3D12_RASTERIZER_DESC RasterizerState;
D3D12_DEPTH_STENCIL_DESC DepthStencilState;
D3D12_PRIMITIVE_TOPOLOGY_TYPE PrimitiveTopologyType;
UINT NumRenderTargets;
DXGI_FORMAT RTVFormats[D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT];
DXGI_FORMAT DSVFormat;
DXGI_SAMPLE_DESC SampleDesc;
UINT NodeMask;
D3D12_CACHED_PIPELINE_STATE CachedPSO;
D3D12_PIPELINE_STATE_FLAGS Flags;
};
// CD3DX12_PIPELINE_STATE_STREAM2 Works on OS Build 19041+ (where there is a new
// mesh shader pipeline). Use CD3DX12_PIPELINE_STATE_STREAM1 for OS Build 16299+
// (where there is a new view instancing subobject). Use
// CD3DX12_PIPELINE_STATE_STREAM for OS Build 15063+ support.
struct CD3DX12_PIPELINE_STATE_STREAM2
{
CD3DX12_PIPELINE_STATE_STREAM2() = default;
// Mesh and amplification shaders must be set manually, since they do not
// have representation in D3D12_GRAPHICS_PIPELINE_STATE_DESC
CD3DX12_PIPELINE_STATE_STREAM2(
const D3D12_GRAPHICS_PIPELINE_STATE_DESC& Desc)
noexcept
: 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_STREAM2(
const D3DX12_MESH_SHADER_PIPELINE_STATE_DESC& Desc)
noexcept
: Flags(Desc.Flags),
NodeMask(Desc.NodeMask),
pRootSignature(Desc.pRootSignature),
PrimitiveTopologyType(Desc.PrimitiveTopologyType),
PS(Desc.PS),
AS(Desc.AS),
MS(Desc.MS),
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_STREAM2(
const D3D12_COMPUTE_PIPELINE_STATE_DESC& Desc)
noexcept
: 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_AS AS;
CD3DX12_PIPELINE_STATE_STREAM_MS MS;
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 noexcept
{
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 noexcept
{
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_STREAM1 Works on OS Build 16299+ (where there is a new
// view instancing subobject). Use CD3DX12_PIPELINE_STATE_STREAM for OS Build
// 15063+ support.
struct CD3DX12_PIPELINE_STATE_STREAM1
{
CD3DX12_PIPELINE_STATE_STREAM1() = default;
// Mesh and amplification shaders must be set manually, since they do not
// have representation in D3D12_GRAPHICS_PIPELINE_STATE_DESC
CD3DX12_PIPELINE_STATE_STREAM1(
const D3D12_GRAPHICS_PIPELINE_STATE_DESC& Desc)
noexcept
: 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 D3DX12_MESH_SHADER_PIPELINE_STATE_DESC& Desc)
noexcept
: Flags(Desc.Flags),
NodeMask(Desc.NodeMask),
pRootSignature(Desc.pRootSignature),
PrimitiveTopologyType(Desc.PrimitiveTopologyType),
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)
noexcept
: 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 noexcept
{
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 noexcept
{
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_MESH_STATE_STREAM
{
CD3DX12_PIPELINE_MESH_STATE_STREAM() = default;
CD3DX12_PIPELINE_MESH_STATE_STREAM(
const D3DX12_MESH_SHADER_PIPELINE_STATE_DESC& Desc)
noexcept
: Flags(Desc.Flags),
NodeMask(Desc.NodeMask),
pRootSignature(Desc.pRootSignature),
PS(Desc.PS),
AS(Desc.AS),
MS(Desc.MS),
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_STREAM_FLAGS Flags;
CD3DX12_PIPELINE_STATE_STREAM_NODE_MASK NodeMask;
CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE pRootSignature;
CD3DX12_PIPELINE_STATE_STREAM_PS PS;
CD3DX12_PIPELINE_STATE_STREAM_AS AS;
CD3DX12_PIPELINE_STATE_STREAM_MS MS;
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;
D3DX12_MESH_SHADER_PIPELINE_STATE_DESC MeshShaderDescV0() const noexcept
{
D3DX12_MESH_SHADER_PIPELINE_STATE_DESC D;
D.Flags = this->Flags;
D.NodeMask = this->NodeMask;
D.pRootSignature = this->pRootSignature;
D.PS = this->PS;
D.AS = this->AS;
D.MS = this->MS;
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;
}
};
// CD3DX12_PIPELINE_STATE_STREAM works on OS Build 15063+ but does not support
// new subobject(s) added in OS Build 16299+. 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)
noexcept
: 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)
noexcept
: 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 noexcept
{
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 noexcept
{
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_STREAM2_PARSE_HELPER
: public ID3DX12PipelineParserCallbacks
{
CD3DX12_PIPELINE_STATE_STREAM2 PipelineStream;
CD3DX12_PIPELINE_STATE_STREAM2_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 ASCb(const D3D12_SHADER_BYTECODE& AS) override
{
PipelineStream.AS = AS;
}
void MSCb(const D3D12_SHADER_BYTECODE& MS) override
{
PipelineStream.MS = MS;
}
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;
};
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) noexcept
{
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_AS:
pCallbacks->ASCb(
*reinterpret_cast<
decltype(CD3DX12_PIPELINE_STATE_STREAM2::AS)*>(pStream));
SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM2::AS);
break;
case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MS:
pCallbacks->MSCb(
*reinterpret_cast<
decltype(CD3DX12_PIPELINE_STATE_STREAM2::MS)*>(pStream));
SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM2::MS);
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;
}
}
return S_OK;
}
//------------------------------------------------------------------------------------------------
inline bool operator==(
const D3D12_CLEAR_VALUE& a, const D3D12_CLEAR_VALUE& b) noexcept
{
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) noexcept
{
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) noexcept
{
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) noexcept
{
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) noexcept
{
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) noexcept
{
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) noexcept
{
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>
# ifndef D3DX12_USE_ATL
# include <wrl/client.h>
# define D3DX12_COM_PTR Microsoft::WRL::ComPtr
# define D3DX12_COM_PTR_GET(x) x.Get()
# define D3DX12_COM_PTR_ADDRESSOF(x) x.GetAddressOf()
# else
# include <atlbase.h>
# define D3DX12_COM_PTR ATL::CComPtr
# define D3DX12_COM_PTR_GET(x) x.p
# define D3DX12_COM_PTR_ADDRESSOF(x) &x.p
# endif
//------------------------------------------------------------------------------------------------
class CD3DX12_STATE_OBJECT_DESC
{
public:
CD3DX12_STATE_OBJECT_DESC() noexcept
{
Init(D3D12_STATE_OBJECT_TYPE_COLLECTION);
}
CD3DX12_STATE_OBJECT_DESC(D3D12_STATE_OBJECT_TYPE Type) noexcept
{
Init(Type);
}
void SetStateObjectType(D3D12_STATE_OBJECT_TYPE Type) noexcept
{
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 = static_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) noexcept
{
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() noexcept
{
m_Strings.clear();
}
private:
std::list<std::wstring> m_Strings;
};
class SUBOBJECT_HELPER_BASE
{
public:
SUBOBJECT_HELPER_BASE() noexcept
{
Init();
}
virtual ~SUBOBJECT_HELPER_BASE() = default;
virtual D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept = 0;
void AddToStateObject(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
{
m_pSubobject = ContainingStateObject.TrackSubobject(Type(), Data());
}
protected:
virtual void* Data() noexcept = 0;
void Init() noexcept
{
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) noexcept
{
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_RAYTRACING_PIPELINE_CONFIG1_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() noexcept
{
Init();
}
CD3DX12_DXIL_LIBRARY_SUBOBJECT(
CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
{
Init();
AddToStateObject(ContainingStateObject);
}
void SetDXILLibrary(const D3D12_SHADER_BYTECODE* pCode) noexcept
{
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(const LPCWSTR* Exports, UINT N)
{
for (UINT i = 0; i < N; i++)
{
DefineExport(Exports[i]);
}
}
D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
{
return D3D12_STATE_SUBOBJECT_TYPE_DXIL_LIBRARY;
}
operator const D3D12_STATE_SUBOBJECT&() const noexcept
{
return *m_pSubobject;
}
operator const D3D12_DXIL_LIBRARY_DESC&() const noexcept
{
return m_Desc;
}
private:
void Init() noexcept
{
SUBOBJECT_HELPER_BASE::Init();
m_Desc = {};
m_Strings.clear();
m_Exports.clear();
}
void* Data() noexcept override
{
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() noexcept
{
Init();
}
CD3DX12_EXISTING_COLLECTION_SUBOBJECT(
CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
{
Init();
AddToStateObject(ContainingStateObject);
}
void SetExistingCollection(ID3D12StateObject* pExistingCollection) noexcept
{
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(const LPCWSTR* Exports, UINT N)
{
for (UINT i = 0; i < N; i++)
{
DefineExport(Exports[i]);
}
}
D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
{
return D3D12_STATE_SUBOBJECT_TYPE_EXISTING_COLLECTION;
}
operator const D3D12_STATE_SUBOBJECT&() const noexcept
{
return *m_pSubobject;
}
operator const D3D12_EXISTING_COLLECTION_DESC&() const noexcept
{
return m_Desc;
}
private:
void Init() noexcept
{
SUBOBJECT_HELPER_BASE::Init();
m_Desc = {};
m_CollectionRef = nullptr;
m_Strings.clear();
m_Exports.clear();
}
void* Data() noexcept override
{
return &m_Desc;
}
D3D12_EXISTING_COLLECTION_DESC m_Desc;
D3DX12_COM_PTR<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() noexcept
{
Init();
}
CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT(
CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
{
Init();
AddToStateObject(ContainingStateObject);
}
void SetSubobjectToAssociate(
const D3D12_STATE_SUBOBJECT& SubobjectToAssociate) noexcept
{
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(const LPCWSTR* Exports, UINT N)
{
for (UINT i = 0; i < N; i++)
{
AddExport(Exports[i]);
}
}
D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
{
return D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
}
operator const D3D12_STATE_SUBOBJECT&() const noexcept
{
return *m_pSubobject;
}
operator const D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION&() const noexcept
{
return m_Desc;
}
private:
void Init() noexcept
{
SUBOBJECT_HELPER_BASE::Init();
m_Desc = {};
m_Strings.clear();
m_Exports.clear();
}
void* Data() noexcept override
{
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() noexcept
{
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(const LPCWSTR* Exports, UINT N)
{
for (UINT i = 0; i < N; i++)
{
AddExport(Exports[i]);
}
}
D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
{
return D3D12_STATE_SUBOBJECT_TYPE_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
}
operator const D3D12_STATE_SUBOBJECT&() const noexcept
{
return *m_pSubobject;
}
operator const D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION&() const noexcept
{
return m_Desc;
}
private:
void Init() noexcept
{
SUBOBJECT_HELPER_BASE::Init();
m_Desc = {};
m_Strings.clear();
m_SubobjectName.clear();
m_Exports.clear();
}
void* Data() noexcept override
{
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() noexcept
{
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) noexcept
{
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 noexcept override
{
return D3D12_STATE_SUBOBJECT_TYPE_HIT_GROUP;
}
operator const D3D12_STATE_SUBOBJECT&() const noexcept
{
return *m_pSubobject;
}
operator const D3D12_HIT_GROUP_DESC&() const noexcept
{
return m_Desc;
}
private:
void Init() noexcept
{
SUBOBJECT_HELPER_BASE::Init();
m_Desc = {};
for (UINT i = 0; i < m_NumStrings; i++)
{
m_Strings[i].clear();
}
}
void* Data() noexcept override
{
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() noexcept
{
Init();
}
CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT(
CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
{
Init();
AddToStateObject(ContainingStateObject);
}
void Config(
UINT MaxPayloadSizeInBytes, UINT MaxAttributeSizeInBytes) noexcept
{
m_Desc.MaxPayloadSizeInBytes = MaxPayloadSizeInBytes;
m_Desc.MaxAttributeSizeInBytes = MaxAttributeSizeInBytes;
}
D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
{
return D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_SHADER_CONFIG;
}
operator const D3D12_STATE_SUBOBJECT&() const noexcept
{
return *m_pSubobject;
}
operator const D3D12_RAYTRACING_SHADER_CONFIG&() const noexcept
{
return m_Desc;
}
private:
void Init() noexcept
{
SUBOBJECT_HELPER_BASE::Init();
m_Desc = {};
}
void* Data() noexcept override
{
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() noexcept
{
Init();
}
CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT(
CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
{
Init();
AddToStateObject(ContainingStateObject);
}
void Config(UINT MaxTraceRecursionDepth) noexcept
{
m_Desc.MaxTraceRecursionDepth = MaxTraceRecursionDepth;
}
D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
{
return D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG;
}
operator const D3D12_STATE_SUBOBJECT&() const noexcept
{
return *m_pSubobject;
}
operator const D3D12_RAYTRACING_PIPELINE_CONFIG&() const noexcept
{
return m_Desc;
}
private:
void Init() noexcept
{
SUBOBJECT_HELPER_BASE::Init();
m_Desc = {};
}
void* Data() noexcept override
{
return &m_Desc;
}
D3D12_RAYTRACING_PIPELINE_CONFIG m_Desc;
};
//------------------------------------------------------------------------------------------------
class CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT
: public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
{
public:
CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT() noexcept
{
Init();
}
CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT(
CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
{
Init();
AddToStateObject(ContainingStateObject);
}
void Config(UINT MaxTraceRecursionDepth,
D3D12_RAYTRACING_PIPELINE_FLAGS Flags) noexcept
{
m_Desc.MaxTraceRecursionDepth = MaxTraceRecursionDepth;
m_Desc.Flags = Flags;
}
D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
{
return D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG1;
}
operator const D3D12_STATE_SUBOBJECT&() const noexcept
{
return *m_pSubobject;
}
operator const D3D12_RAYTRACING_PIPELINE_CONFIG1&() const noexcept
{
return m_Desc;
}
private:
void Init() noexcept
{
SUBOBJECT_HELPER_BASE::Init();
m_Desc = {};
}
void* Data() noexcept override
{
return &m_Desc;
}
D3D12_RAYTRACING_PIPELINE_CONFIG1 m_Desc;
};
//------------------------------------------------------------------------------------------------
class CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT
: public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
{
public:
CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT() noexcept
{
Init();
}
CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT(
CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
{
Init();
AddToStateObject(ContainingStateObject);
}
void SetRootSignature(ID3D12RootSignature* pRootSig) noexcept
{
m_pRootSig = pRootSig;
}
D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
{
return D3D12_STATE_SUBOBJECT_TYPE_GLOBAL_ROOT_SIGNATURE;
}
operator const D3D12_STATE_SUBOBJECT&() const noexcept
{
return *m_pSubobject;
}
operator ID3D12RootSignature*() const noexcept
{
return D3DX12_COM_PTR_GET(m_pRootSig);
}
private:
void Init() noexcept
{
SUBOBJECT_HELPER_BASE::Init();
m_pRootSig = nullptr;
}
void* Data() noexcept override
{
return D3DX12_COM_PTR_ADDRESSOF(m_pRootSig);
}
D3DX12_COM_PTR<ID3D12RootSignature> m_pRootSig;
};
//------------------------------------------------------------------------------------------------
class CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT
: public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
{
public:
CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT() noexcept
{
Init();
}
CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT(
CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
{
Init();
AddToStateObject(ContainingStateObject);
}
void SetRootSignature(ID3D12RootSignature* pRootSig) noexcept
{
m_pRootSig = pRootSig;
}
D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
{
return D3D12_STATE_SUBOBJECT_TYPE_LOCAL_ROOT_SIGNATURE;
}
operator const D3D12_STATE_SUBOBJECT&() const noexcept
{
return *m_pSubobject;
}
operator ID3D12RootSignature*() const noexcept
{
return D3DX12_COM_PTR_GET(m_pRootSig);
}
private:
void Init() noexcept
{
SUBOBJECT_HELPER_BASE::Init();
m_pRootSig = nullptr;
}
void* Data() noexcept override
{
return D3DX12_COM_PTR_ADDRESSOF(m_pRootSig);
}
D3DX12_COM_PTR<ID3D12RootSignature> m_pRootSig;
};
//------------------------------------------------------------------------------------------------
class CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT
: public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE
{
public:
CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT() noexcept
{
Init();
}
CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT(
CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
{
Init();
AddToStateObject(ContainingStateObject);
}
void SetFlags(D3D12_STATE_OBJECT_FLAGS Flags) noexcept
{
m_Desc.Flags = Flags;
}
D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
{
return D3D12_STATE_SUBOBJECT_TYPE_STATE_OBJECT_CONFIG;
}
operator const D3D12_STATE_SUBOBJECT&() const noexcept
{
return *m_pSubobject;
}
operator const D3D12_STATE_OBJECT_CONFIG&() const noexcept
{
return m_Desc;
}
private:
void Init() noexcept
{
SUBOBJECT_HELPER_BASE::Init();
m_Desc = {};
}
void* Data() noexcept override
{
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() noexcept
{
Init();
}
CD3DX12_NODE_MASK_SUBOBJECT(
CD3DX12_STATE_OBJECT_DESC& ContainingStateObject)
{
Init();
AddToStateObject(ContainingStateObject);
}
void SetNodeMask(UINT NodeMask) noexcept
{
m_Desc.NodeMask = NodeMask;
}
D3D12_STATE_SUBOBJECT_TYPE Type() const noexcept override
{
return D3D12_STATE_SUBOBJECT_TYPE_NODE_MASK;
}
operator const D3D12_STATE_SUBOBJECT&() const noexcept
{
return *m_pSubobject;
}
operator const D3D12_NODE_MASK&() const noexcept
{
return m_Desc;
}
private:
void Init() noexcept
{
SUBOBJECT_HELPER_BASE::Init();
m_Desc = {};
}
void* Data() noexcept override
{
return &m_Desc;
}
D3D12_NODE_MASK m_Desc;
};
# undef D3DX12_COM_PTR
# undef D3DX12_COM_PTR_GET
# undef D3DX12_COM_PTR_ADDRESSOF
# endif // #ifndef D3DX12_NO_STATE_OBJECT_HELPERS
#endif // defined( __cplusplus )
#endif //__D3DX12_H__