summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/bgfx/src/renderer_d3d12.cpp
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/bgfx/src/renderer_d3d12.cpp')
-rw-r--r--3rdparty/bgfx/src/renderer_d3d12.cpp5002
1 files changed, 5001 insertions, 1 deletions
diff --git a/3rdparty/bgfx/src/renderer_d3d12.cpp b/3rdparty/bgfx/src/renderer_d3d12.cpp
index b41207cbc31..902eb8b4610 100644
--- a/3rdparty/bgfx/src/renderer_d3d12.cpp
+++ b/3rdparty/bgfx/src/renderer_d3d12.cpp
@@ -6,7 +6,5007 @@
#include "bgfx_p.h"
#if BGFX_CONFIG_RENDERER_DIRECT3D12
-# include "../../d3d12/src/renderer_d3d12.cpp"
+# include "renderer_d3d12.h"
+
+# if !USE_D3D12_DYNAMIC_LIB
+# pragma comment(lib, "D3D12.lib")
+# endif // !USE_D3D12_DYNAMIC_LIB
+
+namespace bgfx { namespace d3d12
+{
+ static wchar_t s_viewNameW[BGFX_CONFIG_MAX_VIEWS][256];
+
+ struct PrimInfo
+ {
+ D3D_PRIMITIVE_TOPOLOGY m_toplogy;
+ D3D12_PRIMITIVE_TOPOLOGY_TYPE m_topologyType;
+ uint32_t m_min;
+ uint32_t m_div;
+ uint32_t m_sub;
+ };
+
+ static const PrimInfo s_primInfo[] =
+ {
+ { D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST, D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE, 3, 3, 0 },
+ { D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP, D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE, 3, 1, 2 },
+ { D3D_PRIMITIVE_TOPOLOGY_LINELIST, D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE, 2, 2, 0 },
+ { D3D_PRIMITIVE_TOPOLOGY_POINTLIST, D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT, 1, 1, 0 },
+ { D3D_PRIMITIVE_TOPOLOGY_UNDEFINED, D3D12_PRIMITIVE_TOPOLOGY_TYPE_UNDEFINED, 0, 0, 0 },
+ };
+
+ static const char* s_primName[] =
+ {
+ "TriList",
+ "TriStrip",
+ "Line",
+ "Point",
+ };
+ BX_STATIC_ASSERT(BX_COUNTOF(s_primInfo) == BX_COUNTOF(s_primName)+1);
+
+ static const uint32_t s_checkMsaa[] =
+ {
+ 0,
+ 2,
+ 4,
+ 8,
+ 16,
+ };
+
+ static DXGI_SAMPLE_DESC s_msaa[] =
+ {
+ { 1, 0 },
+ { 2, 0 },
+ { 4, 0 },
+ { 8, 0 },
+ { 16, 0 },
+ };
+
+ static const D3D12_BLEND s_blendFactor[][2] =
+ {
+ { (D3D12_BLEND)0, (D3D12_BLEND)0 }, // ignored
+ { D3D12_BLEND_ZERO, D3D12_BLEND_ZERO }, // ZERO
+ { D3D12_BLEND_ONE, D3D12_BLEND_ONE }, // ONE
+ { D3D12_BLEND_SRC_COLOR, D3D12_BLEND_SRC_ALPHA }, // SRC_COLOR
+ { D3D12_BLEND_INV_SRC_COLOR, D3D12_BLEND_INV_SRC_ALPHA }, // INV_SRC_COLOR
+ { D3D12_BLEND_SRC_ALPHA, D3D12_BLEND_SRC_ALPHA }, // SRC_ALPHA
+ { D3D12_BLEND_INV_SRC_ALPHA, D3D12_BLEND_INV_SRC_ALPHA }, // INV_SRC_ALPHA
+ { D3D12_BLEND_DEST_ALPHA, D3D12_BLEND_DEST_ALPHA }, // DST_ALPHA
+ { D3D12_BLEND_INV_DEST_ALPHA, D3D12_BLEND_INV_DEST_ALPHA }, // INV_DST_ALPHA
+ { D3D12_BLEND_DEST_COLOR, D3D12_BLEND_DEST_ALPHA }, // DST_COLOR
+ { D3D12_BLEND_INV_DEST_COLOR, D3D12_BLEND_INV_DEST_ALPHA }, // INV_DST_COLOR
+ { D3D12_BLEND_SRC_ALPHA_SAT, D3D12_BLEND_ONE }, // SRC_ALPHA_SAT
+ { D3D12_BLEND_BLEND_FACTOR, D3D12_BLEND_BLEND_FACTOR }, // FACTOR
+ { D3D12_BLEND_INV_BLEND_FACTOR, D3D12_BLEND_INV_BLEND_FACTOR }, // INV_FACTOR
+ };
+
+ static const D3D12_BLEND_OP s_blendEquation[] =
+ {
+ D3D12_BLEND_OP_ADD,
+ D3D12_BLEND_OP_SUBTRACT,
+ D3D12_BLEND_OP_REV_SUBTRACT,
+ D3D12_BLEND_OP_MIN,
+ D3D12_BLEND_OP_MAX,
+ };
+
+ static const D3D12_COMPARISON_FUNC s_cmpFunc[] =
+ {
+ D3D12_COMPARISON_FUNC(0), // ignored
+ D3D12_COMPARISON_FUNC_LESS,
+ D3D12_COMPARISON_FUNC_LESS_EQUAL,
+ D3D12_COMPARISON_FUNC_EQUAL,
+ D3D12_COMPARISON_FUNC_GREATER_EQUAL,
+ D3D12_COMPARISON_FUNC_GREATER,
+ D3D12_COMPARISON_FUNC_NOT_EQUAL,
+ D3D12_COMPARISON_FUNC_NEVER,
+ D3D12_COMPARISON_FUNC_ALWAYS,
+ };
+
+ static const D3D12_STENCIL_OP s_stencilOp[] =
+ {
+ D3D12_STENCIL_OP_ZERO,
+ D3D12_STENCIL_OP_KEEP,
+ D3D12_STENCIL_OP_REPLACE,
+ D3D12_STENCIL_OP_INCR,
+ D3D12_STENCIL_OP_INCR_SAT,
+ D3D12_STENCIL_OP_DECR,
+ D3D12_STENCIL_OP_DECR_SAT,
+ D3D12_STENCIL_OP_INVERT,
+ };
+
+ static const D3D12_CULL_MODE s_cullMode[] =
+ {
+ D3D12_CULL_MODE_NONE,
+ D3D12_CULL_MODE_FRONT,
+ D3D12_CULL_MODE_BACK,
+ };
+
+ static const D3D12_TEXTURE_ADDRESS_MODE s_textureAddress[] =
+ {
+ D3D12_TEXTURE_ADDRESS_MODE_WRAP,
+ D3D12_TEXTURE_ADDRESS_MODE_MIRROR,
+ D3D12_TEXTURE_ADDRESS_MODE_CLAMP,
+ D3D12_TEXTURE_ADDRESS_MODE_BORDER,
+ };
+
+ /*
+ * D3D11_FILTER_MIN_MAG_MIP_POINT = 0x00,
+ * D3D11_FILTER_MIN_MAG_POINT_MIP_LINEAR = 0x01,
+ * D3D11_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x04,
+ * D3D11_FILTER_MIN_POINT_MAG_MIP_LINEAR = 0x05,
+ * D3D11_FILTER_MIN_LINEAR_MAG_MIP_POINT = 0x10,
+ * D3D11_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x11,
+ * D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT = 0x14,
+ * D3D11_FILTER_MIN_MAG_MIP_LINEAR = 0x15,
+ * D3D11_FILTER_ANISOTROPIC = 0x55,
+ *
+ * D3D11_COMPARISON_FILTERING_BIT = 0x80,
+ * D3D11_ANISOTROPIC_FILTERING_BIT = 0x40,
+ *
+ * According to D3D11_FILTER enum bits for mip, mag and mip are:
+ * 0x10 // MIN_LINEAR
+ * 0x04 // MAG_LINEAR
+ * 0x01 // MIP_LINEAR
+ */
+
+ static const uint8_t s_textureFilter[3][3] =
+ {
+ {
+ 0x10, // min linear
+ 0x00, // min point
+ 0x55, // anisotropic
+ },
+ {
+ 0x04, // mag linear
+ 0x00, // mag point
+ 0x55, // anisotropic
+ },
+ {
+ 0x01, // mip linear
+ 0x00, // mip point
+ 0x55, // anisotropic
+ },
+ };
+
+ struct TextureFormatInfo
+ {
+ DXGI_FORMAT m_fmt;
+ DXGI_FORMAT m_fmtSrv;
+ DXGI_FORMAT m_fmtDsv;
+ DXGI_FORMAT m_fmtSrgb;
+ };
+
+ static const TextureFormatInfo s_textureFormat[] =
+ {
+ { DXGI_FORMAT_BC1_UNORM, DXGI_FORMAT_BC1_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_BC1_UNORM_SRGB }, // BC1
+ { DXGI_FORMAT_BC2_UNORM, DXGI_FORMAT_BC2_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_BC2_UNORM_SRGB }, // BC2
+ { DXGI_FORMAT_BC3_UNORM, DXGI_FORMAT_BC3_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_BC3_UNORM_SRGB }, // BC3
+ { DXGI_FORMAT_BC4_UNORM, DXGI_FORMAT_BC4_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // BC4
+ { DXGI_FORMAT_BC5_UNORM, DXGI_FORMAT_BC5_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // BC5
+ { DXGI_FORMAT_BC6H_SF16, DXGI_FORMAT_BC6H_SF16, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // BC6H
+ { DXGI_FORMAT_BC7_UNORM, DXGI_FORMAT_BC7_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_BC7_UNORM_SRGB }, // BC7
+ { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // ETC1
+ { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // ETC2
+ { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // ETC2A
+ { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // ETC2A1
+ { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // PTC12
+ { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // PTC14
+ { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // PTC12A
+ { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // PTC14A
+ { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // PTC22
+ { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // PTC24
+ { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // Unknown
+ { DXGI_FORMAT_R1_UNORM, DXGI_FORMAT_R1_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // R1
+ { DXGI_FORMAT_A8_UNORM, DXGI_FORMAT_A8_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // A8
+ { DXGI_FORMAT_R8_UNORM, DXGI_FORMAT_R8_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // R8
+ { DXGI_FORMAT_R8_SINT, DXGI_FORMAT_R8_SINT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // R8I
+ { DXGI_FORMAT_R8_UINT, DXGI_FORMAT_R8_UINT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // R8U
+ { DXGI_FORMAT_R8_SNORM, DXGI_FORMAT_R8_SNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // R8S
+ { DXGI_FORMAT_R16_UNORM, DXGI_FORMAT_R16_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // R16
+ { DXGI_FORMAT_R16_SINT, DXGI_FORMAT_R16_SINT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // R16I
+ { DXGI_FORMAT_R16_UNORM, DXGI_FORMAT_R16_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // R16U
+ { DXGI_FORMAT_R16_FLOAT, DXGI_FORMAT_R16_FLOAT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // R16F
+ { DXGI_FORMAT_R16_SNORM, DXGI_FORMAT_R16_SNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // R16S
+ { DXGI_FORMAT_R32_SINT, DXGI_FORMAT_R32_SINT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // R32I
+ { DXGI_FORMAT_R32_UINT, DXGI_FORMAT_R32_UINT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // R32U
+ { DXGI_FORMAT_R32_FLOAT, DXGI_FORMAT_R32_FLOAT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // R32F
+ { DXGI_FORMAT_R8G8_UNORM, DXGI_FORMAT_R8G8_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RG8
+ { DXGI_FORMAT_R8G8_SINT, DXGI_FORMAT_R8G8_SINT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RG8I
+ { DXGI_FORMAT_R8G8_UINT, DXGI_FORMAT_R8G8_UINT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RG8U
+ { DXGI_FORMAT_R8G8_SNORM, DXGI_FORMAT_R8G8_SNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RG8S
+ { DXGI_FORMAT_R16G16_UNORM, DXGI_FORMAT_R16G16_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RG16
+ { DXGI_FORMAT_R16G16_SINT, DXGI_FORMAT_R16G16_SINT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RG16I
+ { DXGI_FORMAT_R16G16_UINT, DXGI_FORMAT_R16G16_UINT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RG16U
+ { DXGI_FORMAT_R16G16_FLOAT, DXGI_FORMAT_R16G16_FLOAT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RG16F
+ { DXGI_FORMAT_R16G16_SNORM, DXGI_FORMAT_R16G16_SNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RG16S
+ { DXGI_FORMAT_R32G32_SINT, DXGI_FORMAT_R32G32_SINT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RG32I
+ { DXGI_FORMAT_R32G32_UINT, DXGI_FORMAT_R32G32_UINT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RG32U
+ { DXGI_FORMAT_R32G32_FLOAT, DXGI_FORMAT_R32G32_FLOAT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RG32F
+ { DXGI_FORMAT_R9G9B9E5_SHAREDEXP, DXGI_FORMAT_R9G9B9E5_SHAREDEXP, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RGB9E5F
+ { DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_B8G8R8A8_UNORM_SRGB }, // BGRA8
+ { DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R8G8B8A8_UNORM_SRGB }, // RGBA8
+ { DXGI_FORMAT_R8G8B8A8_SINT, DXGI_FORMAT_R8G8B8A8_SINT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R8G8B8A8_UNORM_SRGB }, // RGBA8I
+ { DXGI_FORMAT_R8G8B8A8_UINT, DXGI_FORMAT_R8G8B8A8_UINT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R8G8B8A8_UNORM_SRGB }, // RGBA8U
+ { DXGI_FORMAT_R8G8B8A8_SNORM, DXGI_FORMAT_R8G8B8A8_SNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RGBA8S
+ { DXGI_FORMAT_R16G16B16A16_UNORM, DXGI_FORMAT_R16G16B16A16_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RGBA16
+ { DXGI_FORMAT_R16G16B16A16_SINT, DXGI_FORMAT_R16G16B16A16_SINT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RGBA16I
+ { DXGI_FORMAT_R16G16B16A16_UINT, DXGI_FORMAT_R16G16B16A16_UINT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RGBA16U
+ { DXGI_FORMAT_R16G16B16A16_FLOAT, DXGI_FORMAT_R16G16B16A16_FLOAT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RGBA16F
+ { DXGI_FORMAT_R16G16B16A16_SNORM, DXGI_FORMAT_R16G16B16A16_SNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RGBA16S
+ { DXGI_FORMAT_R32G32B32A32_SINT, DXGI_FORMAT_R32G32B32A32_SINT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RGBA32I
+ { DXGI_FORMAT_R32G32B32A32_UINT, DXGI_FORMAT_R32G32B32A32_UINT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RGBA32U
+ { DXGI_FORMAT_R32G32B32A32_FLOAT, DXGI_FORMAT_R32G32B32A32_FLOAT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RGBA32F
+ { DXGI_FORMAT_B5G6R5_UNORM, DXGI_FORMAT_B5G6R5_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // R5G6B5
+ { DXGI_FORMAT_B4G4R4A4_UNORM, DXGI_FORMAT_B4G4R4A4_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RGBA4
+ { DXGI_FORMAT_B5G5R5A1_UNORM, DXGI_FORMAT_B5G5R5A1_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RGB5A1
+ { DXGI_FORMAT_R10G10B10A2_UNORM, DXGI_FORMAT_R10G10B10A2_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // RGB10A2
+ { DXGI_FORMAT_R11G11B10_FLOAT, DXGI_FORMAT_R11G11B10_FLOAT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // R11G11B10F
+ { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // UnknownDepth
+ { DXGI_FORMAT_R16_TYPELESS, DXGI_FORMAT_R16_UNORM, DXGI_FORMAT_D16_UNORM, DXGI_FORMAT_UNKNOWN }, // D16
+ { DXGI_FORMAT_R24G8_TYPELESS, DXGI_FORMAT_R24_UNORM_X8_TYPELESS, DXGI_FORMAT_D24_UNORM_S8_UINT, DXGI_FORMAT_UNKNOWN }, // D24
+ { DXGI_FORMAT_R24G8_TYPELESS, DXGI_FORMAT_R24_UNORM_X8_TYPELESS, DXGI_FORMAT_D24_UNORM_S8_UINT, DXGI_FORMAT_UNKNOWN }, // D24S8
+ { DXGI_FORMAT_R24G8_TYPELESS, DXGI_FORMAT_R24_UNORM_X8_TYPELESS, DXGI_FORMAT_D24_UNORM_S8_UINT, DXGI_FORMAT_UNKNOWN }, // D32
+ { DXGI_FORMAT_R32_TYPELESS, DXGI_FORMAT_R32_FLOAT, DXGI_FORMAT_D32_FLOAT, DXGI_FORMAT_UNKNOWN }, // D16F
+ { DXGI_FORMAT_R32_TYPELESS, DXGI_FORMAT_R32_FLOAT, DXGI_FORMAT_D32_FLOAT, DXGI_FORMAT_UNKNOWN }, // D24F
+ { DXGI_FORMAT_R32_TYPELESS, DXGI_FORMAT_R32_FLOAT, DXGI_FORMAT_D32_FLOAT, DXGI_FORMAT_UNKNOWN }, // D32F
+ { DXGI_FORMAT_R24G8_TYPELESS, DXGI_FORMAT_R24_UNORM_X8_TYPELESS, DXGI_FORMAT_D24_UNORM_S8_UINT, DXGI_FORMAT_UNKNOWN }, // D0S8
+ };
+ BX_STATIC_ASSERT(TextureFormat::Count == BX_COUNTOF(s_textureFormat) );
+
+ static const D3D12_INPUT_ELEMENT_DESC s_attrib[] =
+ {
+ { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
+ { "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
+ { "TANGENT", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
+ { "BITANGENT", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
+ { "COLOR", 0, DXGI_FORMAT_R8G8B8A8_UINT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
+ { "COLOR", 1, DXGI_FORMAT_R8G8B8A8_UINT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
+ { "BLENDINDICES", 0, DXGI_FORMAT_R8G8B8A8_UINT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
+ { "BLENDWEIGHT", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
+ { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
+ { "TEXCOORD", 1, DXGI_FORMAT_R32G32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
+ { "TEXCOORD", 2, DXGI_FORMAT_R32G32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
+ { "TEXCOORD", 3, DXGI_FORMAT_R32G32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
+ { "TEXCOORD", 4, DXGI_FORMAT_R32G32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
+ { "TEXCOORD", 5, DXGI_FORMAT_R32G32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
+ { "TEXCOORD", 6, DXGI_FORMAT_R32G32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
+ { "TEXCOORD", 7, DXGI_FORMAT_R32G32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
+ };
+ BX_STATIC_ASSERT(Attrib::Count == BX_COUNTOF(s_attrib) );
+
+ static const DXGI_FORMAT s_attribType[][4][2] =
+ {
+ { // Uint8
+ { DXGI_FORMAT_R8_UINT, DXGI_FORMAT_R8_UNORM },
+ { DXGI_FORMAT_R8G8_UINT, DXGI_FORMAT_R8G8_UNORM },
+ { DXGI_FORMAT_R8G8B8A8_UINT, DXGI_FORMAT_R8G8B8A8_UNORM },
+ { DXGI_FORMAT_R8G8B8A8_UINT, DXGI_FORMAT_R8G8B8A8_UNORM },
+ },
+ { // Uint10
+ { DXGI_FORMAT_R10G10B10A2_UINT, DXGI_FORMAT_R10G10B10A2_UNORM },
+ { DXGI_FORMAT_R10G10B10A2_UINT, DXGI_FORMAT_R10G10B10A2_UNORM },
+ { DXGI_FORMAT_R10G10B10A2_UINT, DXGI_FORMAT_R10G10B10A2_UNORM },
+ { DXGI_FORMAT_R10G10B10A2_UINT, DXGI_FORMAT_R10G10B10A2_UNORM },
+ },
+ { // Int16
+ { DXGI_FORMAT_R16_SINT, DXGI_FORMAT_R16_SNORM },
+ { DXGI_FORMAT_R16G16_SINT, DXGI_FORMAT_R16G16_SNORM },
+ { DXGI_FORMAT_R16G16B16A16_SINT, DXGI_FORMAT_R16G16B16A16_SNORM },
+ { DXGI_FORMAT_R16G16B16A16_SINT, DXGI_FORMAT_R16G16B16A16_SNORM },
+ },
+ { // Half
+ { DXGI_FORMAT_R16_FLOAT, DXGI_FORMAT_R16_FLOAT },
+ { DXGI_FORMAT_R16G16_FLOAT, DXGI_FORMAT_R16G16_FLOAT },
+ { DXGI_FORMAT_R16G16B16A16_FLOAT, DXGI_FORMAT_R16G16B16A16_FLOAT },
+ { DXGI_FORMAT_R16G16B16A16_FLOAT, DXGI_FORMAT_R16G16B16A16_FLOAT },
+ },
+ { // Float
+ { DXGI_FORMAT_R32_FLOAT, DXGI_FORMAT_R32_FLOAT },
+ { DXGI_FORMAT_R32G32_FLOAT, DXGI_FORMAT_R32G32_FLOAT },
+ { DXGI_FORMAT_R32G32B32_FLOAT, DXGI_FORMAT_R32G32B32_FLOAT },
+ { DXGI_FORMAT_R32G32B32A32_FLOAT, DXGI_FORMAT_R32G32B32A32_FLOAT },
+ },
+ };
+ BX_STATIC_ASSERT(AttribType::Count == BX_COUNTOF(s_attribType) );
+
+ static D3D12_INPUT_ELEMENT_DESC* fillVertexDecl(D3D12_INPUT_ELEMENT_DESC* _out, const VertexDecl& _decl)
+ {
+ D3D12_INPUT_ELEMENT_DESC* elem = _out;
+
+ for (uint32_t attr = 0; attr < Attrib::Count; ++attr)
+ {
+ if (UINT16_MAX != _decl.m_attributes[attr])
+ {
+ memcpy(elem, &s_attrib[attr], sizeof(D3D12_INPUT_ELEMENT_DESC) );
+
+ if (0 == _decl.m_attributes[attr])
+ {
+ elem->AlignedByteOffset = 0;
+ }
+ else
+ {
+ uint8_t num;
+ AttribType::Enum type;
+ bool normalized;
+ bool asInt;
+ _decl.decode(Attrib::Enum(attr), num, type, normalized, asInt);
+ elem->Format = s_attribType[type][num-1][normalized];
+ elem->AlignedByteOffset = _decl.m_offset[attr];
+ }
+
+ ++elem;
+ }
+ }
+
+ return elem;
+ }
+
+ void setResourceBarrier(ID3D12GraphicsCommandList* _commandList, const ID3D12Resource* _resource, D3D12_RESOURCE_STATES _stateBefore, D3D12_RESOURCE_STATES _stateAfter)
+ {
+ D3D12_RESOURCE_BARRIER barrier;
+ barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
+ barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
+ barrier.Transition.pResource = const_cast<ID3D12Resource*>(_resource);
+ barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
+ barrier.Transition.StateBefore = _stateBefore;
+ barrier.Transition.StateAfter = _stateAfter;
+ _commandList->ResourceBarrier(1, &barrier);
+ }
+
+ static const GUID IID_ID3D12CommandAllocator = { 0x6102dee4, 0xaf59, 0x4b09, { 0xb9, 0x99, 0xb4, 0x4d, 0x73, 0xf0, 0x9b, 0x24 } };
+ static const GUID IID_ID3D12CommandQueue = { 0x0ec870a6, 0x5d7e, 0x4c22, { 0x8c, 0xfc, 0x5b, 0xaa, 0xe0, 0x76, 0x16, 0xed } };
+ static const GUID IID_ID3D12CommandSignature = { 0xc36a797c, 0xec80, 0x4f0a, { 0x89, 0x85, 0xa7, 0xb2, 0x47, 0x50, 0x82, 0xd1 } };
+ static const GUID IID_ID3D12Debug = { 0x344488b7, 0x6846, 0x474b, { 0xb9, 0x89, 0xf0, 0x27, 0x44, 0x82, 0x45, 0xe0 } };
+ static const GUID IID_ID3D12DescriptorHeap = { 0x8efb471d, 0x616c, 0x4f49, { 0x90, 0xf7, 0x12, 0x7b, 0xb7, 0x63, 0xfa, 0x51 } };
+ static const GUID IID_ID3D12Device = { 0x189819f1, 0x1db6, 0x4b57, { 0xbe, 0x54, 0x18, 0x21, 0x33, 0x9b, 0x85, 0xf7 } };
+ static const GUID IID_ID3D12Fence = { 0x0a753dcf, 0xc4d8, 0x4b91, { 0xad, 0xf6, 0xbe, 0x5a, 0x60, 0xd9, 0x5a, 0x76 } };
+ static const GUID IID_ID3D12GraphicsCommandList = { 0x5b160d0f, 0xac1b, 0x4185, { 0x8b, 0xa8, 0xb3, 0xae, 0x42, 0xa5, 0xa4, 0x55 } };
+ static const GUID IID_ID3D12InfoQueue = { 0x0742a90b, 0xc387, 0x483f, { 0xb9, 0x46, 0x30, 0xa7, 0xe4, 0xe6, 0x14, 0x58 } };
+ static const GUID IID_ID3D12PipelineState = { 0x765a30f3, 0xf624, 0x4c6f, { 0xa8, 0x28, 0xac, 0xe9, 0x48, 0x62, 0x24, 0x45 } };
+ static const GUID IID_ID3D12Resource = { 0x696442be, 0xa72e, 0x4059, { 0xbc, 0x79, 0x5b, 0x5c, 0x98, 0x04, 0x0f, 0xad } };
+ static const GUID IID_ID3D12RootSignature = { 0xc54a6b66, 0x72df, 0x4ee8, { 0x8b, 0xe5, 0xa9, 0x46, 0xa1, 0x42, 0x92, 0x14 } };
+ static const GUID IID_IDXGIFactory4 = { 0x1bc6ea02, 0xef36, 0x464f, { 0xbf, 0x0c, 0x21, 0xca, 0x39, 0xe5, 0x16, 0x8a } };
+
+ struct HeapProperty
+ {
+ enum Enum
+ {
+ Default,
+ Upload,
+ ReadBack,
+
+ Count
+ };
+
+ D3D12_HEAP_PROPERTIES m_properties;
+ D3D12_RESOURCE_STATES m_state;
+ };
+
+ static const HeapProperty s_heapProperties[] =
+ {
+ { { D3D12_HEAP_TYPE_DEFAULT, D3D12_CPU_PAGE_PROPERTY_UNKNOWN, D3D12_MEMORY_POOL_UNKNOWN, 1, 1 }, D3D12_RESOURCE_STATE_COMMON },
+ { { D3D12_HEAP_TYPE_UPLOAD, D3D12_CPU_PAGE_PROPERTY_UNKNOWN, D3D12_MEMORY_POOL_UNKNOWN, 1, 1 }, D3D12_RESOURCE_STATE_GENERIC_READ },
+ { { D3D12_HEAP_TYPE_READBACK, D3D12_CPU_PAGE_PROPERTY_UNKNOWN, D3D12_MEMORY_POOL_UNKNOWN, 1, 1 }, D3D12_RESOURCE_STATE_COPY_DEST },
+ };
+ BX_STATIC_ASSERT(BX_COUNTOF(s_heapProperties) == HeapProperty::Count);
+
+ ID3D12Resource* createCommittedResource(ID3D12Device* _device, HeapProperty::Enum _heapProperty, D3D12_RESOURCE_DESC* _resourceDesc, D3D12_CLEAR_VALUE* _clearValue)
+ {
+ const HeapProperty& heapProperty = s_heapProperties[_heapProperty];
+ ID3D12Resource* resource;
+ DX_CHECK(_device->CreateCommittedResource(&heapProperty.m_properties
+ , D3D12_HEAP_FLAG_NONE
+ , _resourceDesc
+ , heapProperty.m_state
+ , _clearValue
+ , IID_ID3D12Resource
+ , (void**)&resource
+ ) );
+ BX_WARN(NULL != resource, "CreateCommittedResource failed (size: %d). Out of memory?"
+ , _resourceDesc->Width
+ );
+
+ return resource;
+ }
+
+ ID3D12Resource* createCommittedResource(ID3D12Device* _device, HeapProperty::Enum _heapProperty, uint64_t _size, D3D12_RESOURCE_FLAGS _flags = D3D12_RESOURCE_FLAG_NONE)
+ {
+ D3D12_RESOURCE_DESC resourceDesc;
+ resourceDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
+ resourceDesc.Alignment = 0;
+ resourceDesc.Width = _size;
+ resourceDesc.Height = 1;
+ resourceDesc.DepthOrArraySize = 1;
+ resourceDesc.MipLevels = 1;
+ resourceDesc.Format = DXGI_FORMAT_UNKNOWN;
+ resourceDesc.SampleDesc.Count = 1;
+ resourceDesc.SampleDesc.Quality = 0;
+ resourceDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
+ resourceDesc.Flags = _flags;
+
+ return createCommittedResource(_device, _heapProperty, &resourceDesc, NULL);
+ }
+
+ BX_NO_INLINE void setDebugObjectName(ID3D12Object* _object, const char* _format, ...)
+ {
+ if (BX_ENABLED(BGFX_CONFIG_DEBUG_OBJECT_NAME) )
+ {
+ char temp[2048];
+ va_list argList;
+ va_start(argList, _format);
+ int size = bx::uint32_min(sizeof(temp)-1, vsnprintf(temp, sizeof(temp), _format, argList) );
+ va_end(argList);
+ temp[size] = '\0';
+
+ wchar_t* wtemp = (wchar_t*)alloca( (size+1)*2);
+ mbstowcs(wtemp, temp, size+1);
+ _object->SetName(wtemp);
+ }
+ }
+
+#if USE_D3D12_DYNAMIC_LIB
+ static PFN_D3D12_CREATE_DEVICE D3D12CreateDevice;
+ static PFN_D3D12_GET_DEBUG_INTERFACE D3D12GetDebugInterface;
+ static PFN_D3D12_SERIALIZE_ROOT_SIGNATURE D3D12SerializeRootSignature;
+ static PFN_CREATE_DXGI_FACTORY CreateDXGIFactory1;
+
+ typedef HANDLE (WINAPI* PFN_CREATE_EVENT_EX_A)(LPSECURITY_ATTRIBUTES _attrs, LPCSTR _name, DWORD _flags, DWORD _access);
+ static PFN_CREATE_EVENT_EX_A CreateEventExA;
+#endif // USE_D3D12_DYNAMIC_LIB
+
+ struct RendererContextD3D12 : public RendererContextI
+ {
+ RendererContextD3D12()
+ : m_wireframe(false)
+ , m_flags(BGFX_RESET_NONE)
+ , m_maxAnisotropy(1)
+ , m_fsChanges(0)
+ , m_vsChanges(0)
+ , m_backBufferColorIdx(0)
+ , m_rtMsaa(false)
+ {
+ }
+
+ ~RendererContextD3D12()
+ {
+ }
+
+ bool init()
+ {
+ struct ErrorState
+ {
+ enum Enum
+ {
+ Default,
+ LoadedKernel32,
+ LoadedD3D12,
+ LoadedDXGI,
+ CreatedDXGIFactory,
+ CreatedCommandQueue,
+ };
+ };
+
+ ErrorState::Enum errorState = ErrorState::Default;
+ LUID luid;
+
+ m_fbh.idx = invalidHandle;
+ memset(m_uniforms, 0, sizeof(m_uniforms) );
+ memset(&m_resolution, 0, sizeof(m_resolution) );
+
+#if USE_D3D12_DYNAMIC_LIB
+ m_kernel32dll = bx::dlopen("kernel32.dll");
+ BX_WARN(NULL != m_kernel32dll, "Failed to load kernel32.dll.");
+ if (NULL == m_kernel32dll)
+ {
+ goto error;
+ }
+
+ CreateEventExA = (PFN_CREATE_EVENT_EX_A)bx::dlsym(m_kernel32dll, "CreateEventExA");
+ BX_WARN(NULL != CreateEventExA, "Function CreateEventExA not found.");
+ if (NULL == CreateEventExA)
+ {
+ goto error;
+ }
+
+ errorState = ErrorState::LoadedKernel32;
+
+ m_d3d12dll = bx::dlopen("d3d12.dll");
+ BX_WARN(NULL != m_d3d12dll, "Failed to load d3d12.dll.");
+ if (NULL == m_d3d12dll)
+ {
+ goto error;
+ }
+
+ errorState = ErrorState::LoadedD3D12;
+
+ D3D12CreateDevice = (PFN_D3D12_CREATE_DEVICE)bx::dlsym(m_d3d12dll, "D3D12CreateDevice");
+ BX_WARN(NULL != D3D12CreateDevice, "Function D3D12CreateDevice not found.");
+
+ D3D12GetDebugInterface = (PFN_D3D12_GET_DEBUG_INTERFACE)bx::dlsym(m_d3d12dll, "D3D12GetDebugInterface");
+ BX_WARN(NULL != D3D12GetDebugInterface, "Function D3D12GetDebugInterface not found.");
+
+ D3D12SerializeRootSignature = (PFN_D3D12_SERIALIZE_ROOT_SIGNATURE)bx::dlsym(m_d3d12dll, "D3D12SerializeRootSignature");
+ BX_WARN(NULL != D3D12SerializeRootSignature, "Function D3D12SerializeRootSignature not found.");
+
+ if (NULL == D3D12CreateDevice
+ || NULL == D3D12GetDebugInterface
+ || NULL == D3D12SerializeRootSignature)
+ {
+ goto error;
+ }
+
+ m_dxgidll = bx::dlopen("dxgi.dll");
+ BX_WARN(NULL != m_dxgidll, "Failed to load dxgi.dll.");
+
+ if (NULL == m_dxgidll)
+ {
+ goto error;
+ }
+
+ CreateDXGIFactory1 = (PFN_CREATE_DXGI_FACTORY)bx::dlsym(m_dxgidll, "CreateDXGIFactory1");
+ BX_WARN(NULL != CreateDXGIFactory1, "Function CreateDXGIFactory1 not found.");
+
+ if (NULL == CreateDXGIFactory1)
+ {
+ goto error;
+ }
+#endif // USE_D3D12_DYNAMIC_LIB
+
+ errorState = ErrorState::LoadedDXGI;
+
+ HRESULT hr;
+
+ hr = CreateDXGIFactory1(IID_IDXGIFactory4, (void**)&m_factory);
+ BX_WARN(SUCCEEDED(hr), "Unable to create DXGI factory.");
+
+ if (FAILED(hr) )
+ {
+ goto error;
+ }
+
+ errorState = ErrorState::CreatedDXGIFactory;
+
+ m_adapter = NULL;
+ m_driverType = D3D_DRIVER_TYPE_HARDWARE;
+
+ {
+ IDXGIAdapter3* adapter;
+ for (uint32_t ii = 0; DXGI_ERROR_NOT_FOUND != m_factory->EnumAdapters(ii, reinterpret_cast<IDXGIAdapter**>(&adapter) ); ++ii)
+ {
+ DXGI_ADAPTER_DESC desc;
+ hr = adapter->GetDesc(&desc);
+ if (SUCCEEDED(hr) )
+ {
+ BX_TRACE("Adapter #%d", ii);
+
+ char description[BX_COUNTOF(desc.Description)];
+ wcstombs(description, desc.Description, BX_COUNTOF(desc.Description) );
+ BX_TRACE("\tDescription: %s", description);
+ BX_TRACE("\tVendorId: 0x%08x, DeviceId: 0x%08x, SubSysId: 0x%08x, Revision: 0x%08x"
+ , desc.VendorId
+ , desc.DeviceId
+ , desc.SubSysId
+ , desc.Revision
+ );
+ BX_TRACE("\tMemory: %" PRIi64 " (video), %" PRIi64 " (system), %" PRIi64 " (shared)"
+ , desc.DedicatedVideoMemory
+ , desc.DedicatedSystemMemory
+ , desc.SharedSystemMemory
+ );
+
+ g_caps.gpu[ii].vendorId = (uint16_t)desc.VendorId;
+ g_caps.gpu[ii].deviceId = (uint16_t)desc.DeviceId;
+ ++g_caps.numGPUs;
+
+ if ( (BGFX_PCI_ID_NONE != g_caps.vendorId || 0 != g_caps.deviceId)
+ && (BGFX_PCI_ID_NONE == g_caps.vendorId || desc.VendorId == g_caps.vendorId)
+ && (0 == g_caps.deviceId || desc.DeviceId == g_caps.deviceId) )
+ {
+ m_adapter = adapter;
+ m_adapter->AddRef();
+ m_driverType = D3D_DRIVER_TYPE_UNKNOWN;
+ }
+
+ if (BX_ENABLED(BGFX_CONFIG_DEBUG_PERFHUD)
+ && 0 != strstr(description, "PerfHUD") )
+ {
+ m_adapter = adapter;
+ m_driverType = D3D_DRIVER_TYPE_REFERENCE;
+ }
+ }
+
+ DX_RELEASE(adapter, adapter == m_adapter ? 1 : 0);
+ }
+ }
+
+ if (BX_ENABLED(BGFX_CONFIG_DEBUG) )
+ {
+ ID3D12Debug* debug;
+ hr = D3D12GetDebugInterface(IID_ID3D12Debug, (void**)&debug);
+
+ if (SUCCEEDED(hr) )
+ {
+ debug->EnableDebugLayer();
+ }
+ }
+
+ {
+ D3D_FEATURE_LEVEL featureLevel[] =
+ {
+ D3D_FEATURE_LEVEL_12_1,
+ D3D_FEATURE_LEVEL_12_0,
+ D3D_FEATURE_LEVEL_11_1,
+ D3D_FEATURE_LEVEL_11_0,
+ };
+
+ hr = E_FAIL;
+ for (uint32_t ii = 0; ii < BX_COUNTOF(featureLevel) && FAILED(hr); ++ii)
+ {
+ hr = D3D12CreateDevice(m_adapter
+ , featureLevel[ii]
+ , IID_ID3D12Device
+ , (void**)&m_device
+ );
+ BX_WARN(FAILED(hr), "Direct3D12 device feature level %d.%d."
+ , (featureLevel[ii] >> 12) & 0xf
+ , (featureLevel[ii] >> 8) & 0xf
+ );
+ }
+ BX_WARN(SUCCEEDED(hr), "Unable to create Direct3D12 device.");
+ }
+
+ if (FAILED(hr) )
+ {
+ goto error;
+ }
+
+ {
+ memset(&m_adapterDesc, 0, sizeof(m_adapterDesc) );
+ luid = m_device->GetAdapterLuid();
+ IDXGIAdapter3* adapter;
+ for (uint32_t ii = 0; DXGI_ERROR_NOT_FOUND != m_factory->EnumAdapters(ii, reinterpret_cast<IDXGIAdapter**>(&adapter) ); ++ii)
+ {
+ adapter->GetDesc(&m_adapterDesc);
+ if (m_adapterDesc.AdapterLuid.LowPart == luid.LowPart
+ && m_adapterDesc.AdapterLuid.HighPart == luid.HighPart)
+ {
+ if (NULL == m_adapter)
+ {
+ m_adapter = adapter;
+ }
+ else
+ {
+ DX_RELEASE(adapter, 0);
+ }
+ break;
+ }
+ DX_RELEASE(adapter, 0);
+ }
+ }
+
+ g_caps.vendorId = (uint16_t)m_adapterDesc.VendorId;
+ g_caps.deviceId = (uint16_t)m_adapterDesc.DeviceId;
+
+ {
+ uint32_t numNodes = m_device->GetNodeCount();
+ BX_TRACE("D3D12 GPU Architecture (num nodes: %d):", numNodes);
+ for (uint32_t ii = 0; ii < numNodes; ++ii)
+ {
+ D3D12_FEATURE_DATA_ARCHITECTURE architecture;
+ architecture.NodeIndex = ii;
+ DX_CHECK(m_device->CheckFeatureSupport(D3D12_FEATURE_ARCHITECTURE, &architecture, sizeof(architecture) ) );
+ BX_TRACE("\tNode % 2d: TileBasedRenderer %d, UMA %d, CacheCoherentUMA %d"
+ , ii
+ , architecture.TileBasedRenderer
+ , architecture.UMA
+ , architecture.CacheCoherentUMA
+ );
+ if (0 == ii)
+ {
+ memcpy(&m_architecture, &architecture, sizeof(architecture) );
+ }
+ }
+ }
+
+ DX_CHECK(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS, &m_options, sizeof(m_options) ) );
+ BX_TRACE("D3D12 options:")
+ BX_TRACE("\tTiledResourcesTier %d", m_options.TiledResourcesTier);
+ BX_TRACE("\tResourceBindingTier %d", m_options.ResourceBindingTier);
+ BX_TRACE("\tROVsSupported %d", m_options.ROVsSupported);
+ BX_TRACE("\tConservativeRasterizationTier %d", m_options.ConservativeRasterizationTier);
+ BX_TRACE("\tCrossNodeSharingTier %d", m_options.CrossNodeSharingTier);
+ BX_TRACE("\tResourceHeapTier %d", m_options.ResourceHeapTier);
+
+ m_cmd.init(m_device);
+ errorState = ErrorState::CreatedCommandQueue;
+
+ m_scd.BufferDesc.Width = BGFX_DEFAULT_WIDTH;
+ m_scd.BufferDesc.Height = BGFX_DEFAULT_HEIGHT;
+ m_scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+ m_scd.BufferDesc.Scaling = DXGI_MODE_SCALING_STRETCHED;
+ m_scd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
+ m_scd.BufferDesc.RefreshRate.Numerator = 60;
+ m_scd.BufferDesc.RefreshRate.Denominator = 1;
+ m_scd.SampleDesc.Count = 1;
+ m_scd.SampleDesc.Quality = 0;
+ m_scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+ m_scd.BufferCount = bx::uint32_min(BX_COUNTOF(m_backBufferColor), 4);
+ m_scd.OutputWindow = (HWND)g_platformData.nwh;
+ m_scd.Windowed = true;
+ m_scd.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
+ m_scd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
+
+ BX_CHECK(m_scd.BufferCount <= BX_COUNTOF(m_backBufferColor), "Swap chain buffer count %d (max %d)."
+ , m_scd.BufferCount
+ , BX_COUNTOF(m_backBufferColor)
+ );
+ hr = m_factory->CreateSwapChain(m_cmd.m_commandQueue
+ , &m_scd
+ , reinterpret_cast<IDXGISwapChain**>(&m_swapChain)
+ );
+ BX_WARN(SUCCEEDED(hr), "Failed to create swap chain.");
+ if (FAILED(hr) )
+ {
+ goto error;
+ }
+
+ m_presentElapsed = 0;
+
+ {
+ m_resolution.m_width = BGFX_DEFAULT_WIDTH;
+ m_resolution.m_height = BGFX_DEFAULT_HEIGHT;
+
+ DX_CHECK(m_factory->MakeWindowAssociation( (HWND)g_platformData.nwh
+ , 0
+ | DXGI_MWA_NO_WINDOW_CHANGES
+ | DXGI_MWA_NO_ALT_ENTER
+ ) );
+
+ m_numWindows = 1;
+
+ if (BX_ENABLED(BGFX_CONFIG_DEBUG) )
+ {
+ hr = m_device->QueryInterface(IID_ID3D12InfoQueue, (void**)&m_infoQueue);
+
+ if (SUCCEEDED(hr) )
+ {
+ m_infoQueue->SetBreakOnSeverity(D3D12_MESSAGE_SEVERITY_CORRUPTION, true);
+ m_infoQueue->SetBreakOnSeverity(D3D12_MESSAGE_SEVERITY_ERROR, true);
+ m_infoQueue->SetBreakOnSeverity(D3D12_MESSAGE_SEVERITY_WARNING, false);
+
+ D3D12_INFO_QUEUE_FILTER filter;
+ memset(&filter, 0, sizeof(filter) );
+
+ D3D12_MESSAGE_CATEGORY catlist[] =
+ {
+ D3D12_MESSAGE_CATEGORY_STATE_CREATION,
+ D3D12_MESSAGE_CATEGORY_EXECUTION,
+ };
+ filter.DenyList.NumCategories = BX_COUNTOF(catlist);
+ filter.DenyList.pCategoryList = catlist;
+ m_infoQueue->PushStorageFilter(&filter);
+
+ DX_RELEASE_WARNONLY(m_infoQueue, 0);
+ }
+ }
+
+ D3D12_DESCRIPTOR_HEAP_DESC rtvDescHeap;
+ rtvDescHeap.NumDescriptors = 0
+ + BX_COUNTOF(m_backBufferColor)
+ + BGFX_CONFIG_MAX_FRAME_BUFFERS*BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS
+ ;
+ rtvDescHeap.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
+ rtvDescHeap.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
+ rtvDescHeap.NodeMask = 1;
+ DX_CHECK(m_device->CreateDescriptorHeap(&rtvDescHeap
+ , IID_ID3D12DescriptorHeap
+ , (void**)&m_rtvDescriptorHeap
+ ) );
+
+ D3D12_DESCRIPTOR_HEAP_DESC dsvDescHeap;
+ dsvDescHeap.NumDescriptors = 0
+ + 1 // reserved for depth backbuffer.
+ + BGFX_CONFIG_MAX_FRAME_BUFFERS
+ ;
+ dsvDescHeap.Type = D3D12_DESCRIPTOR_HEAP_TYPE_DSV;
+ dsvDescHeap.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
+ dsvDescHeap.NodeMask = 1;
+ DX_CHECK(m_device->CreateDescriptorHeap(&dsvDescHeap
+ , IID_ID3D12DescriptorHeap
+ , (void**)&m_dsvDescriptorHeap
+ ) );
+
+ for (uint32_t ii = 0; ii < BX_COUNTOF(m_scratchBuffer); ++ii)
+ {
+ m_scratchBuffer[ii].create(BGFX_CONFIG_MAX_DRAW_CALLS*1024
+ , BGFX_CONFIG_MAX_TEXTURES + BGFX_CONFIG_MAX_SHADERS + BGFX_CONFIG_MAX_DRAW_CALLS
+ );
+ }
+ m_samplerAllocator.create(D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER
+ , 1024
+ , BGFX_CONFIG_MAX_TEXTURE_SAMPLERS
+ );
+
+ D3D12_DESCRIPTOR_RANGE descRange[] =
+ {
+ { D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER, BGFX_CONFIG_MAX_TEXTURE_SAMPLERS, 0, 0, D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND },
+ { D3D12_DESCRIPTOR_RANGE_TYPE_SRV, BGFX_CONFIG_MAX_TEXTURE_SAMPLERS, 0, 0, D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND },
+ { D3D12_DESCRIPTOR_RANGE_TYPE_CBV, 1, 0, 0, D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND },
+ { D3D12_DESCRIPTOR_RANGE_TYPE_UAV, BGFX_CONFIG_MAX_TEXTURE_SAMPLERS, 0, 0, D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND },
+ };
+ BX_STATIC_ASSERT(BX_COUNTOF(descRange) == Rdt::Count);
+
+ D3D12_ROOT_PARAMETER rootParameter[] =
+ {
+ { D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE, { { 1, &descRange[Rdt::Sampler] } }, D3D12_SHADER_VISIBILITY_ALL },
+ { D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE, { { 1, &descRange[Rdt::SRV] } }, D3D12_SHADER_VISIBILITY_ALL },
+ { D3D12_ROOT_PARAMETER_TYPE_CBV, { { 0, 0 } }, D3D12_SHADER_VISIBILITY_ALL },
+ { D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE, { { 1, &descRange[Rdt::UAV] } }, D3D12_SHADER_VISIBILITY_ALL },
+ };
+ rootParameter[Rdt::CBV].Descriptor.RegisterSpace = 0;
+ rootParameter[Rdt::CBV].Descriptor.ShaderRegister = 0;
+
+ D3D12_ROOT_SIGNATURE_DESC descRootSignature;
+ descRootSignature.NumParameters = BX_COUNTOF(rootParameter);
+ descRootSignature.pParameters = rootParameter;
+ descRootSignature.NumStaticSamplers = 0;
+ descRootSignature.pStaticSamplers = NULL;
+ descRootSignature.Flags = D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT;
+
+ ID3DBlob* outBlob;
+ ID3DBlob* errorBlob;
+ DX_CHECK(D3D12SerializeRootSignature(&descRootSignature
+ , D3D_ROOT_SIGNATURE_VERSION_1
+ , &outBlob
+ , &errorBlob
+ ) );
+
+ DX_CHECK(m_device->CreateRootSignature(0
+ , outBlob->GetBufferPointer()
+ , outBlob->GetBufferSize()
+ , IID_ID3D12RootSignature
+ , (void**)&m_rootSignature
+ ) );
+
+ UniformHandle handle = BGFX_INVALID_HANDLE;
+ for (uint32_t ii = 0; ii < PredefinedUniform::Count; ++ii)
+ {
+ m_uniformReg.add(handle, getPredefinedUniformName(PredefinedUniform::Enum(ii) ), &m_predefinedUniforms[ii]);
+ }
+
+ g_caps.supported |= ( 0
+ | BGFX_CAPS_TEXTURE_3D
+ | BGFX_CAPS_TEXTURE_COMPARE_ALL
+ | BGFX_CAPS_INSTANCING
+ | BGFX_CAPS_VERTEX_ATTRIB_HALF
+ | BGFX_CAPS_VERTEX_ATTRIB_UINT10
+ | BGFX_CAPS_FRAGMENT_DEPTH
+ | BGFX_CAPS_BLEND_INDEPENDENT
+ | BGFX_CAPS_COMPUTE
+ | (m_options.ROVsSupported ? BGFX_CAPS_FRAGMENT_ORDERING : 0)
+// | BGFX_CAPS_SWAP_CHAIN
+ );
+ g_caps.maxTextureSize = 16384;
+ g_caps.maxFBAttachments = uint8_t(bx::uint32_min(16, BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS) );
+
+ for (uint32_t ii = 0; ii < TextureFormat::Count; ++ii)
+ {
+ uint8_t support = BGFX_CAPS_FORMAT_TEXTURE_NONE;
+
+ const DXGI_FORMAT fmt = isDepth(TextureFormat::Enum(ii) )
+ ? s_textureFormat[ii].m_fmtDsv
+ : s_textureFormat[ii].m_fmt
+ ;
+ const DXGI_FORMAT fmtSrgb = s_textureFormat[ii].m_fmtSrgb;
+
+ if (DXGI_FORMAT_UNKNOWN != fmt)
+ {
+ D3D12_FEATURE_DATA_FORMAT_SUPPORT data;
+ data.Format = fmt;
+ hr = m_device->CheckFeatureSupport(D3D12_FEATURE_FORMAT_SUPPORT, &data, sizeof(data) );
+ if (SUCCEEDED(hr) )
+ {
+ support |= 0 != (data.Support1 & (0
+ | D3D12_FORMAT_SUPPORT1_TEXTURE2D
+ | D3D12_FORMAT_SUPPORT1_TEXTURE3D
+ | D3D12_FORMAT_SUPPORT1_TEXTURECUBE
+ ) )
+ ? BGFX_CAPS_FORMAT_TEXTURE_COLOR
+ : BGFX_CAPS_FORMAT_TEXTURE_NONE
+ ;
+
+ support |= 0 != (data.Support1 & (0
+ | D3D12_FORMAT_SUPPORT1_BUFFER
+ | D3D12_FORMAT_SUPPORT1_IA_VERTEX_BUFFER
+ | D3D12_FORMAT_SUPPORT1_IA_INDEX_BUFFER
+ ) )
+ ? BGFX_CAPS_FORMAT_TEXTURE_VERTEX
+ : BGFX_CAPS_FORMAT_TEXTURE_NONE
+ ;
+
+ support |= 0 != (data.Support1 & (0
+ | D3D12_FORMAT_SUPPORT1_SHADER_LOAD
+ ) )
+ ? BGFX_CAPS_FORMAT_TEXTURE_IMAGE
+ : BGFX_CAPS_FORMAT_TEXTURE_NONE
+ ;
+
+ support |= 0 != (data.Support1 & (0
+ | D3D12_FORMAT_SUPPORT1_RENDER_TARGET
+ | D3D12_FORMAT_SUPPORT1_DEPTH_STENCIL
+ ) )
+ ? BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER
+ : BGFX_CAPS_FORMAT_TEXTURE_NONE
+ ;
+
+ support |= 0 != (data.Support1 & (0
+ | D3D12_FORMAT_SUPPORT1_MULTISAMPLE_RENDERTARGET
+ ) )
+ ? BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER_MSAA
+ : BGFX_CAPS_FORMAT_TEXTURE_NONE
+ ;
+
+ support |= 0 != (data.Support1 & (0
+ | D3D12_FORMAT_SUPPORT1_MULTISAMPLE_LOAD
+ ) )
+ ? BGFX_CAPS_FORMAT_TEXTURE_MSAA
+ : BGFX_CAPS_FORMAT_TEXTURE_NONE
+ ;
+ }
+ else
+ {
+ BX_TRACE("CheckFeatureSupport failed with %x for format %s.", hr, getName(TextureFormat::Enum(ii) ) );
+ }
+
+ if (0 != (support & BGFX_CAPS_FORMAT_TEXTURE_IMAGE) )
+ {
+ // clear image flag for additional testing
+ support &= ~BGFX_CAPS_FORMAT_TEXTURE_IMAGE;
+
+ data.Format = s_textureFormat[ii].m_fmt;
+ hr = m_device->CheckFeatureSupport(D3D12_FEATURE_FORMAT_SUPPORT, &data, sizeof(data) );
+ if (SUCCEEDED(hr) )
+ {
+ support |= 0 != (data.Support2 & (0
+ | D3D12_FORMAT_SUPPORT2_UAV_TYPED_LOAD
+ | D3D12_FORMAT_SUPPORT2_UAV_TYPED_STORE
+ ) )
+ ? BGFX_CAPS_FORMAT_TEXTURE_IMAGE
+ : BGFX_CAPS_FORMAT_TEXTURE_NONE
+ ;
+ }
+ }
+ }
+
+ if (DXGI_FORMAT_UNKNOWN != fmtSrgb)
+ {
+ struct D3D11_FEATURE_DATA_FORMAT_SUPPORT
+ {
+ DXGI_FORMAT InFormat;
+ UINT OutFormatSupport;
+ };
+
+ D3D12_FEATURE_DATA_FORMAT_SUPPORT data;
+ data.Format = fmtSrgb;
+ hr = m_device->CheckFeatureSupport(D3D12_FEATURE_FORMAT_SUPPORT, &data, sizeof(data) );
+ if (SUCCEEDED(hr) )
+ {
+ support |= 0 != (data.Support1 & (0
+ | D3D12_FORMAT_SUPPORT1_TEXTURE2D
+ | D3D12_FORMAT_SUPPORT1_TEXTURE3D
+ | D3D12_FORMAT_SUPPORT1_TEXTURECUBE
+ ) )
+ ? BGFX_CAPS_FORMAT_TEXTURE_COLOR_SRGB
+ : BGFX_CAPS_FORMAT_TEXTURE_NONE
+ ;
+ }
+ else
+ {
+ BX_TRACE("CheckFeatureSupport failed with %x for sRGB format %s.", hr, getName(TextureFormat::Enum(ii) ) );
+ }
+ }
+
+ g_caps.formats[ii] = support;
+ }
+
+ postReset();
+
+ m_batch.create(4<<10);
+ }
+ return true;
+
+ error:
+ switch (errorState)
+ {
+ case ErrorState::CreatedCommandQueue:
+ m_cmd.shutdown();
+ case ErrorState::CreatedDXGIFactory:
+ DX_RELEASE(m_device, 0);
+ DX_RELEASE(m_adapter, 0);
+ DX_RELEASE(m_factory, 0);
+#if USE_D3D12_DYNAMIC_LIB
+ case ErrorState::LoadedDXGI:
+ bx::dlclose(m_dxgidll);
+ case ErrorState::LoadedD3D12:
+ bx::dlclose(m_d3d12dll);
+ case ErrorState::LoadedKernel32:
+ bx::dlclose(m_kernel32dll);
+#endif // USE_D3D12_DYNAMIC_LIB
+ case ErrorState::Default:
+ break;
+ }
+
+ return false;
+ }
+
+ void shutdown()
+ {
+ m_batch.destroy();
+
+ preReset();
+
+ m_samplerAllocator.destroy();
+
+ for (uint32_t ii = 0; ii < BX_COUNTOF(m_scratchBuffer); ++ii)
+ {
+ m_scratchBuffer[ii].destroy();
+ }
+
+ m_pipelineStateCache.invalidate();
+
+ for (uint32_t ii = 0; ii < BX_COUNTOF(m_indexBuffers); ++ii)
+ {
+ m_indexBuffers[ii].destroy();
+ }
+
+ for (uint32_t ii = 0; ii < BX_COUNTOF(m_vertexBuffers); ++ii)
+ {
+ m_vertexBuffers[ii].destroy();
+ }
+
+ for (uint32_t ii = 0; ii < BX_COUNTOF(m_shaders); ++ii)
+ {
+ m_shaders[ii].destroy();
+ }
+
+ for (uint32_t ii = 0; ii < BX_COUNTOF(m_textures); ++ii)
+ {
+ m_textures[ii].destroy();
+ }
+
+ DX_RELEASE(m_rtvDescriptorHeap, 0);
+ DX_RELEASE(m_dsvDescriptorHeap, 0);
+
+ DX_RELEASE(m_rootSignature, 0);
+
+ DX_RELEASE(m_swapChain, 0);
+
+ m_cmd.shutdown();
+
+ DX_RELEASE(m_device, 0);
+ DX_RELEASE(m_adapter, 0);
+ DX_RELEASE(m_factory, 0);
+
+#if USE_D3D12_DYNAMIC_LIB
+ bx::dlclose(m_dxgidll);
+ bx::dlclose(m_d3d12dll);
+ bx::dlclose(m_kernel32dll);
+#endif // USE_D3D12_DYNAMIC_LIB
+ }
+
+ RendererType::Enum getRendererType() const BX_OVERRIDE
+ {
+ return RendererType::Direct3D12;
+ }
+
+ const char* getRendererName() const BX_OVERRIDE
+ {
+ return BGFX_RENDERER_DIRECT3D12_NAME;
+ }
+
+ static bool isLost(HRESULT _hr)
+ {
+ return DXGI_ERROR_DEVICE_REMOVED == _hr
+ || DXGI_ERROR_DEVICE_HUNG == _hr
+ || DXGI_ERROR_DEVICE_RESET == _hr
+ || DXGI_ERROR_DRIVER_INTERNAL_ERROR == _hr
+ || DXGI_ERROR_NOT_CURRENTLY_AVAILABLE == _hr
+ ;
+ }
+
+ void flip(HMD& /*_hmd*/) BX_OVERRIDE
+ {
+ if (NULL != m_swapChain)
+ {
+ int64_t start = bx::getHPCounter();
+
+ HRESULT hr = 0;
+ uint32_t syncInterval = !!(m_flags & BGFX_RESET_VSYNC);
+ uint32_t flags = 0 == syncInterval ? DXGI_PRESENT_RESTART : 0;
+ for (uint32_t ii = 1, num = m_numWindows; ii < num && SUCCEEDED(hr); ++ii)
+ {
+ hr = m_frameBuffers[m_windows[ii].idx].m_swapChain->Present(syncInterval, flags);
+ }
+
+ if (SUCCEEDED(hr) )
+ {
+ m_cmd.finish(m_backBufferColorFence[(m_backBufferColorIdx-1) % m_scd.BufferCount]);
+ hr = m_swapChain->Present(syncInterval, flags);
+ }
+
+ int64_t now = bx::getHPCounter();
+ m_presentElapsed = now - start;
+
+ if (FAILED(hr)
+ && isLost(hr) )
+ {
+ ++m_lost;
+ BGFX_FATAL(10 > m_lost, bgfx::Fatal::DeviceLost, "Device is lost. FAILED 0x%08x", hr);
+ }
+ else
+ {
+ m_lost = 0;
+ }
+ }
+ }
+
+ void createIndexBuffer(IndexBufferHandle _handle, Memory* _mem, uint16_t _flags) BX_OVERRIDE
+ {
+ m_indexBuffers[_handle.idx].create(_mem->size, _mem->data, _flags, false);
+ }
+
+ void destroyIndexBuffer(IndexBufferHandle _handle) BX_OVERRIDE
+ {
+ m_indexBuffers[_handle.idx].destroy();
+ }
+
+ void createVertexDecl(VertexDeclHandle _handle, const VertexDecl& _decl) BX_OVERRIDE
+ {
+ VertexDecl& decl = m_vertexDecls[_handle.idx];
+ memcpy(&decl, &_decl, sizeof(VertexDecl) );
+ dump(decl);
+ }
+
+ void destroyVertexDecl(VertexDeclHandle /*_handle*/) BX_OVERRIDE
+ {
+ }
+
+ void createVertexBuffer(VertexBufferHandle _handle, Memory* _mem, VertexDeclHandle _declHandle, uint16_t _flags) BX_OVERRIDE
+ {
+ m_vertexBuffers[_handle.idx].create(_mem->size, _mem->data, _declHandle, _flags);
+ }
+
+ void destroyVertexBuffer(VertexBufferHandle _handle) BX_OVERRIDE
+ {
+ m_vertexBuffers[_handle.idx].destroy();
+ }
+
+ void createDynamicIndexBuffer(IndexBufferHandle _handle, uint32_t _size, uint16_t _flags) BX_OVERRIDE
+ {
+ m_indexBuffers[_handle.idx].create(_size, NULL, _flags, false);
+ }
+
+ void updateDynamicIndexBuffer(IndexBufferHandle _handle, uint32_t _offset, uint32_t _size, Memory* _mem) BX_OVERRIDE
+ {
+ m_indexBuffers[_handle.idx].update(m_commandList, _offset, bx::uint32_min(_size, _mem->size), _mem->data);
+ }
+
+ void destroyDynamicIndexBuffer(IndexBufferHandle _handle) BX_OVERRIDE
+ {
+ m_indexBuffers[_handle.idx].destroy();
+ }
+
+ void createDynamicVertexBuffer(VertexBufferHandle _handle, uint32_t _size, uint16_t _flags) BX_OVERRIDE
+ {
+ VertexDeclHandle decl = BGFX_INVALID_HANDLE;
+ m_vertexBuffers[_handle.idx].create(_size, NULL, decl, _flags);
+ }
+
+ void updateDynamicVertexBuffer(VertexBufferHandle _handle, uint32_t _offset, uint32_t _size, Memory* _mem) BX_OVERRIDE
+ {
+ m_vertexBuffers[_handle.idx].update(m_commandList, _offset, bx::uint32_min(_size, _mem->size), _mem->data);
+ }
+
+ void destroyDynamicVertexBuffer(VertexBufferHandle _handle) BX_OVERRIDE
+ {
+ m_vertexBuffers[_handle.idx].destroy();
+ }
+
+ void createShader(ShaderHandle _handle, Memory* _mem) BX_OVERRIDE
+ {
+ m_shaders[_handle.idx].create(_mem);
+ }
+
+ void destroyShader(ShaderHandle _handle) BX_OVERRIDE
+ {
+ m_shaders[_handle.idx].destroy();
+ }
+
+ void createProgram(ProgramHandle _handle, ShaderHandle _vsh, ShaderHandle _fsh) BX_OVERRIDE
+ {
+ m_program[_handle.idx].create(&m_shaders[_vsh.idx], isValid(_fsh) ? &m_shaders[_fsh.idx] : NULL);
+ }
+
+ void destroyProgram(ProgramHandle _handle) BX_OVERRIDE
+ {
+ m_program[_handle.idx].destroy();
+ }
+
+ void createTexture(TextureHandle _handle, Memory* _mem, uint32_t _flags, uint8_t _skip) BX_OVERRIDE
+ {
+ m_textures[_handle.idx].create(_mem, _flags, _skip);
+ }
+
+ void updateTextureBegin(TextureHandle /*_handle*/, uint8_t /*_side*/, uint8_t /*_mip*/) BX_OVERRIDE
+ {
+ }
+
+ void updateTexture(TextureHandle _handle, uint8_t _side, uint8_t _mip, const Rect& _rect, uint16_t _z, uint16_t _depth, uint16_t _pitch, const Memory* _mem) BX_OVERRIDE
+ {
+ m_textures[_handle.idx].update(m_commandList, _side, _mip, _rect, _z, _depth, _pitch, _mem);
+ }
+
+ void updateTextureEnd() BX_OVERRIDE
+ {
+ }
+
+ void resizeTexture(TextureHandle _handle, uint16_t _width, uint16_t _height) BX_OVERRIDE
+ {
+ TextureD3D12& texture = m_textures[_handle.idx];
+
+ uint32_t size = sizeof(uint32_t) + sizeof(TextureCreate);
+ const Memory* mem = alloc(size);
+
+ bx::StaticMemoryBlockWriter writer(mem->data, mem->size);
+ uint32_t magic = BGFX_CHUNK_MAGIC_TEX;
+ bx::write(&writer, magic);
+
+ TextureCreate tc;
+ tc.m_flags = texture.m_flags;
+ tc.m_width = _width;
+ tc.m_height = _height;
+ tc.m_sides = 0;
+ tc.m_depth = 0;
+ tc.m_numMips = 1;
+ tc.m_format = texture.m_requestedFormat;
+ tc.m_cubeMap = false;
+ tc.m_mem = NULL;
+ bx::write(&writer, tc);
+
+ texture.destroy();
+ texture.create(mem, tc.m_flags, 0);
+
+ release(mem);
+ }
+
+ void destroyTexture(TextureHandle _handle) BX_OVERRIDE
+ {
+ m_textures[_handle.idx].destroy();
+ }
+
+ void createFrameBuffer(FrameBufferHandle _handle, uint8_t _num, const TextureHandle* _textureHandles) BX_OVERRIDE
+ {
+ m_frameBuffers[_handle.idx].create(_num, _textureHandles);
+ }
+
+ void createFrameBuffer(FrameBufferHandle _handle, void* _nwh, uint32_t _width, uint32_t _height, TextureFormat::Enum _depthFormat) BX_OVERRIDE
+ {
+ uint16_t denseIdx = m_numWindows++;
+ m_windows[denseIdx] = _handle;
+ m_frameBuffers[_handle.idx].create(denseIdx, _nwh, _width, _height, _depthFormat);
+ }
+
+ void destroyFrameBuffer(FrameBufferHandle _handle) BX_OVERRIDE
+ {
+ uint16_t denseIdx = m_frameBuffers[_handle.idx].destroy();
+ if (UINT16_MAX != denseIdx)
+ {
+ --m_numWindows;
+ if (m_numWindows > 1)
+ {
+ FrameBufferHandle handle = m_windows[m_numWindows];
+ m_windows[denseIdx] = handle;
+ m_frameBuffers[handle.idx].m_denseIdx = denseIdx;
+ }
+ }
+ }
+
+ void createUniform(UniformHandle _handle, UniformType::Enum _type, uint16_t _num, const char* _name) BX_OVERRIDE
+ {
+ if (NULL != m_uniforms[_handle.idx])
+ {
+ BX_FREE(g_allocator, m_uniforms[_handle.idx]);
+ }
+
+ uint32_t size = BX_ALIGN_16(g_uniformTypeSize[_type] * _num);
+ void* data = BX_ALLOC(g_allocator, size);
+ memset(data, 0, size);
+ m_uniforms[_handle.idx] = data;
+ m_uniformReg.add(_handle, _name, data);
+ }
+
+ void destroyUniform(UniformHandle _handle) BX_OVERRIDE
+ {
+ BX_FREE(g_allocator, m_uniforms[_handle.idx]);
+ m_uniforms[_handle.idx] = NULL;
+ }
+
+ void saveScreenShot(const char* _filePath) BX_OVERRIDE
+ {
+ uint32_t idx = (m_backBufferColorIdx-1) % m_scd.BufferCount;
+ m_cmd.finish(m_backBufferColorFence[idx]);
+ ID3D12Resource* backBuffer = m_backBufferColor[idx];
+
+ D3D12_RESOURCE_DESC desc = backBuffer->GetDesc();
+
+ const uint32_t width = (uint32_t)desc.Width;
+ const uint32_t height = (uint32_t)desc.Height;
+
+ D3D12_PLACED_SUBRESOURCE_FOOTPRINT layout;
+ uint32_t numRows;
+ uint64_t total;
+ uint64_t pitch;
+ m_device->GetCopyableFootprints(&desc
+ , 0
+ , 1
+ , 0
+ , &layout
+ , &numRows
+ , &pitch
+ , &total
+ );
+
+ ID3D12Resource* readback = createCommittedResource(m_device, HeapProperty::ReadBack, total);
+
+ D3D12_BOX box;
+ box.left = 0;
+ box.top = 0;
+ box.right = width;
+ box.bottom = height;
+ box.front = 0;
+ box.back = 1;
+
+ setResourceBarrier(m_commandList, backBuffer, D3D12_RESOURCE_STATE_PRESENT, D3D12_RESOURCE_STATE_COPY_SOURCE);
+ D3D12_TEXTURE_COPY_LOCATION dst = { readback, D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT, { layout } };
+ D3D12_TEXTURE_COPY_LOCATION src = { backBuffer, D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX, {} };
+ m_commandList->CopyTextureRegion(&dst, 0, 0, 0, &src, &box);
+ setResourceBarrier(m_commandList, backBuffer, D3D12_RESOURCE_STATE_COPY_SOURCE, D3D12_RESOURCE_STATE_PRESENT);
+ finish();
+ m_commandList = m_cmd.alloc();
+
+ void* data;
+ readback->Map(0, NULL, (void**)&data);
+ imageSwizzleBgra8(width
+ , height
+ , (uint32_t)pitch
+ , data
+ , data
+ );
+ g_callback->screenShot(_filePath
+ , width
+ , height
+ , (uint32_t)pitch
+ , data
+ , (uint32_t)total
+ , false
+ );
+ readback->Unmap(0, NULL);
+
+ DX_RELEASE(readback, 0);
+ }
+
+ void updateViewName(uint8_t /*_id*/, const char* /*_name*/) BX_OVERRIDE
+ {
+ }
+
+ void updateUniform(uint16_t _loc, const void* _data, uint32_t _size) BX_OVERRIDE
+ {
+ memcpy(m_uniforms[_loc], _data, _size);
+ }
+
+ void setMarker(const char* /*_marker*/, uint32_t /*_size*/) BX_OVERRIDE
+ {
+ }
+
+ void submit(Frame* _render, ClearQuad& _clearQuad, TextVideoMemBlitter& _textVideoMemBlitter) BX_OVERRIDE;
+
+ void blitSetup(TextVideoMemBlitter& _blitter) BX_OVERRIDE
+ {
+ const uint32_t width = m_scd.BufferDesc.Width;
+ const uint32_t height = m_scd.BufferDesc.Height;
+
+ FrameBufferHandle fbh = BGFX_INVALID_HANDLE;
+ setFrameBuffer(fbh, false);
+
+ D3D12_VIEWPORT vp;
+ vp.TopLeftX = 0;
+ vp.TopLeftY = 0;
+ vp.Width = (float)width;
+ vp.Height = (float)height;
+ vp.MinDepth = 0.0f;
+ vp.MaxDepth = 1.0f;
+ m_commandList->RSSetViewports(1, &vp);
+
+ D3D12_RECT rc;
+ rc.left = 0;
+ rc.top = 0;
+ rc.right = width;
+ rc.bottom = height;
+ m_commandList->RSSetScissorRects(1, &rc);
+
+ const uint64_t state = 0
+ | BGFX_STATE_RGB_WRITE
+ | BGFX_STATE_ALPHA_WRITE
+ | BGFX_STATE_DEPTH_TEST_ALWAYS
+ ;
+
+ ID3D12PipelineState* pso = getPipelineState(state
+ , packStencil(BGFX_STENCIL_DEFAULT, BGFX_STENCIL_DEFAULT)
+ , _blitter.m_vb->decl.idx
+ , _blitter.m_program.idx
+ , 0
+ );
+ m_commandList->SetPipelineState(pso);
+ m_commandList->SetGraphicsRootSignature(m_rootSignature);
+
+ float proj[16];
+ bx::mtxOrtho(proj, 0.0f, (float)width, (float)height, 0.0f, 0.0f, 1000.0f);
+
+ PredefinedUniform& predefined = m_program[_blitter.m_program.idx].m_predefined[0];
+ uint8_t flags = predefined.m_type;
+ setShaderUniform(flags, predefined.m_loc, proj, 4);
+
+ D3D12_GPU_VIRTUAL_ADDRESS gpuAddress;
+ commitShaderConstants(_blitter.m_program.idx, gpuAddress);
+
+ ScratchBufferD3D12& scratchBuffer = m_scratchBuffer[m_backBufferColorIdx];
+ ID3D12DescriptorHeap* heaps[] =
+ {
+ m_samplerAllocator.getHeap(),
+ scratchBuffer.getHeap(),
+ };
+ m_commandList->SetDescriptorHeaps(BX_COUNTOF(heaps), heaps);
+ m_commandList->SetGraphicsRootConstantBufferView(Rdt::CBV, gpuAddress);
+
+ TextureD3D12& texture = m_textures[_blitter.m_texture.idx];
+ uint32_t samplerFlags[BGFX_CONFIG_MAX_TEXTURE_SAMPLERS] = { texture.m_flags & BGFX_TEXTURE_SAMPLER_BITS_MASK };
+ uint16_t samplerStateIdx = getSamplerState(samplerFlags, BGFX_CONFIG_MAX_TEXTURE_SAMPLERS, NULL);
+ m_commandList->SetGraphicsRootDescriptorTable(Rdt::Sampler, m_samplerAllocator.get(samplerStateIdx) );
+ D3D12_GPU_DESCRIPTOR_HANDLE srvHandle;
+ scratchBuffer.allocSrv(srvHandle, texture);
+ m_commandList->SetGraphicsRootDescriptorTable(Rdt::SRV, srvHandle);
+
+ VertexBufferD3D12& vb = m_vertexBuffers[_blitter.m_vb->handle.idx];
+ const VertexDecl& vertexDecl = m_vertexDecls[_blitter.m_vb->decl.idx];
+ D3D12_VERTEX_BUFFER_VIEW viewDesc;
+ viewDesc.BufferLocation = vb.m_gpuVA;
+ viewDesc.StrideInBytes = vertexDecl.m_stride;
+ viewDesc.SizeInBytes = vb.m_size;
+ m_commandList->IASetVertexBuffers(0, 1, &viewDesc);
+
+ const BufferD3D12& ib = m_indexBuffers[_blitter.m_ib->handle.idx];
+ D3D12_INDEX_BUFFER_VIEW ibv;
+ ibv.Format = DXGI_FORMAT_R16_UINT;
+ ibv.BufferLocation = ib.m_gpuVA;
+ ibv.SizeInBytes = ib.m_size;
+ m_commandList->IASetIndexBuffer(&ibv);
+
+ m_commandList->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
+ }
+
+ void blitRender(TextVideoMemBlitter& _blitter, uint32_t _numIndices) BX_OVERRIDE
+ {
+ const uint32_t numVertices = _numIndices*4/6;
+ if (0 < numVertices)
+ {
+ m_indexBuffers [_blitter.m_ib->handle.idx].update(m_commandList, 0, _numIndices*2, _blitter.m_ib->data);
+ m_vertexBuffers[_blitter.m_vb->handle.idx].update(m_commandList, 0, numVertices*_blitter.m_decl.m_stride, _blitter.m_vb->data, true);
+
+ m_commandList->DrawIndexedInstanced(_numIndices
+ , 1
+ , 0
+ , 0
+ , 0
+ );
+ }
+ }
+
+ void preReset()
+ {
+ finishAll();
+
+ for (uint32_t ii = 0, num = m_scd.BufferCount; ii < num; ++ii)
+ {
+ DX_RELEASE(m_backBufferColor[ii], num-1-ii);
+ }
+ DX_RELEASE(m_backBufferDepthStencil, 0);
+
+ for (uint32_t ii = 0; ii < BX_COUNTOF(m_frameBuffers); ++ii)
+ {
+ m_frameBuffers[ii].preReset();
+ }
+
+ invalidateCache();
+
+// capturePreReset();
+ }
+
+ void postReset()
+ {
+ memset(m_backBufferColorFence, 0, sizeof(m_backBufferColorFence) );
+
+ uint32_t rtvDescriptorSize = m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
+
+ for (uint32_t ii = 0, num = m_scd.BufferCount; ii < num; ++ii)
+ {
+ D3D12_CPU_DESCRIPTOR_HANDLE handle = m_rtvDescriptorHeap->GetCPUDescriptorHandleForHeapStart();
+ handle.ptr += ii * rtvDescriptorSize;
+ DX_CHECK(m_swapChain->GetBuffer(ii
+ , IID_ID3D12Resource
+ , (void**)&m_backBufferColor[ii]
+ ) );
+ m_device->CreateRenderTargetView(m_backBufferColor[ii], NULL, handle);
+ }
+
+ D3D12_RESOURCE_DESC resourceDesc;
+ resourceDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
+ resourceDesc.Alignment = 0;
+ resourceDesc.Width = bx::uint32_max(m_resolution.m_width, 1);
+ resourceDesc.Height = bx::uint32_max(m_resolution.m_height, 1);
+ resourceDesc.DepthOrArraySize = 1;
+ resourceDesc.MipLevels = 0;
+ resourceDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
+ resourceDesc.SampleDesc.Count = 1;
+ resourceDesc.SampleDesc.Quality = 0;
+ resourceDesc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
+ resourceDesc.Flags = D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL;
+
+ D3D12_CLEAR_VALUE clearValue;
+ clearValue.Format = resourceDesc.Format;
+ clearValue.DepthStencil.Depth = 1.0f;
+ clearValue.DepthStencil.Stencil = 0;
+
+ m_backBufferDepthStencil = createCommittedResource(m_device, HeapProperty::Default, &resourceDesc, &clearValue);
+
+ D3D12_DEPTH_STENCIL_VIEW_DESC dsvDesc;
+ ZeroMemory(&dsvDesc, sizeof(dsvDesc) );
+ dsvDesc.Format = resourceDesc.Format;
+ dsvDesc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2D;
+ dsvDesc.Flags = D3D12_DSV_FLAGS(0)
+// | D3D12_DSV_FLAG_READ_ONLY_DEPTH
+// | D3D12_DSV_FLAG_READ_ONLY_DEPTH
+ ;
+
+ m_device->CreateDepthStencilView(m_backBufferDepthStencil
+ , &dsvDesc
+ , m_dsvDescriptorHeap->GetCPUDescriptorHandleForHeapStart()
+ );
+
+ for (uint32_t ii = 0; ii < BX_COUNTOF(m_frameBuffers); ++ii)
+ {
+ m_frameBuffers[ii].postReset();
+ }
+
+ m_commandList = m_cmd.alloc();
+// capturePostReset();
+ }
+
+ void invalidateCache()
+ {
+ m_pipelineStateCache.invalidate();
+
+ m_samplerStateCache.invalidate();
+ m_samplerAllocator.reset();
+ }
+
+ void updateMsaa()
+ {
+ for (uint32_t ii = 1, last = 0; ii < BX_COUNTOF(s_msaa); ++ii)
+ {
+ uint32_t msaa = s_checkMsaa[ii];
+
+ D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS data;
+ memset(&data, 0, sizeof(msaa) );
+ data.Format = m_scd.BufferDesc.Format;
+ data.SampleCount = msaa;
+ data.Flags = D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_NONE;
+ HRESULT hr = m_device->CheckFeatureSupport(D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS, &data, sizeof(data) );
+
+data.NumQualityLevels = 0;
+
+ if (SUCCEEDED(hr)
+ && 0 < data.NumQualityLevels)
+ {
+ s_msaa[ii].Count = data.SampleCount;
+ s_msaa[ii].Quality = data.NumQualityLevels - 1;
+ last = ii;
+ }
+ else
+ {
+ s_msaa[ii] = s_msaa[last];
+ }
+ }
+ }
+
+ void updateResolution(const Resolution& _resolution)
+ {
+ if (!!(_resolution.m_flags & BGFX_RESET_MAXANISOTROPY) )
+ {
+ m_maxAnisotropy = D3D12_REQ_MAXANISOTROPY;
+ }
+ else
+ {
+ m_maxAnisotropy = 1;
+ }
+
+ if ( (uint32_t)m_scd.BufferDesc.Width != _resolution.m_width
+ || (uint32_t)m_scd.BufferDesc.Height != _resolution.m_height
+ || m_flags != _resolution.m_flags)
+ {
+ bool resize = (m_flags&BGFX_RESET_MSAA_MASK) == (_resolution.m_flags&BGFX_RESET_MSAA_MASK);
+ m_flags = _resolution.m_flags;
+
+ m_textVideoMem.resize(false, _resolution.m_width, _resolution.m_height);
+ m_textVideoMem.clear();
+
+ m_resolution = _resolution;
+ m_scd.BufferDesc.Width = _resolution.m_width;
+ m_scd.BufferDesc.Height = _resolution.m_height;
+
+ preReset();
+
+ if (resize)
+ {
+ uint32_t nodeMask[] = { 1, 1, 1, 1 };
+ BX_STATIC_ASSERT(BX_COUNTOF(m_backBufferColor) == BX_COUNTOF(nodeMask) );
+ IUnknown* presentQueue[] ={ m_cmd.m_commandQueue, m_cmd.m_commandQueue, m_cmd.m_commandQueue, m_cmd.m_commandQueue };
+ BX_STATIC_ASSERT(BX_COUNTOF(m_backBufferColor) == BX_COUNTOF(presentQueue) );
+
+ DX_CHECK(m_swapChain->ResizeBuffers1(m_scd.BufferCount
+ , m_scd.BufferDesc.Width
+ , m_scd.BufferDesc.Height
+ , m_scd.BufferDesc.Format
+ , m_scd.Flags
+ , nodeMask
+ , presentQueue
+ ) );
+ }
+ else
+ {
+ updateMsaa();
+ m_scd.SampleDesc = s_msaa[(m_flags&BGFX_RESET_MSAA_MASK)>>BGFX_RESET_MSAA_SHIFT];
+
+ DX_RELEASE(m_swapChain, 0);
+
+ HRESULT hr;
+ hr = m_factory->CreateSwapChain(m_cmd.m_commandQueue
+ , &m_scd
+ , reinterpret_cast<IDXGISwapChain**>(&m_swapChain)
+ );
+ BGFX_FATAL(SUCCEEDED(hr), bgfx::Fatal::UnableToInitialize, "Failed to create swap chain.");
+ }
+
+ postReset();
+ }
+ }
+
+ void setShaderUniform(uint8_t _flags, uint32_t _regIndex, const void* _val, uint32_t _numRegs)
+ {
+ if (_flags&BGFX_UNIFORM_FRAGMENTBIT)
+ {
+ memcpy(&m_fsScratch[_regIndex], _val, _numRegs*16);
+ m_fsChanges += _numRegs;
+ }
+ else
+ {
+ memcpy(&m_vsScratch[_regIndex], _val, _numRegs*16);
+ m_vsChanges += _numRegs;
+ }
+ }
+
+ void setShaderUniform4f(uint8_t _flags, uint32_t _regIndex, const void* _val, uint32_t _numRegs)
+ {
+ setShaderUniform(_flags, _regIndex, _val, _numRegs);
+ }
+
+ void setShaderUniform4x4f(uint8_t _flags, uint32_t _regIndex, const void* _val, uint32_t _numRegs)
+ {
+ setShaderUniform(_flags, _regIndex, _val, _numRegs);
+ }
+
+ void commitShaderConstants(uint16_t _programIdx, D3D12_GPU_VIRTUAL_ADDRESS& _gpuAddress)
+ {
+ ProgramD3D12& program = m_program[_programIdx];
+ uint32_t total = bx::strideAlign(0
+ + program.m_vsh->m_size
+ + (NULL != program.m_fsh ? program.m_fsh->m_size : 0)
+ , D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT
+ );
+ uint8_t* data = (uint8_t*)m_scratchBuffer[m_backBufferColorIdx].allocCbv(_gpuAddress, total);
+
+ {
+ uint32_t size = program.m_vsh->m_size;
+ memcpy(data, m_vsScratch, size);
+ data += size;
+
+ m_vsChanges = 0;
+ }
+
+ if (NULL != program.m_fsh)
+ {
+ memcpy(data, m_fsScratch, program.m_fsh->m_size);
+
+ m_fsChanges = 0;
+ }
+ }
+
+ void setFrameBuffer(FrameBufferHandle _fbh, bool _msaa = true)
+ {
+ if (isValid(m_fbh)
+ && m_fbh.idx != _fbh.idx)
+ {
+ const FrameBufferD3D12& frameBuffer = m_frameBuffers[m_fbh.idx];
+
+ for (uint8_t ii = 0, num = frameBuffer.m_num; ii < num; ++ii)
+ {
+ TextureD3D12& texture = m_textures[frameBuffer.m_texture[ii].idx];
+ texture.setState(m_commandList, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE);
+ }
+
+ if (isValid(frameBuffer.m_depth) )
+ {
+ TextureD3D12& texture = m_textures[frameBuffer.m_depth.idx];
+ const bool bufferOnly = 0 != (texture.m_flags&BGFX_TEXTURE_RT_BUFFER_ONLY);
+ if (!bufferOnly)
+ {
+ texture.setState(m_commandList, D3D12_RESOURCE_STATE_DEPTH_READ);
+ }
+ }
+ }
+
+ if (!isValid(_fbh) )
+ {
+ m_rtvHandle = m_rtvDescriptorHeap->GetCPUDescriptorHandleForHeapStart();
+ uint32_t rtvDescriptorSize = m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
+ m_rtvHandle.ptr += m_backBufferColorIdx * rtvDescriptorSize;
+ m_dsvHandle = m_dsvDescriptorHeap->GetCPUDescriptorHandleForHeapStart();
+
+ m_currentColor = &m_rtvHandle;
+ m_currentDepthStencil = &m_dsvHandle;
+ m_commandList->OMSetRenderTargets(1, m_currentColor, true, m_currentDepthStencil);
+ }
+ else
+ {
+ const FrameBufferD3D12& frameBuffer = m_frameBuffers[_fbh.idx];
+
+ if (0 < frameBuffer.m_num)
+ {
+ D3D12_CPU_DESCRIPTOR_HANDLE rtvDescriptor = m_rtvDescriptorHeap->GetCPUDescriptorHandleForHeapStart();
+ uint32_t rtvDescriptorSize = m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
+ m_rtvHandle.ptr = rtvDescriptor.ptr + (BX_COUNTOF(m_backBufferColor) + _fbh.idx * BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS) * rtvDescriptorSize;
+ m_currentColor = &m_rtvHandle;
+ }
+ else
+ {
+ m_currentColor = NULL;
+ }
+
+ if (isValid(frameBuffer.m_depth) )
+ {
+ D3D12_CPU_DESCRIPTOR_HANDLE dsvDescriptor = m_dsvDescriptorHeap->GetCPUDescriptorHandleForHeapStart();
+ uint32_t dsvDescriptorSize = m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_DSV);
+ m_dsvHandle.ptr = dsvDescriptor.ptr + (1 + _fbh.idx) * dsvDescriptorSize;
+ m_currentDepthStencil = &m_dsvHandle;
+ }
+ else
+ {
+ m_currentDepthStencil = NULL;
+ }
+
+ for (uint8_t ii = 0, num = frameBuffer.m_num; ii < num; ++ii)
+ {
+ TextureD3D12& texture = m_textures[frameBuffer.m_texture[ii].idx];
+ texture.setState(m_commandList, D3D12_RESOURCE_STATE_RENDER_TARGET);
+ }
+
+ if (isValid(frameBuffer.m_depth) )
+ {
+ TextureD3D12& texture = m_textures[frameBuffer.m_depth.idx];
+ texture.setState(m_commandList, D3D12_RESOURCE_STATE_DEPTH_WRITE);
+ }
+
+ m_commandList->OMSetRenderTargets(frameBuffer.m_num
+ , m_currentColor
+ , true
+ , m_currentDepthStencil
+ );
+ }
+
+ m_fbh = _fbh;
+ m_rtMsaa = _msaa;
+ }
+
+ void setBlendState(D3D12_BLEND_DESC& desc, uint64_t _state, uint32_t _rgba = 0)
+ {
+ memset(&desc, 0, sizeof(desc) );
+ desc.IndependentBlendEnable = !!(BGFX_STATE_BLEND_INDEPENDENT & _state);
+
+ D3D12_RENDER_TARGET_BLEND_DESC* drt = &desc.RenderTarget[0];
+ drt->BlendEnable = !!(BGFX_STATE_BLEND_MASK & _state);
+
+ {
+ const uint32_t blend = uint32_t( (_state & BGFX_STATE_BLEND_MASK ) >> BGFX_STATE_BLEND_SHIFT);
+ const uint32_t equation = uint32_t( (_state & BGFX_STATE_BLEND_EQUATION_MASK) >> BGFX_STATE_BLEND_EQUATION_SHIFT);
+
+ const uint32_t srcRGB = (blend ) & 0xf;
+ const uint32_t dstRGB = (blend >> 4) & 0xf;
+ const uint32_t srcA = (blend >> 8) & 0xf;
+ const uint32_t dstA = (blend >> 12) & 0xf;
+
+ const uint32_t equRGB = (equation ) & 0x7;
+ const uint32_t equA = (equation >> 3) & 0x7;
+
+ drt->SrcBlend = s_blendFactor[srcRGB][0];
+ drt->DestBlend = s_blendFactor[dstRGB][0];
+ drt->BlendOp = s_blendEquation[equRGB];
+
+ drt->SrcBlendAlpha = s_blendFactor[srcA][1];
+ drt->DestBlendAlpha = s_blendFactor[dstA][1];
+ drt->BlendOpAlpha = s_blendEquation[equA];
+ }
+
+ uint8_t writeMask = (_state & BGFX_STATE_ALPHA_WRITE)
+ ? D3D12_COLOR_WRITE_ENABLE_ALPHA
+ : 0
+ ;
+ writeMask |= (_state & BGFX_STATE_RGB_WRITE)
+ ? D3D12_COLOR_WRITE_ENABLE_RED
+ | D3D12_COLOR_WRITE_ENABLE_GREEN
+ | D3D12_COLOR_WRITE_ENABLE_BLUE
+ : 0
+ ;
+
+ drt->RenderTargetWriteMask = writeMask;
+
+ if (desc.IndependentBlendEnable)
+ {
+ for (uint32_t ii = 1, rgba = _rgba; ii < BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS; ++ii, rgba >>= 11)
+ {
+ drt = &desc.RenderTarget[ii];
+ drt->BlendEnable = 0 != (rgba & 0x7ff);
+
+ const uint32_t src = (rgba ) & 0xf;
+ const uint32_t dst = (rgba >> 4) & 0xf;
+ const uint32_t equation = (rgba >> 8) & 0x7;
+
+ drt->SrcBlend = s_blendFactor[src][0];
+ drt->DestBlend = s_blendFactor[dst][0];
+ drt->BlendOp = s_blendEquation[equation];
+
+ drt->SrcBlendAlpha = s_blendFactor[src][1];
+ drt->DestBlendAlpha = s_blendFactor[dst][1];
+ drt->BlendOpAlpha = s_blendEquation[equation];
+
+ drt->RenderTargetWriteMask = writeMask;
+ }
+ }
+ else
+ {
+ for (uint32_t ii = 1; ii < BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS; ++ii)
+ {
+ memcpy(&desc.RenderTarget[ii], drt, sizeof(D3D12_RENDER_TARGET_BLEND_DESC) );
+ }
+ }
+ }
+
+ void setRasterizerState(D3D12_RASTERIZER_DESC& desc, uint64_t _state, bool _wireframe = false)
+ {
+ const uint32_t cull = (_state&BGFX_STATE_CULL_MASK) >> BGFX_STATE_CULL_SHIFT;
+
+ desc.FillMode = _wireframe
+ ? D3D12_FILL_MODE_WIREFRAME
+ : D3D12_FILL_MODE_SOLID
+ ;
+ desc.CullMode = s_cullMode[cull];
+ desc.FrontCounterClockwise = false;
+ desc.DepthBias = 0;
+ desc.DepthBiasClamp = 0.0f;
+ desc.SlopeScaledDepthBias = 0.0f;
+ desc.DepthClipEnable = false;
+ desc.MultisampleEnable = !!(_state&BGFX_STATE_MSAA);
+ desc.AntialiasedLineEnable = false;
+ desc.ForcedSampleCount = 0;
+ desc.ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF;
+ }
+
+ void setDepthStencilState(D3D12_DEPTH_STENCIL_DESC& desc, uint64_t _state, uint64_t _stencil = 0)
+ {
+ const uint32_t fstencil = unpackStencil(0, _stencil);
+
+ memset(&desc, 0, sizeof(desc) );
+ uint32_t func = (_state&BGFX_STATE_DEPTH_TEST_MASK)>>BGFX_STATE_DEPTH_TEST_SHIFT;
+ desc.DepthEnable = 0 != func;
+ desc.DepthWriteMask = !!(BGFX_STATE_DEPTH_WRITE & _state)
+ ? D3D12_DEPTH_WRITE_MASK_ALL
+ : D3D12_DEPTH_WRITE_MASK_ZERO
+ ;
+ desc.DepthFunc = s_cmpFunc[func];
+
+ uint32_t bstencil = unpackStencil(1, _stencil);
+ uint32_t frontAndBack = bstencil != BGFX_STENCIL_NONE && bstencil != fstencil;
+ bstencil = frontAndBack ? bstencil : fstencil;
+
+ desc.StencilEnable = 0 != _stencil;
+ desc.StencilReadMask = (fstencil & BGFX_STENCIL_FUNC_RMASK_MASK) >> BGFX_STENCIL_FUNC_RMASK_SHIFT;
+ desc.StencilWriteMask = 0xff;
+
+ desc.FrontFace.StencilFailOp = s_stencilOp[(fstencil & BGFX_STENCIL_OP_FAIL_S_MASK) >> BGFX_STENCIL_OP_FAIL_S_SHIFT];
+ desc.FrontFace.StencilDepthFailOp = s_stencilOp[(fstencil & BGFX_STENCIL_OP_FAIL_Z_MASK) >> BGFX_STENCIL_OP_FAIL_Z_SHIFT];
+ desc.FrontFace.StencilPassOp = s_stencilOp[(fstencil & BGFX_STENCIL_OP_PASS_Z_MASK) >> BGFX_STENCIL_OP_PASS_Z_SHIFT];
+ desc.FrontFace.StencilFunc = s_cmpFunc[(fstencil & BGFX_STENCIL_TEST_MASK) >> BGFX_STENCIL_TEST_SHIFT];
+
+ desc.BackFace.StencilFailOp = s_stencilOp[(bstencil & BGFX_STENCIL_OP_FAIL_S_MASK) >> BGFX_STENCIL_OP_FAIL_S_SHIFT];
+ desc.BackFace.StencilDepthFailOp = s_stencilOp[(bstencil & BGFX_STENCIL_OP_FAIL_Z_MASK) >> BGFX_STENCIL_OP_FAIL_Z_SHIFT];
+ desc.BackFace.StencilPassOp = s_stencilOp[(bstencil & BGFX_STENCIL_OP_PASS_Z_MASK) >> BGFX_STENCIL_OP_PASS_Z_SHIFT];
+ desc.BackFace.StencilFunc = s_cmpFunc[(bstencil&BGFX_STENCIL_TEST_MASK) >> BGFX_STENCIL_TEST_SHIFT];
+ }
+
+ uint32_t setInputLayout(D3D12_INPUT_ELEMENT_DESC* _vertexElements, const VertexDecl& _vertexDecl, const ProgramD3D12& _program, uint8_t _numInstanceData)
+ {
+ VertexDecl decl;
+ memcpy(&decl, &_vertexDecl, sizeof(VertexDecl) );
+ const uint16_t* attrMask = _program.m_vsh->m_attrMask;
+
+ for (uint32_t ii = 0; ii < Attrib::Count; ++ii)
+ {
+ uint16_t mask = attrMask[ii];
+ uint16_t attr = (decl.m_attributes[ii] & mask);
+ decl.m_attributes[ii] = attr == 0 ? UINT16_MAX : attr == UINT16_MAX ? 0 : attr;
+ }
+
+ D3D12_INPUT_ELEMENT_DESC* elem = fillVertexDecl(_vertexElements, decl);
+ uint32_t num = uint32_t(elem-_vertexElements);
+
+ const D3D12_INPUT_ELEMENT_DESC inst = { "TEXCOORD", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA, 1 };
+
+ for (uint32_t ii = 0; ii < _numInstanceData; ++ii)
+ {
+ uint32_t index = 7 - ii; // TEXCOORD7 = i_data0, TEXCOORD6 = i_data1, etc.
+
+ uint32_t jj;
+ D3D12_INPUT_ELEMENT_DESC* curr = _vertexElements;
+ for (jj = 0; jj < num; ++jj)
+ {
+ curr = &_vertexElements[jj];
+ if (0 == strcmp(curr->SemanticName, "TEXCOORD")
+ && curr->SemanticIndex == index)
+ {
+ break;
+ }
+ }
+
+ if (jj == num)
+ {
+ curr = elem;
+ ++elem;
+ }
+
+ memcpy(curr, &inst, sizeof(D3D12_INPUT_ELEMENT_DESC) );
+ curr->InputSlot = 1;
+ curr->SemanticIndex = index;
+ curr->AlignedByteOffset = ii*16;
+ }
+
+ return uint32_t(elem-_vertexElements);
+ }
+
+ static void patchCb0(DxbcInstruction& _instruction, void* _userData)
+ {
+ union { void* ptr; uint32_t offset; } cast = { _userData };
+
+ for (uint32_t ii = 0; ii < _instruction.numOperands; ++ii)
+ {
+ DxbcOperand& operand = _instruction.operand[ii];
+ if (DxbcOperandType::ConstantBuffer == operand.type)
+ {
+ if (DxbcOperandAddrMode::Imm32 == operand.addrMode[0]
+ && 0 == operand.regIndex[0]
+ && DxbcOperandAddrMode::Imm32 == operand.addrMode[1])
+ {
+ operand.regIndex[1] += cast.offset;
+ }
+ }
+ }
+ }
+
+ ID3D12PipelineState* getPipelineState(uint16_t _programIdx)
+ {
+ ProgramD3D12& program = m_program[_programIdx];
+
+ const uint32_t hash = program.m_vsh->m_hash;
+
+ ID3D12PipelineState* pso = m_pipelineStateCache.find(hash);
+
+ if (BX_LIKELY(NULL != pso) )
+ {
+ return pso;
+ }
+
+ D3D12_COMPUTE_PIPELINE_STATE_DESC desc;
+ memset(&desc, 0, sizeof(desc) );
+
+ desc.pRootSignature = m_rootSignature;
+
+ desc.CS.pShaderBytecode = program.m_vsh->m_code->data;
+ desc.CS.BytecodeLength = program.m_vsh->m_code->size;
+
+ DX_CHECK(m_device->CreateComputePipelineState(&desc
+ , IID_ID3D12PipelineState
+ , (void**)&pso
+ ) );
+ m_pipelineStateCache.add(hash, pso);
+
+ return pso;
+ }
+
+ ID3D12PipelineState* getPipelineState(uint64_t _state, uint64_t _stencil, uint16_t _declIdx, uint16_t _programIdx, uint8_t _numInstanceData)
+ {
+ ProgramD3D12& program = m_program[_programIdx];
+
+ _state &= 0
+ | BGFX_STATE_RGB_WRITE
+ | BGFX_STATE_ALPHA_WRITE
+ | BGFX_STATE_DEPTH_WRITE
+ | BGFX_STATE_DEPTH_TEST_MASK
+ | BGFX_STATE_BLEND_MASK
+ | BGFX_STATE_BLEND_EQUATION_MASK
+ | BGFX_STATE_BLEND_INDEPENDENT
+ | BGFX_STATE_CULL_MASK
+ | BGFX_STATE_MSAA
+ | BGFX_STATE_PT_MASK
+ ;
+
+ _stencil &= packStencil(~BGFX_STENCIL_FUNC_REF_MASK, BGFX_STENCIL_MASK);
+
+ VertexDecl decl;
+ memcpy(&decl, &m_vertexDecls[_declIdx], sizeof(VertexDecl) );
+ const uint16_t* attrMask = program.m_vsh->m_attrMask;
+
+ for (uint32_t ii = 0; ii < Attrib::Count; ++ii)
+ {
+ uint16_t mask = attrMask[ii];
+ uint16_t attr = (decl.m_attributes[ii] & mask);
+ decl.m_attributes[ii] = attr == 0 ? UINT16_MAX : attr == UINT16_MAX ? 0 : attr;
+ }
+
+ bx::HashMurmur2A murmur;
+ murmur.begin();
+ murmur.add(_state);
+ murmur.add(_stencil);
+ murmur.add(program.m_vsh->m_hash);
+ murmur.add(program.m_vsh->m_attrMask, sizeof(program.m_vsh->m_attrMask) );
+ murmur.add(program.m_fsh->m_hash);
+ murmur.add(m_vertexDecls[_declIdx].m_hash);
+ murmur.add(decl.m_attributes, sizeof(decl.m_attributes) );
+ murmur.add(m_fbh.idx);
+ murmur.add(_numInstanceData);
+ const uint32_t hash = murmur.end();
+
+ ID3D12PipelineState* pso = m_pipelineStateCache.find(hash);
+
+ if (NULL != pso)
+ {
+ return pso;
+ }
+
+ D3D12_GRAPHICS_PIPELINE_STATE_DESC desc;
+ memset(&desc, 0, sizeof(desc) );
+
+ desc.pRootSignature = m_rootSignature;
+
+ desc.VS.pShaderBytecode = program.m_vsh->m_code->data;
+ desc.VS.BytecodeLength = program.m_vsh->m_code->size;
+
+ const Memory* temp = alloc(program.m_fsh->m_code->size);
+ memset(temp->data, 0, temp->size);
+ bx::MemoryReader rd(program.m_fsh->m_code->data, program.m_fsh->m_code->size);
+ bx::StaticMemoryBlockWriter wr(temp->data, temp->size);
+
+ DxbcContext dxbc;
+ read(&rd, dxbc);
+
+ bool patchShader = true;
+ if (BX_ENABLED(BGFX_CONFIG_DEBUG) )
+ {
+ union { uint32_t offset; void* ptr; } cast = { 0 };
+ filter(dxbc.shader, dxbc.shader, patchCb0, cast.ptr);
+
+ write(&wr, dxbc);
+
+ dxbcHash(temp->data + 20, temp->size - 20, temp->data + 4);
+
+ patchShader = 0 == memcmp(program.m_fsh->m_code->data, temp->data, 16);
+ BX_CHECK(patchShader, "DXBC fragment shader patching error (ShaderHandle: %d).", program.m_fsh - m_shaders);
+
+ if (!patchShader)
+ {
+ for (uint32_t ii = 20; ii < temp->size; ii += 16)
+ {
+ if (0 != memcmp(&program.m_fsh->m_code->data[ii], &temp->data[ii], 16) )
+ {
+// dbgPrintfData(&program.m_fsh->m_code->data[ii], temp->size-ii, "");
+// dbgPrintfData(&temp->data[ii], temp->size-ii, "");
+ break;
+ }
+ }
+
+ desc.PS.pShaderBytecode = program.m_fsh->m_code->data;
+ desc.PS.BytecodeLength = program.m_fsh->m_code->size;
+ }
+ }
+
+ if (patchShader)
+ {
+ memcpy(temp->data, program.m_fsh->m_code->data, program.m_fsh->m_code->size);
+
+ bx::seek(&wr, 0, bx::Whence::Begin);
+ union { uint32_t offset; void* ptr; } cast =
+ {
+ uint32_t(program.m_vsh->m_size)/16
+ };
+ filter(dxbc.shader, dxbc.shader, patchCb0, cast.ptr);
+ write(&wr, dxbc);
+ dxbcHash(temp->data + 20, temp->size - 20, temp->data + 4);
+
+ desc.PS.pShaderBytecode = temp->data;
+ desc.PS.BytecodeLength = temp->size;
+ }
+
+ desc.DS.pShaderBytecode = NULL;
+ desc.DS.BytecodeLength = 0;
+
+ desc.HS.pShaderBytecode = NULL;
+ desc.HS.BytecodeLength = 0;
+
+ desc.GS.pShaderBytecode = NULL;
+ desc.GS.BytecodeLength = 0;
+
+ desc.StreamOutput.pSODeclaration = NULL;
+ desc.StreamOutput.NumEntries = 0;
+ desc.StreamOutput.pBufferStrides = NULL;
+ desc.StreamOutput.NumStrides = 0;
+ desc.StreamOutput.RasterizedStream = 0;
+
+ setBlendState(desc.BlendState, _state);
+ desc.SampleMask = 1;
+ setRasterizerState(desc.RasterizerState, _state);
+ setDepthStencilState(desc.DepthStencilState, _state, _stencil);
+
+ D3D12_INPUT_ELEMENT_DESC vertexElements[Attrib::Count + 1 + BGFX_CONFIG_MAX_INSTANCE_DATA_COUNT];
+ desc.InputLayout.NumElements = setInputLayout(vertexElements, m_vertexDecls[_declIdx], program, _numInstanceData);
+ desc.InputLayout.pInputElementDescs = vertexElements;
+
+ uint8_t primIndex = uint8_t( (_state&BGFX_STATE_PT_MASK) >> BGFX_STATE_PT_SHIFT);
+ desc.PrimitiveTopologyType = s_primInfo[primIndex].m_topologyType;
+
+ if (isValid(m_fbh) )
+ {
+ const FrameBufferD3D12& frameBuffer = m_frameBuffers[m_fbh.idx];
+ desc.NumRenderTargets = frameBuffer.m_num;
+
+ for (uint8_t ii = 0, num = frameBuffer.m_num; ii < num; ++ii)
+ {
+ desc.RTVFormats[ii] = m_textures[frameBuffer.m_texture[ii].idx].m_srvd.Format;
+ }
+
+ if (isValid(frameBuffer.m_depth) )
+ {
+ desc.DSVFormat = s_textureFormat[m_textures[frameBuffer.m_depth.idx].m_textureFormat].m_fmtDsv;
+ }
+ else
+ {
+ desc.DSVFormat = DXGI_FORMAT_UNKNOWN;
+ }
+ }
+ else
+ {
+ desc.NumRenderTargets = 1;
+ desc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM;
+ desc.DSVFormat = DXGI_FORMAT_D24_UNORM_S8_UINT;
+ }
+
+ desc.SampleDesc.Count = 1;
+ desc.SampleDesc.Quality = 0;
+
+ uint32_t length = g_callback->cacheReadSize(hash);
+ bool cached = length > 0;
+
+ void* cachedData = NULL;
+
+ if (cached)
+ {
+ cachedData = BX_ALLOC(g_allocator, length);
+ if (g_callback->cacheRead(hash, cachedData, length) )
+ {
+ BX_TRACE("Loading cached PSO (size %d).", length);
+ bx::MemoryReader reader(cachedData, length);
+
+ desc.CachedPSO.pCachedBlob = reader.getDataPtr();
+ desc.CachedPSO.CachedBlobSizeInBytes = (size_t)reader.remaining();
+
+ HRESULT hr = m_device->CreateGraphicsPipelineState(&desc
+ , IID_ID3D12PipelineState
+ , (void**)&pso
+ );
+ if (FAILED(hr) )
+ {
+ BX_TRACE("Failed to load cached PSO (HRESULT 0x%08x).", hr);
+ memset(&desc.CachedPSO, 0, sizeof(desc.CachedPSO) );
+ }
+ }
+ }
+
+ if (NULL == pso)
+ {
+ DX_CHECK(m_device->CreateGraphicsPipelineState(&desc
+ , IID_ID3D12PipelineState
+ , (void**)&pso
+ ) );
+ }
+ m_pipelineStateCache.add(hash, pso);
+
+ release(temp);
+
+ ID3DBlob* blob;
+ HRESULT hr = pso->GetCachedBlob(&blob);
+ if (SUCCEEDED(hr) )
+ {
+ void* data = blob->GetBufferPointer();
+ length = (uint32_t)blob->GetBufferSize();
+
+ g_callback->cacheWrite(hash, data, length);
+
+ DX_RELEASE(blob, 0);
+ }
+
+ if (NULL != cachedData)
+ {
+ BX_FREE(g_allocator, cachedData);
+ }
+
+ return pso;
+ }
+
+ uint16_t getSamplerState(const uint32_t* _flags, uint32_t _num, const float _palette[][4])
+ {
+ bx::HashMurmur2A murmur;
+ murmur.begin();
+ murmur.add(_flags, _num * sizeof(uint32_t) );
+ uint32_t hash = murmur.end();
+
+ uint16_t sampler = m_samplerStateCache.find(hash);
+ if (UINT16_MAX == sampler)
+ {
+ sampler = m_samplerAllocator.alloc(_flags, _num, _palette);
+ m_samplerStateCache.add(hash, sampler);
+ }
+
+ return sampler;
+ }
+
+ void commit(UniformBuffer& _uniformBuffer)
+ {
+ _uniformBuffer.reset();
+
+ for (;;)
+ {
+ uint32_t opcode = _uniformBuffer.read();
+
+ if (UniformType::End == opcode)
+ {
+ break;
+ }
+
+ UniformType::Enum type;
+ uint16_t loc;
+ uint16_t num;
+ uint16_t copy;
+ UniformBuffer::decodeOpcode(opcode, type, loc, num, copy);
+
+ const char* data;
+ if (copy)
+ {
+ data = _uniformBuffer.read(g_uniformTypeSize[type]*num);
+ }
+ else
+ {
+ UniformHandle handle;
+ memcpy(&handle, _uniformBuffer.read(sizeof(UniformHandle) ), sizeof(UniformHandle) );
+ data = (const char*)m_uniforms[handle.idx];
+ }
+
+#define CASE_IMPLEMENT_UNIFORM(_uniform, _dxsuffix, _type) \
+ case UniformType::_uniform: \
+ case UniformType::_uniform|BGFX_UNIFORM_FRAGMENTBIT: \
+ { \
+ setShaderUniform(uint8_t(type), loc, data, num); \
+ } \
+ break;
+
+ switch ( (uint32_t)type)
+ {
+ case UniformType::Mat3:
+ case UniformType::Mat3|BGFX_UNIFORM_FRAGMENTBIT:
+ {
+ float* value = (float*)data;
+ for (uint32_t ii = 0, count = num/3; ii < count; ++ii, loc += 3*16, value += 9)
+ {
+ Matrix4 mtx;
+ mtx.un.val[ 0] = value[0];
+ mtx.un.val[ 1] = value[1];
+ mtx.un.val[ 2] = value[2];
+ mtx.un.val[ 3] = 0.0f;
+ mtx.un.val[ 4] = value[3];
+ mtx.un.val[ 5] = value[4];
+ mtx.un.val[ 6] = value[5];
+ mtx.un.val[ 7] = 0.0f;
+ mtx.un.val[ 8] = value[6];
+ mtx.un.val[ 9] = value[7];
+ mtx.un.val[10] = value[8];
+ mtx.un.val[11] = 0.0f;
+ setShaderUniform(uint8_t(type), loc, &mtx.un.val[0], 3);
+ }
+ }
+ break;
+
+ CASE_IMPLEMENT_UNIFORM(Int1, I, int);
+ CASE_IMPLEMENT_UNIFORM(Vec4, F, float);
+ CASE_IMPLEMENT_UNIFORM(Mat4, F, float);
+
+ case UniformType::End:
+ break;
+
+ default:
+ BX_TRACE("%4d: INVALID 0x%08x, t %d, l %d, n %d, c %d", _uniformBuffer.getPos(), opcode, type, loc, num, copy);
+ break;
+ }
+#undef CASE_IMPLEMENT_UNIFORM
+ }
+ }
+
+ void clear(const Clear& _clear, const float _palette[][4], const D3D12_RECT* _rect = NULL, uint32_t _num = 0)
+ {
+ if (isValid(m_fbh) )
+ {
+ FrameBufferD3D12& frameBuffer = m_frameBuffers[m_fbh.idx];
+ frameBuffer.clear(m_commandList, _clear, _palette);
+ }
+ else
+ {
+ if (NULL != m_currentColor
+ && BGFX_CLEAR_COLOR & _clear.m_flags)
+ {
+ if (BGFX_CLEAR_COLOR_USE_PALETTE & _clear.m_flags)
+ {
+ uint8_t index = _clear.m_index[0];
+ if (UINT8_MAX != index)
+ {
+ m_commandList->ClearRenderTargetView(*m_currentColor
+ , _palette[index]
+ , _num
+ , _rect
+ );
+ }
+ }
+ else
+ {
+ float frgba[4] =
+ {
+ _clear.m_index[0] * 1.0f / 255.0f,
+ _clear.m_index[1] * 1.0f / 255.0f,
+ _clear.m_index[2] * 1.0f / 255.0f,
+ _clear.m_index[3] * 1.0f / 255.0f,
+ };
+ m_commandList->ClearRenderTargetView(*m_currentColor
+ , frgba
+ , _num
+ , _rect
+ );
+ }
+ }
+
+ if (NULL != m_currentDepthStencil
+ && (BGFX_CLEAR_DEPTH | BGFX_CLEAR_STENCIL) & _clear.m_flags)
+ {
+ uint32_t flags = 0;
+ flags |= (_clear.m_flags & BGFX_CLEAR_DEPTH ) ? D3D12_CLEAR_FLAG_DEPTH : 0;
+ flags |= (_clear.m_flags & BGFX_CLEAR_STENCIL) ? D3D12_CLEAR_FLAG_STENCIL : 0;
+
+ m_commandList->ClearDepthStencilView(*m_currentDepthStencil
+ , D3D12_CLEAR_FLAGS(flags)
+ , _clear.m_depth
+ , _clear.m_stencil
+ , _num
+ , _rect
+ );
+ }
+ }
+ }
+
+ void clearQuad(const Rect& _rect, const Clear& _clear, const float _palette[][4])
+ {
+ uint32_t width;
+ uint32_t height;
+
+ if (isValid(m_fbh) )
+ {
+ const FrameBufferD3D12& fb = m_frameBuffers[m_fbh.idx];
+ width = fb.m_width;
+ height = fb.m_height;
+ }
+ else
+ {
+ width = m_scd.BufferDesc.Width;
+ height = m_scd.BufferDesc.Height;
+ }
+
+ if (0 == _rect.m_x
+ && 0 == _rect.m_y
+ && width == _rect.m_width
+ && height == _rect.m_height)
+ {
+ clear(_clear, _palette);
+ }
+ else
+ {
+ D3D12_RECT rect;
+ rect.left = _rect.m_x;
+ rect.top = _rect.m_y;
+ rect.right = _rect.m_x + _rect.m_width;
+ rect.bottom = _rect.m_y + _rect.m_height;
+ clear(_clear, _palette, &rect);
+ }
+ }
+
+ uint64_t kick()
+ {
+ uint64_t fence = m_cmd.kick();
+ m_commandList = m_cmd.alloc();
+ return fence;
+ }
+
+ void finish()
+ {
+ m_cmd.kick();
+ m_cmd.finish();
+ m_commandList = NULL;
+ }
+
+ void finishAll()
+ {
+ uint64_t fence = m_cmd.kick();
+ m_cmd.finish(fence, true);
+ m_commandList = NULL;
+ }
+
+ void* m_kernel32dll;
+ void* m_d3d12dll;
+ void* m_dxgidll;
+
+ D3D_DRIVER_TYPE m_driverType;
+ IDXGIAdapter3* m_adapter;
+ DXGI_ADAPTER_DESC m_adapterDesc;
+ D3D12_FEATURE_DATA_ARCHITECTURE m_architecture;
+ D3D12_FEATURE_DATA_D3D12_OPTIONS m_options;
+
+ IDXGIFactory4* m_factory;
+
+ IDXGISwapChain3* m_swapChain;
+ int64_t m_presentElapsed;
+ uint16_t m_lost;
+ uint16_t m_numWindows;
+ FrameBufferHandle m_windows[BGFX_CONFIG_MAX_FRAME_BUFFERS];
+
+ ID3D12Device* m_device;
+ ID3D12InfoQueue* m_infoQueue;
+
+ ID3D12DescriptorHeap* m_rtvDescriptorHeap;
+ ID3D12DescriptorHeap* m_dsvDescriptorHeap;
+ D3D12_CPU_DESCRIPTOR_HANDLE m_rtvHandle;
+ D3D12_CPU_DESCRIPTOR_HANDLE m_dsvHandle;
+ D3D12_CPU_DESCRIPTOR_HANDLE* m_currentColor;
+ D3D12_CPU_DESCRIPTOR_HANDLE* m_currentDepthStencil;
+ ID3D12Resource* m_backBufferColor[4];
+ uint64_t m_backBufferColorFence[4];
+ ID3D12Resource* m_backBufferDepthStencil;
+
+ ScratchBufferD3D12 m_scratchBuffer[4];
+ DescriptorAllocatorD3D12 m_samplerAllocator;
+
+ ID3D12RootSignature* m_rootSignature;
+
+ CommandQueueD3D12 m_cmd;
+ BatchD3D12 m_batch;
+ ID3D12GraphicsCommandList* m_commandList;
+
+ Resolution m_resolution;
+ bool m_wireframe;
+
+ DXGI_SWAP_CHAIN_DESC m_scd;
+ uint32_t m_flags;
+ uint32_t m_maxAnisotropy;
+
+ BufferD3D12 m_indexBuffers[BGFX_CONFIG_MAX_INDEX_BUFFERS];
+ VertexBufferD3D12 m_vertexBuffers[BGFX_CONFIG_MAX_VERTEX_BUFFERS];
+ ShaderD3D12 m_shaders[BGFX_CONFIG_MAX_SHADERS];
+ ProgramD3D12 m_program[BGFX_CONFIG_MAX_PROGRAMS];
+ TextureD3D12 m_textures[BGFX_CONFIG_MAX_TEXTURES];
+ VertexDecl m_vertexDecls[BGFX_CONFIG_MAX_VERTEX_DECLS];
+ FrameBufferD3D12 m_frameBuffers[BGFX_CONFIG_MAX_FRAME_BUFFERS];
+ void* m_uniforms[BGFX_CONFIG_MAX_UNIFORMS];
+ Matrix4 m_predefinedUniforms[PredefinedUniform::Count];
+ UniformRegistry m_uniformReg;
+
+ StateCacheT<ID3D12PipelineState> m_pipelineStateCache;
+ StateCache m_samplerStateCache;
+
+ TextVideoMem m_textVideoMem;
+
+ uint8_t m_fsScratch[64<<10];
+ uint8_t m_vsScratch[64<<10];
+ uint32_t m_fsChanges;
+ uint32_t m_vsChanges;
+
+ FrameBufferHandle m_fbh;
+ uint32_t m_backBufferColorIdx;
+ bool m_rtMsaa;
+ };
+
+ static RendererContextD3D12* s_renderD3D12;
+
+ RendererContextI* rendererCreate()
+ {
+ s_renderD3D12 = BX_NEW(g_allocator, RendererContextD3D12);
+ if (!s_renderD3D12->init() )
+ {
+ BX_DELETE(g_allocator, s_renderD3D12);
+ s_renderD3D12 = NULL;
+ }
+ return s_renderD3D12;
+ }
+
+ void rendererDestroy()
+ {
+ s_renderD3D12->shutdown();
+ BX_DELETE(g_allocator, s_renderD3D12);
+ s_renderD3D12 = NULL;
+ }
+
+ void ScratchBufferD3D12::create(uint32_t _size, uint32_t _maxDescriptors)
+ {
+ m_size = _size;
+
+ ID3D12Device* device = s_renderD3D12->m_device;
+
+ m_incrementSize = device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
+
+ D3D12_DESCRIPTOR_HEAP_DESC desc;
+ desc.NumDescriptors = _maxDescriptors;
+ desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
+ desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
+ desc.NodeMask = 1;
+ DX_CHECK(device->CreateDescriptorHeap(&desc
+ , IID_ID3D12DescriptorHeap
+ , (void**)&m_heap
+ ) );
+
+ m_upload = createCommittedResource(device, HeapProperty::Upload, desc.NumDescriptors * 1024);
+ m_gpuVA = m_upload->GetGPUVirtualAddress();
+ m_upload->Map(0, NULL, (void**)&m_data);
+
+ reset(m_gpuHandle);
+ }
+
+ void ScratchBufferD3D12::destroy()
+ {
+ m_upload->Unmap(0, NULL);
+
+ DX_RELEASE(m_upload, 0);
+ DX_RELEASE(m_heap, 0);
+ }
+
+ void ScratchBufferD3D12::reset(D3D12_GPU_DESCRIPTOR_HANDLE& gpuHandle)
+ {
+ m_pos = 0;
+ m_cpuHandle = m_heap->GetCPUDescriptorHandleForHeapStart();
+ m_gpuHandle = m_heap->GetGPUDescriptorHandleForHeapStart();
+ gpuHandle = m_gpuHandle;
+ }
+
+ void* ScratchBufferD3D12::allocCbv(D3D12_GPU_VIRTUAL_ADDRESS& _gpuAddress, uint32_t _size)
+ {
+ _gpuAddress = m_gpuVA + m_pos;
+ D3D12_CONSTANT_BUFFER_VIEW_DESC desc;
+ desc.BufferLocation = _gpuAddress;
+ desc.SizeInBytes = _size;
+
+ void* data = &m_data[m_pos];
+
+ m_pos += BX_ALIGN_256(_size);
+
+ ID3D12Device* device = s_renderD3D12->m_device;
+ device->CreateConstantBufferView(&desc
+ , m_cpuHandle
+ );
+ m_cpuHandle.ptr += m_incrementSize;
+ m_gpuHandle.ptr += m_incrementSize;
+
+ return data;
+ }
+
+ void ScratchBufferD3D12::allocSrv(D3D12_GPU_DESCRIPTOR_HANDLE& _gpuHandle, TextureD3D12& _texture, uint8_t _mip)
+ {
+ ID3D12Device* device = s_renderD3D12->m_device;
+
+ D3D12_SHADER_RESOURCE_VIEW_DESC tmpSrvd;
+ D3D12_SHADER_RESOURCE_VIEW_DESC* srvd = &_texture.m_srvd;
+ if (0 != _mip)
+ {
+ memcpy(&tmpSrvd, srvd, sizeof(tmpSrvd) );
+ srvd = &tmpSrvd;
+
+ switch (_texture.m_srvd.ViewDimension)
+ {
+ default:
+ case D3D12_SRV_DIMENSION_TEXTURE2D:
+ srvd->Texture2D.MostDetailedMip = _mip;
+ srvd->Texture2D.MipLevels = 1;
+ srvd->Texture2D.PlaneSlice = 0;
+ srvd->Texture2D.ResourceMinLODClamp = 0;
+ break;
+
+ case D3D12_SRV_DIMENSION_TEXTURECUBE:
+ srvd->TextureCube.MostDetailedMip = _mip;
+ srvd->TextureCube.MipLevels = 1;
+ srvd->TextureCube.ResourceMinLODClamp = 0;
+ break;
+
+ case D3D12_SRV_DIMENSION_TEXTURE3D:
+ srvd->Texture3D.MostDetailedMip = _mip;
+ srvd->Texture3D.MipLevels = 1;
+ srvd->Texture3D.ResourceMinLODClamp = 0;
+ break;
+ }
+ }
+
+ device->CreateShaderResourceView(_texture.m_ptr
+ , srvd
+ , m_cpuHandle
+ );
+ m_cpuHandle.ptr += m_incrementSize;
+
+ _gpuHandle = m_gpuHandle;
+ m_gpuHandle.ptr += m_incrementSize;
+ }
+
+ void ScratchBufferD3D12::allocUav(D3D12_GPU_DESCRIPTOR_HANDLE& _gpuHandle, TextureD3D12& _texture, uint8_t _mip)
+ {
+ ID3D12Device* device = s_renderD3D12->m_device;
+
+ D3D12_UNORDERED_ACCESS_VIEW_DESC tmpUavd;
+ D3D12_UNORDERED_ACCESS_VIEW_DESC* uavd = &_texture.m_uavd;
+ if (0 != _mip)
+ {
+ memcpy(&tmpUavd, uavd, sizeof(tmpUavd) );
+ uavd = &tmpUavd;
+
+ switch (_texture.m_uavd.ViewDimension)
+ {
+ default:
+ case D3D12_UAV_DIMENSION_TEXTURE2D:
+ uavd->Texture2D.MipSlice = _mip;
+ uavd->Texture2D.PlaneSlice = 0;
+ break;
+
+ case D3D12_UAV_DIMENSION_TEXTURE3D:
+ uavd->Texture3D.MipSlice = _mip;
+ break;
+ }
+ }
+
+ device->CreateUnorderedAccessView(_texture.m_ptr
+ , NULL
+ , uavd
+ , m_cpuHandle
+ );
+ m_cpuHandle.ptr += m_incrementSize;
+
+ _gpuHandle = m_gpuHandle;
+ m_gpuHandle.ptr += m_incrementSize;
+ }
+
+ void ScratchBufferD3D12::allocSrv(D3D12_GPU_DESCRIPTOR_HANDLE& _gpuHandle, BufferD3D12& _buffer)
+ {
+ ID3D12Device* device = s_renderD3D12->m_device;
+ device->CreateShaderResourceView(_buffer.m_ptr
+ , &_buffer.m_srvd
+ , m_cpuHandle
+ );
+ m_cpuHandle.ptr += m_incrementSize;
+
+ _gpuHandle = m_gpuHandle;
+ m_gpuHandle.ptr += m_incrementSize;
+ }
+
+ void ScratchBufferD3D12::allocUav(D3D12_GPU_DESCRIPTOR_HANDLE& _gpuHandle, BufferD3D12& _buffer)
+ {
+ ID3D12Device* device = s_renderD3D12->m_device;
+ device->CreateUnorderedAccessView(_buffer.m_ptr
+ , NULL
+ , &_buffer.m_uavd
+ , m_cpuHandle
+ );
+ m_cpuHandle.ptr += m_incrementSize;
+
+ _gpuHandle = m_gpuHandle;
+ m_gpuHandle.ptr += m_incrementSize;
+ }
+
+ void DescriptorAllocatorD3D12::create(D3D12_DESCRIPTOR_HEAP_TYPE _type, uint16_t _maxDescriptors, uint16_t _numDescriptorsPerBlock)
+ {
+ m_handleAlloc = bx::createHandleAlloc(g_allocator, _maxDescriptors);
+ m_numDescriptorsPerBlock = _numDescriptorsPerBlock;
+
+ ID3D12Device* device = s_renderD3D12->m_device;
+
+ m_incrementSize = device->GetDescriptorHandleIncrementSize(_type);
+
+ D3D12_DESCRIPTOR_HEAP_DESC desc;
+ desc.NumDescriptors = _maxDescriptors;
+ desc.Type = _type;
+ desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
+ desc.NodeMask = 1;
+ DX_CHECK(device->CreateDescriptorHeap(&desc
+ , IID_ID3D12DescriptorHeap
+ , (void**)&m_heap
+ ) );
+
+ m_cpuHandle = m_heap->GetCPUDescriptorHandleForHeapStart();
+ m_gpuHandle = m_heap->GetGPUDescriptorHandleForHeapStart();
+ }
+
+ void DescriptorAllocatorD3D12::destroy()
+ {
+ bx::destroyHandleAlloc(g_allocator, m_handleAlloc);
+
+ DX_RELEASE(m_heap, 0);
+ }
+
+ uint16_t DescriptorAllocatorD3D12::alloc(ID3D12Resource* _ptr, const D3D12_SHADER_RESOURCE_VIEW_DESC* _desc)
+ {
+ uint16_t idx = m_handleAlloc->alloc();
+
+ D3D12_CPU_DESCRIPTOR_HANDLE cpuHandle = { m_cpuHandle.ptr + idx * m_incrementSize };
+
+ ID3D12Device* device = s_renderD3D12->m_device;
+ device->CreateShaderResourceView(_ptr
+ , _desc
+ , cpuHandle
+ );
+
+ return idx;
+ }
+
+ uint16_t DescriptorAllocatorD3D12::alloc(const uint32_t* _flags, uint32_t _num, const float _palette[][4])
+ {
+ uint16_t idx = m_handleAlloc->alloc();
+
+ ID3D12Device* device = s_renderD3D12->m_device;
+ uint32_t maxAnisotropy = s_renderD3D12->m_maxAnisotropy;
+
+ for (uint32_t ii = 0; ii < _num; ++ii)
+ {
+ uint32_t flags = _flags[ii];
+
+ const uint32_t cmpFunc = (flags&BGFX_TEXTURE_COMPARE_MASK)>>BGFX_TEXTURE_COMPARE_SHIFT;
+ const uint8_t minFilter = s_textureFilter[0][(flags&BGFX_TEXTURE_MIN_MASK)>>BGFX_TEXTURE_MIN_SHIFT];
+ const uint8_t magFilter = s_textureFilter[1][(flags&BGFX_TEXTURE_MAG_MASK)>>BGFX_TEXTURE_MAG_SHIFT];
+ const uint8_t mipFilter = s_textureFilter[2][(flags&BGFX_TEXTURE_MIP_MASK)>>BGFX_TEXTURE_MIP_SHIFT];
+ const uint8_t filter = 0 == cmpFunc ? 0 : D3D12_FILTER_COMPARISON_MIN_MAG_MIP_POINT;
+
+ D3D12_SAMPLER_DESC sd;
+ sd.Filter = (D3D12_FILTER)(filter|minFilter|magFilter|mipFilter);
+ sd.AddressU = s_textureAddress[(flags&BGFX_TEXTURE_U_MASK)>>BGFX_TEXTURE_U_SHIFT];
+ sd.AddressV = s_textureAddress[(flags&BGFX_TEXTURE_V_MASK)>>BGFX_TEXTURE_V_SHIFT];
+ sd.AddressW = s_textureAddress[(flags&BGFX_TEXTURE_W_MASK)>>BGFX_TEXTURE_W_SHIFT];
+ sd.MipLODBias = 0.0f;
+ sd.MaxAnisotropy = maxAnisotropy;
+ sd.ComparisonFunc = 0 == cmpFunc ? D3D12_COMPARISON_FUNC_NEVER : s_cmpFunc[cmpFunc];
+
+ uint32_t index = (flags & BGFX_TEXTURE_BORDER_COLOR_MASK) >> BGFX_TEXTURE_BORDER_COLOR_SHIFT;
+
+ if (NULL != _palette
+ && needBorderColor(flags) )
+ {
+ const float* rgba = _palette[index];
+ sd.BorderColor[0] = rgba[0];
+ sd.BorderColor[1] = rgba[1];
+ sd.BorderColor[2] = rgba[2];
+ sd.BorderColor[3] = rgba[3];
+ }
+ else
+ {
+ sd.BorderColor[0] = 0.0f;
+ sd.BorderColor[1] = 0.0f;
+ sd.BorderColor[2] = 0.0f;
+ sd.BorderColor[3] = 0.0f;
+ }
+ sd.MinLOD = 0;
+ sd.MaxLOD = D3D12_FLOAT32_MAX;
+
+ D3D12_CPU_DESCRIPTOR_HANDLE cpuHandle =
+ {
+ m_cpuHandle.ptr + (idx * m_numDescriptorsPerBlock + ii) * m_incrementSize
+ };
+
+ device->CreateSampler(&sd, cpuHandle);
+ }
+
+ return idx;
+ }
+
+ void DescriptorAllocatorD3D12::free(uint16_t _idx)
+ {
+ m_handleAlloc->free(_idx);
+ }
+
+ void DescriptorAllocatorD3D12::reset()
+ {
+ uint16_t max = m_handleAlloc->getMaxHandles();
+ bx::destroyHandleAlloc(g_allocator, m_handleAlloc);
+ m_handleAlloc = bx::createHandleAlloc(g_allocator, max);
+ }
+
+ D3D12_GPU_DESCRIPTOR_HANDLE DescriptorAllocatorD3D12::get(uint16_t _idx)
+ {
+ D3D12_GPU_DESCRIPTOR_HANDLE gpuHandle = { m_gpuHandle.ptr + _idx * m_numDescriptorsPerBlock * m_incrementSize };
+ return gpuHandle;
+ }
+
+ void CommandQueueD3D12::init(ID3D12Device* _device)
+ {
+ D3D12_COMMAND_QUEUE_DESC queueDesc;
+ queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
+ queueDesc.Priority = 0;
+ queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
+ queueDesc.NodeMask = 1;
+ DX_CHECK(_device->CreateCommandQueue(&queueDesc
+ , IID_ID3D12CommandQueue
+ , (void**)&m_commandQueue
+ ) );
+
+ m_completedFence = 0;
+ m_currentFence = 0;
+ DX_CHECK(_device->CreateFence(0
+ , D3D12_FENCE_FLAG_NONE
+ , IID_ID3D12Fence
+ , (void**)&m_fence
+ ) );
+
+ for (uint32_t ii = 0; ii < BX_COUNTOF(m_commandList); ++ii)
+ {
+ DX_CHECK(_device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT
+ , IID_ID3D12CommandAllocator
+ , (void**)&m_commandList[ii].m_commandAllocator
+ ) );
+
+ DX_CHECK(_device->CreateCommandList(0
+ , D3D12_COMMAND_LIST_TYPE_DIRECT
+ , m_commandList[ii].m_commandAllocator
+ , NULL
+ , IID_ID3D12GraphicsCommandList
+ , (void**)&m_commandList[ii].m_commandList
+ ) );
+
+ DX_CHECK(m_commandList[ii].m_commandList->Close() );
+ }
+ }
+
+ void CommandQueueD3D12::shutdown()
+ {
+ finish(UINT64_MAX, true);
+
+ DX_RELEASE(m_fence, 0);
+
+ for (uint32_t ii = 0; ii < BX_COUNTOF(m_commandList); ++ii)
+ {
+ DX_RELEASE(m_commandList[ii].m_commandAllocator, 0);
+ DX_RELEASE(m_commandList[ii].m_commandList, 0);
+ }
+
+ DX_RELEASE(m_commandQueue, 0);
+ }
+
+ ID3D12GraphicsCommandList* CommandQueueD3D12::alloc()
+ {
+ while (0 == m_control.reserve(1) )
+ {
+ consume();
+ }
+
+ CommandList& commandList = m_commandList[m_control.m_current];
+ DX_CHECK(commandList.m_commandAllocator->Reset() );
+ DX_CHECK(commandList.m_commandList->Reset(commandList.m_commandAllocator, NULL) );
+ return commandList.m_commandList;
+ }
+
+ uint64_t CommandQueueD3D12::kick()
+ {
+ CommandList& commandList = m_commandList[m_control.m_current];
+ DX_CHECK(commandList.m_commandList->Close() );
+
+ ID3D12CommandList* commandLists[] = { commandList.m_commandList };
+ m_commandQueue->ExecuteCommandLists(BX_COUNTOF(commandLists), commandLists);
+
+ commandList.m_event = CreateEventExA(NULL, NULL, 0, EVENT_ALL_ACCESS);
+ const uint64_t fence = m_currentFence++;
+ m_commandQueue->Signal(m_fence, fence);
+ m_fence->SetEventOnCompletion(fence, commandList.m_event);
+
+ m_control.commit(1);
+
+ return fence;
+ }
+
+ void CommandQueueD3D12::finish(uint64_t _waitFence, bool _finishAll)
+ {
+ while (0 < m_control.available() )
+ {
+ consume();
+
+ if (!_finishAll
+ && _waitFence <= m_completedFence)
+ {
+ return;
+ }
+ }
+
+ BX_CHECK(0 == m_control.available(), "");
+ }
+
+ bool CommandQueueD3D12::tryFinish(uint64_t _waitFence)
+ {
+ if (0 < m_control.available() )
+ {
+ if (consume(0)
+ && _waitFence <= m_completedFence)
+ {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ void CommandQueueD3D12::release(ID3D12Resource* _ptr)
+ {
+ m_release[m_control.m_current].push_back(_ptr);
+ }
+
+ bool CommandQueueD3D12::consume(uint32_t _ms)
+ {
+ CommandList& commandList = m_commandList[m_control.m_read];
+ if (WAIT_OBJECT_0 == WaitForSingleObject(commandList.m_event, _ms) )
+ {
+ CloseHandle(commandList.m_event);
+ commandList.m_event = NULL;
+ m_completedFence = m_fence->GetCompletedValue();
+ m_commandQueue->Wait(m_fence, m_completedFence);
+
+ ResourceArray& ra = m_release[m_control.m_read];
+ for (ResourceArray::iterator it = ra.begin(), itEnd = ra.end(); it != itEnd; ++it)
+ {
+ DX_RELEASE(*it, 0);
+ }
+ ra.clear();
+
+ m_control.consume(1);
+
+ return true;
+ }
+
+ return false;
+ }
+
+ void BatchD3D12::create(uint32_t _maxDrawPerBatch)
+ {
+ m_maxDrawPerBatch = _maxDrawPerBatch;
+ setSeqMode(false);
+ setIndirectMode(true);
+
+ ID3D12Device* device = s_renderD3D12->m_device;
+ ID3D12RootSignature* rootSignature = s_renderD3D12->m_rootSignature;
+
+ D3D12_INDIRECT_ARGUMENT_DESC drawArgDesc[] =
+ {
+ { D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT_BUFFER_VIEW, { { Rdt::CBV } } },
+ { D3D12_INDIRECT_ARGUMENT_TYPE_VERTEX_BUFFER_VIEW, { { 0 } } },
+ { D3D12_INDIRECT_ARGUMENT_TYPE_VERTEX_BUFFER_VIEW, { { 1 } } },
+ { D3D12_INDIRECT_ARGUMENT_TYPE_DRAW, { { 0 } } },
+ };
+
+ D3D12_COMMAND_SIGNATURE_DESC drawCommandSignature =
+ {
+ sizeof(DrawIndirectCommand),
+ BX_COUNTOF(drawArgDesc),
+ drawArgDesc,
+ 1,
+ };
+
+ DX_CHECK(device->CreateCommandSignature(&drawCommandSignature
+ , rootSignature
+ , IID_ID3D12CommandSignature
+ , (void**)&m_commandSignature[Draw]
+ ) );
+
+ D3D12_INDIRECT_ARGUMENT_DESC drawIndexedArgDesc[] =
+ {
+ { D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT_BUFFER_VIEW, { { Rdt::CBV } } },
+ { D3D12_INDIRECT_ARGUMENT_TYPE_VERTEX_BUFFER_VIEW, { { 0 } } },
+ { D3D12_INDIRECT_ARGUMENT_TYPE_VERTEX_BUFFER_VIEW, { { 1 } } },
+ { D3D12_INDIRECT_ARGUMENT_TYPE_INDEX_BUFFER_VIEW, { { 0 } } },
+ { D3D12_INDIRECT_ARGUMENT_TYPE_DRAW_INDEXED, { { 0 } } },
+ };
+
+ D3D12_COMMAND_SIGNATURE_DESC drawIndexedCommandSignature =
+ {
+ sizeof(DrawIndexedIndirectCommand),
+ BX_COUNTOF(drawIndexedArgDesc),
+ drawIndexedArgDesc,
+ 1,
+ };
+
+ DX_CHECK(device->CreateCommandSignature(&drawIndexedCommandSignature
+ , rootSignature
+ , IID_ID3D12CommandSignature
+ , (void**)&m_commandSignature[DrawIndexed]
+ ) );
+
+ m_cmds[Draw ] = BX_ALLOC(g_allocator, m_maxDrawPerBatch*sizeof(DrawIndirectCommand) );
+ m_cmds[DrawIndexed] = BX_ALLOC(g_allocator, m_maxDrawPerBatch*sizeof(DrawIndexedIndirectCommand) );
+
+ for (uint32_t ii = 0; ii < BX_COUNTOF(m_indirect); ++ii)
+ {
+ m_indirect[ii].create(m_maxDrawPerBatch*sizeof(DrawIndexedIndirectCommand)
+ , NULL
+ , BGFX_BUFFER_DRAW_INDIRECT
+ , false
+ , sizeof(DrawIndexedIndirectCommand)
+ );
+ }
+ }
+
+ void BatchD3D12::destroy()
+ {
+ BX_FREE(g_allocator, m_cmds[0]);
+ BX_FREE(g_allocator, m_cmds[1]);
+
+ DX_RELEASE(m_commandSignature[0], 0);
+ DX_RELEASE(m_commandSignature[1], 0);
+
+ for (uint32_t ii = 0; ii < BX_COUNTOF(m_indirect); ++ii)
+ {
+ m_indirect[ii].destroy();
+ }
+ }
+
+ template<typename Ty>
+ Ty& BatchD3D12::getCmd(Enum _type)
+ {
+ uint32_t index = m_num[_type];
+ BX_CHECK(index < m_maxDrawPerBatch, "Memory corruption...");
+ m_num[_type]++;
+ Ty* cmd = &reinterpret_cast<Ty*>(m_cmds[_type])[index];
+ return *cmd;
+ }
+
+ uint32_t BatchD3D12::draw(ID3D12GraphicsCommandList* _commandList, D3D12_GPU_VIRTUAL_ADDRESS _cbv, const RenderDraw& _draw)
+ {
+ Enum type = Enum(!!isValid(_draw.m_indexBuffer) );
+
+ VertexBufferD3D12& vb = s_renderD3D12->m_vertexBuffers[_draw.m_vertexBuffer.idx];
+ vb.setState(_commandList, D3D12_RESOURCE_STATE_GENERIC_READ);
+
+ uint16_t declIdx = !isValid(vb.m_decl) ? _draw.m_vertexDecl.idx : vb.m_decl.idx;
+ const VertexDecl& vertexDecl = s_renderD3D12->m_vertexDecls[declIdx];
+ uint32_t numIndices = 0;
+
+ if (Draw == type)
+ {
+ const uint32_t numVertices = UINT32_MAX == _draw.m_numVertices
+ ? vb.m_size / vertexDecl.m_stride
+ : _draw.m_numVertices
+ ;
+
+ DrawIndirectCommand& cmd = getCmd<DrawIndirectCommand>(Draw);
+ cmd.cbv = _cbv;
+ cmd.vbv[0].BufferLocation = vb.m_gpuVA;
+ cmd.vbv[0].StrideInBytes = vertexDecl.m_stride;
+ cmd.vbv[0].SizeInBytes = vb.m_size;
+ if (isValid(_draw.m_instanceDataBuffer) )
+ {
+ VertexBufferD3D12& inst = s_renderD3D12->m_vertexBuffers[_draw.m_instanceDataBuffer.idx];
+ inst.setState(_commandList, D3D12_RESOURCE_STATE_GENERIC_READ);
+ cmd.vbv[1].BufferLocation = inst.m_gpuVA + _draw.m_instanceDataOffset;
+ cmd.vbv[1].StrideInBytes = _draw.m_instanceDataStride;
+ cmd.vbv[1].SizeInBytes = _draw.m_numInstances * _draw.m_instanceDataStride;
+ }
+ else
+ {
+ memset(&cmd.vbv[1], 0, sizeof(cmd.vbv[1]) );
+ }
+ cmd.draw.InstanceCount = _draw.m_numInstances;
+ cmd.draw.VertexCountPerInstance = numVertices;
+ cmd.draw.StartVertexLocation = _draw.m_startVertex;
+ cmd.draw.StartInstanceLocation = 0;
+ }
+ else
+ {
+ BufferD3D12& ib = s_renderD3D12->m_indexBuffers[_draw.m_indexBuffer.idx];
+ ib.setState(_commandList, D3D12_RESOURCE_STATE_GENERIC_READ);
+
+ const bool hasIndex16 = 0 == (ib.m_flags & BGFX_BUFFER_INDEX32);
+ const uint32_t indexSize = hasIndex16 ? 2 : 4;
+
+ numIndices = UINT32_MAX == _draw.m_numIndices
+ ? ib.m_size / indexSize
+ : _draw.m_numIndices
+ ;
+
+ DrawIndexedIndirectCommand& cmd = getCmd<DrawIndexedIndirectCommand>(DrawIndexed);
+ cmd.cbv = _cbv;
+ cmd.ibv.BufferLocation = ib.m_gpuVA;
+ cmd.ibv.SizeInBytes = ib.m_size;
+ cmd.ibv.Format = hasIndex16
+ ? DXGI_FORMAT_R16_UINT
+ : DXGI_FORMAT_R32_UINT
+ ;
+ cmd.vbv[0].BufferLocation = vb.m_gpuVA;
+ cmd.vbv[0].StrideInBytes = vertexDecl.m_stride;
+ cmd.vbv[0].SizeInBytes = vb.m_size;
+ if (isValid(_draw.m_instanceDataBuffer) )
+ {
+ VertexBufferD3D12& inst = s_renderD3D12->m_vertexBuffers[_draw.m_instanceDataBuffer.idx];
+ inst.setState(_commandList, D3D12_RESOURCE_STATE_GENERIC_READ);
+ cmd.vbv[1].BufferLocation = inst.m_gpuVA + _draw.m_instanceDataOffset;
+ cmd.vbv[1].StrideInBytes = _draw.m_instanceDataStride;
+ cmd.vbv[1].SizeInBytes = _draw.m_numInstances * _draw.m_instanceDataStride;
+ }
+ else
+ {
+ memset(&cmd.vbv[1], 0, sizeof(cmd.vbv[1]) );
+ }
+ cmd.drawIndexed.IndexCountPerInstance = numIndices;
+ cmd.drawIndexed.InstanceCount = _draw.m_numInstances;
+ cmd.drawIndexed.StartIndexLocation = _draw.m_startIndex;
+ cmd.drawIndexed.BaseVertexLocation = _draw.m_startVertex;
+ cmd.drawIndexed.StartInstanceLocation = 0;
+ }
+
+ if (BX_UNLIKELY(m_flushPerBatch == m_num[type]) )
+ {
+ flush(_commandList, type);
+ }
+
+ return numIndices;
+ }
+
+ static const uint32_t s_indirectCommandSize[] =
+ {
+ sizeof(BatchD3D12::DrawIndirectCommand),
+ sizeof(BatchD3D12::DrawIndexedIndirectCommand),
+ };
+ BX_STATIC_ASSERT(BX_COUNTOF(s_indirectCommandSize) == BatchD3D12::Count);
+
+ void BatchD3D12::flush(ID3D12GraphicsCommandList* _commandList, Enum _type)
+ {
+ uint32_t num = m_num[_type];
+ if (0 != num)
+ {
+ m_num[_type] = 0;
+
+ if (m_minIndirect < num)
+ {
+ m_stats.m_numIndirect[_type]++;
+
+ BufferD3D12& indirect = m_indirect[m_currIndirect++];
+ m_currIndirect %= BX_COUNTOF(m_indirect);
+
+ indirect.update(_commandList, 0, num*s_indirectCommandSize[_type], m_cmds[_type]);
+
+ _commandList->ExecuteIndirect(m_commandSignature[_type]
+ , num
+ , indirect.m_ptr
+ , 0
+ , NULL
+ , 0
+ );
+ }
+ else
+ {
+ m_stats.m_numImmediate[_type]++;
+
+ if (Draw == _type)
+ {
+ const DrawIndirectCommand* cmds = reinterpret_cast<DrawIndirectCommand*>(m_cmds[_type]);
+
+ for (uint32_t ii = 0; ii < num; ++ii)
+ {
+ const DrawIndirectCommand& cmd = cmds[ii];
+ if (m_current.cbv != cmd.cbv)
+ {
+ m_current.cbv = cmd.cbv;
+ _commandList->SetGraphicsRootConstantBufferView(Rdt::CBV, cmd.cbv);
+ }
+
+ if (0 != memcmp(m_current.vbv, cmd.vbv, sizeof(cmd.vbv) ) )
+ {
+ memcpy(m_current.vbv, cmd.vbv, sizeof(cmd.vbv) );
+ _commandList->IASetVertexBuffers(0
+ , 0 == cmd.vbv[1].BufferLocation ? 1 : 2
+ , cmd.vbv
+ );
+ }
+
+ _commandList->DrawInstanced(
+ cmd.draw.VertexCountPerInstance
+ , cmd.draw.InstanceCount
+ , cmd.draw.StartVertexLocation
+ , cmd.draw.StartInstanceLocation
+ );
+ }
+ }
+ else
+ {
+ const DrawIndexedIndirectCommand* cmds = reinterpret_cast<DrawIndexedIndirectCommand*>(m_cmds[_type]);
+
+ for (uint32_t ii = 0; ii < num; ++ii)
+ {
+ const DrawIndexedIndirectCommand& cmd = cmds[ii];
+ if (m_current.cbv != cmd.cbv)
+ {
+ m_current.cbv = cmd.cbv;
+ _commandList->SetGraphicsRootConstantBufferView(Rdt::CBV, cmd.cbv);
+ }
+
+ if (0 != memcmp(m_current.vbv, cmd.vbv, sizeof(cmd.vbv) ) )
+ {
+ memcpy(m_current.vbv, cmd.vbv, sizeof(cmd.vbv) );
+ _commandList->IASetVertexBuffers(0
+ , 0 == cmd.vbv[1].BufferLocation ? 1 : 2
+ , cmd.vbv
+ );
+ }
+
+ if (0 != memcmp(&m_current.ibv, &cmd.ibv, sizeof(cmd.ibv) ) )
+ {
+ memcpy(&m_current.ibv, &cmd.ibv, sizeof(cmd.ibv) );
+ _commandList->IASetIndexBuffer(&cmd.ibv);
+ }
+
+ _commandList->DrawIndexedInstanced(
+ cmd.drawIndexed.IndexCountPerInstance
+ , cmd.drawIndexed.InstanceCount
+ , cmd.drawIndexed.StartIndexLocation
+ , cmd.drawIndexed.BaseVertexLocation
+ , cmd.drawIndexed.StartInstanceLocation
+ );
+ }
+ }
+ }
+ }
+ }
+
+ void BatchD3D12::flush(ID3D12GraphicsCommandList* _commandList, bool _clean)
+ {
+ flush(_commandList, Draw);
+ flush(_commandList, DrawIndexed);
+
+ if (_clean)
+ {
+ memset(&m_current, 0, sizeof(m_current) );
+ }
+ }
+
+ void BatchD3D12::begin()
+ {
+ memset(&m_stats, 0, sizeof(m_stats) );
+ memset(&m_current, 0, sizeof(m_current) );
+ }
+
+ void BatchD3D12::end(ID3D12GraphicsCommandList* _commandList)
+ {
+ flush(_commandList);
+ }
+
+ struct UavFormat
+ {
+ DXGI_FORMAT format[3];
+ uint32_t stride;
+ };
+
+ static const UavFormat s_uavFormat[] =
+ { // BGFX_BUFFER_COMPUTE_TYPE_UINT, BGFX_BUFFER_COMPUTE_TYPE_INT, BGFX_BUFFER_COMPUTE_TYPE_FLOAT
+ { { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, 0 }, // ignored
+ { { DXGI_FORMAT_R8_SINT, DXGI_FORMAT_R8_UINT, DXGI_FORMAT_UNKNOWN }, 1 }, // BGFX_BUFFER_COMPUTE_FORMAT_8x1
+ { { DXGI_FORMAT_R8G8_SINT, DXGI_FORMAT_R8G8_UINT, DXGI_FORMAT_UNKNOWN }, 2 }, // BGFX_BUFFER_COMPUTE_FORMAT_8x2
+ { { DXGI_FORMAT_R8G8B8A8_SINT, DXGI_FORMAT_R8G8B8A8_UINT, DXGI_FORMAT_UNKNOWN }, 4 }, // BGFX_BUFFER_COMPUTE_FORMAT_8x4
+ { { DXGI_FORMAT_R16_SINT, DXGI_FORMAT_R16_UINT, DXGI_FORMAT_R16_FLOAT }, 2 }, // BGFX_BUFFER_COMPUTE_FORMAT_16x1
+ { { DXGI_FORMAT_R16G16_SINT, DXGI_FORMAT_R16G16_UINT, DXGI_FORMAT_R16G16_FLOAT }, 4 }, // BGFX_BUFFER_COMPUTE_FORMAT_16x2
+ { { DXGI_FORMAT_R16G16B16A16_SINT, DXGI_FORMAT_R16G16B16A16_UINT, DXGI_FORMAT_R16G16B16A16_FLOAT }, 8 }, // BGFX_BUFFER_COMPUTE_FORMAT_16x4
+ { { DXGI_FORMAT_R32_SINT, DXGI_FORMAT_R32_UINT, DXGI_FORMAT_R32_FLOAT }, 4 }, // BGFX_BUFFER_COMPUTE_FORMAT_32x1
+ { { DXGI_FORMAT_R32G32_SINT, DXGI_FORMAT_R32G32_UINT, DXGI_FORMAT_R32G32_FLOAT }, 8 }, // BGFX_BUFFER_COMPUTE_FORMAT_32x2
+ { { DXGI_FORMAT_R32G32B32A32_SINT, DXGI_FORMAT_R32G32B32A32_UINT, DXGI_FORMAT_R32G32B32A32_FLOAT }, 16 }, // BGFX_BUFFER_COMPUTE_FORMAT_32x4
+ };
+
+ void BufferD3D12::create(uint32_t _size, void* _data, uint16_t _flags, bool _vertex, uint32_t _stride)
+ {
+ m_size = _size;
+ m_flags = _flags;
+
+ const bool needUav = 0 != (_flags & (BGFX_BUFFER_COMPUTE_WRITE|BGFX_BUFFER_DRAW_INDIRECT) );
+ const bool drawIndirect = 0 != (_flags & BGFX_BUFFER_DRAW_INDIRECT);
+ m_dynamic = NULL == _data || needUav;
+
+ DXGI_FORMAT format;
+ uint32_t stride;
+
+ D3D12_RESOURCE_FLAGS flags = needUav
+ ? D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS
+ : D3D12_RESOURCE_FLAG_NONE
+ ;
+
+ if (drawIndirect)
+ {
+ format = DXGI_FORMAT_R32G32B32A32_UINT;
+ stride = 16;
+ }
+ else
+ {
+ uint32_t uavFormat = (_flags & BGFX_BUFFER_COMPUTE_FORMAT_MASK) >> BGFX_BUFFER_COMPUTE_FORMAT_SHIFT;
+ if (0 == uavFormat)
+ {
+ if (_vertex)
+ {
+ format = DXGI_FORMAT_R32G32B32A32_FLOAT;
+ stride = 16;
+ }
+ else
+ {
+ if (0 == (_flags & BGFX_BUFFER_INDEX32) )
+ {
+ format = DXGI_FORMAT_R16_UINT;
+ stride = 2;
+ }
+ else
+ {
+ format = DXGI_FORMAT_R32_UINT;
+ stride = 4;
+ }
+ }
+ }
+ else
+ {
+ const uint32_t uavType = bx::uint32_satsub( (_flags & BGFX_BUFFER_COMPUTE_TYPE_MASK) >> BGFX_BUFFER_COMPUTE_TYPE_SHIFT, 1);
+ format = s_uavFormat[uavFormat].format[uavType];
+ stride = s_uavFormat[uavFormat].stride;
+ }
+ }
+
+ stride = 0 == _stride ? stride : _stride;
+
+ m_srvd.Format = format;
+ m_srvd.ViewDimension = D3D12_SRV_DIMENSION_BUFFER;
+ m_srvd.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
+ m_srvd.Buffer.FirstElement = 0;
+ m_srvd.Buffer.NumElements = m_size / stride;
+ m_srvd.Buffer.StructureByteStride = 0;
+ m_srvd.Buffer.Flags = D3D12_BUFFER_SRV_FLAG_NONE;
+
+ m_uavd.Format = format;
+ m_uavd.ViewDimension = D3D12_UAV_DIMENSION_BUFFER;
+ m_uavd.Buffer.FirstElement = 0;
+ m_uavd.Buffer.NumElements = m_size / stride;
+ m_uavd.Buffer.StructureByteStride = 0;
+ m_uavd.Buffer.CounterOffsetInBytes = 0;
+ m_uavd.Buffer.Flags = D3D12_BUFFER_UAV_FLAG_NONE;
+
+ ID3D12Device* device = s_renderD3D12->m_device;
+ ID3D12GraphicsCommandList* commandList = s_renderD3D12->m_commandList;
+
+ m_ptr = createCommittedResource(device, HeapProperty::Default, _size, flags);
+ m_gpuVA = m_ptr->GetGPUVirtualAddress();
+ setState(commandList, drawIndirect
+ ? D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT
+ : D3D12_RESOURCE_STATE_GENERIC_READ
+ );
+
+ if (!m_dynamic)
+ {
+ update(commandList, 0, _size, _data);
+ }
+ }
+
+ void BufferD3D12::update(ID3D12GraphicsCommandList* _commandList, uint32_t _offset, uint32_t _size, void* _data, bool /*_discard*/)
+ {
+ ID3D12Resource* staging = createCommittedResource(s_renderD3D12->m_device, HeapProperty::Upload, _size);
+ uint8_t* data;
+ DX_CHECK(staging->Map(0, NULL, (void**)&data) );
+ memcpy(data, _data, _size);
+ staging->Unmap(0, NULL);
+
+ D3D12_RESOURCE_STATES state = setState(_commandList, D3D12_RESOURCE_STATE_COPY_DEST);
+ _commandList->CopyBufferRegion(m_ptr, _offset, staging, 0, _size);
+ setState(_commandList, state);
+
+ s_renderD3D12->m_cmd.release(staging);
+ }
+
+ void BufferD3D12::destroy()
+ {
+ if (NULL != m_ptr)
+ {
+ s_renderD3D12->m_cmd.release(m_ptr);
+ m_dynamic = false;
+ }
+ }
+
+ D3D12_RESOURCE_STATES BufferD3D12::setState(ID3D12GraphicsCommandList* _commandList, D3D12_RESOURCE_STATES _state)
+ {
+ if (m_state != _state)
+ {
+ setResourceBarrier(_commandList
+ , m_ptr
+ , m_state
+ , _state
+ );
+
+ bx::xchg(m_state, _state);
+ }
+
+ return _state;
+ }
+
+ void VertexBufferD3D12::create(uint32_t _size, void* _data, VertexDeclHandle _declHandle, uint16_t _flags)
+ {
+ BufferD3D12::create(_size, _data, _flags, true);
+ m_decl = _declHandle;
+ }
+
+ void ShaderD3D12::create(const Memory* _mem)
+ {
+ bx::MemoryReader reader(_mem->data, _mem->size);
+
+ uint32_t magic;
+ bx::read(&reader, magic);
+
+ switch (magic)
+ {
+ case BGFX_CHUNK_MAGIC_CSH:
+ case BGFX_CHUNK_MAGIC_FSH:
+ case BGFX_CHUNK_MAGIC_VSH:
+ break;
+
+ default:
+ BGFX_FATAL(false, Fatal::InvalidShader, "Unknown shader format %x.", magic);
+ break;
+ }
+
+ bool fragment = BGFX_CHUNK_MAGIC_FSH == magic;
+
+ uint32_t iohash;
+ bx::read(&reader, iohash);
+
+ uint16_t count;
+ bx::read(&reader, count);
+
+ m_numPredefined = 0;
+ m_numUniforms = count;
+
+ BX_TRACE("%s Shader consts %d"
+ , BGFX_CHUNK_MAGIC_FSH == magic ? "Fragment" : BGFX_CHUNK_MAGIC_VSH == magic ? "Vertex" : "Compute"
+ , count
+ );
+
+ uint8_t fragmentBit = fragment ? BGFX_UNIFORM_FRAGMENTBIT : 0;
+
+ if (0 < count)
+ {
+ for (uint32_t ii = 0; ii < count; ++ii)
+ {
+ uint8_t nameSize;
+ bx::read(&reader, nameSize);
+
+ char name[256];
+ bx::read(&reader, &name, nameSize);
+ name[nameSize] = '\0';
+
+ uint8_t type;
+ bx::read(&reader, type);
+
+ uint8_t num;
+ bx::read(&reader, num);
+
+ uint16_t regIndex;
+ bx::read(&reader, regIndex);
+
+ uint16_t regCount;
+ bx::read(&reader, regCount);
+
+ const char* kind = "invalid";
+
+ PredefinedUniform::Enum predefined = nameToPredefinedUniformEnum(name);
+ if (PredefinedUniform::Count != predefined)
+ {
+ kind = "predefined";
+ m_predefined[m_numPredefined].m_loc = regIndex;
+ m_predefined[m_numPredefined].m_count = regCount;
+ m_predefined[m_numPredefined].m_type = uint8_t(predefined|fragmentBit);
+ m_numPredefined++;
+ }
+ else if (0 == (BGFX_UNIFORM_SAMPLERBIT & type) )
+ {
+ const UniformInfo* info = s_renderD3D12->m_uniformReg.find(name);
+ BX_CHECK(NULL != info, "User defined uniform '%s' is not found, it won't be set.", name);
+
+ if (NULL != info)
+ {
+ if (NULL == m_constantBuffer)
+ {
+ m_constantBuffer = UniformBuffer::create(1024);
+ }
+
+ kind = "user";
+ m_constantBuffer->writeUniformHandle( (UniformType::Enum)(type|fragmentBit), regIndex, info->m_handle, regCount);
+ }
+ }
+ else
+ {
+ kind = "sampler";
+ }
+
+ BX_TRACE("\t%s: %s (%s), num %2d, r.index %3d, r.count %2d"
+ , kind
+ , name
+ , getUniformTypeName(UniformType::Enum(type&~BGFX_UNIFORM_MASK) )
+ , num
+ , regIndex
+ , regCount
+ );
+ BX_UNUSED(kind);
+ }
+
+ if (NULL != m_constantBuffer)
+ {
+ m_constantBuffer->finish();
+ }
+ }
+
+ uint16_t shaderSize;
+ bx::read(&reader, shaderSize);
+
+ const DWORD* code = (const DWORD*)reader.getDataPtr();
+ bx::skip(&reader, shaderSize+1);
+
+ m_code = copy(code, shaderSize);
+
+ uint8_t numAttrs;
+ bx::read(&reader, numAttrs);
+
+ memset(m_attrMask, 0, sizeof(m_attrMask) );
+
+ for (uint32_t ii = 0; ii < numAttrs; ++ii)
+ {
+ uint16_t id;
+ bx::read(&reader, id);
+
+ Attrib::Enum attr = idToAttrib(id);
+
+ if (Attrib::Count != attr)
+ {
+ m_attrMask[attr] = UINT16_MAX;
+ }
+ }
+
+ bx::HashMurmur2A murmur;
+ murmur.begin();
+ murmur.add(iohash);
+ murmur.add(code, shaderSize);
+ murmur.add(numAttrs);
+ murmur.add(m_attrMask, numAttrs);
+ m_hash = murmur.end();
+
+ bx::read(&reader, m_size);
+ }
+
+ void TextureD3D12::create(const Memory* _mem, uint32_t _flags, uint8_t _skip)
+ {
+ ImageContainer imageContainer;
+
+ if (imageParse(imageContainer, _mem->data, _mem->size) )
+ {
+ uint8_t numMips = imageContainer.m_numMips;
+ const uint8_t startLod = uint8_t(bx::uint32_min(_skip, numMips-1) );
+ numMips -= startLod;
+ const ImageBlockInfo& blockInfo = getBlockInfo(TextureFormat::Enum(imageContainer.m_format) );
+ const uint32_t textureWidth = bx::uint32_max(blockInfo.blockWidth, imageContainer.m_width >>startLod);
+ const uint32_t textureHeight = bx::uint32_max(blockInfo.blockHeight, imageContainer.m_height>>startLod);
+
+ m_flags = _flags;
+ m_requestedFormat = (uint8_t)imageContainer.m_format;
+ m_textureFormat = (uint8_t)imageContainer.m_format;
+
+ const TextureFormatInfo& tfi = s_textureFormat[m_requestedFormat];
+ const bool convert = DXGI_FORMAT_UNKNOWN == tfi.m_fmt;
+
+ uint8_t bpp = getBitsPerPixel(TextureFormat::Enum(m_textureFormat) );
+ if (convert)
+ {
+ m_textureFormat = (uint8_t)TextureFormat::BGRA8;
+ bpp = 32;
+ }
+
+ if (imageContainer.m_cubeMap)
+ {
+ m_type = TextureCube;
+ }
+ else if (imageContainer.m_depth > 1)
+ {
+ m_type = Texture3D;
+ }
+ else
+ {
+ m_type = Texture2D;
+ }
+
+ m_numMips = numMips;
+ const uint16_t numSides = imageContainer.m_cubeMap ? 6 : 1;
+
+ uint32_t numSrd = numMips*numSides;
+ D3D12_SUBRESOURCE_DATA* srd = (D3D12_SUBRESOURCE_DATA*)alloca(numSrd*sizeof(D3D12_SUBRESOURCE_DATA) );
+
+ uint32_t kk = 0;
+
+ const bool compressed = isCompressed(TextureFormat::Enum(m_textureFormat) );
+ const bool swizzle = TextureFormat::BGRA8 == m_textureFormat && 0 != (m_flags&BGFX_TEXTURE_COMPUTE_WRITE);
+ uint32_t blockWidth = 1;
+ uint32_t blockHeight = 1;
+
+ if (convert && compressed)
+ {
+ blockWidth = blockInfo.blockWidth;
+ blockHeight = blockInfo.blockHeight;
+ }
+
+ const bool bufferOnly = 0 != (m_flags&BGFX_TEXTURE_RT_BUFFER_ONLY);
+ const bool computeWrite = 0 != (m_flags&BGFX_TEXTURE_COMPUTE_WRITE);
+ const bool renderTarget = 0 != (m_flags&BGFX_TEXTURE_RT_MASK);
+
+ BX_TRACE("Texture %3d: %s (requested: %s), %dx%d%s RT[%c], BO[%c], CW[%c]%s."
+ , this - s_renderD3D12->m_textures
+ , getName( (TextureFormat::Enum)m_textureFormat)
+ , getName( (TextureFormat::Enum)m_requestedFormat)
+ , textureWidth
+ , textureHeight
+ , imageContainer.m_cubeMap ? "x6" : ""
+ , renderTarget ? 'x' : ' '
+ , bufferOnly ? 'x' : ' '
+ , computeWrite ? 'x' : ' '
+ , swizzle ? " (swizzle BGRA8 -> RGBA8)" : ""
+ );
+
+ uint32_t totalSize = 0;
+
+ for (uint8_t side = 0; side < numSides; ++side)
+ {
+ uint32_t width = textureWidth;
+ uint32_t height = textureHeight;
+ uint32_t depth = imageContainer.m_depth;
+
+ for (uint8_t lod = 0; lod < numMips; ++lod)
+ {
+ width = bx::uint32_max(blockWidth, width);
+ height = bx::uint32_max(blockHeight, height);
+ depth = bx::uint32_max(1, depth);
+
+ ImageMip mip;
+ if (imageGetRawData(imageContainer, side, lod+startLod, _mem->data, _mem->size, mip) )
+ {
+ if (convert)
+ {
+ const uint32_t pitch = bx::strideAlign(width*bpp / 8, D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
+ const uint32_t slice = bx::strideAlign(pitch * height, D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT);
+
+ uint8_t* temp = (uint8_t*)BX_ALLOC(g_allocator, slice);
+ imageDecodeToBgra8(temp
+ , mip.m_data
+ , mip.m_width
+ , mip.m_height
+ , pitch, mip.m_format
+ );
+
+ srd[kk].pData = temp;
+ srd[kk].RowPitch = pitch;
+ srd[kk].SlicePitch = slice;
+ totalSize += slice;
+ }
+ else if (compressed)
+ {
+ uint32_t pitch = bx::strideAlign( (mip.m_width /blockInfo.blockWidth )*mip.m_blockSize, D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
+ uint32_t slice = bx::strideAlign( (mip.m_height/blockInfo.blockHeight)*pitch, D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT);
+
+ uint8_t* temp = (uint8_t*)BX_ALLOC(g_allocator, slice);
+ imageCopy(mip.m_height/blockInfo.blockHeight
+ , (mip.m_width /blockInfo.blockWidth )*mip.m_blockSize
+ , mip.m_data
+ , pitch
+ , temp
+ );
+
+ srd[kk].pData = temp;
+ srd[kk].RowPitch = pitch;
+ srd[kk].SlicePitch = slice;
+ totalSize += slice;
+ }
+ else
+ {
+ const uint32_t pitch = bx::strideAlign(mip.m_width*mip.m_bpp / 8, D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
+ const uint32_t slice = bx::strideAlign(pitch * mip.m_height, D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT);
+
+ uint8_t* temp = (uint8_t*)BX_ALLOC(g_allocator, slice);
+ imageCopy(mip.m_height
+ , mip.m_width*mip.m_bpp / 8
+ , mip.m_data
+ , pitch
+ , temp
+ );
+
+ srd[kk].pData = temp;
+ srd[kk].RowPitch = pitch;
+ srd[kk].SlicePitch = slice;
+ totalSize += slice;
+ }
+
+ if (swizzle)
+ {
+// imageSwizzleBgra8(width, height, mip.m_width*4, data, temp);
+ }
+
+ srd[kk].SlicePitch = mip.m_height*srd[kk].RowPitch;
+ ++kk;
+ }
+ else
+ {
+ const uint32_t pitch = bx::strideAlign(width*bpp / 8, D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
+ const uint32_t slice = bx::strideAlign(pitch * height, D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT);
+ totalSize += slice;
+ }
+
+ width >>= 1;
+ height >>= 1;
+ depth >>= 1;
+ }
+ }
+
+ BX_TRACE("texture total size: %d", totalSize);
+
+ const uint32_t msaaQuality = bx::uint32_satsub( (m_flags&BGFX_TEXTURE_RT_MSAA_MASK)>>BGFX_TEXTURE_RT_MSAA_SHIFT, 1);
+ const DXGI_SAMPLE_DESC& msaa = s_msaa[msaaQuality];
+
+ memset(&m_srvd, 0, sizeof(m_srvd) );
+ m_srvd.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
+ m_srvd.Format = s_textureFormat[m_textureFormat].m_fmtSrv;
+ DXGI_FORMAT format = s_textureFormat[m_textureFormat].m_fmt;
+ if (swizzle)
+ {
+ format = DXGI_FORMAT_R8G8B8A8_UNORM;
+ m_srvd.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+ }
+
+ m_uavd.Format = m_srvd.Format;
+
+ ID3D12Device* device = s_renderD3D12->m_device;
+ ID3D12GraphicsCommandList* commandList = s_renderD3D12->m_commandList;
+
+ D3D12_RESOURCE_DESC resourceDesc;
+ resourceDesc.Alignment = 0;
+ resourceDesc.Width = textureWidth;
+ resourceDesc.Height = textureHeight;
+ resourceDesc.MipLevels = numMips;
+ resourceDesc.Format = format;
+ resourceDesc.SampleDesc = msaa;
+ resourceDesc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
+ resourceDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
+ resourceDesc.DepthOrArraySize = numSides;
+
+ D3D12_RESOURCE_STATES state = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
+
+ D3D12_CLEAR_VALUE* clearValue = NULL;
+ if (isDepth(TextureFormat::Enum(m_textureFormat) ) )
+ {
+ resourceDesc.Format = s_textureFormat[m_textureFormat].m_fmt;
+ resourceDesc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL;
+ state |= D3D12_RESOURCE_STATE_DEPTH_WRITE;
+ state &= ~D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
+
+ clearValue = (D3D12_CLEAR_VALUE*)alloca(sizeof(D3D12_CLEAR_VALUE) );
+ clearValue->Format = s_textureFormat[m_textureFormat].m_fmtDsv;
+ clearValue->DepthStencil.Depth = 1.0f;
+ clearValue->DepthStencil.Stencil = 0;
+ }
+ else if (renderTarget)
+ {
+ clearValue = (D3D12_CLEAR_VALUE*)alloca(sizeof(D3D12_CLEAR_VALUE) );
+ clearValue->Format = resourceDesc.Format;
+ clearValue->Color[0] = 0.0f;
+ clearValue->Color[1] = 0.0f;
+ clearValue->Color[2] = 0.0f;
+ clearValue->Color[3] = 0.0f;
+
+ resourceDesc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
+ }
+
+ if (bufferOnly)
+ {
+ resourceDesc.Flags |= D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE;
+ state &= ~D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
+ }
+
+ if (computeWrite)
+ {
+ resourceDesc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
+ }
+
+ switch (m_type)
+ {
+ case Texture2D:
+ resourceDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
+ m_srvd.ViewDimension = 1 < msaa.Count ? D3D12_SRV_DIMENSION_TEXTURE2DMS : D3D12_SRV_DIMENSION_TEXTURE2D;
+ m_srvd.Texture2D.MostDetailedMip = 0;
+ m_srvd.Texture2D.MipLevels = numMips;
+ m_srvd.Texture2D.ResourceMinLODClamp = 0.0f;
+
+ m_uavd.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2D;
+ m_uavd.Texture2D.MipSlice = 0;
+ m_uavd.Texture2D.PlaneSlice = 0;
+ break;
+
+ case Texture3D:
+ resourceDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE3D;
+ m_srvd.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE3D;
+ m_srvd.Texture3D.MostDetailedMip = 0;
+ m_srvd.Texture3D.MipLevels = numMips;
+ m_srvd.Texture3D.ResourceMinLODClamp = 0.0f;
+
+ m_uavd.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE3D;
+ m_uavd.Texture3D.MipSlice = 0;
+ m_uavd.Texture3D.FirstWSlice = 0;
+ m_uavd.Texture3D.WSize = 0;
+ break;
+
+ case TextureCube:
+ resourceDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
+ m_srvd.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBE;
+ m_srvd.TextureCube.MostDetailedMip = 0;
+ m_srvd.TextureCube.MipLevels = numMips;
+ m_srvd.TextureCube.ResourceMinLODClamp = 0.0f;
+
+ m_uavd.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2D;
+ m_uavd.Texture2D.MipSlice = 0;
+ m_uavd.Texture2D.PlaneSlice = 0;
+ break;
+ }
+
+ m_ptr = createCommittedResource(device, HeapProperty::Default, &resourceDesc, clearValue);
+
+ {
+ uint64_t uploadBufferSize;
+ uint32_t* numRows = (uint32_t*)alloca(sizeof(uint32_t)*numSrd);
+ uint64_t* rowSizeInBytes = (uint64_t*)alloca(sizeof(uint64_t)*numSrd);
+ D3D12_PLACED_SUBRESOURCE_FOOTPRINT* layouts = (D3D12_PLACED_SUBRESOURCE_FOOTPRINT*)alloca(sizeof(D3D12_PLACED_SUBRESOURCE_FOOTPRINT)*numSrd);
+
+ device->GetCopyableFootprints(&resourceDesc
+ , 0
+ , numSrd
+ , 0
+ , layouts
+ , numRows
+ , rowSizeInBytes
+ , &uploadBufferSize
+ );
+ BX_WARN(uploadBufferSize == totalSize, "uploadBufferSize %d (totalSize %d), numRows %d, rowSizeInBytes %d"
+ , uploadBufferSize
+ , totalSize
+ , numRows[0]
+ , rowSizeInBytes[0]
+ );
+ }
+
+ if (kk != 0)
+ {
+ ID3D12Resource* staging = createCommittedResource(s_renderD3D12->m_device, HeapProperty::Upload, totalSize);
+
+ setState(commandList,D3D12_RESOURCE_STATE_COPY_DEST);
+
+ uint64_t result = UpdateSubresources(commandList
+ , m_ptr
+ , staging
+ , 0
+ , 0
+ , numSrd
+ , srd
+ );
+ BX_CHECK(0 != result, "Invalid size"); BX_UNUSED(result);
+ BX_TRACE("Update subresource %" PRId64, result);
+
+ setState(commandList, state);
+
+ s_renderD3D12->m_cmd.release(staging);
+ }
+ else
+ {
+ setState(commandList, state);
+ }
+
+ if (0 != kk)
+ {
+ kk = 0;
+ for (uint8_t side = 0; side < numSides; ++side)
+ {
+ for (uint32_t lod = 0, num = numMips; lod < num; ++lod)
+ {
+ BX_FREE(g_allocator, const_cast<void*>(srd[kk].pData) );
+ ++kk;
+ }
+ }
+ }
+ }
+ }
+
+ void TextureD3D12::destroy()
+ {
+ if (NULL != m_ptr)
+ {
+ s_renderD3D12->m_cmd.release(m_ptr);
+ m_ptr = NULL;
+ }
+ }
+
+ void TextureD3D12::update(ID3D12GraphicsCommandList* _commandList, uint8_t _side, uint8_t _mip, const Rect& _rect, uint16_t _z, uint16_t _depth, uint16_t _pitch, const Memory* _mem)
+ {
+ setState(_commandList, D3D12_RESOURCE_STATE_COPY_DEST);
+
+ const uint32_t subres = _mip + (_side * m_numMips);
+ const uint32_t bpp = getBitsPerPixel(TextureFormat::Enum(m_textureFormat) );
+ const uint32_t rectpitch = _rect.m_width*bpp/8;
+ const uint32_t srcpitch = UINT16_MAX == _pitch ? rectpitch : _pitch;
+
+ D3D12_RESOURCE_DESC desc = m_ptr->GetDesc();
+
+ desc.Height = _rect.m_height;
+
+ uint32_t numRows;
+ uint64_t rowPitch;
+ uint64_t totalBytes;
+ D3D12_PLACED_SUBRESOURCE_FOOTPRINT layout;
+ s_renderD3D12->m_device->GetCopyableFootprints(&desc
+ , subres
+ , 1
+ , 0
+ , &layout
+ , &numRows
+ , &rowPitch
+ , &totalBytes
+ );
+
+ ID3D12Resource* staging = createCommittedResource(s_renderD3D12->m_device, HeapProperty::Upload, totalBytes);
+
+ uint8_t* data;
+
+ DX_CHECK(staging->Map(0, NULL, (void**)&data) );
+ for (uint32_t ii = 0, height = _rect.m_height; ii < height; ++ii)
+ {
+ memcpy(&data[ii*rowPitch], &_mem->data[ii*srcpitch], srcpitch);
+ }
+ staging->Unmap(0, NULL);
+
+ D3D12_BOX box;
+ box.left = 0;
+ box.top = 0;
+ box.right = box.left + _rect.m_width;
+ box.bottom = box.top + _rect.m_height;
+ box.front = _z;
+ box.back = _z+_depth;
+
+ D3D12_TEXTURE_COPY_LOCATION dst = { m_ptr, D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX, { } };
+ dst.SubresourceIndex = subres;
+ D3D12_TEXTURE_COPY_LOCATION src = { staging, D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT, { layout } };
+ _commandList->CopyTextureRegion(&dst, _rect.m_x, _rect.m_y, 0, &src, &box);
+
+ setState(_commandList, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE);
+
+ s_renderD3D12->m_cmd.release(staging);
+ }
+
+ void TextureD3D12::resolve()
+ {
+ }
+
+ D3D12_RESOURCE_STATES TextureD3D12::setState(ID3D12GraphicsCommandList* _commandList, D3D12_RESOURCE_STATES _state)
+ {
+ if (m_state != _state)
+ {
+ setResourceBarrier(_commandList
+ , m_ptr
+ , m_state
+ , _state
+ );
+
+ bx::xchg(m_state, _state);
+ }
+
+ return _state;
+ }
+
+ void FrameBufferD3D12::create(uint8_t _num, const TextureHandle* _handles)
+ {
+ m_numTh = _num;
+ memcpy(m_th, _handles, _num*sizeof(TextureHandle) );
+
+ postReset();
+ }
+
+ void FrameBufferD3D12::create(uint16_t /*_denseIdx*/, void* /*_nwh*/, uint32_t /*_width*/, uint32_t /*_height*/, TextureFormat::Enum /*_depthFormat*/)
+ {
+ }
+
+ void FrameBufferD3D12::preReset()
+ {
+ }
+
+ void FrameBufferD3D12::postReset()
+ {
+ if (m_numTh != 0)
+ {
+ ID3D12Device* device = s_renderD3D12->m_device;
+
+ D3D12_CPU_DESCRIPTOR_HANDLE rtvDescriptor = s_renderD3D12->m_rtvDescriptorHeap->GetCPUDescriptorHandleForHeapStart();
+ uint32_t rtvDescriptorSize = device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
+ uint32_t fbhIdx = (uint32_t)(this - s_renderD3D12->m_frameBuffers);
+ rtvDescriptor.ptr += (BX_COUNTOF(s_renderD3D12->m_backBufferColor) + fbhIdx * BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS) * rtvDescriptorSize;
+
+ m_width = 0;
+ m_height = 0;
+ m_depth.idx = bgfx::invalidHandle;
+ m_num = 0;
+ for (uint32_t ii = 0; ii < m_numTh; ++ii)
+ {
+ TextureHandle handle = m_th[ii];
+ if (isValid(handle) )
+ {
+ const TextureD3D12& texture = s_renderD3D12->m_textures[handle.idx];
+
+ if (0 == m_width)
+ {
+ D3D12_RESOURCE_DESC desc = texture.m_ptr->GetDesc();
+ m_width = uint32_t(desc.Width);
+ m_height = uint32_t(desc.Height);
+ }
+
+ if (isDepth( (TextureFormat::Enum)texture.m_textureFormat) )
+ {
+ BX_CHECK(!isValid(m_depth), "");
+ m_depth = handle;
+ D3D12_CPU_DESCRIPTOR_HANDLE dsvDescriptor = s_renderD3D12->m_dsvDescriptorHeap->GetCPUDescriptorHandleForHeapStart();
+ uint32_t dsvDescriptorSize = device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_DSV);
+ dsvDescriptor.ptr += (1 + fbhIdx) * dsvDescriptorSize;
+
+ const ImageBlockInfo& blockInfo = getBlockInfo(TextureFormat::Enum(texture.m_textureFormat) );
+ BX_UNUSED(blockInfo);
+
+ D3D12_DEPTH_STENCIL_VIEW_DESC dsvDesc;
+ ZeroMemory(&dsvDesc, sizeof(dsvDesc) );
+ dsvDesc.Format = s_textureFormat[texture.m_textureFormat].m_fmtDsv;
+ dsvDesc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2D;
+ dsvDesc.Flags = D3D12_DSV_FLAG_NONE
+// | (blockInfo.depthBits > 0 ? D3D12_DSV_FLAG_READ_ONLY_DEPTH : D3D12_DSV_FLAG_NONE)
+// | (blockInfo.stencilBits > 0 ? D3D12_DSV_FLAG_READ_ONLY_STENCIL : D3D12_DSV_FLAG_NONE)
+ ;
+
+ device->CreateDepthStencilView(texture.m_ptr
+ , &dsvDesc
+ , dsvDescriptor
+ );
+ }
+ else
+ {
+ m_texture[m_num] = handle;
+ D3D12_CPU_DESCRIPTOR_HANDLE rtv = { rtvDescriptor.ptr + m_num * rtvDescriptorSize };
+ device->CreateRenderTargetView(texture.m_ptr
+ , NULL
+ , rtv
+ );
+ m_num++;
+ }
+ }
+ }
+ }
+ }
+
+ uint16_t FrameBufferD3D12::destroy()
+ {
+ m_numTh = 0;
+
+ m_depth.idx = bgfx::invalidHandle;
+
+ uint16_t denseIdx = m_denseIdx;
+ m_denseIdx = UINT16_MAX;
+
+ return denseIdx;
+ }
+
+ void FrameBufferD3D12::resolve()
+ {
+ }
+
+ void FrameBufferD3D12::clear(ID3D12GraphicsCommandList* _commandList, const Clear& _clear, const float _palette[][4], const D3D12_RECT* _rect, uint32_t _num)
+ {
+ ID3D12Device* device = s_renderD3D12->m_device;
+ const uint32_t fbhIdx = (uint32_t)(this - s_renderD3D12->m_frameBuffers);
+
+ if (BGFX_CLEAR_COLOR & _clear.m_flags
+ && 0 != m_num)
+ {
+ D3D12_CPU_DESCRIPTOR_HANDLE rtvDescriptor = s_renderD3D12->m_rtvDescriptorHeap->GetCPUDescriptorHandleForHeapStart();
+ uint32_t rtvDescriptorSize = device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
+ rtvDescriptor.ptr += (BX_COUNTOF(s_renderD3D12->m_backBufferColor) + fbhIdx * BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS) * rtvDescriptorSize;
+
+ if (BGFX_CLEAR_COLOR_USE_PALETTE & _clear.m_flags)
+ {
+ for (uint32_t ii = 0, num = m_num; ii < num; ++ii)
+ {
+ uint8_t index = _clear.m_index[ii];
+ if (UINT8_MAX != index)
+ {
+ D3D12_CPU_DESCRIPTOR_HANDLE rtv = { rtvDescriptor.ptr + ii * rtvDescriptorSize };
+ _commandList->ClearRenderTargetView(rtv
+ , _palette[index]
+ , _num
+ , _rect
+ );
+ }
+ }
+ }
+ else
+ {
+ float frgba[4] =
+ {
+ _clear.m_index[0]*1.0f/255.0f,
+ _clear.m_index[1]*1.0f/255.0f,
+ _clear.m_index[2]*1.0f/255.0f,
+ _clear.m_index[3]*1.0f/255.0f,
+ };
+ for (uint32_t ii = 0, num = m_num; ii < num; ++ii)
+ {
+ D3D12_CPU_DESCRIPTOR_HANDLE rtv = { rtvDescriptor.ptr + ii * rtvDescriptorSize };
+ _commandList->ClearRenderTargetView(rtv
+ , frgba
+ , _num
+ , _rect
+ );
+ }
+ }
+ }
+
+ if (isValid(m_depth)
+ && (BGFX_CLEAR_DEPTH|BGFX_CLEAR_STENCIL) & _clear.m_flags)
+ {
+ D3D12_CPU_DESCRIPTOR_HANDLE dsvDescriptor = s_renderD3D12->m_dsvDescriptorHeap->GetCPUDescriptorHandleForHeapStart();
+ uint32_t dsvDescriptorSize = device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_DSV);
+ dsvDescriptor.ptr += (1 + fbhIdx) * dsvDescriptorSize;
+
+ DWORD flags = 0;
+ flags |= (_clear.m_flags & BGFX_CLEAR_DEPTH) ? D3D12_CLEAR_FLAG_DEPTH : 0;
+ flags |= (_clear.m_flags & BGFX_CLEAR_STENCIL) ? D3D12_CLEAR_FLAG_STENCIL : 0;
+
+ _commandList->ClearDepthStencilView(dsvDescriptor
+ , D3D12_CLEAR_FLAGS(flags)
+ , _clear.m_depth
+ , _clear.m_stencil
+ , _num
+ , _rect
+ );
+ }
+ }
+
+ struct Bind
+ {
+ D3D12_GPU_DESCRIPTOR_HANDLE m_srvHandle;
+ uint16_t m_samplerStateIdx;
+ };
+
+ void RendererContextD3D12::submit(Frame* _render, ClearQuad& /*_clearQuad*/, TextVideoMemBlitter& _textVideoMemBlitter)
+ {
+// PIX_BEGINEVENT(D3DCOLOR_RGBA(0xff, 0x00, 0x00, 0xff), L"rendererSubmit");
+
+ updateResolution(_render->m_resolution);
+
+ int64_t elapsed = -bx::getHPCounter();
+ int64_t captureElapsed = 0;
+
+ if (0 < _render->m_iboffset)
+ {
+ TransientIndexBuffer* ib = _render->m_transientIb;
+ m_indexBuffers[ib->handle.idx].update(m_commandList, 0, _render->m_iboffset, ib->data);
+ }
+
+ if (0 < _render->m_vboffset)
+ {
+ TransientVertexBuffer* vb = _render->m_transientVb;
+ m_vertexBuffers[vb->handle.idx].update(m_commandList, 0, _render->m_vboffset, vb->data);
+ }
+
+ _render->sort();
+
+ RenderDraw currentState;
+ currentState.clear();
+ currentState.m_flags = BGFX_STATE_NONE;
+ currentState.m_stencil = packStencil(BGFX_STENCIL_NONE, BGFX_STENCIL_NONE);
+
+ _render->m_hmdInitialized = false;
+
+ const bool hmdEnabled = false;
+ ViewState viewState(_render, hmdEnabled);
+ viewState.reset(_render, hmdEnabled);
+
+// bool wireframe = !!(_render->m_debug&BGFX_DEBUG_WIREFRAME);
+// setDebugWireframe(wireframe);
+
+ uint16_t currentSamplerStateIdx = invalidHandle;
+ uint16_t currentProgramIdx = invalidHandle;
+ bool hasPredefined = false;
+ uint32_t currentBindHash = 0;
+ ID3D12PipelineState* currentPso = NULL;
+ SortKey key;
+ uint16_t view = UINT16_MAX;
+ FrameBufferHandle fbh = BGFX_INVALID_HANDLE;
+ uint32_t blendFactor = 0;
+
+ const uint64_t primType = _render->m_debug&BGFX_DEBUG_WIREFRAME ? BGFX_STATE_PT_LINES : 0;
+ uint8_t primIndex = uint8_t(primType >> BGFX_STATE_PT_SHIFT);
+ PrimInfo prim = s_primInfo[primIndex];
+
+ bool wasCompute = false;
+ bool viewHasScissor = false;
+ bool restoreScissor = false;
+ Rect viewScissorRect;
+ viewScissorRect.clear();
+
+ uint32_t statsNumPrimsSubmitted[BX_COUNTOF(s_primInfo)] = {};
+ uint32_t statsNumPrimsRendered[BX_COUNTOF(s_primInfo)] = {};
+ uint32_t statsNumInstances[BX_COUNTOF(s_primInfo)] = {};
+ uint32_t statsNumIndices = 0;
+ uint32_t statsKeyType[2] = {};
+
+ m_backBufferColorIdx = m_swapChain->GetCurrentBackBufferIndex();
+
+ const uint64_t f0 = BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_FACTOR, BGFX_STATE_BLEND_FACTOR);
+ const uint64_t f1 = BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_INV_FACTOR, BGFX_STATE_BLEND_INV_FACTOR);
+
+ D3D12_GPU_DESCRIPTOR_HANDLE gpuHandle;
+ ScratchBufferD3D12& scratchBuffer = m_scratchBuffer[m_backBufferColorIdx];
+ scratchBuffer.reset(gpuHandle);
+
+ D3D12_GPU_VIRTUAL_ADDRESS gpuAddress = UINT64_C(0);
+
+ StateCacheLru<Bind, 64> bindLru;
+
+ setResourceBarrier(m_commandList
+ , m_backBufferColor[m_backBufferColorIdx]
+ , D3D12_RESOURCE_STATE_PRESENT
+ , D3D12_RESOURCE_STATE_RENDER_TARGET
+ );
+
+ if (0 == (_render->m_debug&BGFX_DEBUG_IFH) )
+ {
+ m_batch.begin();
+
+// uint8_t eye = 0;
+// uint8_t restartState = 0;
+ viewState.m_rect = _render->m_rect[0];
+
+ int32_t numItems = _render->m_num;
+ for (int32_t item = 0, restartItem = numItems; item < numItems || restartItem < numItems;)
+ {
+ const bool isCompute = key.decode(_render->m_sortKeys[item], _render->m_viewRemap);
+ statsKeyType[isCompute]++;
+
+ const bool viewChanged = 0
+ || key.m_view != view
+ || item == numItems
+ ;
+
+ const RenderItem& renderItem = _render->m_renderItem[_render->m_sortValues[item] ];
+ ++item;
+
+ if (viewChanged)
+ {
+ m_batch.flush(m_commandList, true);
+ kick();
+
+ view = key.m_view;
+ currentPso = NULL;
+ currentSamplerStateIdx = invalidHandle;
+ currentProgramIdx = invalidHandle;
+ hasPredefined = false;
+
+ fbh = _render->m_fb[view];
+ setFrameBuffer(fbh);
+
+ viewState.m_rect = _render->m_rect[view];
+ const Rect& rect = _render->m_rect[view];
+ const Rect& scissorRect = _render->m_scissor[view];
+ viewHasScissor = !scissorRect.isZero();
+ viewScissorRect = viewHasScissor ? scissorRect : rect;
+
+ D3D12_VIEWPORT vp;
+ vp.TopLeftX = rect.m_x;
+ vp.TopLeftY = rect.m_y;
+ vp.Width = rect.m_width;
+ vp.Height = rect.m_height;
+ vp.MinDepth = 0.0f;
+ vp.MaxDepth = 1.0f;
+ m_commandList->RSSetViewports(1, &vp);
+
+ D3D12_RECT rc;
+ rc.left = viewScissorRect.m_x;
+ rc.top = viewScissorRect.m_y;
+ rc.right = viewScissorRect.m_x + viewScissorRect.m_width;
+ rc.bottom = viewScissorRect.m_y + viewScissorRect.m_height;
+ m_commandList->RSSetScissorRects(1, &rc);
+ restoreScissor = false;
+
+ Clear& clr = _render->m_clear[view];
+ if (BGFX_CLEAR_NONE != clr.m_flags)
+ {
+ Rect clearRect = rect;
+ clearRect.intersect(rect, viewScissorRect);
+ clearQuad(clearRect, clr, _render->m_colorPalette);
+ }
+
+ prim = s_primInfo[BX_COUNTOF(s_primName)]; // Force primitive type update.
+ }
+
+ if (isCompute)
+ {
+ if (!wasCompute)
+ {
+ wasCompute = true;
+
+ m_commandList->SetComputeRootSignature(m_rootSignature);
+ ID3D12DescriptorHeap* heaps[] = {
+ m_samplerAllocator.getHeap(),
+ scratchBuffer.getHeap(),
+ };
+ m_commandList->SetDescriptorHeaps(BX_COUNTOF(heaps), heaps);
+ }
+
+ const RenderCompute& compute = renderItem.compute;
+
+ ID3D12PipelineState* pso = getPipelineState(key.m_program);
+ if (pso != currentPso)
+ {
+ currentPso = pso;
+ m_commandList->SetPipelineState(pso);
+ currentBindHash = 0;
+ }
+
+ uint32_t bindHash = bx::hashMurmur2A(compute.m_bind, sizeof(compute.m_bind) );
+ if (currentBindHash != bindHash)
+ {
+ currentBindHash = bindHash;
+
+ Bind* bindCached = bindLru.find(bindHash);
+ if (NULL == bindCached)
+ {
+ D3D12_GPU_DESCRIPTOR_HANDLE srvHandle[BGFX_MAX_COMPUTE_BINDINGS] = {};
+ uint32_t samplerFlags[BGFX_MAX_COMPUTE_BINDINGS] = {};
+
+ for (uint32_t ii = 0; ii < BGFX_MAX_COMPUTE_BINDINGS; ++ii)
+ {
+ const Binding& bind = compute.m_bind[ii];
+ if (invalidHandle != bind.m_idx)
+ {
+ switch (bind.m_type)
+ {
+ case Binding::Image:
+ {
+ TextureD3D12& texture = m_textures[bind.m_idx];
+
+ if (Access::Read != bind.m_un.m_compute.m_access)
+ {
+ texture.setState(m_commandList, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
+ scratchBuffer.allocUav(srvHandle[ii], texture, bind.m_un.m_compute.m_mip);
+ }
+ else
+ {
+ texture.setState(m_commandList, D3D12_RESOURCE_STATE_GENERIC_READ);
+ scratchBuffer.allocSrv(srvHandle[ii], texture, bind.m_un.m_compute.m_mip);
+ samplerFlags[ii] = texture.m_flags;
+ }
+ }
+ break;
+
+ case Binding::IndexBuffer:
+ case Binding::VertexBuffer:
+ {
+ BufferD3D12& buffer = Binding::IndexBuffer == bind.m_type
+ ? m_indexBuffers[bind.m_idx]
+ : m_vertexBuffers[bind.m_idx]
+ ;
+
+ if (Access::Read != bind.m_un.m_compute.m_access)
+ {
+ buffer.setState(m_commandList, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
+ scratchBuffer.allocUav(srvHandle[ii], buffer);
+ }
+ else
+ {
+ buffer.setState(m_commandList, D3D12_RESOURCE_STATE_GENERIC_READ);
+ scratchBuffer.allocSrv(srvHandle[ii], buffer);
+ }
+ }
+ break;
+ }
+ }
+ }
+
+ uint16_t samplerStateIdx = getSamplerState(samplerFlags, BGFX_MAX_COMPUTE_BINDINGS, _render->m_colorPalette);
+ if (samplerStateIdx != currentSamplerStateIdx)
+ {
+ currentSamplerStateIdx = samplerStateIdx;
+ m_commandList->SetComputeRootDescriptorTable(Rdt::Sampler, m_samplerAllocator.get(samplerStateIdx) );
+ }
+
+ m_commandList->SetComputeRootDescriptorTable(Rdt::SRV, srvHandle[0]);
+ m_commandList->SetComputeRootDescriptorTable(Rdt::UAV, srvHandle[0]);
+
+ Bind bind;
+ bind.m_srvHandle = srvHandle[0];
+ bind.m_samplerStateIdx = samplerStateIdx;
+ bindLru.add(bindHash, bind, 0);
+ }
+ else
+ {
+ uint16_t samplerStateIdx = bindCached->m_samplerStateIdx;
+ if (samplerStateIdx != currentSamplerStateIdx)
+ {
+ currentSamplerStateIdx = samplerStateIdx;
+ m_commandList->SetComputeRootDescriptorTable(Rdt::Sampler, m_samplerAllocator.get(samplerStateIdx) );
+ }
+ m_commandList->SetComputeRootDescriptorTable(Rdt::SRV, bindCached->m_srvHandle);
+ m_commandList->SetComputeRootDescriptorTable(Rdt::UAV, bindCached->m_srvHandle);
+ }
+ }
+
+ bool constantsChanged = false;
+ if (compute.m_constBegin < compute.m_constEnd
+ || currentProgramIdx != key.m_program)
+ {
+ rendererUpdateUniforms(this, _render->m_uniformBuffer, compute.m_constBegin, compute.m_constEnd);
+
+ currentProgramIdx = key.m_program;
+ ProgramD3D12& program = m_program[currentProgramIdx];
+
+ UniformBuffer* vcb = program.m_vsh->m_constantBuffer;
+ if (NULL != vcb)
+ {
+ commit(*vcb);
+ }
+
+ hasPredefined = 0 < program.m_numPredefined;
+ constantsChanged = true;
+ }
+
+ if (constantsChanged
+ || hasPredefined)
+ {
+ ProgramD3D12& program = m_program[currentProgramIdx];
+ viewState.setPredefined<4>(this, view, 0, program, _render, compute);
+ commitShaderConstants(key.m_program, gpuAddress);
+ m_commandList->SetComputeRootConstantBufferView(Rdt::CBV, gpuAddress);
+ }
+
+ if (isValid(compute.m_indirectBuffer) )
+ {
+ const VertexBufferD3D12& vb = m_vertexBuffers[compute.m_indirectBuffer.idx];
+
+ uint32_t numDrawIndirect = UINT16_MAX == compute.m_numIndirect
+ ? vb.m_size/BGFX_CONFIG_DRAW_INDIRECT_STRIDE
+ : compute.m_numIndirect
+ ;
+
+ uint32_t args = compute.m_startIndirect * BGFX_CONFIG_DRAW_INDIRECT_STRIDE;
+ for (uint32_t ii = 0; ii < numDrawIndirect; ++ii)
+ {
+// m_commandList->ExecuteIndirect(ptr, args);
+ args += BGFX_CONFIG_DRAW_INDIRECT_STRIDE;
+ }
+ }
+ else
+ {
+ m_commandList->Dispatch(compute.m_numX, compute.m_numY, compute.m_numZ);
+ }
+
+ continue;
+ }
+
+ const RenderDraw& draw = renderItem.draw;
+
+ const uint64_t newFlags = draw.m_flags;
+ uint64_t changedFlags = currentState.m_flags ^ draw.m_flags;
+ currentState.m_flags = newFlags;
+
+ const uint64_t newStencil = draw.m_stencil;
+ uint64_t changedStencil = (currentState.m_stencil ^ draw.m_stencil) & BGFX_STENCIL_FUNC_REF_MASK;
+ currentState.m_stencil = newStencil;
+
+ if (viewChanged
+ || wasCompute)
+ {
+ if (wasCompute)
+ {
+ wasCompute = false;
+ }
+
+ if (BX_ENABLED(BGFX_CONFIG_DEBUG_PIX) )
+ {
+ BX_UNUSED(s_viewNameW);
+// wchar_t* viewNameW = s_viewNameW[view];
+// viewNameW[3] = L' ';
+// PIX_ENDEVENT();
+// PIX_BEGINEVENT(D3DCOLOR_RGBA(0xff, 0x00, 0x00, 0xff), viewNameW);
+ }
+
+ currentSamplerStateIdx = invalidHandle;
+ currentProgramIdx = invalidHandle;
+
+ m_commandList->SetGraphicsRootSignature(m_rootSignature);
+ ID3D12DescriptorHeap* heaps[] = {
+ m_samplerAllocator.getHeap(),
+ scratchBuffer.getHeap(),
+ };
+ m_commandList->SetDescriptorHeaps(BX_COUNTOF(heaps), heaps);
+
+ currentState.clear();
+ currentState.m_scissor = !draw.m_scissor;
+ changedFlags = BGFX_STATE_MASK;
+ changedStencil = packStencil(BGFX_STENCIL_MASK, BGFX_STENCIL_MASK);
+ currentState.m_flags = newFlags;
+ currentState.m_stencil = newStencil;
+
+ const uint64_t pt = newFlags&BGFX_STATE_PT_MASK;
+ primIndex = uint8_t(pt>>BGFX_STATE_PT_SHIFT);
+ }
+
+ rendererUpdateUniforms(this, _render->m_uniformBuffer, draw.m_constBegin, draw.m_constEnd);
+
+ if (isValid(draw.m_vertexBuffer) )
+ {
+ const uint64_t state = draw.m_flags;
+ bool hasFactor = 0
+ || f0 == (state & f0)
+ || f1 == (state & f1)
+ ;
+
+ const VertexBufferD3D12& vb = m_vertexBuffers[draw.m_vertexBuffer.idx];
+ uint16_t declIdx = !isValid(vb.m_decl) ? draw.m_vertexDecl.idx : vb.m_decl.idx;
+
+ ID3D12PipelineState* pso =
+ getPipelineState(state
+ , draw.m_stencil
+ , declIdx
+ , key.m_program
+ , uint8_t(draw.m_instanceDataStride/16)
+ );
+
+ uint16_t scissor = draw.m_scissor;
+ uint32_t bindHash = bx::hashMurmur2A(draw.m_bind, sizeof(draw.m_bind) );
+ if (currentBindHash != bindHash
+ || 0 != changedStencil
+ || (hasFactor && blendFactor != draw.m_rgba)
+ || (0 != (BGFX_STATE_PT_MASK & changedFlags)
+ || prim.m_toplogy != s_primInfo[primIndex].m_toplogy)
+ || currentState.m_scissor != scissor
+ || pso != currentPso)
+ {
+ m_batch.flush(m_commandList);
+ }
+
+ if (currentBindHash != bindHash)
+ {
+ currentBindHash = bindHash;
+
+ Bind* bindCached = bindLru.find(bindHash);
+ if (NULL == bindCached)
+ {
+ D3D12_GPU_DESCRIPTOR_HANDLE srvHandle[BGFX_CONFIG_MAX_TEXTURE_SAMPLERS];
+ uint32_t samplerFlags[BGFX_CONFIG_MAX_TEXTURE_SAMPLERS];
+ {
+ srvHandle[0].ptr = 0;
+ for (uint32_t stage = 0; stage < BGFX_CONFIG_MAX_TEXTURE_SAMPLERS; ++stage)
+ {
+ const Binding& bind = draw.m_bind[stage];
+ if (invalidHandle != bind.m_idx)
+ {
+ TextureD3D12& texture = m_textures[bind.m_idx];
+ texture.setState(m_commandList, D3D12_RESOURCE_STATE_GENERIC_READ);
+ scratchBuffer.allocSrv(srvHandle[stage], texture);
+ samplerFlags[stage] = (0 == (BGFX_SAMPLER_DEFAULT_FLAGS & bind.m_un.m_draw.m_flags)
+ ? bind.m_un.m_draw.m_flags
+ : texture.m_flags
+ ) & (BGFX_TEXTURE_SAMPLER_BITS_MASK|BGFX_TEXTURE_BORDER_COLOR_MASK)
+ ;
+ }
+ else
+ {
+ memcpy(&srvHandle[stage], &srvHandle[0], sizeof(D3D12_GPU_DESCRIPTOR_HANDLE) );
+ samplerFlags[stage] = 0;
+ }
+ }
+ }
+
+ if (srvHandle[0].ptr != 0)
+ {
+ uint16_t samplerStateIdx = getSamplerState(samplerFlags, BGFX_CONFIG_MAX_TEXTURE_SAMPLERS, _render->m_colorPalette);
+ if (samplerStateIdx != currentSamplerStateIdx)
+ {
+ currentSamplerStateIdx = samplerStateIdx;
+ m_commandList->SetGraphicsRootDescriptorTable(Rdt::Sampler, m_samplerAllocator.get(samplerStateIdx) );
+ }
+
+ m_commandList->SetGraphicsRootDescriptorTable(Rdt::SRV, srvHandle[0]);
+
+ Bind bind;
+ bind.m_srvHandle = srvHandle[0];
+ bind.m_samplerStateIdx = samplerStateIdx;
+ bindLru.add(bindHash, bind, 0);
+ }
+ }
+ else
+ {
+ uint16_t samplerStateIdx = bindCached->m_samplerStateIdx;
+ if (samplerStateIdx != currentSamplerStateIdx)
+ {
+ currentSamplerStateIdx = samplerStateIdx;
+ m_commandList->SetGraphicsRootDescriptorTable(Rdt::Sampler, m_samplerAllocator.get(samplerStateIdx) );
+ }
+ m_commandList->SetGraphicsRootDescriptorTable(Rdt::SRV, bindCached->m_srvHandle);
+ }
+ }
+
+ if (0 != changedStencil)
+ {
+ const uint32_t fstencil = unpackStencil(0, draw.m_stencil);
+ const uint32_t ref = (fstencil&BGFX_STENCIL_FUNC_REF_MASK)>>BGFX_STENCIL_FUNC_REF_SHIFT;
+ m_commandList->OMSetStencilRef(ref);
+ }
+
+ if (hasFactor
+ && blendFactor != draw.m_rgba)
+ {
+ blendFactor = draw.m_rgba;
+
+ float bf[4];
+ bf[0] = ( (draw.m_rgba>>24) )/255.0f;
+ bf[1] = ( (draw.m_rgba>>16)&0xff)/255.0f;
+ bf[2] = ( (draw.m_rgba>> 8)&0xff)/255.0f;
+ bf[3] = ( (draw.m_rgba )&0xff)/255.0f;
+ m_commandList->OMSetBlendFactor(bf);
+ }
+
+ if (0 != (BGFX_STATE_PT_MASK & changedFlags)
+ || prim.m_toplogy != s_primInfo[primIndex].m_toplogy)
+ {
+ const uint64_t pt = newFlags&BGFX_STATE_PT_MASK;
+ primIndex = uint8_t(pt>>BGFX_STATE_PT_SHIFT);
+ prim = s_primInfo[primIndex];
+ m_commandList->IASetPrimitiveTopology(prim.m_toplogy);
+ }
+
+ if (currentState.m_scissor != scissor)
+ {
+ currentState.m_scissor = scissor;
+
+ if (UINT16_MAX == scissor)
+ {
+ if (restoreScissor
+ || viewHasScissor)
+ {
+ restoreScissor = false;
+ D3D12_RECT rc;
+ rc.left = viewScissorRect.m_x;
+ rc.top = viewScissorRect.m_y;
+ rc.right = viewScissorRect.m_x + viewScissorRect.m_width;
+ rc.bottom = viewScissorRect.m_y + viewScissorRect.m_height;
+ m_commandList->RSSetScissorRects(1, &rc);
+ }
+ }
+ else
+ {
+ restoreScissor = true;
+ Rect scissorRect;
+ scissorRect.intersect(viewScissorRect,_render->m_rectCache.m_cache[scissor]);
+ D3D12_RECT rc;
+ rc.left = scissorRect.m_x;
+ rc.top = scissorRect.m_y;
+ rc.right = scissorRect.m_x + scissorRect.m_width;
+ rc.bottom = scissorRect.m_y + scissorRect.m_height;
+ m_commandList->RSSetScissorRects(1, &rc);
+ }
+ }
+
+ if (pso != currentPso)
+ {
+ currentPso = pso;
+ m_commandList->SetPipelineState(pso);
+ }
+
+ bool constantsChanged = false;
+ if (draw.m_constBegin < draw.m_constEnd
+ || currentProgramIdx != key.m_program
+ || BGFX_STATE_ALPHA_REF_MASK & changedFlags)
+ {
+ currentProgramIdx = key.m_program;
+ ProgramD3D12& program = m_program[currentProgramIdx];
+
+ UniformBuffer* vcb = program.m_vsh->m_constantBuffer;
+ if (NULL != vcb)
+ {
+ commit(*vcb);
+ }
+
+ UniformBuffer* fcb = program.m_fsh->m_constantBuffer;
+ if (NULL != fcb)
+ {
+ commit(*fcb);
+ }
+
+ hasPredefined = 0 < program.m_numPredefined;
+ constantsChanged = true;
+ }
+
+ if (constantsChanged
+ || hasPredefined)
+ {
+ ProgramD3D12& program = m_program[currentProgramIdx];
+ uint32_t ref = (newFlags&BGFX_STATE_ALPHA_REF_MASK)>>BGFX_STATE_ALPHA_REF_SHIFT;
+ viewState.m_alphaRef = ref/255.0f;
+ viewState.setPredefined<4>(this, view, 0, program, _render, draw);
+ commitShaderConstants(key.m_program, gpuAddress);
+ }
+
+ uint32_t numIndices = m_batch.draw(m_commandList, gpuAddress, draw);
+ uint32_t numPrimsSubmitted = numIndices / prim.m_div - prim.m_sub;
+ uint32_t numPrimsRendered = numPrimsSubmitted*draw.m_numInstances;
+
+ statsNumPrimsSubmitted[primIndex] += numPrimsSubmitted;
+ statsNumPrimsRendered[primIndex] += numPrimsRendered;
+ statsNumInstances[primIndex] += draw.m_numInstances;
+ statsNumIndices += numIndices;
+ }
+ }
+
+ m_batch.end(m_commandList);
+ }
+
+ int64_t now = bx::getHPCounter();
+ elapsed += now;
+
+ static int64_t last = now;
+ int64_t frameTime = now - last;
+ last = now;
+
+ static int64_t min = frameTime;
+ static int64_t max = frameTime;
+ min = bx::int64_min(min, frameTime);
+ max = bx::int64_max(max, frameTime);
+
+ static int64_t presentMin = m_presentElapsed;
+ static int64_t presentMax = m_presentElapsed;
+ presentMin = bx::int64_min(presentMin, m_presentElapsed);
+ presentMax = bx::int64_max(presentMax, m_presentElapsed);
+
+ if (_render->m_debug & (BGFX_DEBUG_IFH | BGFX_DEBUG_STATS) )
+ {
+// PIX_BEGINEVENT(D3DCOLOR_RGBA(0x40, 0x40, 0x40, 0xff), L"debugstats");
+
+ TextVideoMem& tvm = m_textVideoMem;
+
+ static int64_t next = now;
+
+ if (now >= next)
+ {
+ next = now + bx::getHPFrequency();
+ double freq = double(bx::getHPFrequency() );
+ double toMs = 1000.0 / freq;
+
+ tvm.clear();
+ uint16_t pos = 0;
+ tvm.printf(0, pos++, BGFX_CONFIG_DEBUG ? 0x89 : 0x8f
+ , " %s / " BX_COMPILER_NAME " / " BX_CPU_NAME " / " BX_ARCH_NAME " / " BX_PLATFORM_NAME " "
+ , getRendererName()
+ );
+
+ const DXGI_ADAPTER_DESC& desc = m_adapterDesc;
+ char description[BX_COUNTOF(desc.Description)];
+ wcstombs(description, desc.Description, BX_COUNTOF(desc.Description) );
+ tvm.printf(0, pos++, 0x8f, " Device: %s", description);
+
+ char dedicatedVideo[16];
+ bx::prettify(dedicatedVideo, BX_COUNTOF(dedicatedVideo), desc.DedicatedVideoMemory);
+
+ char dedicatedSystem[16];
+ bx::prettify(dedicatedSystem, BX_COUNTOF(dedicatedSystem), desc.DedicatedSystemMemory);
+
+ char sharedSystem[16];
+ bx::prettify(sharedSystem, BX_COUNTOF(sharedSystem), desc.SharedSystemMemory);
+
+ char processMemoryUsed[16];
+ bx::prettify(processMemoryUsed, BX_COUNTOF(processMemoryUsed), bx::getProcessMemoryUsed() );
+
+ tvm.printf(0, pos++, 0x8f, " Memory: %s (video), %s (system), %s (shared), %s (process) "
+ , dedicatedVideo
+ , dedicatedSystem
+ , sharedSystem
+ , processMemoryUsed
+ );
+
+ DXGI_QUERY_VIDEO_MEMORY_INFO memInfo;
+ DX_CHECK(m_adapter->QueryVideoMemoryInfo(0, DXGI_MEMORY_SEGMENT_GROUP_LOCAL, &memInfo) );
+
+ char budget[16];
+ bx::prettify(budget, BX_COUNTOF(budget), memInfo.Budget);
+
+ char currentUsage[16];
+ bx::prettify(currentUsage, BX_COUNTOF(currentUsage), memInfo.CurrentUsage);
+
+ char availableForReservation[16];
+ bx::prettify(availableForReservation, BX_COUNTOF(currentUsage), memInfo.AvailableForReservation);
+
+ char currentReservation[16];
+ bx::prettify(currentReservation, BX_COUNTOF(currentReservation), memInfo.CurrentReservation);
+
+ tvm.printf(0, pos++, 0x8f, " Budget: %s, Usage: %s, AvailRes: %s, CurrRes: %s "
+ , budget
+ , currentUsage
+ , availableForReservation
+ , currentReservation
+ );
+
+ pos = 10;
+ tvm.printf(10, pos++, 0x8e, " Frame: % 7.3f, % 7.3f \x1f, % 7.3f \x1e [ms] / % 6.2f FPS "
+ , double(frameTime)*toMs
+ , double(min)*toMs
+ , double(max)*toMs
+ , freq/frameTime
+ );
+ tvm.printf(10, pos++, 0x8e, " Present: % 7.3f, % 7.3f \x1f, % 7.3f \x1e [ms] "
+ , double(m_presentElapsed)*toMs
+ , double(presentMin)*toMs
+ , double(presentMax)*toMs
+ );
+
+ char hmd[16];
+ bx::snprintf(hmd, BX_COUNTOF(hmd), ", [%c] HMD ", hmdEnabled ? '\xfe' : ' ');
+
+ const uint32_t msaa = (m_resolution.m_flags&BGFX_RESET_MSAA_MASK)>>BGFX_RESET_MSAA_SHIFT;
+ tvm.printf(10, pos++, 0x8e, " Reset flags: [%c] vsync, [%c] MSAAx%d%s, [%c] MaxAnisotropy "
+ , !!(m_resolution.m_flags&BGFX_RESET_VSYNC) ? '\xfe' : ' '
+ , 0 != msaa ? '\xfe' : ' '
+ , 1<<msaa
+ , ", no-HMD "
+ , !!(m_resolution.m_flags&BGFX_RESET_MAXANISOTROPY) ? '\xfe' : ' '
+ );
+
+ double elapsedCpuMs = double(elapsed)*toMs;
+ tvm.printf(10, pos++, 0x8e, " Submitted: %5d (draw %5d, compute %4d) / CPU %7.4f [ms] "
+ , _render->m_num
+ , statsKeyType[0]
+ , statsKeyType[1]
+ , elapsedCpuMs
+ );
+
+ for (uint32_t ii = 0; ii < BX_COUNTOF(s_primName); ++ii)
+ {
+ tvm.printf(10, pos++, 0x8e, " %9s: %7d (#inst: %5d), submitted: %7d "
+ , s_primName[ii]
+ , statsNumPrimsRendered[ii]
+ , statsNumInstances[ii]
+ , statsNumPrimsSubmitted[ii]
+ );
+ }
+
+ tvm.printf(10, pos++, 0x8e, " Batch: %7dx%d indirect, %7d immediate "
+ , m_batch.m_stats.m_numIndirect[BatchD3D12::Draw]
+ , m_batch.m_maxDrawPerBatch
+ , m_batch.m_stats.m_numImmediate[BatchD3D12::Draw]
+ );
+
+ tvm.printf(10, pos++, 0x8e, " %7dx%d indirect, %7d immediate "
+ , m_batch.m_stats.m_numIndirect[BatchD3D12::DrawIndexed]
+ , m_batch.m_maxDrawPerBatch
+ , m_batch.m_stats.m_numImmediate[BatchD3D12::DrawIndexed]
+ );
+
+// if (NULL != m_renderdocdll)
+// {
+// tvm.printf(tvm.m_width-27, 0, 0x1f, " [F11 - RenderDoc capture] ");
+// }
+
+ tvm.printf(10, pos++, 0x8e, " Indices: %7d ", statsNumIndices);
+ tvm.printf(10, pos++, 0x8e, " Uniform size: %7d, Max: %7d ", _render->m_uniformEnd, _render->m_uniformMax);
+ tvm.printf(10, pos++, 0x8e, " DVB size: %7d ", _render->m_vboffset);
+ tvm.printf(10, pos++, 0x8e, " DIB size: %7d ", _render->m_iboffset);
+
+ pos++;
+ tvm.printf(10, pos++, 0x8e, " State cache: ");
+ tvm.printf(10, pos++, 0x8e, " PSO | Sampler | Bind | Queued ");
+ tvm.printf(10, pos++, 0x8e, " %6d | %6d | %6d | %6d "
+ , m_pipelineStateCache.getCount()
+ , m_samplerStateCache.getCount()
+ , bindLru.getCount()
+ , m_cmd.m_control.available()
+ );
+ pos++;
+
+ double captureMs = double(captureElapsed)*toMs;
+ tvm.printf(10, pos++, 0x8e, " Capture: %7.4f [ms] ", captureMs);
+
+ uint8_t attr[2] = { 0x89, 0x8a };
+ uint8_t attrIndex = _render->m_waitSubmit < _render->m_waitRender;
+
+ tvm.printf(10, pos++, attr[attrIndex&1], " Submit wait: %7.4f [ms] ", _render->m_waitSubmit*toMs);
+ tvm.printf(10, pos++, attr[(attrIndex+1)&1], " Render wait: %7.4f [ms] ", _render->m_waitRender*toMs);
+
+ min = frameTime;
+ max = frameTime;
+ presentMin = m_presentElapsed;
+ presentMax = m_presentElapsed;
+ }
+
+ blit(this, _textVideoMemBlitter, tvm);
+
+// PIX_ENDEVENT();
+ }
+ else if (_render->m_debug & BGFX_DEBUG_TEXT)
+ {
+// PIX_BEGINEVENT(D3DCOLOR_RGBA(0x40, 0x40, 0x40, 0xff), L"debugtext");
+
+ blit(this, _textVideoMemBlitter, _render->m_textVideoMem);
+
+// PIX_ENDEVENT();
+ }
+
+ setResourceBarrier(m_commandList
+ , m_backBufferColor[m_backBufferColorIdx]
+ , D3D12_RESOURCE_STATE_RENDER_TARGET
+ , D3D12_RESOURCE_STATE_PRESENT
+ );
+ m_backBufferColorFence[m_backBufferColorIdx] = kick();
+ }
+
+} /* namespace d3d12 */ } // namespace bgfx
+
#else
namespace bgfx { namespace d3d12