|
|
@@ -0,0 +1,1532 @@
|
|
|
+//////////////////////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// Copyright (C) Microsoft Corporation. All Rights Reserved.
|
|
|
+//
|
|
|
+// File: d3dx12.h
|
|
|
+// Content: D3DX12 utility library
|
|
|
+//
|
|
|
+//////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+#ifndef __D3DX12_H__
|
|
|
+#define __D3DX12_H__
|
|
|
+
|
|
|
+#include "d3d12.h"
|
|
|
+
|
|
|
+#if defined( __cplusplus )
|
|
|
+
|
|
|
+struct CD3DX12_DEFAULT {};
|
|
|
+extern const DECLSPEC_SELECTANY CD3DX12_DEFAULT D3D12_DEFAULT;
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+inline bool operator==(const D3D12_VIEWPORT& l, const D3D12_VIEWPORT& r)
|
|
|
+{
|
|
|
+ return l.TopLeftX == r.TopLeftX && l.TopLeftY == r.TopLeftY && l.Width == r.Width &&
|
|
|
+ l.Height == r.Height && l.MinDepth == r.MinDepth && l.MaxDepth == r.MaxDepth;
|
|
|
+}
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+inline bool operator!=(const D3D12_VIEWPORT& l, const D3D12_VIEWPORT& r)
|
|
|
+{
|
|
|
+ return !(l == r);
|
|
|
+}
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_RECT : public D3D12_RECT
|
|
|
+{
|
|
|
+ CD3DX12_RECT()
|
|
|
+ {}
|
|
|
+ explicit CD3DX12_RECT(const D3D12_RECT& o) :
|
|
|
+ D3D12_RECT(o)
|
|
|
+ {}
|
|
|
+ explicit CD3DX12_RECT(
|
|
|
+ LONG Left,
|
|
|
+ LONG Top,
|
|
|
+ LONG Right,
|
|
|
+ LONG Bottom)
|
|
|
+ {
|
|
|
+ left = Left;
|
|
|
+ top = Top;
|
|
|
+ right = Right;
|
|
|
+ bottom = Bottom;
|
|
|
+ }
|
|
|
+ ~CD3DX12_RECT() {}
|
|
|
+ operator const D3D12_RECT& () const { return *this; }
|
|
|
+};
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_BOX : public D3D12_BOX
|
|
|
+{
|
|
|
+ CD3DX12_BOX()
|
|
|
+ {}
|
|
|
+ explicit CD3DX12_BOX(const D3D12_BOX& o) :
|
|
|
+ D3D12_BOX(o)
|
|
|
+ {}
|
|
|
+ explicit CD3DX12_BOX(
|
|
|
+ LONG Left,
|
|
|
+ LONG Right)
|
|
|
+ {
|
|
|
+ left = Left;
|
|
|
+ top = 0;
|
|
|
+ front = 0;
|
|
|
+ right = Right;
|
|
|
+ bottom = 1;
|
|
|
+ back = 1;
|
|
|
+ }
|
|
|
+ explicit CD3DX12_BOX(
|
|
|
+ LONG Left,
|
|
|
+ LONG Top,
|
|
|
+ LONG Right,
|
|
|
+ LONG Bottom)
|
|
|
+ {
|
|
|
+ left = Left;
|
|
|
+ top = Top;
|
|
|
+ front = 0;
|
|
|
+ right = Right;
|
|
|
+ bottom = Bottom;
|
|
|
+ back = 1;
|
|
|
+ }
|
|
|
+ explicit CD3DX12_BOX(
|
|
|
+ LONG Left,
|
|
|
+ LONG Top,
|
|
|
+ LONG Front,
|
|
|
+ LONG Right,
|
|
|
+ LONG Bottom,
|
|
|
+ LONG Back)
|
|
|
+ {
|
|
|
+ left = Left;
|
|
|
+ top = Top;
|
|
|
+ front = Front;
|
|
|
+ right = Right;
|
|
|
+ bottom = Bottom;
|
|
|
+ back = Back;
|
|
|
+ }
|
|
|
+ ~CD3DX12_BOX() {}
|
|
|
+ operator const D3D12_BOX& () const { return *this; }
|
|
|
+};
|
|
|
+inline bool operator==(const D3D12_BOX& l, const D3D12_BOX& r)
|
|
|
+{
|
|
|
+ return l.left == r.left && l.top == r.top && l.front == r.front &&
|
|
|
+ l.right == r.right && l.bottom == r.bottom && l.back == r.back;
|
|
|
+}
|
|
|
+inline bool operator!=(const D3D12_BOX& l, const D3D12_BOX& r)
|
|
|
+{
|
|
|
+ return !(l == r);
|
|
|
+}
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_DEPTH_STENCIL_DESC : public D3D12_DEPTH_STENCIL_DESC
|
|
|
+{
|
|
|
+ CD3DX12_DEPTH_STENCIL_DESC()
|
|
|
+ {}
|
|
|
+ explicit CD3DX12_DEPTH_STENCIL_DESC(const D3D12_DEPTH_STENCIL_DESC& o) :
|
|
|
+ D3D12_DEPTH_STENCIL_DESC(o)
|
|
|
+ {}
|
|
|
+ explicit CD3DX12_DEPTH_STENCIL_DESC(CD3DX12_DEFAULT)
|
|
|
+ {
|
|
|
+ DepthEnable = TRUE;
|
|
|
+ DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL;
|
|
|
+ DepthFunc = D3D12_COMPARISON_FUNC_LESS;
|
|
|
+ StencilEnable = FALSE;
|
|
|
+ StencilReadMask = D3D12_DEFAULT_STENCIL_READ_MASK;
|
|
|
+ StencilWriteMask = D3D12_DEFAULT_STENCIL_WRITE_MASK;
|
|
|
+ const D3D12_DEPTH_STENCILOP_DESC defaultStencilOp =
|
|
|
+ { D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_COMPARISON_FUNC_ALWAYS };
|
|
|
+ FrontFace = defaultStencilOp;
|
|
|
+ BackFace = defaultStencilOp;
|
|
|
+ }
|
|
|
+ explicit CD3DX12_DEPTH_STENCIL_DESC(
|
|
|
+ BOOL depthEnable,
|
|
|
+ D3D12_DEPTH_WRITE_MASK depthWriteMask,
|
|
|
+ D3D12_COMPARISON_FUNC depthFunc,
|
|
|
+ BOOL stencilEnable,
|
|
|
+ UINT8 stencilReadMask,
|
|
|
+ UINT8 stencilWriteMask,
|
|
|
+ D3D12_STENCIL_OP frontStencilFailOp,
|
|
|
+ D3D12_STENCIL_OP frontStencilDepthFailOp,
|
|
|
+ D3D12_STENCIL_OP frontStencilPassOp,
|
|
|
+ D3D12_COMPARISON_FUNC frontStencilFunc,
|
|
|
+ D3D12_STENCIL_OP backStencilFailOp,
|
|
|
+ D3D12_STENCIL_OP backStencilDepthFailOp,
|
|
|
+ D3D12_STENCIL_OP backStencilPassOp,
|
|
|
+ D3D12_COMPARISON_FUNC backStencilFunc)
|
|
|
+ {
|
|
|
+ DepthEnable = depthEnable;
|
|
|
+ DepthWriteMask = depthWriteMask;
|
|
|
+ DepthFunc = depthFunc;
|
|
|
+ StencilEnable = stencilEnable;
|
|
|
+ StencilReadMask = stencilReadMask;
|
|
|
+ StencilWriteMask = stencilWriteMask;
|
|
|
+ FrontFace.StencilFailOp = frontStencilFailOp;
|
|
|
+ FrontFace.StencilDepthFailOp = frontStencilDepthFailOp;
|
|
|
+ FrontFace.StencilPassOp = frontStencilPassOp;
|
|
|
+ FrontFace.StencilFunc = frontStencilFunc;
|
|
|
+ BackFace.StencilFailOp = backStencilFailOp;
|
|
|
+ BackFace.StencilDepthFailOp = backStencilDepthFailOp;
|
|
|
+ BackFace.StencilPassOp = backStencilPassOp;
|
|
|
+ BackFace.StencilFunc = backStencilFunc;
|
|
|
+ }
|
|
|
+ ~CD3DX12_DEPTH_STENCIL_DESC() {}
|
|
|
+ operator const D3D12_DEPTH_STENCIL_DESC& () const { return *this; }
|
|
|
+};
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_BLEND_DESC : public D3D12_BLEND_DESC
|
|
|
+{
|
|
|
+ CD3DX12_BLEND_DESC()
|
|
|
+ {}
|
|
|
+ explicit CD3DX12_BLEND_DESC(const D3D12_BLEND_DESC& o) :
|
|
|
+ D3D12_BLEND_DESC(o)
|
|
|
+ {}
|
|
|
+ explicit CD3DX12_BLEND_DESC(CD3DX12_DEFAULT)
|
|
|
+ {
|
|
|
+ AlphaToCoverageEnable = FALSE;
|
|
|
+ IndependentBlendEnable = FALSE;
|
|
|
+ const D3D12_RENDER_TARGET_BLEND_DESC defaultRenderTargetBlendDesc =
|
|
|
+ {
|
|
|
+ FALSE,FALSE,
|
|
|
+ D3D12_BLEND_ONE, D3D12_BLEND_ZERO, D3D12_BLEND_OP_ADD,
|
|
|
+ D3D12_BLEND_ONE, D3D12_BLEND_ZERO, D3D12_BLEND_OP_ADD,
|
|
|
+ D3D12_LOGIC_OP_NOOP,
|
|
|
+ D3D12_COLOR_WRITE_ENABLE_ALL,
|
|
|
+ };
|
|
|
+ for (UINT i = 0; i < D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
|
|
|
+ RenderTarget[i] = defaultRenderTargetBlendDesc;
|
|
|
+ }
|
|
|
+ ~CD3DX12_BLEND_DESC() {}
|
|
|
+ operator const D3D12_BLEND_DESC& () const { return *this; }
|
|
|
+};
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_RASTERIZER_DESC : public D3D12_RASTERIZER_DESC
|
|
|
+{
|
|
|
+ CD3DX12_RASTERIZER_DESC()
|
|
|
+ {}
|
|
|
+ explicit CD3DX12_RASTERIZER_DESC(const D3D12_RASTERIZER_DESC& o) :
|
|
|
+ D3D12_RASTERIZER_DESC(o)
|
|
|
+ {}
|
|
|
+ explicit CD3DX12_RASTERIZER_DESC(CD3DX12_DEFAULT)
|
|
|
+ {
|
|
|
+ FillMode = D3D12_FILL_MODE_SOLID;
|
|
|
+ CullMode = D3D12_CULL_MODE_BACK;
|
|
|
+ FrontCounterClockwise = FALSE;
|
|
|
+ DepthBias = D3D12_DEFAULT_DEPTH_BIAS;
|
|
|
+ DepthBiasClamp = D3D12_DEFAULT_DEPTH_BIAS_CLAMP;
|
|
|
+ SlopeScaledDepthBias = D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS;
|
|
|
+ DepthClipEnable = TRUE;
|
|
|
+ MultisampleEnable = FALSE;
|
|
|
+ AntialiasedLineEnable = FALSE;
|
|
|
+ ForcedSampleCount = 0;
|
|
|
+ ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF;
|
|
|
+ }
|
|
|
+ explicit CD3DX12_RASTERIZER_DESC(
|
|
|
+ D3D12_FILL_MODE fillMode,
|
|
|
+ D3D12_CULL_MODE cullMode,
|
|
|
+ BOOL frontCounterClockwise,
|
|
|
+ INT depthBias,
|
|
|
+ FLOAT depthBiasClamp,
|
|
|
+ FLOAT slopeScaledDepthBias,
|
|
|
+ BOOL depthClipEnable,
|
|
|
+ BOOL multisampleEnable,
|
|
|
+ BOOL antialiasedLineEnable,
|
|
|
+ UINT forcedSampleCount,
|
|
|
+ D3D12_CONSERVATIVE_RASTERIZATION_MODE conservativeRaster)
|
|
|
+ {
|
|
|
+ FillMode = fillMode;
|
|
|
+ CullMode = cullMode;
|
|
|
+ FrontCounterClockwise = frontCounterClockwise;
|
|
|
+ DepthBias = depthBias;
|
|
|
+ DepthBiasClamp = depthBiasClamp;
|
|
|
+ SlopeScaledDepthBias = slopeScaledDepthBias;
|
|
|
+ DepthClipEnable = depthClipEnable;
|
|
|
+ MultisampleEnable = multisampleEnable;
|
|
|
+ AntialiasedLineEnable = antialiasedLineEnable;
|
|
|
+ ForcedSampleCount = forcedSampleCount;
|
|
|
+ ConservativeRaster = conservativeRaster;
|
|
|
+ }
|
|
|
+ ~CD3DX12_RASTERIZER_DESC() {}
|
|
|
+ operator const D3D12_RASTERIZER_DESC& () const { return *this; }
|
|
|
+};
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_RESOURCE_ALLOCATION_INFO : public D3D12_RESOURCE_ALLOCATION_INFO
|
|
|
+{
|
|
|
+ CD3DX12_RESOURCE_ALLOCATION_INFO()
|
|
|
+ {}
|
|
|
+ explicit CD3DX12_RESOURCE_ALLOCATION_INFO(const D3D12_RESOURCE_ALLOCATION_INFO& o) :
|
|
|
+ D3D12_RESOURCE_ALLOCATION_INFO(o)
|
|
|
+ {}
|
|
|
+ CD3DX12_RESOURCE_ALLOCATION_INFO(
|
|
|
+ UINT64 size,
|
|
|
+ UINT64 alignment)
|
|
|
+ {
|
|
|
+ SizeInBytes = size;
|
|
|
+ Alignment = alignment;
|
|
|
+ }
|
|
|
+ operator const D3D12_RESOURCE_ALLOCATION_INFO& () const { return *this; }
|
|
|
+};
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_HEAP_PROPERTIES : public D3D12_HEAP_PROPERTIES
|
|
|
+{
|
|
|
+ CD3DX12_HEAP_PROPERTIES()
|
|
|
+ {}
|
|
|
+ explicit CD3DX12_HEAP_PROPERTIES(const D3D12_HEAP_PROPERTIES& o) :
|
|
|
+ D3D12_HEAP_PROPERTIES(o)
|
|
|
+ {}
|
|
|
+ CD3DX12_HEAP_PROPERTIES(
|
|
|
+ D3D12_CPU_PAGE_PROPERTY cpuPageProperty,
|
|
|
+ D3D12_MEMORY_POOL memoryPoolPreference,
|
|
|
+ UINT creationNodeMask = 1,
|
|
|
+ UINT nodeMask = 1)
|
|
|
+ {
|
|
|
+ Type = D3D12_HEAP_TYPE_CUSTOM;
|
|
|
+ CPUPageProperty = cpuPageProperty;
|
|
|
+ MemoryPoolPreference = memoryPoolPreference;
|
|
|
+ CreationNodeMask = creationNodeMask;
|
|
|
+ VisibleNodeMask = nodeMask;
|
|
|
+ }
|
|
|
+ explicit CD3DX12_HEAP_PROPERTIES(
|
|
|
+ D3D12_HEAP_TYPE type,
|
|
|
+ UINT creationNodeMask = 1,
|
|
|
+ UINT nodeMask = 1)
|
|
|
+ {
|
|
|
+ Type = type;
|
|
|
+ CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
|
|
|
+ MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
|
|
|
+ CreationNodeMask = creationNodeMask;
|
|
|
+ VisibleNodeMask = nodeMask;
|
|
|
+ }
|
|
|
+ operator const D3D12_HEAP_PROPERTIES& () const { return *this; }
|
|
|
+ bool IsCPUAccessible() const
|
|
|
+ {
|
|
|
+ return Type == D3D12_HEAP_TYPE_UPLOAD || Type == D3D12_HEAP_TYPE_READBACK || (Type == D3D12_HEAP_TYPE_CUSTOM &&
|
|
|
+ (CPUPageProperty == D3D12_CPU_PAGE_PROPERTY_WRITE_COMBINE || CPUPageProperty == D3D12_CPU_PAGE_PROPERTY_WRITE_BACK));
|
|
|
+ }
|
|
|
+};
|
|
|
+inline bool operator==(const D3D12_HEAP_PROPERTIES& l, const D3D12_HEAP_PROPERTIES& r)
|
|
|
+{
|
|
|
+ return l.Type == r.Type && l.CPUPageProperty == r.CPUPageProperty &&
|
|
|
+ l.MemoryPoolPreference == r.MemoryPoolPreference &&
|
|
|
+ l.CreationNodeMask == r.CreationNodeMask &&
|
|
|
+ l.VisibleNodeMask == r.VisibleNodeMask;
|
|
|
+}
|
|
|
+inline bool operator!=(const D3D12_HEAP_PROPERTIES& l, const D3D12_HEAP_PROPERTIES& r)
|
|
|
+{
|
|
|
+ return !(l == r);
|
|
|
+}
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_HEAP_DESC : public D3D12_HEAP_DESC
|
|
|
+{
|
|
|
+ CD3DX12_HEAP_DESC()
|
|
|
+ {}
|
|
|
+ explicit CD3DX12_HEAP_DESC(const D3D12_HEAP_DESC& o) :
|
|
|
+ D3D12_HEAP_DESC(o)
|
|
|
+ {}
|
|
|
+ CD3DX12_HEAP_DESC(
|
|
|
+ UINT64 size,
|
|
|
+ D3D12_HEAP_PROPERTIES properties,
|
|
|
+ UINT64 alignment = 0,
|
|
|
+ D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE)
|
|
|
+ {
|
|
|
+ SizeInBytes = size;
|
|
|
+ Properties = properties;
|
|
|
+ Alignment = alignment;
|
|
|
+ Flags = flags;
|
|
|
+ }
|
|
|
+ CD3DX12_HEAP_DESC(
|
|
|
+ UINT64 size,
|
|
|
+ D3D12_HEAP_TYPE type,
|
|
|
+ UINT64 alignment = 0,
|
|
|
+ D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE)
|
|
|
+ {
|
|
|
+ SizeInBytes = size;
|
|
|
+ Properties = CD3DX12_HEAP_PROPERTIES(type);
|
|
|
+ Alignment = alignment;
|
|
|
+ Flags = flags;
|
|
|
+ }
|
|
|
+ CD3DX12_HEAP_DESC(
|
|
|
+ UINT64 size,
|
|
|
+ D3D12_CPU_PAGE_PROPERTY cpuPageProperty,
|
|
|
+ D3D12_MEMORY_POOL memoryPoolPreference,
|
|
|
+ UINT64 alignment = 0,
|
|
|
+ D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE)
|
|
|
+ {
|
|
|
+ SizeInBytes = size;
|
|
|
+ Properties = CD3DX12_HEAP_PROPERTIES(cpuPageProperty, memoryPoolPreference);
|
|
|
+ Alignment = alignment;
|
|
|
+ Flags = flags;
|
|
|
+ }
|
|
|
+ CD3DX12_HEAP_DESC(
|
|
|
+ const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
|
|
|
+ D3D12_HEAP_PROPERTIES properties,
|
|
|
+ D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE)
|
|
|
+ {
|
|
|
+ SizeInBytes = resAllocInfo.SizeInBytes;
|
|
|
+ Properties = properties;
|
|
|
+ Alignment = resAllocInfo.Alignment;
|
|
|
+ Flags = flags;
|
|
|
+ }
|
|
|
+ CD3DX12_HEAP_DESC(
|
|
|
+ const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
|
|
|
+ D3D12_HEAP_TYPE type,
|
|
|
+ D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE)
|
|
|
+ {
|
|
|
+ SizeInBytes = resAllocInfo.SizeInBytes;
|
|
|
+ Properties = CD3DX12_HEAP_PROPERTIES(type);
|
|
|
+ Alignment = resAllocInfo.Alignment;
|
|
|
+ Flags = flags;
|
|
|
+ }
|
|
|
+ CD3DX12_HEAP_DESC(
|
|
|
+ const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
|
|
|
+ D3D12_CPU_PAGE_PROPERTY cpuPageProperty,
|
|
|
+ D3D12_MEMORY_POOL memoryPoolPreference,
|
|
|
+ D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE)
|
|
|
+ {
|
|
|
+ SizeInBytes = resAllocInfo.SizeInBytes;
|
|
|
+ Properties = CD3DX12_HEAP_PROPERTIES(cpuPageProperty, memoryPoolPreference);
|
|
|
+ Alignment = resAllocInfo.Alignment;
|
|
|
+ Flags = flags;
|
|
|
+ }
|
|
|
+ operator const D3D12_HEAP_DESC& () const { return *this; }
|
|
|
+ bool IsCPUAccessible() const
|
|
|
+ {
|
|
|
+ return static_cast<const CD3DX12_HEAP_PROPERTIES*>(&Properties)->IsCPUAccessible();
|
|
|
+ }
|
|
|
+};
|
|
|
+inline bool operator==(const D3D12_HEAP_DESC& l, const D3D12_HEAP_DESC& r)
|
|
|
+{
|
|
|
+ return l.SizeInBytes == r.SizeInBytes &&
|
|
|
+ l.Properties == r.Properties &&
|
|
|
+ l.Alignment == r.Alignment &&
|
|
|
+ l.Flags == r.Flags;
|
|
|
+}
|
|
|
+inline bool operator!=(const D3D12_HEAP_DESC& l, const D3D12_HEAP_DESC& r)
|
|
|
+{
|
|
|
+ return !(l == r);
|
|
|
+}
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_CLEAR_VALUE : public D3D12_CLEAR_VALUE
|
|
|
+{
|
|
|
+ CD3DX12_CLEAR_VALUE()
|
|
|
+ {}
|
|
|
+ explicit CD3DX12_CLEAR_VALUE(const D3D12_CLEAR_VALUE& o) :
|
|
|
+ D3D12_CLEAR_VALUE(o)
|
|
|
+ {}
|
|
|
+ CD3DX12_CLEAR_VALUE(
|
|
|
+ DXGI_FORMAT format,
|
|
|
+ const FLOAT color[4])
|
|
|
+ {
|
|
|
+ Format = format;
|
|
|
+ memcpy(Color, color, sizeof(Color));
|
|
|
+ }
|
|
|
+ CD3DX12_CLEAR_VALUE(
|
|
|
+ DXGI_FORMAT format,
|
|
|
+ FLOAT depth,
|
|
|
+ UINT8 stencil)
|
|
|
+ {
|
|
|
+ Format = format;
|
|
|
+ /* Use memcpy to preserve NAN values */
|
|
|
+ memcpy(&DepthStencil.Depth, &depth, sizeof(depth));
|
|
|
+ DepthStencil.Stencil = stencil;
|
|
|
+ }
|
|
|
+ operator const D3D12_CLEAR_VALUE& () const { return *this; }
|
|
|
+};
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_RANGE : public D3D12_RANGE
|
|
|
+{
|
|
|
+ CD3DX12_RANGE()
|
|
|
+ {}
|
|
|
+ explicit CD3DX12_RANGE(const D3D12_RANGE& o) :
|
|
|
+ D3D12_RANGE(o)
|
|
|
+ {}
|
|
|
+ CD3DX12_RANGE(
|
|
|
+ SIZE_T begin,
|
|
|
+ SIZE_T end)
|
|
|
+ {
|
|
|
+ Begin = begin;
|
|
|
+ End = end;
|
|
|
+ }
|
|
|
+ operator const D3D12_RANGE& () const { return *this; }
|
|
|
+};
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_TILED_RESOURCE_COORDINATE : public D3D12_TILED_RESOURCE_COORDINATE
|
|
|
+{
|
|
|
+ CD3DX12_TILED_RESOURCE_COORDINATE()
|
|
|
+ {}
|
|
|
+ explicit CD3DX12_TILED_RESOURCE_COORDINATE(const D3D12_TILED_RESOURCE_COORDINATE& o) :
|
|
|
+ D3D12_TILED_RESOURCE_COORDINATE(o)
|
|
|
+ {}
|
|
|
+ CD3DX12_TILED_RESOURCE_COORDINATE(
|
|
|
+ UINT x,
|
|
|
+ UINT y,
|
|
|
+ UINT z,
|
|
|
+ UINT subresource)
|
|
|
+ {
|
|
|
+ X = x;
|
|
|
+ Y = y;
|
|
|
+ Z = z;
|
|
|
+ Subresource = subresource;
|
|
|
+ }
|
|
|
+ operator const D3D12_TILED_RESOURCE_COORDINATE& () const { return *this; }
|
|
|
+};
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_TILE_REGION_SIZE : public D3D12_TILE_REGION_SIZE
|
|
|
+{
|
|
|
+ CD3DX12_TILE_REGION_SIZE()
|
|
|
+ {}
|
|
|
+ explicit CD3DX12_TILE_REGION_SIZE(const D3D12_TILE_REGION_SIZE& o) :
|
|
|
+ D3D12_TILE_REGION_SIZE(o)
|
|
|
+ {}
|
|
|
+ CD3DX12_TILE_REGION_SIZE(
|
|
|
+ UINT numTiles,
|
|
|
+ BOOL useBox,
|
|
|
+ UINT width,
|
|
|
+ UINT16 height,
|
|
|
+ UINT16 depth)
|
|
|
+ {
|
|
|
+ NumTiles = numTiles;
|
|
|
+ UseBox = useBox;
|
|
|
+ Width = width;
|
|
|
+ Height = height;
|
|
|
+ Depth = depth;
|
|
|
+ }
|
|
|
+ operator const D3D12_TILE_REGION_SIZE& () const { return *this; }
|
|
|
+};
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_SUBRESOURCE_TILING : public D3D12_SUBRESOURCE_TILING
|
|
|
+{
|
|
|
+ CD3DX12_SUBRESOURCE_TILING()
|
|
|
+ {}
|
|
|
+ explicit CD3DX12_SUBRESOURCE_TILING(const D3D12_SUBRESOURCE_TILING& o) :
|
|
|
+ D3D12_SUBRESOURCE_TILING(o)
|
|
|
+ {}
|
|
|
+ CD3DX12_SUBRESOURCE_TILING(
|
|
|
+ UINT widthInTiles,
|
|
|
+ UINT16 heightInTiles,
|
|
|
+ UINT16 depthInTiles,
|
|
|
+ UINT startTileIndexInOverallResource)
|
|
|
+ {
|
|
|
+ WidthInTiles = widthInTiles;
|
|
|
+ HeightInTiles = heightInTiles;
|
|
|
+ DepthInTiles = depthInTiles;
|
|
|
+ StartTileIndexInOverallResource = startTileIndexInOverallResource;
|
|
|
+ }
|
|
|
+ operator const D3D12_SUBRESOURCE_TILING& () const { return *this; }
|
|
|
+};
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_TILE_SHAPE : public D3D12_TILE_SHAPE
|
|
|
+{
|
|
|
+ CD3DX12_TILE_SHAPE()
|
|
|
+ {}
|
|
|
+ explicit CD3DX12_TILE_SHAPE(const D3D12_TILE_SHAPE& o) :
|
|
|
+ D3D12_TILE_SHAPE(o)
|
|
|
+ {}
|
|
|
+ CD3DX12_TILE_SHAPE(
|
|
|
+ UINT widthInTexels,
|
|
|
+ UINT heightInTexels,
|
|
|
+ UINT depthInTexels)
|
|
|
+ {
|
|
|
+ WidthInTexels = widthInTexels;
|
|
|
+ HeightInTexels = heightInTexels;
|
|
|
+ DepthInTexels = depthInTexels;
|
|
|
+ }
|
|
|
+ operator const D3D12_TILE_SHAPE& () const { return *this; }
|
|
|
+};
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_RESOURCE_BARRIER : public D3D12_RESOURCE_BARRIER
|
|
|
+{
|
|
|
+ CD3DX12_RESOURCE_BARRIER()
|
|
|
+ {}
|
|
|
+ explicit CD3DX12_RESOURCE_BARRIER(const D3D12_RESOURCE_BARRIER& o) :
|
|
|
+ D3D12_RESOURCE_BARRIER(o)
|
|
|
+ {}
|
|
|
+ static inline CD3DX12_RESOURCE_BARRIER Transition(
|
|
|
+ _In_ ID3D12Resource* pResource,
|
|
|
+ D3D12_RESOURCE_STATES stateBefore,
|
|
|
+ D3D12_RESOURCE_STATES stateAfter,
|
|
|
+ UINT subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES,
|
|
|
+ D3D12_RESOURCE_BARRIER_FLAGS flags = D3D12_RESOURCE_BARRIER_FLAG_NONE)
|
|
|
+ {
|
|
|
+ CD3DX12_RESOURCE_BARRIER result;
|
|
|
+ ZeroMemory(&result, sizeof(result));
|
|
|
+ D3D12_RESOURCE_BARRIER& barrier = result;
|
|
|
+ result.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
|
|
|
+ result.Flags = flags;
|
|
|
+ barrier.Transition.pResource = pResource;
|
|
|
+ barrier.Transition.StateBefore = stateBefore;
|
|
|
+ barrier.Transition.StateAfter = stateAfter;
|
|
|
+ barrier.Transition.Subresource = subresource;
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+ static inline CD3DX12_RESOURCE_BARRIER Aliasing(
|
|
|
+ _In_ ID3D12Resource* pResourceBefore,
|
|
|
+ _In_ ID3D12Resource* pResourceAfter)
|
|
|
+ {
|
|
|
+ CD3DX12_RESOURCE_BARRIER result;
|
|
|
+ ZeroMemory(&result, sizeof(result));
|
|
|
+ D3D12_RESOURCE_BARRIER& barrier = result;
|
|
|
+ result.Type = D3D12_RESOURCE_BARRIER_TYPE_ALIASING;
|
|
|
+ barrier.Aliasing.pResourceBefore = pResourceBefore;
|
|
|
+ barrier.Aliasing.pResourceAfter = pResourceAfter;
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+ static inline CD3DX12_RESOURCE_BARRIER UAV(
|
|
|
+ _In_ ID3D12Resource* pResource)
|
|
|
+ {
|
|
|
+ CD3DX12_RESOURCE_BARRIER result;
|
|
|
+ ZeroMemory(&result, sizeof(result));
|
|
|
+ D3D12_RESOURCE_BARRIER& barrier = result;
|
|
|
+ result.Type = D3D12_RESOURCE_BARRIER_TYPE_UAV;
|
|
|
+ barrier.UAV.pResource = pResource;
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+ operator const D3D12_RESOURCE_BARRIER& () const { return *this; }
|
|
|
+};
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_PACKED_MIP_INFO : public D3D12_PACKED_MIP_INFO
|
|
|
+{
|
|
|
+ CD3DX12_PACKED_MIP_INFO()
|
|
|
+ {}
|
|
|
+ explicit CD3DX12_PACKED_MIP_INFO(const D3D12_PACKED_MIP_INFO& o) :
|
|
|
+ D3D12_PACKED_MIP_INFO(o)
|
|
|
+ {}
|
|
|
+ CD3DX12_PACKED_MIP_INFO(
|
|
|
+ UINT8 numStandardMips,
|
|
|
+ UINT8 numPackedMips,
|
|
|
+ UINT numTilesForPackedMips,
|
|
|
+ UINT startTileIndexInOverallResource)
|
|
|
+ {
|
|
|
+ NumStandardMips = numStandardMips;
|
|
|
+ NumPackedMips = numPackedMips;
|
|
|
+ NumTilesForPackedMips = numTilesForPackedMips;
|
|
|
+ StartTileIndexInOverallResource = startTileIndexInOverallResource;
|
|
|
+ }
|
|
|
+ operator const D3D12_PACKED_MIP_INFO& () const { return *this; }
|
|
|
+};
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_SUBRESOURCE_FOOTPRINT : public D3D12_SUBRESOURCE_FOOTPRINT
|
|
|
+{
|
|
|
+ CD3DX12_SUBRESOURCE_FOOTPRINT()
|
|
|
+ {}
|
|
|
+ explicit CD3DX12_SUBRESOURCE_FOOTPRINT(const D3D12_SUBRESOURCE_FOOTPRINT& o) :
|
|
|
+ D3D12_SUBRESOURCE_FOOTPRINT(o)
|
|
|
+ {}
|
|
|
+ CD3DX12_SUBRESOURCE_FOOTPRINT(
|
|
|
+ DXGI_FORMAT format,
|
|
|
+ UINT width,
|
|
|
+ UINT height,
|
|
|
+ UINT depth,
|
|
|
+ UINT rowPitch)
|
|
|
+ {
|
|
|
+ Format = format;
|
|
|
+ Width = width;
|
|
|
+ Height = height;
|
|
|
+ Depth = depth;
|
|
|
+ RowPitch = rowPitch;
|
|
|
+ }
|
|
|
+ explicit CD3DX12_SUBRESOURCE_FOOTPRINT(
|
|
|
+ const D3D12_RESOURCE_DESC& resDesc,
|
|
|
+ UINT rowPitch)
|
|
|
+ {
|
|
|
+ Format = resDesc.Format;
|
|
|
+ Width = UINT(resDesc.Width);
|
|
|
+ Height = resDesc.Height;
|
|
|
+ Depth = (resDesc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? resDesc.DepthOrArraySize : 1);
|
|
|
+ RowPitch = rowPitch;
|
|
|
+ }
|
|
|
+ operator const D3D12_SUBRESOURCE_FOOTPRINT& () const { return *this; }
|
|
|
+};
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_TEXTURE_COPY_LOCATION : public D3D12_TEXTURE_COPY_LOCATION
|
|
|
+{
|
|
|
+ CD3DX12_TEXTURE_COPY_LOCATION()
|
|
|
+ {}
|
|
|
+ explicit CD3DX12_TEXTURE_COPY_LOCATION(const D3D12_TEXTURE_COPY_LOCATION& o) :
|
|
|
+ D3D12_TEXTURE_COPY_LOCATION(o)
|
|
|
+ {}
|
|
|
+ CD3DX12_TEXTURE_COPY_LOCATION(ID3D12Resource* pRes) { pResource = pRes; }
|
|
|
+ CD3DX12_TEXTURE_COPY_LOCATION(ID3D12Resource* pRes, D3D12_PLACED_SUBRESOURCE_FOOTPRINT const& Footprint)
|
|
|
+ {
|
|
|
+ pResource = pRes;
|
|
|
+ Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
|
|
|
+ PlacedFootprint = Footprint;
|
|
|
+ }
|
|
|
+ CD3DX12_TEXTURE_COPY_LOCATION(ID3D12Resource* pRes, UINT Sub)
|
|
|
+ {
|
|
|
+ pResource = pRes;
|
|
|
+ Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
|
|
|
+ SubresourceIndex = Sub;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_DESCRIPTOR_RANGE : public D3D12_DESCRIPTOR_RANGE
|
|
|
+{
|
|
|
+ CD3DX12_DESCRIPTOR_RANGE() { }
|
|
|
+ explicit CD3DX12_DESCRIPTOR_RANGE(const D3D12_DESCRIPTOR_RANGE& o) :
|
|
|
+ D3D12_DESCRIPTOR_RANGE(o)
|
|
|
+ {}
|
|
|
+ CD3DX12_DESCRIPTOR_RANGE(
|
|
|
+ D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
|
|
|
+ UINT numDescriptors,
|
|
|
+ UINT baseShaderRegister,
|
|
|
+ UINT registerSpace = 0,
|
|
|
+ UINT offsetInDescriptorsFromTableStart =
|
|
|
+ D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND)
|
|
|
+ {
|
|
|
+ Init(rangeType, numDescriptors, baseShaderRegister, registerSpace, offsetInDescriptorsFromTableStart);
|
|
|
+ }
|
|
|
+
|
|
|
+ inline void Init(
|
|
|
+ D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
|
|
|
+ UINT numDescriptors,
|
|
|
+ UINT baseShaderRegister,
|
|
|
+ UINT registerSpace = 0,
|
|
|
+ UINT offsetInDescriptorsFromTableStart =
|
|
|
+ D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND)
|
|
|
+ {
|
|
|
+ Init(*this, rangeType, numDescriptors, baseShaderRegister, registerSpace, offsetInDescriptorsFromTableStart);
|
|
|
+ }
|
|
|
+
|
|
|
+ static inline void Init(
|
|
|
+ _Out_ D3D12_DESCRIPTOR_RANGE& range,
|
|
|
+ D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
|
|
|
+ UINT numDescriptors,
|
|
|
+ UINT baseShaderRegister,
|
|
|
+ UINT registerSpace = 0,
|
|
|
+ UINT offsetInDescriptorsFromTableStart =
|
|
|
+ D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND)
|
|
|
+ {
|
|
|
+ range.RangeType = rangeType;
|
|
|
+ range.NumDescriptors = numDescriptors;
|
|
|
+ range.BaseShaderRegister = baseShaderRegister;
|
|
|
+ range.RegisterSpace = registerSpace;
|
|
|
+ range.OffsetInDescriptorsFromTableStart = offsetInDescriptorsFromTableStart;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_ROOT_DESCRIPTOR_TABLE : public D3D12_ROOT_DESCRIPTOR_TABLE
|
|
|
+{
|
|
|
+ CD3DX12_ROOT_DESCRIPTOR_TABLE() {}
|
|
|
+ explicit CD3DX12_ROOT_DESCRIPTOR_TABLE(const D3D12_ROOT_DESCRIPTOR_TABLE& o) :
|
|
|
+ D3D12_ROOT_DESCRIPTOR_TABLE(o)
|
|
|
+ {}
|
|
|
+ CD3DX12_ROOT_DESCRIPTOR_TABLE(
|
|
|
+ UINT numDescriptorRanges,
|
|
|
+ _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges)
|
|
|
+ {
|
|
|
+ Init(numDescriptorRanges, _pDescriptorRanges);
|
|
|
+ }
|
|
|
+
|
|
|
+ inline void Init(
|
|
|
+ UINT numDescriptorRanges,
|
|
|
+ _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges)
|
|
|
+ {
|
|
|
+ Init(*this, numDescriptorRanges, _pDescriptorRanges);
|
|
|
+ }
|
|
|
+
|
|
|
+ static inline void Init(
|
|
|
+ _Out_ D3D12_ROOT_DESCRIPTOR_TABLE& rootDescriptorTable,
|
|
|
+ UINT numDescriptorRanges,
|
|
|
+ _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges)
|
|
|
+ {
|
|
|
+ rootDescriptorTable.NumDescriptorRanges = numDescriptorRanges;
|
|
|
+ rootDescriptorTable.pDescriptorRanges = _pDescriptorRanges;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_ROOT_CONSTANTS : public D3D12_ROOT_CONSTANTS
|
|
|
+{
|
|
|
+ CD3DX12_ROOT_CONSTANTS() {}
|
|
|
+ explicit CD3DX12_ROOT_CONSTANTS(const D3D12_ROOT_CONSTANTS& o) :
|
|
|
+ D3D12_ROOT_CONSTANTS(o)
|
|
|
+ {}
|
|
|
+ CD3DX12_ROOT_CONSTANTS(
|
|
|
+ UINT num32BitValues,
|
|
|
+ UINT shaderRegister,
|
|
|
+ UINT registerSpace = 0)
|
|
|
+ {
|
|
|
+ Init(num32BitValues, shaderRegister, registerSpace);
|
|
|
+ }
|
|
|
+
|
|
|
+ inline void Init(
|
|
|
+ UINT num32BitValues,
|
|
|
+ UINT shaderRegister,
|
|
|
+ UINT registerSpace = 0)
|
|
|
+ {
|
|
|
+ Init(*this, num32BitValues, shaderRegister, registerSpace);
|
|
|
+ }
|
|
|
+
|
|
|
+ static inline void Init(
|
|
|
+ _Out_ D3D12_ROOT_CONSTANTS& rootConstants,
|
|
|
+ UINT num32BitValues,
|
|
|
+ UINT shaderRegister,
|
|
|
+ UINT registerSpace = 0)
|
|
|
+ {
|
|
|
+ rootConstants.Num32BitValues = num32BitValues;
|
|
|
+ rootConstants.ShaderRegister = shaderRegister;
|
|
|
+ rootConstants.RegisterSpace = registerSpace;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_ROOT_DESCRIPTOR : public D3D12_ROOT_DESCRIPTOR
|
|
|
+{
|
|
|
+ CD3DX12_ROOT_DESCRIPTOR() {}
|
|
|
+ explicit CD3DX12_ROOT_DESCRIPTOR(const D3D12_ROOT_DESCRIPTOR& o) :
|
|
|
+ D3D12_ROOT_DESCRIPTOR(o)
|
|
|
+ {}
|
|
|
+ CD3DX12_ROOT_DESCRIPTOR(
|
|
|
+ UINT shaderRegister,
|
|
|
+ UINT registerSpace = 0)
|
|
|
+ {
|
|
|
+ Init(shaderRegister, registerSpace);
|
|
|
+ }
|
|
|
+
|
|
|
+ inline void Init(
|
|
|
+ UINT shaderRegister,
|
|
|
+ UINT registerSpace = 0)
|
|
|
+ {
|
|
|
+ Init(*this, shaderRegister, registerSpace);
|
|
|
+ }
|
|
|
+
|
|
|
+ static inline void Init(_Out_ D3D12_ROOT_DESCRIPTOR& table, UINT shaderRegister, UINT registerSpace = 0)
|
|
|
+ {
|
|
|
+ table.ShaderRegister = shaderRegister;
|
|
|
+ table.RegisterSpace = registerSpace;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_ROOT_PARAMETER : public D3D12_ROOT_PARAMETER
|
|
|
+{
|
|
|
+ CD3DX12_ROOT_PARAMETER() {}
|
|
|
+ explicit CD3DX12_ROOT_PARAMETER(const D3D12_ROOT_PARAMETER& o) :
|
|
|
+ D3D12_ROOT_PARAMETER(o)
|
|
|
+ {}
|
|
|
+
|
|
|
+ static inline void InitAsDescriptorTable(
|
|
|
+ _Out_ D3D12_ROOT_PARAMETER& rootParam,
|
|
|
+ UINT numDescriptorRanges,
|
|
|
+ _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* pDescriptorRanges,
|
|
|
+ D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
|
|
|
+ {
|
|
|
+ rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
|
|
|
+ rootParam.ShaderVisibility = visibility;
|
|
|
+ CD3DX12_ROOT_DESCRIPTOR_TABLE::Init(rootParam.DescriptorTable, numDescriptorRanges, pDescriptorRanges);
|
|
|
+ }
|
|
|
+
|
|
|
+ static inline void InitAsConstants(
|
|
|
+ _Out_ D3D12_ROOT_PARAMETER& rootParam,
|
|
|
+ UINT num32BitValues,
|
|
|
+ UINT shaderRegister,
|
|
|
+ UINT registerSpace = 0,
|
|
|
+ D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
|
|
|
+ {
|
|
|
+ rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS;
|
|
|
+ rootParam.ShaderVisibility = visibility;
|
|
|
+ CD3DX12_ROOT_CONSTANTS::Init(rootParam.Constants, num32BitValues, shaderRegister, registerSpace);
|
|
|
+ }
|
|
|
+
|
|
|
+ static inline void InitAsConstantBufferView(
|
|
|
+ _Out_ D3D12_ROOT_PARAMETER& rootParam,
|
|
|
+ UINT shaderRegister,
|
|
|
+ UINT registerSpace = 0,
|
|
|
+ D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
|
|
|
+ {
|
|
|
+ rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
|
|
|
+ rootParam.ShaderVisibility = visibility;
|
|
|
+ CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister, registerSpace);
|
|
|
+ }
|
|
|
+
|
|
|
+ static inline void InitAsShaderResourceView(
|
|
|
+ _Out_ D3D12_ROOT_PARAMETER& rootParam,
|
|
|
+ UINT shaderRegister,
|
|
|
+ UINT registerSpace = 0,
|
|
|
+ D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
|
|
|
+ {
|
|
|
+ rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_SRV;
|
|
|
+ rootParam.ShaderVisibility = visibility;
|
|
|
+ CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister, registerSpace);
|
|
|
+ }
|
|
|
+
|
|
|
+ static inline void InitAsUnorderedAccessView(
|
|
|
+ _Out_ D3D12_ROOT_PARAMETER& rootParam,
|
|
|
+ UINT shaderRegister,
|
|
|
+ UINT registerSpace = 0,
|
|
|
+ D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
|
|
|
+ {
|
|
|
+ rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_UAV;
|
|
|
+ rootParam.ShaderVisibility = visibility;
|
|
|
+ CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister, registerSpace);
|
|
|
+ }
|
|
|
+
|
|
|
+ inline void InitAsDescriptorTable(
|
|
|
+ UINT numDescriptorRanges,
|
|
|
+ _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* pDescriptorRanges,
|
|
|
+ D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
|
|
|
+ {
|
|
|
+ InitAsDescriptorTable(*this, numDescriptorRanges, pDescriptorRanges, visibility);
|
|
|
+ }
|
|
|
+
|
|
|
+ inline void InitAsConstants(
|
|
|
+ UINT num32BitValues,
|
|
|
+ UINT shaderRegister,
|
|
|
+ UINT registerSpace = 0,
|
|
|
+ D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
|
|
|
+ {
|
|
|
+ InitAsConstants(*this, num32BitValues, shaderRegister, registerSpace, visibility);
|
|
|
+ }
|
|
|
+
|
|
|
+ inline void InitAsConstantBufferView(
|
|
|
+ UINT shaderRegister,
|
|
|
+ UINT registerSpace = 0,
|
|
|
+ D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
|
|
|
+ {
|
|
|
+ InitAsConstantBufferView(*this, shaderRegister, registerSpace, visibility);
|
|
|
+ }
|
|
|
+
|
|
|
+ inline void InitAsShaderResourceView(
|
|
|
+ UINT shaderRegister,
|
|
|
+ UINT registerSpace = 0,
|
|
|
+ D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
|
|
|
+ {
|
|
|
+ InitAsShaderResourceView(*this, shaderRegister, registerSpace, visibility);
|
|
|
+ }
|
|
|
+
|
|
|
+ inline void InitAsUnorderedAccessView(
|
|
|
+ UINT shaderRegister,
|
|
|
+ UINT registerSpace = 0,
|
|
|
+ D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
|
|
|
+ {
|
|
|
+ InitAsUnorderedAccessView(*this, shaderRegister, registerSpace, visibility);
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_STATIC_SAMPLER_DESC : public D3D12_STATIC_SAMPLER_DESC
|
|
|
+{
|
|
|
+ CD3DX12_STATIC_SAMPLER_DESC() {}
|
|
|
+ explicit CD3DX12_STATIC_SAMPLER_DESC(const D3D12_STATIC_SAMPLER_DESC& o) :
|
|
|
+ D3D12_STATIC_SAMPLER_DESC(o)
|
|
|
+ {}
|
|
|
+ CD3DX12_STATIC_SAMPLER_DESC(
|
|
|
+ UINT shaderRegister,
|
|
|
+ D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC,
|
|
|
+ D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
|
|
|
+ D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
|
|
|
+ D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
|
|
|
+ FLOAT mipLODBias = 0,
|
|
|
+ UINT maxAnisotropy = 16,
|
|
|
+ D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL,
|
|
|
+ D3D12_STATIC_BORDER_COLOR borderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE,
|
|
|
+ FLOAT minLOD = 0.f,
|
|
|
+ FLOAT maxLOD = D3D12_FLOAT32_MAX,
|
|
|
+ D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL,
|
|
|
+ UINT registerSpace = 0)
|
|
|
+ {
|
|
|
+ Init(
|
|
|
+ shaderRegister,
|
|
|
+ filter,
|
|
|
+ addressU,
|
|
|
+ addressV,
|
|
|
+ addressW,
|
|
|
+ mipLODBias,
|
|
|
+ maxAnisotropy,
|
|
|
+ comparisonFunc,
|
|
|
+ borderColor,
|
|
|
+ minLOD,
|
|
|
+ maxLOD,
|
|
|
+ shaderVisibility,
|
|
|
+ registerSpace);
|
|
|
+ }
|
|
|
+
|
|
|
+ static inline void Init(
|
|
|
+ _Out_ D3D12_STATIC_SAMPLER_DESC& samplerDesc,
|
|
|
+ UINT shaderRegister,
|
|
|
+ D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC,
|
|
|
+ D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
|
|
|
+ D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
|
|
|
+ D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
|
|
|
+ FLOAT mipLODBias = 0,
|
|
|
+ UINT maxAnisotropy = 16,
|
|
|
+ D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL,
|
|
|
+ D3D12_STATIC_BORDER_COLOR borderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE,
|
|
|
+ FLOAT minLOD = 0.f,
|
|
|
+ FLOAT maxLOD = D3D12_FLOAT32_MAX,
|
|
|
+ D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL,
|
|
|
+ UINT registerSpace = 0)
|
|
|
+ {
|
|
|
+ samplerDesc.ShaderRegister = shaderRegister;
|
|
|
+ samplerDesc.Filter = filter;
|
|
|
+ samplerDesc.AddressU = addressU;
|
|
|
+ samplerDesc.AddressV = addressV;
|
|
|
+ samplerDesc.AddressW = addressW;
|
|
|
+ samplerDesc.MipLODBias = mipLODBias;
|
|
|
+ samplerDesc.MaxAnisotropy = maxAnisotropy;
|
|
|
+ samplerDesc.ComparisonFunc = comparisonFunc;
|
|
|
+ samplerDesc.BorderColor = borderColor;
|
|
|
+ samplerDesc.MinLOD = minLOD;
|
|
|
+ samplerDesc.MaxLOD = maxLOD;
|
|
|
+ samplerDesc.ShaderVisibility = shaderVisibility;
|
|
|
+ samplerDesc.RegisterSpace = registerSpace;
|
|
|
+ }
|
|
|
+ inline void Init(
|
|
|
+ UINT shaderRegister,
|
|
|
+ D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC,
|
|
|
+ D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
|
|
|
+ D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
|
|
|
+ D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP,
|
|
|
+ FLOAT mipLODBias = 0,
|
|
|
+ UINT maxAnisotropy = 16,
|
|
|
+ D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL,
|
|
|
+ D3D12_STATIC_BORDER_COLOR borderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE,
|
|
|
+ FLOAT minLOD = 0.f,
|
|
|
+ FLOAT maxLOD = D3D12_FLOAT32_MAX,
|
|
|
+ D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL,
|
|
|
+ UINT registerSpace = 0)
|
|
|
+ {
|
|
|
+ Init(
|
|
|
+ *this,
|
|
|
+ shaderRegister,
|
|
|
+ filter,
|
|
|
+ addressU,
|
|
|
+ addressV,
|
|
|
+ addressW,
|
|
|
+ mipLODBias,
|
|
|
+ maxAnisotropy,
|
|
|
+ comparisonFunc,
|
|
|
+ borderColor,
|
|
|
+ minLOD,
|
|
|
+ maxLOD,
|
|
|
+ shaderVisibility,
|
|
|
+ registerSpace);
|
|
|
+ }
|
|
|
+
|
|
|
+};
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_ROOT_SIGNATURE_DESC : public D3D12_ROOT_SIGNATURE_DESC
|
|
|
+{
|
|
|
+ CD3DX12_ROOT_SIGNATURE_DESC() {}
|
|
|
+ explicit CD3DX12_ROOT_SIGNATURE_DESC(const D3D12_ROOT_SIGNATURE_DESC& o) :
|
|
|
+ D3D12_ROOT_SIGNATURE_DESC(o)
|
|
|
+ {}
|
|
|
+ CD3DX12_ROOT_SIGNATURE_DESC(
|
|
|
+ UINT numParameters,
|
|
|
+ _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
|
|
|
+ UINT numStaticSamplers = 0,
|
|
|
+ _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = NULL,
|
|
|
+ D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE)
|
|
|
+ {
|
|
|
+ Init(numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
|
|
|
+ }
|
|
|
+ CD3DX12_ROOT_SIGNATURE_DESC(CD3DX12_DEFAULT)
|
|
|
+ {
|
|
|
+ Init(0, NULL, 0, NULL, 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 = NULL,
|
|
|
+ D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE)
|
|
|
+ {
|
|
|
+ Init(*this, numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags);
|
|
|
+ }
|
|
|
+
|
|
|
+ static inline void Init(
|
|
|
+ _Out_ D3D12_ROOT_SIGNATURE_DESC& desc,
|
|
|
+ UINT numParameters,
|
|
|
+ _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters,
|
|
|
+ UINT numStaticSamplers = 0,
|
|
|
+ _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = NULL,
|
|
|
+ D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE)
|
|
|
+ {
|
|
|
+ desc.NumParameters = numParameters;
|
|
|
+ desc.pParameters = _pParameters;
|
|
|
+ desc.NumStaticSamplers = numStaticSamplers;
|
|
|
+ desc.pStaticSamplers = _pStaticSamplers;
|
|
|
+ desc.Flags = flags;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_CPU_DESCRIPTOR_HANDLE : public D3D12_CPU_DESCRIPTOR_HANDLE
|
|
|
+{
|
|
|
+ CD3DX12_CPU_DESCRIPTOR_HANDLE() {}
|
|
|
+ explicit CD3DX12_CPU_DESCRIPTOR_HANDLE(const D3D12_CPU_DESCRIPTOR_HANDLE& o) :
|
|
|
+ D3D12_CPU_DESCRIPTOR_HANDLE(o)
|
|
|
+ {}
|
|
|
+ CD3DX12_CPU_DESCRIPTOR_HANDLE(CD3DX12_DEFAULT) { ptr = 0; }
|
|
|
+ CD3DX12_CPU_DESCRIPTOR_HANDLE(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE& other, INT offsetScaledByIncrementSize)
|
|
|
+ {
|
|
|
+ InitOffsetted(other, offsetScaledByIncrementSize);
|
|
|
+ }
|
|
|
+ CD3DX12_CPU_DESCRIPTOR_HANDLE(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE& other, INT offsetInDescriptors, UINT descriptorIncrementSize)
|
|
|
+ {
|
|
|
+ InitOffsetted(other, offsetInDescriptors, descriptorIncrementSize);
|
|
|
+ }
|
|
|
+ CD3DX12_CPU_DESCRIPTOR_HANDLE& Offset(INT offsetInDescriptors, UINT descriptorIncrementSize)
|
|
|
+ {
|
|
|
+ ptr += offsetInDescriptors * descriptorIncrementSize;
|
|
|
+ return *this;
|
|
|
+ }
|
|
|
+ CD3DX12_CPU_DESCRIPTOR_HANDLE& Offset(INT offsetScaledByIncrementSize)
|
|
|
+ {
|
|
|
+ ptr += offsetScaledByIncrementSize;
|
|
|
+ return *this;
|
|
|
+ }
|
|
|
+ bool operator==(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE& other)
|
|
|
+ {
|
|
|
+ return (ptr == other.ptr);
|
|
|
+ }
|
|
|
+ bool operator!=(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE& other)
|
|
|
+ {
|
|
|
+ return (ptr != other.ptr);
|
|
|
+ }
|
|
|
+ CD3DX12_CPU_DESCRIPTOR_HANDLE& operator=(const D3D12_CPU_DESCRIPTOR_HANDLE& other)
|
|
|
+ {
|
|
|
+ ptr = other.ptr;
|
|
|
+ return *this;
|
|
|
+ }
|
|
|
+
|
|
|
+ inline void InitOffsetted(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE& base, INT offsetScaledByIncrementSize)
|
|
|
+ {
|
|
|
+ InitOffsetted(*this, base, offsetScaledByIncrementSize);
|
|
|
+ }
|
|
|
+
|
|
|
+ inline void InitOffsetted(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE& base, INT offsetInDescriptors, UINT descriptorIncrementSize)
|
|
|
+ {
|
|
|
+ InitOffsetted(*this, base, offsetInDescriptors, descriptorIncrementSize);
|
|
|
+ }
|
|
|
+
|
|
|
+ static inline void InitOffsetted(_Out_ D3D12_CPU_DESCRIPTOR_HANDLE& handle, _In_ const D3D12_CPU_DESCRIPTOR_HANDLE& base, INT offsetScaledByIncrementSize)
|
|
|
+ {
|
|
|
+ handle.ptr = base.ptr + offsetScaledByIncrementSize;
|
|
|
+ }
|
|
|
+
|
|
|
+ static inline void InitOffsetted(_Out_ D3D12_CPU_DESCRIPTOR_HANDLE& handle, _In_ const D3D12_CPU_DESCRIPTOR_HANDLE& base, INT offsetInDescriptors, UINT descriptorIncrementSize)
|
|
|
+ {
|
|
|
+ handle.ptr = base.ptr + offsetInDescriptors * descriptorIncrementSize;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+struct CD3DX12_GPU_DESCRIPTOR_HANDLE : public D3D12_GPU_DESCRIPTOR_HANDLE
|
|
|
+{
|
|
|
+ CD3DX12_GPU_DESCRIPTOR_HANDLE() {}
|
|
|
+ explicit CD3DX12_GPU_DESCRIPTOR_HANDLE(const D3D12_GPU_DESCRIPTOR_HANDLE& o) :
|
|
|
+ D3D12_GPU_DESCRIPTOR_HANDLE(o)
|
|
|
+ {}
|
|
|
+ CD3DX12_GPU_DESCRIPTOR_HANDLE(CD3DX12_DEFAULT) { ptr = 0; }
|
|
|
+ CD3DX12_GPU_DESCRIPTOR_HANDLE(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE& other, INT offsetScaledByIncrementSize)
|
|
|
+ {
|
|
|
+ InitOffsetted(other, offsetScaledByIncrementSize);
|
|
|
+ }
|
|
|
+ CD3DX12_GPU_DESCRIPTOR_HANDLE(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE& other, INT offsetInDescriptors, UINT descriptorIncrementSize)
|
|
|
+ {
|
|
|
+ InitOffsetted(other, offsetInDescriptors, descriptorIncrementSize);
|
|
|
+ }
|
|
|
+ CD3DX12_GPU_DESCRIPTOR_HANDLE& Offset(INT offsetInDescriptors, UINT descriptorIncrementSize)
|
|
|
+ {
|
|
|
+ ptr += offsetInDescriptors * descriptorIncrementSize;
|
|
|
+ return *this;
|
|
|
+ }
|
|
|
+ CD3DX12_GPU_DESCRIPTOR_HANDLE& Offset(INT offsetScaledByIncrementSize)
|
|
|
+ {
|
|
|
+ ptr += offsetScaledByIncrementSize;
|
|
|
+ return *this;
|
|
|
+ }
|
|
|
+ inline bool operator==(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE& other)
|
|
|
+ {
|
|
|
+ return (ptr == other.ptr);
|
|
|
+ }
|
|
|
+ inline bool operator!=(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE& other)
|
|
|
+ {
|
|
|
+ return (ptr != other.ptr);
|
|
|
+ }
|
|
|
+ CD3DX12_GPU_DESCRIPTOR_HANDLE& operator=(const D3D12_GPU_DESCRIPTOR_HANDLE& other)
|
|
|
+ {
|
|
|
+ ptr = other.ptr;
|
|
|
+ return *this;
|
|
|
+ }
|
|
|
+
|
|
|
+ inline void InitOffsetted(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE& base, INT offsetScaledByIncrementSize)
|
|
|
+ {
|
|
|
+ InitOffsetted(*this, base, offsetScaledByIncrementSize);
|
|
|
+ }
|
|
|
+
|
|
|
+ inline void InitOffsetted(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE& base, INT offsetInDescriptors, UINT descriptorIncrementSize)
|
|
|
+ {
|
|
|
+ InitOffsetted(*this, base, offsetInDescriptors, descriptorIncrementSize);
|
|
|
+ }
|
|
|
+
|
|
|
+ static inline void InitOffsetted(_Out_ D3D12_GPU_DESCRIPTOR_HANDLE& handle, _In_ const D3D12_GPU_DESCRIPTOR_HANDLE& base, INT offsetScaledByIncrementSize)
|
|
|
+ {
|
|
|
+ handle.ptr = base.ptr + offsetScaledByIncrementSize;
|
|
|
+ }
|
|
|
+
|
|
|
+ static inline void InitOffsetted(_Out_ D3D12_GPU_DESCRIPTOR_HANDLE& handle, _In_ const D3D12_GPU_DESCRIPTOR_HANDLE& base, INT offsetInDescriptors, UINT descriptorIncrementSize)
|
|
|
+ {
|
|
|
+ handle.ptr = base.ptr + offsetInDescriptors * descriptorIncrementSize;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+inline UINT D3D12CalcSubresource(UINT MipSlice, UINT ArraySlice, UINT PlaneSlice, UINT MipLevels, UINT ArraySize)
|
|
|
+{
|
|
|
+ return MipSlice + ArraySlice * MipLevels + PlaneSlice * MipLevels * ArraySize;
|
|
|
+}
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+template <typename T, typename U, typename V>
|
|
|
+inline void D3D12DecomposeSubresource(UINT Subresource, UINT MipLevels, UINT ArraySize, _Out_ T& MipSlice, _Out_ U& ArraySlice, _Out_ V& PlaneSlice)
|
|
|
+{
|
|
|
+ MipSlice = static_cast<T>(Subresource % MipLevels);
|
|
|
+ ArraySlice = static_cast<U>((Subresource / MipLevels) % ArraySize);
|
|
|
+ PlaneSlice = static_cast<V>(Subresource / (MipLevels * ArraySize));
|
|
|
+}
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+inline UINT8 D3D12GetFormatPlaneCount(
|
|
|
+ _In_ ID3D12Device* pDevice,
|
|
|
+ DXGI_FORMAT Format
|
|
|
+)
|
|
|
+{
|
|
|
+ D3D12_FEATURE_DATA_FORMAT_INFO formatInfo = { Format };
|
|
|
+ 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()
|
|
|
+ {}
|
|
|
+ explicit CD3DX12_RESOURCE_DESC(const D3D12_RESOURCE_DESC& o) :
|
|
|
+ D3D12_RESOURCE_DESC(o)
|
|
|
+ {}
|
|
|
+ CD3DX12_RESOURCE_DESC(
|
|
|
+ D3D12_RESOURCE_DIMENSION dimension,
|
|
|
+ UINT64 alignment,
|
|
|
+ UINT64 width,
|
|
|
+ UINT height,
|
|
|
+ UINT16 depthOrArraySize,
|
|
|
+ UINT16 mipLevels,
|
|
|
+ DXGI_FORMAT format,
|
|
|
+ UINT sampleCount,
|
|
|
+ UINT sampleQuality,
|
|
|
+ D3D12_TEXTURE_LAYOUT layout,
|
|
|
+ D3D12_RESOURCE_FLAGS flags)
|
|
|
+ {
|
|
|
+ Dimension = dimension;
|
|
|
+ Alignment = alignment;
|
|
|
+ Width = width;
|
|
|
+ Height = height;
|
|
|
+ DepthOrArraySize = depthOrArraySize;
|
|
|
+ MipLevels = mipLevels;
|
|
|
+ Format = format;
|
|
|
+ SampleDesc.Count = sampleCount;
|
|
|
+ SampleDesc.Quality = sampleQuality;
|
|
|
+ Layout = layout;
|
|
|
+ Flags = flags;
|
|
|
+ }
|
|
|
+ static inline CD3DX12_RESOURCE_DESC Buffer(
|
|
|
+ const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo,
|
|
|
+ D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE)
|
|
|
+ {
|
|
|
+ return CD3DX12_RESOURCE_DESC(D3D12_RESOURCE_DIMENSION_BUFFER, resAllocInfo.Alignment, resAllocInfo.SizeInBytes,
|
|
|
+ 1, 1, 1, DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags);
|
|
|
+ }
|
|
|
+ static inline CD3DX12_RESOURCE_DESC Buffer(
|
|
|
+ UINT64 width,
|
|
|
+ D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
|
|
|
+ UINT64 alignment = 0)
|
|
|
+ {
|
|
|
+ return CD3DX12_RESOURCE_DESC(D3D12_RESOURCE_DIMENSION_BUFFER, alignment, width, 1, 1, 1,
|
|
|
+ DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags);
|
|
|
+ }
|
|
|
+ static inline CD3DX12_RESOURCE_DESC Tex1D(
|
|
|
+ DXGI_FORMAT format,
|
|
|
+ UINT64 width,
|
|
|
+ UINT16 arraySize = 1,
|
|
|
+ UINT16 mipLevels = 0,
|
|
|
+ D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
|
|
|
+ D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
|
|
|
+ UINT64 alignment = 0)
|
|
|
+ {
|
|
|
+ return CD3DX12_RESOURCE_DESC(D3D12_RESOURCE_DIMENSION_TEXTURE1D, alignment, width, 1, arraySize,
|
|
|
+ mipLevels, format, 1, 0, layout, flags);
|
|
|
+ }
|
|
|
+ static inline CD3DX12_RESOURCE_DESC Tex2D(
|
|
|
+ DXGI_FORMAT format,
|
|
|
+ UINT64 width,
|
|
|
+ UINT height,
|
|
|
+ UINT16 arraySize = 1,
|
|
|
+ UINT16 mipLevels = 0,
|
|
|
+ UINT sampleCount = 1,
|
|
|
+ UINT sampleQuality = 0,
|
|
|
+ D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
|
|
|
+ D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
|
|
|
+ UINT64 alignment = 0)
|
|
|
+ {
|
|
|
+ return CD3DX12_RESOURCE_DESC(D3D12_RESOURCE_DIMENSION_TEXTURE2D, alignment, width, height, arraySize,
|
|
|
+ mipLevels, format, sampleCount, sampleQuality, layout, flags);
|
|
|
+ }
|
|
|
+ static inline CD3DX12_RESOURCE_DESC Tex3D(
|
|
|
+ DXGI_FORMAT format,
|
|
|
+ UINT64 width,
|
|
|
+ UINT height,
|
|
|
+ UINT16 depth,
|
|
|
+ UINT16 mipLevels = 0,
|
|
|
+ D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
|
|
|
+ D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
|
|
|
+ UINT64 alignment = 0)
|
|
|
+ {
|
|
|
+ return CD3DX12_RESOURCE_DESC(D3D12_RESOURCE_DIMENSION_TEXTURE3D, alignment, width, height, depth,
|
|
|
+ mipLevels, format, 1, 0, layout, flags);
|
|
|
+ }
|
|
|
+ inline UINT16 Depth() const
|
|
|
+ {
|
|
|
+ return (Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize : 1);
|
|
|
+ }
|
|
|
+ inline UINT16 ArraySize() const
|
|
|
+ {
|
|
|
+ return (Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize : 1);
|
|
|
+ }
|
|
|
+ inline UINT8 PlaneCount(_In_ ID3D12Device* pDevice) const
|
|
|
+ {
|
|
|
+ return D3D12GetFormatPlaneCount(pDevice, Format);
|
|
|
+ }
|
|
|
+ inline UINT Subresources(_In_ ID3D12Device* pDevice) const
|
|
|
+ {
|
|
|
+ return MipLevels * ArraySize() * PlaneCount(pDevice);
|
|
|
+ }
|
|
|
+ inline UINT CalcSubresource(UINT MipSlice, UINT ArraySlice, UINT PlaneSlice)
|
|
|
+ {
|
|
|
+ return D3D12CalcSubresource(MipSlice, ArraySlice, PlaneSlice, MipLevels, ArraySize());
|
|
|
+ }
|
|
|
+ operator const D3D12_RESOURCE_DESC& () const { return *this; }
|
|
|
+};
|
|
|
+inline bool operator==(const D3D12_RESOURCE_DESC& l, const D3D12_RESOURCE_DESC& r)
|
|
|
+{
|
|
|
+ return l.Dimension == r.Dimension &&
|
|
|
+ l.Alignment == r.Alignment &&
|
|
|
+ l.Width == r.Width &&
|
|
|
+ l.Height == r.Height &&
|
|
|
+ l.DepthOrArraySize == r.DepthOrArraySize &&
|
|
|
+ l.MipLevels == r.MipLevels &&
|
|
|
+ l.Format == r.Format &&
|
|
|
+ l.SampleDesc.Count == r.SampleDesc.Count &&
|
|
|
+ l.SampleDesc.Quality == r.SampleDesc.Quality &&
|
|
|
+ l.Layout == r.Layout &&
|
|
|
+ l.Flags == r.Flags;
|
|
|
+}
|
|
|
+inline bool operator!=(const D3D12_RESOURCE_DESC& l, const D3D12_RESOURCE_DESC& r)
|
|
|
+{
|
|
|
+ return !(l == r);
|
|
|
+}
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+// Row-by-row memcpy
|
|
|
+inline void MemcpySubresource(
|
|
|
+ _In_ const D3D12_MEMCPY_DEST* pDest,
|
|
|
+ _In_ const D3D12_SUBRESOURCE_DATA* pSrc,
|
|
|
+ SIZE_T RowSizeInBytes,
|
|
|
+ UINT NumRows,
|
|
|
+ UINT NumSlices)
|
|
|
+{
|
|
|
+ for (UINT z = 0; z < NumSlices; ++z)
|
|
|
+ {
|
|
|
+ BYTE* pDestSlice = reinterpret_cast<BYTE*>(pDest->pData) + pDest->SlicePitch * z;
|
|
|
+ const BYTE* pSrcSlice = reinterpret_cast<const BYTE*>(pSrc->pData) + pSrc->SlicePitch * z;
|
|
|
+ for (UINT y = 0; y < NumRows; ++y)
|
|
|
+ {
|
|
|
+ memcpy(pDestSlice + pDest->RowPitch * y,
|
|
|
+ pSrcSlice + pSrc->RowPitch * 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)
|
|
|
+{
|
|
|
+ D3D12_RESOURCE_DESC Desc = pDestinationResource->GetDesc();
|
|
|
+ UINT64 RequiredSize = 0;
|
|
|
+
|
|
|
+ ID3D12Device* pDevice;
|
|
|
+ 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)
|
|
|
+{
|
|
|
+ // Minor validation
|
|
|
+ D3D12_RESOURCE_DESC IntermediateDesc = pIntermediate->GetDesc();
|
|
|
+ D3D12_RESOURCE_DESC 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, NULL, 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, pLayouts[i].Footprint.RowPitch * pNumRows[i] };
|
|
|
+ MemcpySubresource(&DestData, &pSrcData[i], (SIZE_T)pRowSizesInBytes[i], pNumRows[i], pLayouts[i].Footprint.Depth);
|
|
|
+ }
|
|
|
+ pIntermediate->Unmap(0, NULL);
|
|
|
+
|
|
|
+ if (DestinationDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER)
|
|
|
+ {
|
|
|
+ CD3DX12_BOX SrcBox(UINT(pLayouts[0].Offset), UINT(pLayouts[0].Offset + pLayouts[0].Footprint.Width));
|
|
|
+ pCmdList->CopyBufferRegion(
|
|
|
+ pDestinationResource, 0, pIntermediate, pLayouts[0].Offset, pLayouts[0].Footprint.Width);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ for (UINT i = 0; i < NumSubresources; ++i)
|
|
|
+ {
|
|
|
+ CD3DX12_TEXTURE_COPY_LOCATION Dst(pDestinationResource, i + FirstSubresource);
|
|
|
+ CD3DX12_TEXTURE_COPY_LOCATION Src(pIntermediate, pLayouts[i]);
|
|
|
+ pCmdList->CopyTextureRegion(&Dst, 0, 0, 0, &Src, nullptr);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return RequiredSize;
|
|
|
+}
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+// Heap-allocating UpdateSubresources implementation
|
|
|
+inline UINT64 UpdateSubresources(
|
|
|
+ _In_ ID3D12GraphicsCommandList* pCmdList,
|
|
|
+ _In_ ID3D12Resource* pDestinationResource,
|
|
|
+ _In_ ID3D12Resource* pIntermediate,
|
|
|
+ UINT64 IntermediateOffset,
|
|
|
+ _In_range_(0, D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
|
|
|
+ _In_range_(0, D3D12_REQ_SUBRESOURCES - FirstSubresource) UINT NumSubresources,
|
|
|
+ _In_reads_(NumSubresources) D3D12_SUBRESOURCE_DATA* pSrcData)
|
|
|
+{
|
|
|
+ UINT64 RequiredSize = 0;
|
|
|
+ UINT64 MemToAlloc = static_cast<UINT64>(sizeof(D3D12_PLACED_SUBRESOURCE_FOOTPRINT) + sizeof(UINT) + sizeof(UINT64)) * NumSubresources;
|
|
|
+ if (MemToAlloc > SIZE_MAX)
|
|
|
+ {
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ void* pMem = HeapAlloc(GetProcessHeap(), 0, static_cast<SIZE_T>(MemToAlloc));
|
|
|
+ if (pMem == NULL)
|
|
|
+ {
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ D3D12_PLACED_SUBRESOURCE_FOOTPRINT* pLayouts = reinterpret_cast<D3D12_PLACED_SUBRESOURCE_FOOTPRINT*>(pMem);
|
|
|
+ UINT64* pRowSizesInBytes = reinterpret_cast<UINT64*>(pLayouts + NumSubresources);
|
|
|
+ UINT* pNumRows = reinterpret_cast<UINT*>(pRowSizesInBytes + NumSubresources);
|
|
|
+
|
|
|
+ D3D12_RESOURCE_DESC Desc = pDestinationResource->GetDesc();
|
|
|
+ ID3D12Device* pDevice;
|
|
|
+ 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;
|
|
|
+}
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+// Stack-allocating UpdateSubresources implementation
|
|
|
+template <UINT MaxSubresources>
|
|
|
+inline UINT64 UpdateSubresources(
|
|
|
+ _In_ ID3D12GraphicsCommandList* pCmdList,
|
|
|
+ _In_ ID3D12Resource* pDestinationResource,
|
|
|
+ _In_ ID3D12Resource* pIntermediate,
|
|
|
+ UINT64 IntermediateOffset,
|
|
|
+ _In_range_(0, MaxSubresources) UINT FirstSubresource,
|
|
|
+ _In_range_(1, MaxSubresources - FirstSubresource) UINT NumSubresources,
|
|
|
+ _In_reads_(NumSubresources) D3D12_SUBRESOURCE_DATA* pSrcData)
|
|
|
+{
|
|
|
+ UINT64 RequiredSize = 0;
|
|
|
+ D3D12_PLACED_SUBRESOURCE_FOOTPRINT Layouts[MaxSubresources];
|
|
|
+ UINT NumRows[MaxSubresources];
|
|
|
+ UINT64 RowSizesInBytes[MaxSubresources];
|
|
|
+
|
|
|
+ D3D12_RESOURCE_DESC Desc = pDestinationResource->GetDesc();
|
|
|
+ ID3D12Device* pDevice;
|
|
|
+ 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);
|
|
|
+}
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+inline bool D3D12IsLayoutOpaque(D3D12_TEXTURE_LAYOUT Layout)
|
|
|
+{
|
|
|
+ return Layout == D3D12_TEXTURE_LAYOUT_UNKNOWN || Layout == D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE;
|
|
|
+}
|
|
|
+
|
|
|
+//------------------------------------------------------------------------------------------------
|
|
|
+inline ID3D12CommandList* const* CommandListCast(ID3D12GraphicsCommandList* const* pp)
|
|
|
+{
|
|
|
+ // This cast is useful for passing strongly typed command list pointers into
|
|
|
+ // ExecuteCommandLists.
|
|
|
+ // This cast is valid as long as the const-ness is respected. D3D12 APIs do
|
|
|
+ // respect the const-ness of their arguments.
|
|
|
+ return reinterpret_cast<ID3D12CommandList* const*>(pp);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+#endif // defined( __cplusplus )
|
|
|
+
|
|
|
+#endif //__D3DX12_H__
|
|
|
+
|
|
|
+
|
|
|
+
|
nicetry12138