|
|
@@ -1,1478 +0,0 @@
|
|
|
-//////////////////////////////////////////////////////////////////////////////
|
|
|
-//
|
|
|
-// 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(); }
|
|
|
-};
|
|
|
-
|
|
|
-//------------------------------------------------------------------------------------------------
|
|
|
-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 = {};
|
|
|
- D3D12_RESOURCE_BARRIER &barrier = result;
|
|
|
- result.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
|
|
|
- result.Flags = flags;
|
|
|
- barrier.Transition.pResource = pResource;
|
|
|
- barrier.Transition.StateBefore = stateBefore;
|
|
|
- barrier.Transition.StateAfter = stateAfter;
|
|
|
- barrier.Transition.Subresource = subresource;
|
|
|
- return result;
|
|
|
- }
|
|
|
- static inline CD3DX12_RESOURCE_BARRIER Aliasing(
|
|
|
- _In_ ID3D12Resource* pResourceBefore,
|
|
|
- _In_ ID3D12Resource* pResourceAfter)
|
|
|
- {
|
|
|
- CD3DX12_RESOURCE_BARRIER result = {};
|
|
|
- D3D12_RESOURCE_BARRIER &barrier = result;
|
|
|
- result.Type = D3D12_RESOURCE_BARRIER_TYPE_ALIASING;
|
|
|
- barrier.Aliasing.pResourceBefore = pResourceBefore;
|
|
|
- barrier.Aliasing.pResourceAfter = pResourceAfter;
|
|
|
- return result;
|
|
|
- }
|
|
|
- static inline CD3DX12_RESOURCE_BARRIER UAV(
|
|
|
- _In_ ID3D12Resource* pResource)
|
|
|
- {
|
|
|
- CD3DX12_RESOURCE_BARRIER result = {};
|
|
|
- D3D12_RESOURCE_BARRIER &barrier = result;
|
|
|
- result.Type = D3D12_RESOURCE_BARRIER_TYPE_UAV;
|
|
|
- barrier.UAV.pResource = pResource;
|
|
|
- return result;
|
|
|
- }
|
|
|
- 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);
|
|
|
- }
|
|
|
-
|
|
|
- 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;
|
|
|
- }
|
|
|
-
|
|
|
- CD3DX12_ROOT_SIGNATURE_DESC(CD3DX12_DEFAULT) : CD3DX12_ROOT_SIGNATURE_DESC(0,NULL,0,NULL,D3D12_ROOT_SIGNATURE_FLAG_NONE) {}
|
|
|
-};
|
|
|
-
|
|
|
-//------------------------------------------------------------------------------------------------
|
|
|
-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; }
|
|
|
-};
|
|
|
-
|
|
|
-//------------------------------------------------------------------------------------------------
|
|
|
-// 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__
|
|
|
-
|
|
|
-
|
|
|
-
|
Ivan Safrin