mirror of
https://github.com/scratchfoundation/bgfx.git
synced 2024-12-11 00:31:28 -05:00
1508 lines
55 KiB
C++
1508 lines
55 KiB
C++
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// 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_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges)
|
|
{
|
|
Init(*this, numDescriptorRanges, _pDescriptorRanges);
|
|
}
|
|
|
|
static inline void Init(
|
|
_Out_ D3D12_ROOT_DESCRIPTOR_TABLE &rootDescriptorTable,
|
|
UINT numDescriptorRanges,
|
|
_In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges)
|
|
{
|
|
rootDescriptorTable.NumDescriptorRanges = numDescriptorRanges;
|
|
rootDescriptorTable.pDescriptorRanges = _pDescriptorRanges;
|
|
}
|
|
};
|
|
|
|
//------------------------------------------------------------------------------------------------
|
|
struct CD3DX12_ROOT_CONSTANTS : public D3D12_ROOT_CONSTANTS
|
|
{
|
|
CD3DX12_ROOT_CONSTANTS() {}
|
|
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(ID3D12Device), reinterpret_cast<void**>(&pDevice));
|
|
pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, 0, nullptr, nullptr, nullptr, &RequiredSize);
|
|
pDevice->Release();
|
|
|
|
return RequiredSize;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------------
|
|
// All arrays must be populated (e.g. by calling GetCopyableFootprints)
|
|
inline UINT64 UpdateSubresources(
|
|
_In_ ID3D12GraphicsCommandList* pCmdList,
|
|
_In_ ID3D12Resource* pDestinationResource,
|
|
_In_ ID3D12Resource* pIntermediate,
|
|
_In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
|
|
_In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources,
|
|
UINT64 RequiredSize,
|
|
_In_reads_(NumSubresources) const D3D12_PLACED_SUBRESOURCE_FOOTPRINT* pLayouts,
|
|
_In_reads_(NumSubresources) const UINT* pNumRows,
|
|
_In_reads_(NumSubresources) const UINT64* pRowSizesInBytes,
|
|
_In_reads_(NumSubresources) const D3D12_SUBRESOURCE_DATA* pSrcData)
|
|
{
|
|
// Minor validation
|
|
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(ID3D12Device), reinterpret_cast<void**>(&pDevice));
|
|
pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, IntermediateOffset, pLayouts, pNumRows, pRowSizesInBytes, &RequiredSize);
|
|
pDevice->Release();
|
|
|
|
UINT64 Result = UpdateSubresources(pCmdList, pDestinationResource, pIntermediate, FirstSubresource, NumSubresources, RequiredSize, pLayouts, pNumRows, pRowSizesInBytes, pSrcData);
|
|
HeapFree(GetProcessHeap(), 0, pMem);
|
|
return Result;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------------
|
|
// Stack-allocating UpdateSubresources implementation
|
|
template <UINT MaxSubresources>
|
|
inline UINT64 UpdateSubresources(
|
|
_In_ ID3D12GraphicsCommandList* pCmdList,
|
|
_In_ ID3D12Resource* pDestinationResource,
|
|
_In_ ID3D12Resource* pIntermediate,
|
|
UINT64 IntermediateOffset,
|
|
_In_range_(0, MaxSubresources) UINT FirstSubresource,
|
|
_In_range_(1, MaxSubresources - FirstSubresource) UINT NumSubresources,
|
|
_In_reads_(NumSubresources) D3D12_SUBRESOURCE_DATA* pSrcData)
|
|
{
|
|
UINT64 RequiredSize = 0;
|
|
D3D12_PLACED_SUBRESOURCE_FOOTPRINT Layouts[MaxSubresources];
|
|
UINT NumRows[MaxSubresources];
|
|
UINT64 RowSizesInBytes[MaxSubresources];
|
|
|
|
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__
|
|
|
|
|
|
|