summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/bgfx/src/renderer_vk.cpp
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/bgfx/src/renderer_vk.cpp')
-rw-r--r--3rdparty/bgfx/src/renderer_vk.cpp8889
1 files changed, 6756 insertions, 2133 deletions
diff --git a/3rdparty/bgfx/src/renderer_vk.cpp b/3rdparty/bgfx/src/renderer_vk.cpp
index b3843e03047..8b2c6cd001e 100644
--- a/3rdparty/bgfx/src/renderer_vk.cpp
+++ b/3rdparty/bgfx/src/renderer_vk.cpp
@@ -1,16 +1,33 @@
/*
- * Copyright 2011-2018 Branimir Karadzic. All rights reserved.
- * License: https://github.com/bkaradzic/bgfx#license-bsd-2-clause
+ * Copyright 2011-2022 Branimir Karadzic. All rights reserved.
+ * License: https://github.com/bkaradzic/bgfx/blob/master/LICENSE
*/
#include "bgfx_p.h"
#if BGFX_CONFIG_RENDERER_VULKAN
+# include <bx/pixelformat.h>
# include "renderer_vk.h"
+# include "shader_spirv.h"
+
+#if BX_PLATFORM_OSX
+# import <Cocoa/Cocoa.h>
+# import <Foundation/Foundation.h>
+# import <QuartzCore/QuartzCore.h>
+# import <Metal/Metal.h>
+#endif // BX_PLATFORM_OSX
namespace bgfx { namespace vk
{
- static char s_viewName[BGFX_CONFIG_MAX_VIEWS][256];
+ static char s_viewName[BGFX_CONFIG_MAX_VIEWS][BGFX_CONFIG_MAX_VIEW_NAME];
+
+ inline void setViewType(ViewId _view, const bx::StringView _str)
+ {
+ if (BX_ENABLED(BGFX_CONFIG_DEBUG_ANNOTATION || BGFX_CONFIG_PROFILER) )
+ {
+ bx::memCopy(&s_viewName[_view][3], _str.getPtr(), _str.getLength() );
+ }
+ }
struct PrimInfo
{
@@ -31,24 +48,15 @@ namespace bgfx { namespace vk
};
BX_STATIC_ASSERT(Topology::Count == BX_COUNTOF(s_primInfo)-1);
- static const uint32_t s_checkMsaa[] =
+ static MsaaSamplerVK s_msaa[] =
{
- 0,
- 2,
- 4,
- 8,
- 16,
+ { 1, VK_SAMPLE_COUNT_1_BIT },
+ { 2, VK_SAMPLE_COUNT_2_BIT },
+ { 4, VK_SAMPLE_COUNT_4_BIT },
+ { 8, VK_SAMPLE_COUNT_8_BIT },
+ { 16, VK_SAMPLE_COUNT_16_BIT },
};
-// static DXGI_SAMPLE_DESC s_msaa[] =
-// {
-// { 1, 0 },
-// { 2, 0 },
-// { 4, 0 },
-// { 8, 0 },
-// { 16, 0 },
-// };
-
static const VkBlendFactor s_blendFactor[][2] =
{
{ VkBlendFactor(0), VkBlendFactor(0) }, // ignored
@@ -116,6 +124,21 @@ namespace bgfx { namespace vk
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
};
+ struct PresentMode
+ {
+ VkPresentModeKHR mode;
+ bool vsync;
+ const char* name;
+ };
+
+ static const PresentMode s_presentMode[] =
+ {
+ { VK_PRESENT_MODE_FIFO_KHR, true, "VK_PRESENT_MODE_FIFO_KHR" },
+ { VK_PRESENT_MODE_FIFO_RELAXED_KHR, true, "VK_PRESENT_MODE_FIFO_RELAXED_KHR" },
+ { VK_PRESENT_MODE_MAILBOX_KHR, true, "VK_PRESENT_MODE_MAILBOX_KHR" },
+ { VK_PRESENT_MODE_IMMEDIATE_KHR, false, "VK_PRESENT_MODE_IMMEDIATE_KHR" },
+ };
+
#define VK_IMPORT_FUNC(_optional, _func) PFN_##_func _func
#define VK_IMPORT_INSTANCE_FUNC VK_IMPORT_FUNC
#define VK_IMPORT_DEVICE_FUNC VK_IMPORT_FUNC
@@ -132,98 +155,277 @@ VK_IMPORT_DEVICE
VkFormat m_fmtSrv;
VkFormat m_fmtDsv;
VkFormat m_fmtSrgb;
+ VkComponentMapping m_mapping;
};
static const TextureFormatInfo s_textureFormat[] =
{
- { VK_FORMAT_BC1_RGB_UNORM_BLOCK, VK_FORMAT_BC1_RGB_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_BC1_RGB_SRGB_BLOCK }, // BC1
- { VK_FORMAT_BC2_UNORM_BLOCK, VK_FORMAT_BC2_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_BC2_SRGB_BLOCK }, // BC2
- { VK_FORMAT_BC3_UNORM_BLOCK, VK_FORMAT_BC3_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_BC3_SRGB_BLOCK }, // BC3
- { VK_FORMAT_BC4_UNORM_BLOCK, VK_FORMAT_BC4_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // BC4
- { VK_FORMAT_BC5_UNORM_BLOCK, VK_FORMAT_BC5_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // BC5
- { VK_FORMAT_BC6H_SFLOAT_BLOCK, VK_FORMAT_BC6H_SFLOAT_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // BC6H
- { VK_FORMAT_BC7_UNORM_BLOCK, VK_FORMAT_BC7_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_BC7_SRGB_BLOCK }, // BC7
- { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // ETC1
- { VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK }, // ETC2
- { VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK }, // ETC2A
- { VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK }, // ETC2A1
- { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // PTC12
- { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // PTC14
- { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // PTC12A
- { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // PTC14A
- { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // PTC22
- { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // PTC24
- { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // ATC
- { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // ATCE
- { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // ATCI
- { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // ASTC4x4
- { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // ASTC5x5
- { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // ASTC6x6
- { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // ASTC8x5
- { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // ASTC8x6
- { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // ASTC10x5
- { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // Unknown
- { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // R1
- { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // A8
- { VK_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_R8_SRGB }, // R8
- { VK_FORMAT_R8_SINT, VK_FORMAT_R8_SINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // R8I
- { VK_FORMAT_R8_UINT, VK_FORMAT_R8_UINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // R8U
- { VK_FORMAT_R8_SNORM, VK_FORMAT_R8_SNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // R8S
- { VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // R16
- { VK_FORMAT_R16_SINT, VK_FORMAT_R16_SINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // R16I
- { VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // R16U
- { VK_FORMAT_R16_SFLOAT, VK_FORMAT_R16_SFLOAT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // R16F
- { VK_FORMAT_R16_SNORM, VK_FORMAT_R16_SNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // R16S
- { VK_FORMAT_R32_SINT, VK_FORMAT_R32_SINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // R32I
- { VK_FORMAT_R32_UINT, VK_FORMAT_R32_UINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // R32U
- { VK_FORMAT_R32_SFLOAT, VK_FORMAT_R32_SFLOAT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // R32F
- { VK_FORMAT_R8G8_UNORM, VK_FORMAT_R8G8_UNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_R8G8_SRGB }, // RG8
- { VK_FORMAT_R8G8_SINT, VK_FORMAT_R8G8_SINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // RG8I
- { VK_FORMAT_R8G8_UINT, VK_FORMAT_R8G8_UINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // RG8U
- { VK_FORMAT_R8G8_SNORM, VK_FORMAT_R8G8_SNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // RG8S
- { VK_FORMAT_R16G16_UNORM, VK_FORMAT_R16G16_UNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // RG16
- { VK_FORMAT_R16G16_SINT, VK_FORMAT_R16G16_SINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // RG16I
- { VK_FORMAT_R16G16_UINT, VK_FORMAT_R16G16_UINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // RG16U
- { VK_FORMAT_R16G16_SFLOAT, VK_FORMAT_R16G16_SFLOAT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // RG16F
- { VK_FORMAT_R16G16_SNORM, VK_FORMAT_R16G16_SNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // RG16S
- { VK_FORMAT_R32G32_SINT, VK_FORMAT_R32G32_SINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // RG32I
- { VK_FORMAT_R32G32_UINT, VK_FORMAT_R32G32_UINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // RG32U
- { VK_FORMAT_R32G32_SFLOAT, VK_FORMAT_R32G32_SFLOAT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // RG32F
- { VK_FORMAT_R8G8B8_UNORM, VK_FORMAT_R8G8B8_UNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_R8G8B8_SRGB }, // RGB8
- { VK_FORMAT_R8G8B8_SINT, VK_FORMAT_R8G8B8_SINT, VK_FORMAT_UNDEFINED, VK_FORMAT_R8G8B8_SRGB }, // RGB8I
- { VK_FORMAT_R8G8B8_UINT, VK_FORMAT_R8G8B8_UINT, VK_FORMAT_UNDEFINED, VK_FORMAT_R8G8B8_SRGB }, // RGB8U
- { VK_FORMAT_R8G8B8_SNORM, VK_FORMAT_R8G8B8_SNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // RGB8S
- { VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // RGB9E5F
- { VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_B8G8R8A8_SRGB }, // BGRA8
- { VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_R8G8B8A8_SRGB }, // RGBA8
- { VK_FORMAT_R8G8B8A8_SINT, VK_FORMAT_R8G8B8A8_SINT, VK_FORMAT_UNDEFINED, VK_FORMAT_R8G8B8A8_SRGB }, // RGBA8I
- { VK_FORMAT_R8G8B8A8_UINT, VK_FORMAT_R8G8B8A8_UINT, VK_FORMAT_UNDEFINED, VK_FORMAT_R8G8B8A8_SRGB }, // RGBA8U
- { VK_FORMAT_R8G8B8A8_SNORM, VK_FORMAT_R8G8B8A8_SNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // RGBA8S
- { VK_FORMAT_R16G16B16A16_UNORM, VK_FORMAT_R16G16B16A16_UNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // RGBA16
- { VK_FORMAT_R16G16B16A16_SINT, VK_FORMAT_R16G16B16A16_SINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // RGBA16I
- { VK_FORMAT_R16G16B16A16_UINT, VK_FORMAT_R16G16B16A16_UINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // RGBA16U
- { VK_FORMAT_R16G16B16A16_SFLOAT, VK_FORMAT_R16G16B16A16_SFLOAT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // RGBA16F
- { VK_FORMAT_R16G16B16A16_SNORM, VK_FORMAT_R16G16B16A16_SNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // RGBA16S
- { VK_FORMAT_R32G32B32A32_SINT, VK_FORMAT_R32G32B32A32_SINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // RGBA32I
- { VK_FORMAT_R32G32B32A32_UINT, VK_FORMAT_R32G32B32A32_UINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // RGBA32U
- { VK_FORMAT_R32G32B32A32_SFLOAT, VK_FORMAT_R32G32B32A32_SFLOAT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // RGBA32F
- { VK_FORMAT_B5G6R5_UNORM_PACK16, VK_FORMAT_B5G6R5_UNORM_PACK16, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // R5G6B5
- { VK_FORMAT_B4G4R4A4_UNORM_PACK16, VK_FORMAT_B4G4R4A4_UNORM_PACK16, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // RGBA4
- { VK_FORMAT_B5G5R5A1_UNORM_PACK16, VK_FORMAT_B5G5R5A1_UNORM_PACK16, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // RGB5A1
- { VK_FORMAT_A2R10G10B10_UNORM_PACK32, VK_FORMAT_A2R10G10B10_UNORM_PACK32, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // RGB10A2
- { VK_FORMAT_B10G11R11_UFLOAT_PACK32, VK_FORMAT_B10G11R11_UFLOAT_PACK32, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // RG11B10F
- { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED }, // UnknownDepth
- { VK_FORMAT_UNDEFINED, VK_FORMAT_R16_UNORM, VK_FORMAT_D16_UNORM, VK_FORMAT_UNDEFINED }, // D16
- { VK_FORMAT_UNDEFINED, VK_FORMAT_X8_D24_UNORM_PACK32, VK_FORMAT_D24_UNORM_S8_UINT, VK_FORMAT_UNDEFINED }, // D24
- { VK_FORMAT_UNDEFINED, VK_FORMAT_X8_D24_UNORM_PACK32, VK_FORMAT_D24_UNORM_S8_UINT, VK_FORMAT_UNDEFINED }, // D24S8
- { VK_FORMAT_UNDEFINED, VK_FORMAT_X8_D24_UNORM_PACK32, VK_FORMAT_D24_UNORM_S8_UINT, VK_FORMAT_UNDEFINED }, // D32
- { VK_FORMAT_UNDEFINED, VK_FORMAT_R32_SFLOAT, VK_FORMAT_D32_SFLOAT, VK_FORMAT_UNDEFINED }, // D16F
- { VK_FORMAT_UNDEFINED, VK_FORMAT_R32_SFLOAT, VK_FORMAT_D32_SFLOAT, VK_FORMAT_UNDEFINED }, // D24F
- { VK_FORMAT_UNDEFINED, VK_FORMAT_R32_SFLOAT, VK_FORMAT_D32_SFLOAT, VK_FORMAT_UNDEFINED }, // D32F
- { VK_FORMAT_UNDEFINED, VK_FORMAT_X8_D24_UNORM_PACK32, VK_FORMAT_D24_UNORM_S8_UINT, VK_FORMAT_UNDEFINED }, // D0S8
+#define $_ VK_COMPONENT_SWIZZLE_IDENTITY
+#define $0 VK_COMPONENT_SWIZZLE_ZERO
+#define $1 VK_COMPONENT_SWIZZLE_ONE
+#define $R VK_COMPONENT_SWIZZLE_R
+#define $G VK_COMPONENT_SWIZZLE_G
+#define $B VK_COMPONENT_SWIZZLE_B
+#define $A VK_COMPONENT_SWIZZLE_A
+ { VK_FORMAT_BC1_RGB_UNORM_BLOCK, VK_FORMAT_BC1_RGB_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_BC1_RGB_SRGB_BLOCK, { $_, $_, $_, $_ } }, // BC1
+ { VK_FORMAT_BC2_UNORM_BLOCK, VK_FORMAT_BC2_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_BC2_SRGB_BLOCK, { $_, $_, $_, $_ } }, // BC2
+ { VK_FORMAT_BC3_UNORM_BLOCK, VK_FORMAT_BC3_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_BC3_SRGB_BLOCK, { $_, $_, $_, $_ } }, // BC3
+ { VK_FORMAT_BC4_UNORM_BLOCK, VK_FORMAT_BC4_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // BC4
+ { VK_FORMAT_BC5_UNORM_BLOCK, VK_FORMAT_BC5_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // BC5
+ { VK_FORMAT_BC6H_SFLOAT_BLOCK, VK_FORMAT_BC6H_SFLOAT_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // BC6H
+ { VK_FORMAT_BC7_UNORM_BLOCK, VK_FORMAT_BC7_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_BC7_SRGB_BLOCK, { $_, $_, $_, $_ } }, // BC7
+ { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // ETC1
+ { VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, { $_, $_, $_, $_ } }, // ETC2
+ { VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, { $_, $_, $_, $_ } }, // ETC2A
+ { VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, { $_, $_, $_, $_ } }, // ETC2A1
+ { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // PTC12
+ { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // PTC14
+ { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // PTC12A
+ { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // PTC14A
+ { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // PTC22
+ { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // PTC24
+ { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // ATC
+ { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // ATCE
+ { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // ATCI
+ { VK_FORMAT_ASTC_4x4_UNORM_BLOCK, VK_FORMAT_ASTC_4x4_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_ASTC_4x4_SRGB_BLOCK, { $_, $_, $_, $_ } }, // ASTC4x4
+ { VK_FORMAT_ASTC_5x4_UNORM_BLOCK, VK_FORMAT_ASTC_5x4_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_ASTC_5x4_SRGB_BLOCK, { $_, $_, $_, $_ } }, // ASTC5x4
+ { VK_FORMAT_ASTC_5x5_UNORM_BLOCK, VK_FORMAT_ASTC_5x5_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_ASTC_5x5_SRGB_BLOCK, { $_, $_, $_, $_ } }, // ASTC5x5
+ { VK_FORMAT_ASTC_6x5_UNORM_BLOCK, VK_FORMAT_ASTC_6x5_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_ASTC_6x5_SRGB_BLOCK, { $_, $_, $_, $_ } }, // ASTC6x5
+ { VK_FORMAT_ASTC_6x6_UNORM_BLOCK, VK_FORMAT_ASTC_6x6_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_ASTC_6x6_SRGB_BLOCK, { $_, $_, $_, $_ } }, // ASTC6x6
+ { VK_FORMAT_ASTC_8x5_UNORM_BLOCK, VK_FORMAT_ASTC_8x5_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_ASTC_8x5_SRGB_BLOCK, { $_, $_, $_, $_ } }, // ASTC8x5
+ { VK_FORMAT_ASTC_8x6_UNORM_BLOCK, VK_FORMAT_ASTC_8x6_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_ASTC_8x6_SRGB_BLOCK, { $_, $_, $_, $_ } }, // ASTC8x6
+ { VK_FORMAT_ASTC_8x8_UNORM_BLOCK, VK_FORMAT_ASTC_8x8_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_ASTC_8x8_SRGB_BLOCK, { $_, $_, $_, $_ } }, // ASTC8x8
+ { VK_FORMAT_ASTC_10x5_UNORM_BLOCK, VK_FORMAT_ASTC_10x5_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_ASTC_10x5_SRGB_BLOCK, { $_, $_, $_, $_ } }, // ASTC10x5
+ { VK_FORMAT_ASTC_10x6_UNORM_BLOCK, VK_FORMAT_ASTC_10x6_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_ASTC_10x6_SRGB_BLOCK, { $_, $_, $_, $_ } }, // ASTC10x6
+ { VK_FORMAT_ASTC_10x8_UNORM_BLOCK, VK_FORMAT_ASTC_10x8_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_ASTC_10x8_SRGB_BLOCK, { $_, $_, $_, $_ } }, // ASTC10x8
+ { VK_FORMAT_ASTC_10x10_UNORM_BLOCK, VK_FORMAT_ASTC_10x10_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_ASTC_10x10_SRGB_BLOCK, { $_, $_, $_, $_ } }, // ASTC10x10
+ { VK_FORMAT_ASTC_12x10_UNORM_BLOCK, VK_FORMAT_ASTC_12x10_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_ASTC_12x10_SRGB_BLOCK, { $_, $_, $_, $_ } }, // ASTC12x10
+ { VK_FORMAT_ASTC_12x12_UNORM_BLOCK, VK_FORMAT_ASTC_12x12_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_ASTC_12x12_SRGB_BLOCK, { $_, $_, $_, $_ } }, // ASTC12x12
+ { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // Unknown
+ { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // R1
+ { VK_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $0, $0, $0, $R } }, // A8
+ { VK_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_R8_SRGB, { $_, $_, $_, $_ } }, // R8
+ { VK_FORMAT_R8_SINT, VK_FORMAT_R8_SINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // R8I
+ { VK_FORMAT_R8_UINT, VK_FORMAT_R8_UINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // R8U
+ { VK_FORMAT_R8_SNORM, VK_FORMAT_R8_SNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // R8S
+ { VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // R16
+ { VK_FORMAT_R16_SINT, VK_FORMAT_R16_SINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // R16I
+ { VK_FORMAT_R16_UINT, VK_FORMAT_R16_UINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // R16U
+ { VK_FORMAT_R16_SFLOAT, VK_FORMAT_R16_SFLOAT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // R16F
+ { VK_FORMAT_R16_SNORM, VK_FORMAT_R16_SNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // R16S
+ { VK_FORMAT_R32_SINT, VK_FORMAT_R32_SINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // R32I
+ { VK_FORMAT_R32_UINT, VK_FORMAT_R32_UINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // R32U
+ { VK_FORMAT_R32_SFLOAT, VK_FORMAT_R32_SFLOAT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // R32F
+ { VK_FORMAT_R8G8_UNORM, VK_FORMAT_R8G8_UNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_R8G8_SRGB, { $_, $_, $_, $_ } }, // RG8
+ { VK_FORMAT_R8G8_SINT, VK_FORMAT_R8G8_SINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // RG8I
+ { VK_FORMAT_R8G8_UINT, VK_FORMAT_R8G8_UINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // RG8U
+ { VK_FORMAT_R8G8_SNORM, VK_FORMAT_R8G8_SNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // RG8S
+ { VK_FORMAT_R16G16_UNORM, VK_FORMAT_R16G16_UNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // RG16
+ { VK_FORMAT_R16G16_SINT, VK_FORMAT_R16G16_SINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // RG16I
+ { VK_FORMAT_R16G16_UINT, VK_FORMAT_R16G16_UINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // RG16U
+ { VK_FORMAT_R16G16_SFLOAT, VK_FORMAT_R16G16_SFLOAT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // RG16F
+ { VK_FORMAT_R16G16_SNORM, VK_FORMAT_R16G16_SNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // RG16S
+ { VK_FORMAT_R32G32_SINT, VK_FORMAT_R32G32_SINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // RG32I
+ { VK_FORMAT_R32G32_UINT, VK_FORMAT_R32G32_UINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // RG32U
+ { VK_FORMAT_R32G32_SFLOAT, VK_FORMAT_R32G32_SFLOAT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // RG32F
+ { VK_FORMAT_R8G8B8_UNORM, VK_FORMAT_R8G8B8_UNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_R8G8B8_SRGB, { $_, $_, $_, $_ } }, // RGB8
+ { VK_FORMAT_R8G8B8_SINT, VK_FORMAT_R8G8B8_SINT, VK_FORMAT_UNDEFINED, VK_FORMAT_R8G8B8_SRGB, { $_, $_, $_, $_ } }, // RGB8I
+ { VK_FORMAT_R8G8B8_UINT, VK_FORMAT_R8G8B8_UINT, VK_FORMAT_UNDEFINED, VK_FORMAT_R8G8B8_SRGB, { $_, $_, $_, $_ } }, // RGB8U
+ { VK_FORMAT_R8G8B8_SNORM, VK_FORMAT_R8G8B8_SNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // RGB8S
+ { VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // RGB9E5F
+ { VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_B8G8R8A8_SRGB, { $_, $_, $_, $_ } }, // BGRA8
+ { VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_R8G8B8A8_SRGB, { $_, $_, $_, $_ } }, // RGBA8
+ { VK_FORMAT_R8G8B8A8_SINT, VK_FORMAT_R8G8B8A8_SINT, VK_FORMAT_UNDEFINED, VK_FORMAT_R8G8B8A8_SRGB, { $_, $_, $_, $_ } }, // RGBA8I
+ { VK_FORMAT_R8G8B8A8_UINT, VK_FORMAT_R8G8B8A8_UINT, VK_FORMAT_UNDEFINED, VK_FORMAT_R8G8B8A8_SRGB, { $_, $_, $_, $_ } }, // RGBA8U
+ { VK_FORMAT_R8G8B8A8_SNORM, VK_FORMAT_R8G8B8A8_SNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // RGBA8S
+ { VK_FORMAT_R16G16B16A16_UNORM, VK_FORMAT_R16G16B16A16_UNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // RGBA16
+ { VK_FORMAT_R16G16B16A16_SINT, VK_FORMAT_R16G16B16A16_SINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // RGBA16I
+ { VK_FORMAT_R16G16B16A16_UINT, VK_FORMAT_R16G16B16A16_UINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // RGBA16U
+ { VK_FORMAT_R16G16B16A16_SFLOAT, VK_FORMAT_R16G16B16A16_SFLOAT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // RGBA16F
+ { VK_FORMAT_R16G16B16A16_SNORM, VK_FORMAT_R16G16B16A16_SNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // RGBA16S
+ { VK_FORMAT_R32G32B32A32_SINT, VK_FORMAT_R32G32B32A32_SINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // RGBA32I
+ { VK_FORMAT_R32G32B32A32_UINT, VK_FORMAT_R32G32B32A32_UINT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // RGBA32U
+ { VK_FORMAT_R32G32B32A32_SFLOAT, VK_FORMAT_R32G32B32A32_SFLOAT, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // RGBA32F
+ { VK_FORMAT_R5G6B5_UNORM_PACK16, VK_FORMAT_R5G6B5_UNORM_PACK16, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // B5G6R5
+ { VK_FORMAT_B5G6R5_UNORM_PACK16, VK_FORMAT_B5G6R5_UNORM_PACK16, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // R5G6B5
+ { VK_FORMAT_B4G4R4A4_UNORM_PACK16, VK_FORMAT_B4G4R4A4_UNORM_PACK16, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $G, $R, $A, $B } }, // BGRA4
+ { VK_FORMAT_R4G4B4A4_UNORM_PACK16, VK_FORMAT_R4G4B4A4_UNORM_PACK16, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $A, $B, $G, $R } }, // RGBA4
+ { VK_FORMAT_A1R5G5B5_UNORM_PACK16, VK_FORMAT_A1R5G5B5_UNORM_PACK16, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // BGR5A1
+ { VK_FORMAT_A1R5G5B5_UNORM_PACK16, VK_FORMAT_A1R5G5B5_UNORM_PACK16, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $B, $G, $R, $A } }, // RGB5A1
+ { VK_FORMAT_A2R10G10B10_UNORM_PACK32, VK_FORMAT_A2R10G10B10_UNORM_PACK32, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $B, $G, $R, $A } }, // RGB10A2
+ { VK_FORMAT_B10G11R11_UFLOAT_PACK32, VK_FORMAT_B10G11R11_UFLOAT_PACK32, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // RG11B10F
+ { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // UnknownDepth
+ { VK_FORMAT_UNDEFINED, VK_FORMAT_R16_UNORM, VK_FORMAT_D16_UNORM, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // D16
+ { VK_FORMAT_UNDEFINED, VK_FORMAT_R32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // D24
+ { VK_FORMAT_UNDEFINED, VK_FORMAT_R32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // D24S8
+ { VK_FORMAT_UNDEFINED, VK_FORMAT_R32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // D32
+ { VK_FORMAT_UNDEFINED, VK_FORMAT_R32_SFLOAT, VK_FORMAT_D32_SFLOAT, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // D16F
+ { VK_FORMAT_UNDEFINED, VK_FORMAT_R32_SFLOAT, VK_FORMAT_D32_SFLOAT, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // D24F
+ { VK_FORMAT_UNDEFINED, VK_FORMAT_R32_SFLOAT, VK_FORMAT_D32_SFLOAT, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // D32F
+ { VK_FORMAT_UNDEFINED, VK_FORMAT_R8_UINT, VK_FORMAT_S8_UINT, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // D0S8
+#undef $_
+#undef $0
+#undef $1
+#undef $R
+#undef $G
+#undef $B
+#undef $A
};
BX_STATIC_ASSERT(TextureFormat::Count == BX_COUNTOF(s_textureFormat) );
+ struct LayerInfo
+ {
+ bool m_supported;
+ bool m_initialize;
+ };
+
+ struct Layer
+ {
+ enum Enum
+ {
+ VK_LAYER_LUNARG_standard_validation,
+ VK_LAYER_KHRONOS_validation,
+
+ Count
+ };
+
+ const char* m_name;
+ uint32_t m_minVersion;
+ LayerInfo m_instance;
+ LayerInfo m_device;
+ };
+
+ // Layer registry
+ //
+ static Layer s_layer[] =
+ {
+ { "VK_LAYER_LUNARG_standard_validation", 1, { false, false }, { false, false } },
+ { "VK_LAYER_KHRONOS_validation", 1, { false, false }, { false, false } },
+ { "", 0, { false, false }, { false, false } },
+ };
+ BX_STATIC_ASSERT(Layer::Count == BX_COUNTOF(s_layer)-1);
+
+ void updateLayer(const char* _name, uint32_t _version, bool _instanceLayer)
+ {
+ bx::StringView layerName(_name);
+
+ for (uint32_t ii = 0; ii < Layer::Count; ++ii)
+ {
+ Layer& layer = s_layer[ii];
+ LayerInfo& layerInfo = _instanceLayer
+ ? layer.m_instance
+ : layer.m_device
+ ;
+
+ if (!layerInfo.m_supported && layerInfo.m_initialize)
+ {
+ if ( 0 == bx::strCmp(layerName, layer.m_name)
+ && _version >= layer.m_minVersion)
+ {
+ layerInfo.m_supported = true;
+ break;
+ }
+ }
+ }
+ }
+
+ struct Extension
+ {
+ enum Enum
+ {
+ EXT_debug_utils,
+ EXT_debug_report,
+ EXT_memory_budget,
+ KHR_get_physical_device_properties2,
+ EXT_conservative_rasterization,
+ EXT_line_rasterization,
+ EXT_shader_viewport_index_layer,
+ EXT_custom_border_color,
+ KHR_draw_indirect_count,
+
+# if BX_PLATFORM_ANDROID
+ KHR_android_surface,
+# elif BX_PLATFORM_LINUX
+ KHR_wayland_surface,
+ KHR_xlib_surface,
+ KHR_xcb_surface,
+# elif BX_PLATFORM_WINDOWS
+ KHR_win32_surface,
+# elif BX_PLATFORM_OSX
+ MVK_macos_surface,
+# endif
+
+ Count
+ };
+
+ const char* m_name;
+ uint32_t m_minVersion;
+ bool m_instanceExt;
+ bool m_supported;
+ bool m_initialize;
+ Layer::Enum m_layer;
+ };
+
+ // Extension registry
+ //
+ static Extension s_extension[] =
+ {
+ { "VK_EXT_debug_utils", 1, false, false, BGFX_CONFIG_DEBUG_OBJECT_NAME || BGFX_CONFIG_DEBUG_ANNOTATION, Layer::Count },
+ { "VK_EXT_debug_report", 1, false, false, false , Layer::Count },
+ { "VK_EXT_memory_budget", 1, false, false, true , Layer::Count },
+ { "VK_KHR_get_physical_device_properties2", 1, false, false, true , Layer::Count },
+ { "VK_EXT_conservative_rasterization", 1, false, false, true , Layer::Count },
+ { "VK_EXT_line_rasterization", 1, false, false, true , Layer::Count },
+ { "VK_EXT_shader_viewport_index_layer", 1, false, false, true , Layer::Count },
+ { "VK_EXT_custom_border_color", 1, false, false, true , Layer::Count },
+ { "VK_KHR_draw_indirect_count", 1, false, false, true , Layer::Count },
+# if BX_PLATFORM_ANDROID
+ { VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, 1, false, false, true, Layer::Count },
+# elif BX_PLATFORM_LINUX
+ { VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME, 1, false, false, true, Layer::Count },
+ { VK_KHR_XLIB_SURFACE_EXTENSION_NAME, 1, false, false, true, Layer::Count },
+ { VK_KHR_XCB_SURFACE_EXTENSION_NAME, 1, false, false, true, Layer::Count },
+# elif BX_PLATFORM_WINDOWS
+ { VK_KHR_WIN32_SURFACE_EXTENSION_NAME, 1, false, false, true, Layer::Count },
+# elif BX_PLATFORM_OSX
+ { VK_MVK_MACOS_SURFACE_EXTENSION_NAME, 1, false, false, true, Layer::Count },
+# endif
+ };
+ BX_STATIC_ASSERT(Extension::Count == BX_COUNTOF(s_extension) );
+
+ bool updateExtension(const char* _name, uint32_t _version, bool _instanceExt, Extension _extensions[Extension::Count])
+ {
+ bool supported = false;
+ if (BX_ENABLED(BGFX_CONFIG_RENDERER_USE_EXTENSIONS) )
+ {
+ const bx::StringView ext(_name);
+ for (uint32_t ii = 0; ii < Extension::Count; ++ii)
+ {
+ Extension& extension = _extensions[ii];
+ const LayerInfo& layerInfo = _instanceExt
+ ? s_layer[extension.m_layer].m_instance
+ : s_layer[extension.m_layer].m_device
+ ;
+
+ if (!extension.m_supported
+ && extension.m_initialize
+ && (extension.m_layer == Layer::Count || layerInfo.m_supported) )
+ {
+ if ( 0 == bx::strCmp(ext, extension.m_name)
+ && _version >= extension.m_minVersion)
+ {
+ extension.m_supported = true;
+ extension.m_instanceExt = _instanceExt;
+ supported = true;
+ break;
+ }
+ }
+ }
+ }
+
+ return supported;
+ }
+
static const VkFormat s_attribType[][4][2] =
{
{ // Uint8
@@ -259,48 +461,83 @@ VK_IMPORT_DEVICE
};
BX_STATIC_ASSERT(AttribType::Count == BX_COUNTOF(s_attribType) );
- uint32_t fillVertexDecl(const ShaderVK* _vsh, VkPipelineVertexInputStateCreateInfo& _vertexInputState, const VertexDecl& _decl)
+ void fillVertexLayout(const ShaderVK* _vsh, VkPipelineVertexInputStateCreateInfo& _vertexInputState, const VertexLayout& _layout)
{
- VkVertexInputBindingDescription* inputBinding = const_cast<VkVertexInputBindingDescription*>(_vertexInputState.pVertexBindingDescriptions);
- VkVertexInputAttributeDescription* inputAttrib = const_cast<VkVertexInputAttributeDescription*>(_vertexInputState.pVertexAttributeDescriptions);
+ uint32_t numBindings = _vertexInputState.vertexBindingDescriptionCount;
+ uint32_t numAttribs = _vertexInputState.vertexAttributeDescriptionCount;
+ VkVertexInputBindingDescription* inputBinding = const_cast<VkVertexInputBindingDescription*>(_vertexInputState.pVertexBindingDescriptions + numBindings);
+ VkVertexInputAttributeDescription* inputAttrib = const_cast<VkVertexInputAttributeDescription*>(_vertexInputState.pVertexAttributeDescriptions + numAttribs);
- inputBinding->binding = 0;
- inputBinding->stride = _decl.m_stride;
+ inputBinding->binding = numBindings;
+ inputBinding->stride = _layout.m_stride;
inputBinding->inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
- _vertexInputState.vertexBindingDescriptionCount = 1;
- uint32_t numAttribs = 0;
for (uint32_t attr = 0; attr < Attrib::Count; ++attr)
{
- if (UINT16_MAX != _decl.m_attributes[attr])
+ if (UINT16_MAX != _layout.m_attributes[attr])
{
inputAttrib->location = _vsh->m_attrRemap[attr];
- inputAttrib->binding = 0;
+ inputAttrib->binding = numBindings;
- if (0 == _decl.m_attributes[attr])
- {
- inputAttrib->format = VK_FORMAT_R32G32B32_SFLOAT;
- inputAttrib->offset = 0;
- }
- else
- {
- uint8_t num;
- AttribType::Enum type;
- bool normalized;
- bool asInt;
- _decl.decode(Attrib::Enum(attr), num, type, normalized, asInt);
- inputAttrib->format = s_attribType[type][num-1][normalized];
- inputAttrib->offset = _decl.m_offset[attr];
- }
+ uint8_t num;
+ AttribType::Enum type;
+ bool normalized;
+ bool asInt;
+ _layout.decode(Attrib::Enum(attr), num, type, normalized, asInt);
+ inputAttrib->format = s_attribType[type][num-1][normalized];
+ inputAttrib->offset = _layout.m_offset[attr];
++inputAttrib;
++numAttribs;
}
}
+ _vertexInputState.vertexBindingDescriptionCount = numBindings + 1;
+ _vertexInputState.vertexAttributeDescriptionCount = numAttribs;
+ }
+
+ void fillInstanceBinding(const ShaderVK* _vsh, VkPipelineVertexInputStateCreateInfo& _vertexInputState, uint32_t _numInstanceData)
+ {
+ BX_UNUSED(_vsh);
+
+ uint32_t numBindings = _vertexInputState.vertexBindingDescriptionCount;
+ uint32_t numAttribs = _vertexInputState.vertexAttributeDescriptionCount;
+ VkVertexInputBindingDescription* inputBinding = const_cast<VkVertexInputBindingDescription*>(_vertexInputState.pVertexBindingDescriptions + numBindings);
+ VkVertexInputAttributeDescription* inputAttrib = const_cast<VkVertexInputAttributeDescription*>(_vertexInputState.pVertexAttributeDescriptions + numAttribs);
+
+ inputBinding->binding = numBindings;
+ inputBinding->stride = _numInstanceData * 16;
+ inputBinding->inputRate = VK_VERTEX_INPUT_RATE_INSTANCE;
+
+ for (uint32_t inst = 0; inst < _numInstanceData; ++inst)
+ {
+ inputAttrib->location = numAttribs;
+ inputAttrib->binding = numBindings;
+ inputAttrib->format = VK_FORMAT_R32G32B32A32_SFLOAT;
+ inputAttrib->offset = inst * 16;
+
+ ++numAttribs;
+ ++inputAttrib;
+ }
+
+ _vertexInputState.vertexBindingDescriptionCount = numBindings + 1;
_vertexInputState.vertexAttributeDescriptionCount = numAttribs;
+ }
+
+ static const char* s_deviceTypeName[] =
+ {
+ "Other",
+ "Integrated GPU",
+ "Discrete GPU",
+ "Virtual GPU",
+ "CPU",
+
+ "Unknown?!"
+ };
- return numAttribs;
+ const char* getName(VkPhysicalDeviceType _type)
+ {
+ return s_deviceTypeName[bx::min<int32_t>(_type, BX_COUNTOF(s_deviceTypeName)-1 )];
}
static const char* s_allocScopeName[] =
@@ -311,7 +548,7 @@ VK_IMPORT_DEVICE
"vkDevice",
"vkInstance",
};
- BX_STATIC_ASSERT(VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE == BX_COUNTOF(s_allocScopeName) );
+ BX_STATIC_ASSERT(VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE == BX_COUNTOF(s_allocScopeName)-1);
static void* VKAPI_PTR allocationFunction(void* _userData, size_t _size, size_t _alignment, VkSystemAllocationScope _allocationScope)
{
@@ -357,6 +594,27 @@ VK_IMPORT_DEVICE
internalFreeNotification,
};
+ VkResult VKAPI_PTR stubSetDebugUtilsObjectNameEXT(VkDevice _device, const VkDebugUtilsObjectNameInfoEXT* _nameInfo)
+ {
+ BX_UNUSED(_device, _nameInfo);
+ return VK_SUCCESS;
+ }
+
+ void VKAPI_PTR stubCmdInsertDebugUtilsLabelEXT(VkCommandBuffer _commandBuffer, const VkDebugUtilsLabelEXT* _labelInfo)
+ {
+ BX_UNUSED(_commandBuffer, _labelInfo);
+ }
+
+ void VKAPI_PTR stubCmdBeginDebugUtilsLabelEXT(VkCommandBuffer _commandBuffer, const VkDebugUtilsLabelEXT* _labelInfo)
+ {
+ BX_UNUSED(_commandBuffer, _labelInfo);
+ }
+
+ void VKAPI_PTR stubCmdEndDebugUtilsLabelEXT(VkCommandBuffer _commandBuffer)
+ {
+ BX_UNUSED(_commandBuffer);
+ }
+
static const char* s_debugReportObjectType[] =
{
"Unknown",
@@ -411,6 +669,16 @@ VK_IMPORT_DEVICE
, _userData
, s_debugReportObjectType
);
+
+ // For more info about 'VUID-VkSwapchainCreateInfoKHR-imageExtent-01274'
+ // check https://github.com/KhronosGroup/Vulkan-Docs/issues/1144
+ if (!bx::strFind(_message, "PointSizeMissing").isEmpty()
+ || !bx::strFind(_message, "SwapchainTooManyImages").isEmpty()
+ || !bx::strFind(_message, "SwapchainImageNotAcquired").isEmpty()
+ || !bx::strFind(_message, "VUID-VkSwapchainCreateInfoKHR-imageExtent-01274").isEmpty() )
+ {
+ return VK_FALSE;
+ }
BX_TRACE("%c%c%c%c%c %19s, %s, %d: %s"
, 0 != (_flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT ) ? 'I' : '-'
, 0 != (_flags & VK_DEBUG_REPORT_WARNING_BIT_EXT ) ? 'W' : '-'
@@ -422,7 +690,7 @@ VK_IMPORT_DEVICE
, _messageCode
, _message
);
- return VK_TRUE;
+ return VK_FALSE;
}
VkResult enumerateLayerProperties(VkPhysicalDevice _physicalDevice, uint32_t* _propertyCount, VkLayerProperties* _properties)
@@ -441,7 +709,7 @@ VK_IMPORT_DEVICE
;
}
- void dumpExtensions(VkPhysicalDevice _physicalDevice = VK_NULL_HANDLE)
+ void dumpExtensions(VkPhysicalDevice _physicalDevice, Extension _extensions[Extension::Count])
{
{ // Global extensions.
uint32_t numExtensionProperties;
@@ -454,25 +722,36 @@ VK_IMPORT_DEVICE
if (VK_SUCCESS == result
&& 0 < numExtensionProperties)
{
- VkExtensionProperties extensionProperties[64];
- numExtensionProperties = bx::uint32_min(numExtensionProperties, BX_COUNTOF(extensionProperties) );
+ VkExtensionProperties* extensionProperties = (VkExtensionProperties*)BX_ALLOC(g_allocator, numExtensionProperties * sizeof(VkExtensionProperties) );
result = enumerateExtensionProperties(_physicalDevice
, NULL
, &numExtensionProperties
, extensionProperties
);
- BX_TRACE("\tGlobal extensions (%d):"
+ BX_TRACE("Global extensions (%d):"
, numExtensionProperties
);
for (uint32_t extension = 0; extension < numExtensionProperties; ++extension)
{
- BX_TRACE("\t\t%s (s: 0x%08x)"
- , extensionProperties[extension].extensionName
+ bool supported = updateExtension(
+ extensionProperties[extension].extensionName
+ , extensionProperties[extension].specVersion
+ , VK_NULL_HANDLE == _physicalDevice
+ , _extensions
+ );
+
+ BX_TRACE("\tv%-3d %s%s"
, extensionProperties[extension].specVersion
+ , extensionProperties[extension].extensionName
+ , supported ? " (supported)" : "", extensionProperties[extension].extensionName
);
+
+ BX_UNUSED(supported);
}
+
+ BX_FREE(g_allocator, extensionProperties);
}
}
@@ -483,11 +762,10 @@ VK_IMPORT_DEVICE
if (VK_SUCCESS == result
&& 0 < numLayerProperties)
{
- VkLayerProperties layerProperties[64];
- numLayerProperties = bx::uint32_min(numLayerProperties, BX_COUNTOF(layerProperties) );
+ VkLayerProperties* layerProperties = (VkLayerProperties*)BX_ALLOC(g_allocator, numLayerProperties * sizeof(VkLayerProperties) );
result = enumerateLayerProperties(_physicalDevice, &numLayerProperties, layerProperties);
- char indent = VK_NULL_HANDLE == _physicalDevice ? ' ' : '\t';
+ char indent = VK_NULL_HANDLE == _physicalDevice ? '\0' : '\t';
BX_UNUSED(indent);
BX_TRACE("%cLayer extensions (%d):"
@@ -496,6 +774,12 @@ VK_IMPORT_DEVICE
);
for (uint32_t layer = 0; layer < numLayerProperties; ++layer)
{
+ updateLayer(
+ layerProperties[layer].layerName
+ , layerProperties[layer].implementationVersion
+ , VK_NULL_HANDLE == _physicalDevice
+ );
+
BX_TRACE("%c\t%s (s: 0x%08x, i: 0x%08x), %s"
, indent
, layerProperties[layer].layerName
@@ -513,8 +797,7 @@ VK_IMPORT_DEVICE
if (VK_SUCCESS == result
&& 0 < numExtensionProperties)
{
- VkExtensionProperties extensionProperties[64];
- numExtensionProperties = bx::uint32_min(numExtensionProperties, BX_COUNTOF(extensionProperties) );
+ VkExtensionProperties* extensionProperties = (VkExtensionProperties*)BX_ALLOC(g_allocator, numExtensionProperties * sizeof(VkExtensionProperties) );
result = enumerateExtensionProperties(_physicalDevice
, layerProperties[layer].layerName
, &numExtensionProperties
@@ -523,14 +806,28 @@ VK_IMPORT_DEVICE
for (uint32_t extension = 0; extension < numExtensionProperties; ++extension)
{
+ bool supported = updateExtension(
+ extensionProperties[extension].extensionName
+ , extensionProperties[extension].specVersion
+ , VK_NULL_HANDLE == _physicalDevice
+ , _extensions
+ );
+
BX_TRACE("%c\t\t%s (s: 0x%08x)"
, indent
, extensionProperties[extension].extensionName
, extensionProperties[extension].specVersion
+ , supported ? " (supported)" : "", extensionProperties[extension].extensionName
);
+
+ BX_UNUSED(supported);
}
+
+ BX_FREE(g_allocator, extensionProperties);
}
}
+
+ BX_FREE(g_allocator, layerProperties);
}
}
@@ -547,6 +844,8 @@ VK_IMPORT_DEVICE
VKENUM(VK_INCOMPLETE);
VKENUM(VK_ERROR_OUT_OF_HOST_MEMORY);
VKENUM(VK_ERROR_OUT_OF_DEVICE_MEMORY);
+ VKENUM(VK_ERROR_OUT_OF_POOL_MEMORY);
+ VKENUM(VK_ERROR_FRAGMENTED_POOL);
VKENUM(VK_ERROR_INITIALIZATION_FAILED);
VKENUM(VK_ERROR_DEVICE_LOST);
VKENUM(VK_ERROR_MEMORY_MAP_FAILED);
@@ -570,101 +869,209 @@ VK_IMPORT_DEVICE
return "<VkResult?>";
}
- void setImageMemoryBarrier(VkCommandBuffer _commandBuffer, VkImage _image, VkImageLayout _oldLayout, VkImageLayout _newLayout)
+ template<typename Ty>
+ constexpr VkObjectType getType();
+
+ template<> VkObjectType getType<VkBuffer >() { return VK_OBJECT_TYPE_BUFFER; }
+ template<> VkObjectType getType<VkCommandPool >() { return VK_OBJECT_TYPE_COMMAND_POOL; }
+ template<> VkObjectType getType<VkDescriptorPool >() { return VK_OBJECT_TYPE_DESCRIPTOR_POOL; }
+ template<> VkObjectType getType<VkDescriptorSet >() { return VK_OBJECT_TYPE_DESCRIPTOR_SET; }
+ template<> VkObjectType getType<VkDescriptorSetLayout>() { return VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT; }
+ template<> VkObjectType getType<VkDeviceMemory >() { return VK_OBJECT_TYPE_DEVICE_MEMORY; }
+ template<> VkObjectType getType<VkFence >() { return VK_OBJECT_TYPE_FENCE; }
+ template<> VkObjectType getType<VkFramebuffer >() { return VK_OBJECT_TYPE_FRAMEBUFFER; }
+ template<> VkObjectType getType<VkImage >() { return VK_OBJECT_TYPE_IMAGE; }
+ template<> VkObjectType getType<VkImageView >() { return VK_OBJECT_TYPE_IMAGE_VIEW; }
+ template<> VkObjectType getType<VkPipeline >() { return VK_OBJECT_TYPE_PIPELINE; }
+ template<> VkObjectType getType<VkPipelineCache >() { return VK_OBJECT_TYPE_PIPELINE_CACHE; }
+ template<> VkObjectType getType<VkPipelineLayout >() { return VK_OBJECT_TYPE_PIPELINE_LAYOUT; }
+ template<> VkObjectType getType<VkQueryPool >() { return VK_OBJECT_TYPE_QUERY_POOL; }
+ template<> VkObjectType getType<VkRenderPass >() { return VK_OBJECT_TYPE_RENDER_PASS; }
+ template<> VkObjectType getType<VkSampler >() { return VK_OBJECT_TYPE_SAMPLER; }
+ template<> VkObjectType getType<VkSemaphore >() { return VK_OBJECT_TYPE_SEMAPHORE; }
+ template<> VkObjectType getType<VkShaderModule >() { return VK_OBJECT_TYPE_SHADER_MODULE; }
+ template<> VkObjectType getType<VkSurfaceKHR >() { return VK_OBJECT_TYPE_SURFACE_KHR; }
+ template<> VkObjectType getType<VkSwapchainKHR >() { return VK_OBJECT_TYPE_SWAPCHAIN_KHR; }
+
+
+ template<typename Ty>
+ static BX_NO_INLINE void setDebugObjectName(VkDevice _device, Ty _object, const char* _format, ...)
+ {
+ if (BX_ENABLED(BGFX_CONFIG_DEBUG_OBJECT_NAME)
+ && s_extension[Extension::EXT_debug_utils].m_supported)
+ {
+ char temp[2048];
+ va_list argList;
+ va_start(argList, _format);
+ int32_t size = bx::min<int32_t>(sizeof(temp)-1, bx::vsnprintf(temp, sizeof(temp), _format, argList) );
+ va_end(argList);
+ temp[size] = '\0';
+
+ VkDebugUtilsObjectNameInfoEXT ni;
+ ni.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
+ ni.pNext = NULL;
+ ni.objectType = getType<Ty>();
+ ni.objectHandle = uint64_t(_object.vk);
+ ni.pObjectName = temp;
+
+ VK_CHECK(vkSetDebugUtilsObjectNameEXT(_device, &ni) );
+ }
+ }
+
+ void setMemoryBarrier(
+ VkCommandBuffer _commandBuffer
+ , VkPipelineStageFlags _srcStages
+ , VkPipelineStageFlags _dstStages
+ )
+ {
+ VkMemoryBarrier mb;
+ mb.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
+ mb.pNext = NULL;
+ mb.srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT;
+ mb.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT;
+
+ vkCmdPipelineBarrier(
+ _commandBuffer
+ , _srcStages
+ , _dstStages
+ , 0
+ , 1
+ , &mb
+ , 0
+ , NULL
+ , 0
+ , NULL
+ );
+ }
+
+ void setImageMemoryBarrier(
+ VkCommandBuffer _commandBuffer
+ , VkImage _image
+ , VkImageAspectFlags _aspectMask
+ , VkImageLayout _oldLayout
+ , VkImageLayout _newLayout
+ , uint32_t _baseMipLevel = 0
+ , uint32_t _levelCount = VK_REMAINING_MIP_LEVELS
+ , uint32_t _baseArrayLayer = 0
+ , uint32_t _layerCount = VK_REMAINING_ARRAY_LAYERS
+ )
{
- BX_CHECK(true
+ BX_ASSERT(true
&& _newLayout != VK_IMAGE_LAYOUT_UNDEFINED
&& _newLayout != VK_IMAGE_LAYOUT_PREINITIALIZED
, "_newLayout cannot use VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED."
);
+ constexpr VkPipelineStageFlags depthStageMask = 0
+ | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
+ | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT
+ ;
+
+ constexpr VkPipelineStageFlags sampledStageMask = 0
+ | VK_PIPELINE_STAGE_VERTEX_SHADER_BIT
+ | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
+ | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT
+ ;
+
+ VkPipelineStageFlags srcStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
+ VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
+
VkAccessFlags srcAccessMask = 0;
VkAccessFlags dstAccessMask = 0;
- VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
switch (_oldLayout)
{
case VK_IMAGE_LAYOUT_UNDEFINED:
-// srcAccessMask |= VK_ACCESS_HOST_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT;
break;
case VK_IMAGE_LAYOUT_GENERAL:
+ srcStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
+ srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT;
break;
case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
- srcAccessMask |= VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+ srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+ srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
break;
case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
- srcAccessMask |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
+ srcStageMask = depthStageMask;
+ srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
break;
case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
+ srcStageMask = depthStageMask | sampledStageMask;
break;
case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
- srcAccessMask |= VK_ACCESS_SHADER_READ_BIT;
+ srcStageMask = sampledStageMask;
break;
case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
- srcAccessMask |= VK_ACCESS_TRANSFER_READ_BIT;
+ srcStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
break;
case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
+ srcStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
+ srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
break;
case VK_IMAGE_LAYOUT_PREINITIALIZED:
- srcAccessMask |= VK_ACCESS_HOST_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT;
+ srcStageMask = VK_PIPELINE_STAGE_HOST_BIT;
+ srcAccessMask = VK_ACCESS_HOST_WRITE_BIT;
break;
case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR:
- srcAccessMask |= VK_ACCESS_MEMORY_READ_BIT;
break;
default:
+ BX_ASSERT(false, "Unknown image layout.");
break;
}
switch (_newLayout)
{
- case VK_IMAGE_LAYOUT_UNDEFINED:
- break;
-
case VK_IMAGE_LAYOUT_GENERAL:
+ dstStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
+ dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT;
break;
case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
- dstAccessMask |= VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+ dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+ dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
break;
case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
- dstAccessMask |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
- aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
+ dstStageMask = depthStageMask;
+ dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
break;
case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
+ dstStageMask = depthStageMask | sampledStageMask;
+ dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
break;
case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
- dstAccessMask |= VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
+ dstStageMask = sampledStageMask;
+ dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
break;
case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
- dstAccessMask |= VK_ACCESS_SHADER_READ_BIT;
+ dstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
+ dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
break;
case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
- dstAccessMask |= VK_ACCESS_TRANSFER_READ_BIT;
- break;
-
- case VK_IMAGE_LAYOUT_PREINITIALIZED:
+ dstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
+ dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
break;
case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR:
- dstAccessMask |= VK_ACCESS_MEMORY_READ_BIT;
+ // vkQueuePresentKHR performs automatic visibility operations
break;
default:
+ BX_ASSERT(false, "Unknown image layout.");
break;
}
@@ -678,14 +1085,14 @@ VK_IMPORT_DEVICE
imb.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
imb.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
imb.image = _image;
- imb.subresourceRange.aspectMask = aspectMask;
- imb.subresourceRange.baseMipLevel = 0;
- imb.subresourceRange.levelCount = 1;
- imb.subresourceRange.baseArrayLayer = 0;
- imb.subresourceRange.layerCount = 1;
+ imb.subresourceRange.aspectMask = _aspectMask;
+ imb.subresourceRange.baseMipLevel = _baseMipLevel;
+ imb.subresourceRange.levelCount = _levelCount;
+ imb.subresourceRange.baseArrayLayer = _baseArrayLayer;
+ imb.subresourceRange.layerCount = _layerCount;
vkCmdPipelineBarrier(_commandBuffer
- , VK_PIPELINE_STAGE_ALL_COMMANDS_BIT
- , VK_PIPELINE_STAGE_ALL_COMMANDS_BIT
+ , srcStageMask
+ , dstStageMask
, 0
, 0
, NULL
@@ -696,15 +1103,20 @@ VK_IMPORT_DEVICE
);
}
+#define MAX_DESCRIPTOR_SETS (1024 * BGFX_CONFIG_MAX_FRAME_LATENCY)
+
struct RendererContextVK : public RendererContextI
{
RendererContextVK()
: m_allocatorCb(NULL)
, m_renderDocDll(NULL)
, m_vulkan1Dll(NULL)
- , m_maxAnisotropy(1)
+ , m_maxAnisotropy(1.0f)
, m_depthClamp(false)
, m_wireframe(false)
+ , m_captureBuffer(VK_NULL_HANDLE)
+ , m_captureMemory(VK_NULL_HANDLE)
+ , m_captureSize(0)
{
}
@@ -714,8 +1126,6 @@ VK_IMPORT_DEVICE
bool init(const Init& _init)
{
- BX_UNUSED(s_checkMsaa, s_textureAddress);
-
struct ErrorState
{
enum Enum
@@ -724,24 +1134,31 @@ VK_IMPORT_DEVICE
LoadedVulkan1,
InstanceCreated,
DeviceCreated,
- RenderPassCreated,
- SurfaceCreated,
- SwapchainCreated,
- CommandBuffersCreated,
+ CommandQueueCreated,
+ SwapChainCreated,
DescriptorCreated,
+ TimerQueryCreated,
};
};
ErrorState::Enum errorState = ErrorState::Default;
+ const bool headless = NULL == g_platformData.nwh;
+
+ const void* nextFeatures = NULL;
+ VkPhysicalDeviceLineRasterizationFeaturesEXT lineRasterizationFeatures;
+ VkPhysicalDeviceCustomBorderColorFeaturesEXT customBorderColorFeatures;
+
+ bx::memSet(&lineRasterizationFeatures, 0, sizeof(lineRasterizationFeatures) );
+ bx::memSet(&customBorderColorFeatures, 0, sizeof(customBorderColorFeatures) );
+
m_fbh.idx = kInvalidHandle;
bx::memSet(m_uniforms, 0, sizeof(m_uniforms) );
bx::memSet(&m_resolution, 0, sizeof(m_resolution) );
bool imported = true;
VkResult result;
- m_qfiGraphics = UINT32_MAX;
- m_qfiCompute = UINT32_MAX;
+ m_globalQueueFamily = UINT32_MAX;
if (_init.debug
|| _init.profile)
@@ -749,15 +1166,19 @@ VK_IMPORT_DEVICE
m_renderDocDll = loadRenderDoc();
}
+ setGraphicsDebuggerPresent(NULL != m_renderDocDll);
+
m_vulkan1Dll = bx::dlopen(
#if BX_PLATFORM_WINDOWS
- "vulkan-1.dll"
+ "vulkan-1.dll"
#elif BX_PLATFORM_ANDROID
- "libvulkan.so"
+ "libvulkan.so"
+#elif BX_PLATFORM_OSX
+ "libvulkan.dylib"
#else
- "libvulkan.so.1"
+ "libvulkan.so.1"
#endif // BX_PLATFORM_*
- );
+ );
if (NULL == m_vulkan1Dll)
{
@@ -768,11 +1189,14 @@ VK_IMPORT_DEVICE
errorState = ErrorState::LoadedVulkan1;
BX_TRACE("Shared library functions:");
+
#define VK_IMPORT_FUNC(_optional, _func) \
_func = (PFN_##_func)bx::dlsym(m_vulkan1Dll, #_func); \
BX_TRACE("\t%p " #_func, _func); \
imported &= _optional || NULL != _func
+
VK_IMPORT
+
#undef VK_IMPORT_FUNC
if (!imported)
@@ -782,53 +1206,127 @@ VK_IMPORT
}
{
- dumpExtensions();
+ s_layer[Layer::VK_LAYER_LUNARG_standard_validation].m_device.m_initialize = _init.debug;
+ s_layer[Layer::VK_LAYER_LUNARG_standard_validation].m_instance.m_initialize = _init.debug;
+ s_layer[Layer::VK_LAYER_KHRONOS_validation ].m_device.m_initialize = _init.debug;
+ s_layer[Layer::VK_LAYER_KHRONOS_validation ].m_instance.m_initialize = _init.debug;
- VkApplicationInfo appInfo;
- appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
- appInfo.pNext = NULL;
- appInfo.pApplicationName = "bgfx";
- appInfo.applicationVersion = BGFX_API_VERSION;
- appInfo.pEngineName = "bgfx";
- appInfo.engineVersion = BGFX_API_VERSION;
- appInfo.apiVersion = VK_MAKE_VERSION(1, 0, 0); //VK_HEADER_VERSION);
+ s_extension[Extension::EXT_debug_report].m_initialize = _init.debug;
- const char* enabledLayerNames[] =
+ s_extension[Extension::EXT_shader_viewport_index_layer].m_initialize = !!(_init.capabilities & BGFX_CAPS_VIEWPORT_LAYER_ARRAY);
+ s_extension[Extension::EXT_conservative_rasterization ].m_initialize = !!(_init.capabilities & BGFX_CAPS_CONSERVATIVE_RASTER );
+ s_extension[Extension::KHR_draw_indirect_count ].m_initialize = !!(_init.capabilities & BGFX_CAPS_DRAW_INDIRECT_COUNT );
+
+ dumpExtensions(VK_NULL_HANDLE, s_extension);
+
+ if (s_layer[Layer::VK_LAYER_KHRONOS_validation].m_device.m_supported
+ || s_layer[Layer::VK_LAYER_KHRONOS_validation].m_instance.m_supported)
{
-#if BGFX_CONFIG_DEBUG
-// "VK_LAYER_GOOGLE_threading",
-// "VK_LAYER_GOOGLE_unique_objects",
-// "VK_LAYER_LUNARG_device_limits",
-// "VK_LAYER_LUNARG_standard_validation",
-// "VK_LAYER_LUNARG_image",
-// "VK_LAYER_LUNARG_mem_tracker",
-// "VK_LAYER_LUNARG_object_tracker",
-// "VK_LAYER_LUNARG_parameter_validation",
-// "VK_LAYER_LUNARG_swapchain",
-// "VK_LAYER_LUNARG_vktrace",
-// "VK_LAYER_RENDERDOC_Capture",
-#endif // BGFX_CONFIG_DEBUG
- /*not used*/ ""
- };
+ s_layer[Layer::VK_LAYER_LUNARG_standard_validation].m_device.m_supported = false;
+ s_layer[Layer::VK_LAYER_LUNARG_standard_validation].m_instance.m_supported = false;
+ }
+
+ uint32_t numEnabledLayers = 0;
+
+ const char* enabledLayer[Layer::Count];
+
+ BX_TRACE("Enabled instance layers:");
+
+ for (uint32_t ii = 0; ii < Layer::Count; ++ii)
+ {
+ const Layer& layer = s_layer[ii];
+
+ if (layer.m_instance.m_supported
+ && layer.m_instance.m_initialize)
+ {
+ enabledLayer[numEnabledLayers++] = layer.m_name;
+ BX_TRACE("\t%s", layer.m_name);
+ }
+ }
+#if BX_PLATFORM_OSX || defined(WL_EGL_PLATFORM)
+ uint32_t numEnabledExtensions = headless ? 0 : 3;
- const char* enabledExtension[] =
+ const char* enabledExtension[Extension::Count + 3] =
+#else
+ uint32_t numEnabledExtensions = headless ? 0 : 1;
+
+ const char* enabledExtension[Extension::Count + 1] =
+#endif
{
VK_KHR_SURFACE_EXTENSION_NAME,
- KHR_SURFACE_EXTENSION_NAME,
-#if BGFX_CONFIG_DEBUG
- VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
-#endif // BGFX_CONFIG_DEBUG
- /*not used*/ ""
+#if BX_PLATFORM_OSX
+ VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME,
+#endif
};
+ for (uint32_t ii = 0; ii < Extension::Count; ++ii)
+ {
+ const Extension& extension = s_extension[ii];
+ const LayerInfo& layerInfo = s_layer[extension.m_layer].m_instance;
+
+ const bool layerEnabled = false
+ || extension.m_layer == Layer::Count
+ || (layerInfo.m_supported && layerInfo.m_initialize)
+ ;
+
+ if (extension.m_supported
+ && extension.m_initialize
+ && extension.m_instanceExt
+ && layerEnabled)
+ {
+ enabledExtension[numEnabledExtensions++] = extension.m_name;
+ }
+ }
+
+ BX_TRACE("Enabled instance extensions:");
+
+ for (uint32_t ii = 0; ii < numEnabledExtensions; ++ii)
+ {
+ BX_TRACE("\t%s", enabledExtension[ii]);
+ }
+
+ uint32_t vulkanApiVersionSelector;
+
+ if (NULL != vkEnumerateInstanceVersion)
+ {
+ result = vkEnumerateInstanceVersion(&vulkanApiVersionSelector);
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE(
+ "Init error: vkEnumerateInstanceVersion failed %d: %s."
+ , result
+ , getName(result)
+ );
+ goto error;
+ }
+ }
+ else
+ {
+ vulkanApiVersionSelector = VK_API_VERSION_1_0;
+ }
+
+ VkApplicationInfo appInfo;
+ appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
+ appInfo.pNext = NULL;
+ appInfo.pApplicationName = "bgfx";
+ appInfo.applicationVersion = BGFX_API_VERSION;
+ appInfo.pEngineName = "bgfx";
+ appInfo.engineVersion = BGFX_API_VERSION;
+ appInfo.apiVersion = vulkanApiVersionSelector;
+
VkInstanceCreateInfo ici;
ici.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
ici.pNext = NULL;
+#if BX_PLATFORM_OSX
+ ici.flags = 0 | VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
+#else
ici.flags = 0;
- ici.pApplicationInfo = &appInfo;
- ici.enabledLayerCount = BX_COUNTOF(enabledLayerNames) - 1;
- ici.ppEnabledLayerNames = enabledLayerNames;
- ici.enabledExtensionCount = BX_COUNTOF(enabledExtension) - 1;
+#endif
+ ici.pApplicationInfo = &appInfo;
+ ici.enabledLayerCount = numEnabledLayers;
+ ici.ppEnabledLayerNames = enabledLayer;
+ ici.enabledExtensionCount = numEnabledExtensions;
ici.ppEnabledExtensionNames = enabledExtension;
if (BX_ENABLED(BGFX_CONFIG_DEBUG) )
@@ -837,16 +1335,26 @@ VK_IMPORT
BX_UNUSED(s_allocationCb);
}
- result = vkCreateInstance(&ici
- , m_allocatorCb
- , &m_instance
- );
- }
+ result = vkCreateInstance(
+ &ici
+ , m_allocatorCb
+ , &m_instance
+ );
- if (VK_SUCCESS != result)
- {
- BX_TRACE("Init error: vkCreateInstance failed %d: %s.", result, getName(result) );
- goto error;
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Init error: vkCreateInstance failed %d: %s.", result, getName(result) );
+ goto error;
+ }
+
+ m_instanceApiVersion = vulkanApiVersionSelector;
+
+ BX_TRACE("Instance API version: %d.%d.%d"
+ , VK_API_VERSION_MAJOR(m_instanceApiVersion)
+ , VK_API_VERSION_MINOR(m_instanceApiVersion)
+ , VK_API_VERSION_PATCH(m_instanceApiVersion)
+ );
+ BX_TRACE("Instance variant: %d", VK_API_VERSION_VARIANT(m_instanceApiVersion) );
}
errorState = ErrorState::InstanceCreated;
@@ -868,7 +1376,7 @@ VK_IMPORT_INSTANCE
m_debugReportCallback = VK_NULL_HANDLE;
- if (BX_ENABLED(BGFX_CONFIG_DEBUG) )
+ if (s_extension[Extension::EXT_debug_report].m_supported)
{
VkDebugReportCallbackCreateInfoEXT drcb;
drcb.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;
@@ -903,7 +1411,7 @@ VK_IMPORT_INSTANCE
}
VkPhysicalDevice physicalDevices[4];
- numPhysicalDevices = bx::uint32_min(numPhysicalDevices, BX_COUNTOF(physicalDevices) );
+ numPhysicalDevices = bx::min<uint32_t>(numPhysicalDevices, BX_COUNTOF(physicalDevices) );
result = vkEnumeratePhysicalDevices(m_instance
, &numPhysicalDevices
, physicalDevices
@@ -915,7 +1423,10 @@ VK_IMPORT_INSTANCE
goto error;
}
- m_physicalDevice = VK_NULL_HANDLE;
+ Extension physicalDeviceExtensions[4][Extension::Count];
+
+ uint32_t physicalDeviceIdx = UINT32_MAX;
+ uint32_t fallbackPhysicalDeviceIdx = UINT32_MAX;
for (uint32_t ii = 0; ii < numPhysicalDevices; ++ii)
{
@@ -923,7 +1434,12 @@ VK_IMPORT_INSTANCE
vkGetPhysicalDeviceProperties(physicalDevices[ii], &pdp);
BX_TRACE("Physical device %d:", ii);
BX_TRACE("\t Name: %s", pdp.deviceName);
- BX_TRACE("\t API version: %x", pdp.apiVersion);
+ BX_TRACE("\t API version: %d.%d.%d"
+ , VK_API_VERSION_MAJOR(pdp.apiVersion)
+ , VK_API_VERSION_MINOR(pdp.apiVersion)
+ , VK_API_VERSION_PATCH(pdp.apiVersion)
+ );
+ BX_TRACE("\t API variant: %d", VK_API_VERSION_VARIANT(pdp.apiVersion) );
BX_TRACE("\tDriver version: %x", pdp.driverVersion);
BX_TRACE("\t VendorId: %x", pdp.vendorID);
BX_TRACE("\t DeviceId: %x", pdp.deviceID);
@@ -937,7 +1453,24 @@ VK_IMPORT_INSTANCE
&& (BGFX_PCI_ID_NONE == g_caps.vendorId || pdp.vendorID == g_caps.vendorId)
&& (0 == g_caps.deviceId || pdp.deviceID == g_caps.deviceId) )
{
- m_physicalDevice = physicalDevices[ii];
+ if (pdp.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU
+ || pdp.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU)
+ {
+ fallbackPhysicalDeviceIdx = ii;
+ }
+
+ physicalDeviceIdx = ii;
+ }
+ else
+ {
+ if (pdp.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU)
+ {
+ fallbackPhysicalDeviceIdx = ii;
+ }
+ else if (pdp.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU)
+ {
+ physicalDeviceIdx = ii;
+ }
}
VkPhysicalDeviceMemoryProperties pdmp;
@@ -947,10 +1480,10 @@ VK_IMPORT_INSTANCE
for (uint32_t jj = 0; jj < pdmp.memoryTypeCount; ++jj)
{
BX_TRACE("\t%3d: flags 0x%08x, index %d"
- , jj
- , pdmp.memoryTypes[jj].propertyFlags
- , pdmp.memoryTypes[jj].heapIndex
- );
+ , jj
+ , pdmp.memoryTypes[jj].propertyFlags
+ , pdmp.memoryTypes[jj].heapIndex
+ );
}
BX_TRACE("\tMemory heap count: %d", pdmp.memoryHeapCount);
@@ -959,51 +1492,189 @@ VK_IMPORT_INSTANCE
char size[16];
bx::prettify(size, BX_COUNTOF(size), pdmp.memoryHeaps[jj].size);
BX_TRACE("\t%3d: flags 0x%08x, size %10s"
- , jj
- , pdmp.memoryHeaps[jj].flags
- , size
- );
+ , jj
+ , pdmp.memoryHeaps[jj].flags
+ , size
+ );
}
- dumpExtensions(physicalDevices[ii]);
+ bx::memCopy(&physicalDeviceExtensions[ii][0], &s_extension[0], sizeof(s_extension) );
+ dumpExtensions(physicalDevices[ii], physicalDeviceExtensions[ii]);
}
- if (VK_NULL_HANDLE == m_physicalDevice)
+ if (UINT32_MAX == physicalDeviceIdx)
{
- m_physicalDevice = physicalDevices[0];
+ physicalDeviceIdx = UINT32_MAX == fallbackPhysicalDeviceIdx
+ ? 0
+ : fallbackPhysicalDeviceIdx
+ ;
}
+ m_physicalDevice = physicalDevices[physicalDeviceIdx];
+
+ bx::memCopy(&s_extension[0], &physicalDeviceExtensions[physicalDeviceIdx][0], sizeof(s_extension) );
+
vkGetPhysicalDeviceProperties(m_physicalDevice, &m_deviceProperties);
g_caps.vendorId = uint16_t(m_deviceProperties.vendorID);
g_caps.deviceId = uint16_t(m_deviceProperties.deviceID);
+ BX_TRACE("Using physical device %d: %s", physicalDeviceIdx, m_deviceProperties.deviceName);
+
+ VkPhysicalDeviceFeatures supportedFeatures;
+
+ if (s_extension[Extension::KHR_get_physical_device_properties2].m_supported)
+ {
+ VkPhysicalDeviceFeatures2KHR deviceFeatures2;
+ deviceFeatures2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
+ deviceFeatures2.pNext = NULL;
+
+ VkBaseOutStructure* next = (VkBaseOutStructure*)&deviceFeatures2;
+
+ if (s_extension[Extension::EXT_line_rasterization].m_supported)
+ {
+ next->pNext = (VkBaseOutStructure*)&lineRasterizationFeatures;
+ next = (VkBaseOutStructure*)&lineRasterizationFeatures;
+ lineRasterizationFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
+ lineRasterizationFeatures.pNext = NULL;
+ }
+
+ if (s_extension[Extension::EXT_custom_border_color].m_supported)
+ {
+ next->pNext = (VkBaseOutStructure*)&customBorderColorFeatures;
+ next = (VkBaseOutStructure*)&customBorderColorFeatures;
+ customBorderColorFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
+ customBorderColorFeatures.pNext = NULL;
+ }
+
+ nextFeatures = deviceFeatures2.pNext;
+
+ vkGetPhysicalDeviceFeatures2KHR(m_physicalDevice, &deviceFeatures2);
+ supportedFeatures = deviceFeatures2.features;
+ }
+ else
+ {
+ vkGetPhysicalDeviceFeatures(m_physicalDevice, &supportedFeatures);
+ }
+
+ bx::memSet(&m_deviceFeatures, 0, sizeof(m_deviceFeatures) );
+
+ m_deviceFeatures.fullDrawIndexUint32 = supportedFeatures.fullDrawIndexUint32;
+ m_deviceFeatures.imageCubeArray = supportedFeatures.imageCubeArray && (_init.capabilities & BGFX_CAPS_TEXTURE_CUBE_ARRAY);
+ m_deviceFeatures.independentBlend = supportedFeatures.independentBlend && (_init.capabilities & BGFX_CAPS_BLEND_INDEPENDENT);
+ m_deviceFeatures.multiDrawIndirect = supportedFeatures.multiDrawIndirect && (_init.capabilities & BGFX_CAPS_DRAW_INDIRECT);
+ m_deviceFeatures.drawIndirectFirstInstance = supportedFeatures.drawIndirectFirstInstance && (_init.capabilities & BGFX_CAPS_DRAW_INDIRECT);
+ m_deviceFeatures.depthClamp = supportedFeatures.depthClamp;
+ m_deviceFeatures.fillModeNonSolid = supportedFeatures.fillModeNonSolid;
+ m_deviceFeatures.largePoints = supportedFeatures.largePoints;
+ m_deviceFeatures.samplerAnisotropy = supportedFeatures.samplerAnisotropy;
+ m_deviceFeatures.textureCompressionETC2 = supportedFeatures.textureCompressionETC2;
+ m_deviceFeatures.textureCompressionBC = supportedFeatures.textureCompressionBC;
+ m_deviceFeatures.vertexPipelineStoresAndAtomics = supportedFeatures.vertexPipelineStoresAndAtomics;
+ m_deviceFeatures.fragmentStoresAndAtomics = supportedFeatures.fragmentStoresAndAtomics;
+ m_deviceFeatures.shaderImageGatherExtended = supportedFeatures.shaderImageGatherExtended;
+ m_deviceFeatures.shaderStorageImageExtendedFormats = supportedFeatures.shaderStorageImageExtendedFormats;
+ m_deviceFeatures.shaderClipDistance = supportedFeatures.shaderClipDistance;
+ m_deviceFeatures.shaderCullDistance = supportedFeatures.shaderCullDistance;
+ m_deviceFeatures.shaderResourceMinLod = supportedFeatures.shaderResourceMinLod;
+
+ m_lineAASupport = true
+ && s_extension[Extension::EXT_line_rasterization].m_supported
+ && lineRasterizationFeatures.smoothLines
+ ;
+
+ m_borderColorSupport = true
+ && s_extension[Extension::EXT_custom_border_color].m_supported
+ && customBorderColorFeatures.customBorderColors
+ ;
+
+ m_timerQuerySupport = m_deviceProperties.limits.timestampComputeAndGraphics;
+
+ const bool indirectDrawSupport = true
+ && m_deviceFeatures.multiDrawIndirect
+ && m_deviceFeatures.drawIndirectFirstInstance
+ ;
+
+ g_caps.supported |= ( 0
+ | BGFX_CAPS_ALPHA_TO_COVERAGE
+ | (m_deviceFeatures.independentBlend ? BGFX_CAPS_BLEND_INDEPENDENT : 0)
+ | BGFX_CAPS_COMPUTE
+ | (indirectDrawSupport ? BGFX_CAPS_DRAW_INDIRECT : 0)
+ | BGFX_CAPS_FRAGMENT_DEPTH
+ | BGFX_CAPS_IMAGE_RW
+ | (m_deviceFeatures.fullDrawIndexUint32 ? BGFX_CAPS_INDEX32 : 0)
+ | BGFX_CAPS_INSTANCING
+ | BGFX_CAPS_OCCLUSION_QUERY
+ | (!headless ? BGFX_CAPS_SWAP_CHAIN : 0)
+ | BGFX_CAPS_TEXTURE_2D_ARRAY
+ | BGFX_CAPS_TEXTURE_3D
+ | BGFX_CAPS_TEXTURE_BLIT
+ | BGFX_CAPS_TEXTURE_COMPARE_ALL
+ | (m_deviceFeatures.imageCubeArray ? BGFX_CAPS_TEXTURE_CUBE_ARRAY : 0)
+ | BGFX_CAPS_TEXTURE_READ_BACK
+ | BGFX_CAPS_VERTEX_ATTRIB_HALF
+ | BGFX_CAPS_VERTEX_ATTRIB_UINT10
+ | BGFX_CAPS_VERTEX_ID
+ );
+
+ g_caps.supported |= 0
+ | (s_extension[Extension::EXT_conservative_rasterization ].m_supported ? BGFX_CAPS_CONSERVATIVE_RASTER : 0)
+ | (s_extension[Extension::EXT_shader_viewport_index_layer].m_supported ? BGFX_CAPS_VIEWPORT_LAYER_ARRAY : 0)
+ | (s_extension[Extension::KHR_draw_indirect_count ].m_supported && indirectDrawSupport ? BGFX_CAPS_DRAW_INDIRECT_COUNT : 0)
+ ;
+
+ const uint32_t maxAttachments = bx::min<uint32_t>(m_deviceProperties.limits.maxFragmentOutputAttachments, m_deviceProperties.limits.maxColorAttachments);
+
g_caps.limits.maxTextureSize = m_deviceProperties.limits.maxImageDimension2D;
- g_caps.limits.maxFBAttachments = uint8_t(bx::uint32_min(m_deviceProperties.limits.maxFragmentOutputAttachments, BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS) );
- g_caps.limits.maxComputeBindings = BGFX_MAX_COMPUTE_BINDINGS;
+ g_caps.limits.maxTextureLayers = m_deviceProperties.limits.maxImageArrayLayers;
+ g_caps.limits.maxFBAttachments = bx::min<uint32_t>(maxAttachments, BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS);
+ g_caps.limits.maxTextureSamplers = bx::min<uint32_t>(m_deviceProperties.limits.maxPerStageResources, BGFX_CONFIG_MAX_TEXTURE_SAMPLERS);
+ g_caps.limits.maxComputeBindings = bx::min<uint32_t>(m_deviceProperties.limits.maxPerStageResources, BGFX_MAX_COMPUTE_BINDINGS);
+ g_caps.limits.maxVertexStreams = bx::min<uint32_t>(m_deviceProperties.limits.maxVertexInputBindings, BGFX_CONFIG_MAX_VERTEX_STREAMS);
{
-// VkFormatProperties fp;
-// vkGetPhysicalDeviceFormatProperties(m_physicalDevice, fmt, &fp);
+ const VkSampleCountFlags sampleMask = ~0
+ & m_deviceProperties.limits.framebufferColorSampleCounts
+ & m_deviceProperties.limits.framebufferDepthSampleCounts
+ ;
+
+ for (uint16_t ii = 0, last = 0; ii < BX_COUNTOF(s_msaa); ii++)
+ {
+ const VkSampleCountFlags sampleBit = s_msaa[ii].Sample;
+
+ if (sampleBit & sampleMask)
+ {
+ last = ii;
+ }
+ else
+ {
+ s_msaa[ii] = s_msaa[last];
+ }
+ }
+ }
+ {
struct ImageTest
{
- VkImageType type;
- VkImageUsageFlags usage;
+ VkImageType type;
+ VkImageUsageFlags usage;
VkImageCreateFlags flags;
- uint32_t formatCaps[2];
+ uint32_t formatCaps[2];
};
const ImageTest imageTest[] =
{
- { VK_IMAGE_TYPE_2D, VK_IMAGE_USAGE_SAMPLED_BIT, 0, { BGFX_CAPS_FORMAT_TEXTURE_2D, BGFX_CAPS_FORMAT_TEXTURE_2D_SRGB } },
- { VK_IMAGE_TYPE_3D, VK_IMAGE_USAGE_SAMPLED_BIT, 0, { BGFX_CAPS_FORMAT_TEXTURE_3D, BGFX_CAPS_FORMAT_TEXTURE_3D_SRGB } },
- { VK_IMAGE_TYPE_2D, VK_IMAGE_USAGE_SAMPLED_BIT, VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, { BGFX_CAPS_FORMAT_TEXTURE_CUBE, BGFX_CAPS_FORMAT_TEXTURE_CUBE_SRGB } },
- { VK_IMAGE_TYPE_2D, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, 0, { BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER, BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER } },
+ { VK_IMAGE_TYPE_2D, VK_IMAGE_USAGE_SAMPLED_BIT, 0, { BGFX_CAPS_FORMAT_TEXTURE_2D, BGFX_CAPS_FORMAT_TEXTURE_2D_SRGB } },
+ { VK_IMAGE_TYPE_3D, VK_IMAGE_USAGE_SAMPLED_BIT, 0, { BGFX_CAPS_FORMAT_TEXTURE_3D, BGFX_CAPS_FORMAT_TEXTURE_3D_SRGB } },
+ { VK_IMAGE_TYPE_2D, VK_IMAGE_USAGE_SAMPLED_BIT, VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, { BGFX_CAPS_FORMAT_TEXTURE_CUBE, BGFX_CAPS_FORMAT_TEXTURE_CUBE_SRGB } },
+ { VK_IMAGE_TYPE_2D, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, 0, { BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER, 0 } },
+ { VK_IMAGE_TYPE_2D, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, 0, { BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER, 0 } },
+ { VK_IMAGE_TYPE_2D, VK_IMAGE_USAGE_STORAGE_BIT, 0, { BGFX_CAPS_FORMAT_TEXTURE_IMAGE_READ, 0 } },
+ { VK_IMAGE_TYPE_2D, VK_IMAGE_USAGE_STORAGE_BIT, 0, { BGFX_CAPS_FORMAT_TEXTURE_IMAGE_WRITE, 0 } },
};
for (uint32_t ii = 0; ii < TextureFormat::Count; ++ii)
{
- uint8_t support = BGFX_CAPS_FORMAT_TEXTURE_NONE;
+ uint16_t support = BGFX_CAPS_FORMAT_TEXTURE_NONE;
const bool depth = bimg::isDepth(bimg::TextureFormat::Enum(ii) );
VkFormat fmt = depth
@@ -1032,9 +1703,22 @@ VK_IMPORT_INSTANCE
if (VK_SUCCESS == result)
{
support |= it.formatCaps[jj];
- if (VK_SAMPLE_COUNT_1_BIT < ifp.sampleCounts)
+
+ const bool multisample = VK_SAMPLE_COUNT_1_BIT < ifp.sampleCounts;
+ if (it.usage & VK_IMAGE_USAGE_SAMPLED_BIT)
+ {
+ support |= 0
+ | BGFX_CAPS_FORMAT_TEXTURE_VERTEX
+ | (multisample ? BGFX_CAPS_FORMAT_TEXTURE_MSAA : 0)
+ ;
+ }
+
+ if (it.usage & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) )
{
- support |= BGFX_CAPS_FORMAT_TEXTURE_MSAA;
+ support |= 0
+ | BGFX_CAPS_FORMAT_TEXTURE_MIP_AUTOGEN
+ | (multisample ? BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER_MSAA : 0)
+ ;
}
}
}
@@ -1054,14 +1738,15 @@ VK_IMPORT_INSTANCE
BX_TRACE("---");
uint32_t queueFamilyPropertyCount = 0;
- vkGetPhysicalDeviceQueueFamilyProperties(m_physicalDevice
+ vkGetPhysicalDeviceQueueFamilyProperties(
+ m_physicalDevice
, &queueFamilyPropertyCount
, NULL
);
- VkQueueFamilyProperties queueFamilyPropertices[10] = {};
- queueFamilyPropertyCount = bx::uint32_min(queueFamilyPropertyCount, BX_COUNTOF(queueFamilyPropertices) );
- vkGetPhysicalDeviceQueueFamilyProperties(m_physicalDevice
+ VkQueueFamilyProperties* queueFamilyPropertices = (VkQueueFamilyProperties*)BX_ALLOC(g_allocator, queueFamilyPropertyCount * sizeof(VkQueueFamilyProperties) );
+ vkGetPhysicalDeviceQueueFamilyProperties(
+ m_physicalDevice
, &queueFamilyPropertyCount
, queueFamilyPropertices
);
@@ -1069,98 +1754,121 @@ VK_IMPORT_INSTANCE
for (uint32_t ii = 0; ii < queueFamilyPropertyCount; ++ii)
{
const VkQueueFamilyProperties& qfp = queueFamilyPropertices[ii];
- BX_UNUSED(qfp);
+
BX_TRACE("Queue family property %d:", ii);
BX_TRACE("\t Queue flags: 0x%08x", qfp.queueFlags);
BX_TRACE("\t Queue count: %d", qfp.queueCount);
BX_TRACE("\tTS valid bits: 0x%08x", qfp.timestampValidBits);
BX_TRACE("\t Min image: %d x %d x %d"
- , qfp.minImageTransferGranularity.width
- , qfp.minImageTransferGranularity.height
- , qfp.minImageTransferGranularity.depth
- );
- }
-
- for (uint32_t ii = 0; ii < queueFamilyPropertyCount; ++ii)
- {
- const VkQueueFamilyProperties& qfp = queueFamilyPropertices[ii];
- if (UINT32_MAX == m_qfiGraphics
- && VK_QUEUE_GRAPHICS_BIT & qfp.queueFlags)
- {
- m_qfiGraphics = ii;
- }
+ , qfp.minImageTransferGranularity.width
+ , qfp.minImageTransferGranularity.height
+ , qfp.minImageTransferGranularity.depth
+ );
- if (UINT32_MAX == m_qfiCompute
- && VK_QUEUE_COMPUTE_BIT & qfp.queueFlags)
- {
- m_qfiCompute = ii;
- }
+ constexpr VkQueueFlags requiredFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT;
- if (UINT32_MAX != m_qfiGraphics
- && UINT32_MAX != m_qfiCompute)
+ if (UINT32_MAX == m_globalQueueFamily
+ && requiredFlags == (requiredFlags & qfp.queueFlags) )
{
- break;
+ m_globalQueueFamily = ii;
}
}
- if (UINT32_MAX == m_qfiGraphics)
+ BX_FREE(g_allocator, queueFamilyPropertices);
+
+ if (UINT32_MAX == m_globalQueueFamily)
{
- BX_TRACE("Init error: Unable to find graphics queue.");
+ BX_TRACE("Init error: Unable to find combined graphics and compute queue.");
goto error;
}
}
{
- const char* enabledLayerNames[] =
+ uint32_t numEnabledLayers = 0;
+
+ const char* enabledLayer[Layer::Count];
+
+ BX_TRACE("Enabled device layers:");
+
+ for (uint32_t ii = 0; ii < Layer::Count; ++ii)
{
-#if BGFX_CONFIG_DEBUG
- "VK_LAYER_GOOGLE_threading",
-// "VK_LAYER_GOOGLE_unique_objects",
- "VK_LAYER_LUNARG_device_limits",
-// "VK_LAYER_LUNARG_standard_validation",
- "VK_LAYER_LUNARG_image",
- "VK_LAYER_LUNARG_object_tracker",
- "VK_LAYER_LUNARG_parameter_validation",
- "VK_LAYER_LUNARG_swapchain",
-// "VK_LAYER_LUNARG_vktrace",
-// "VK_LAYER_RENDERDOC_Capture",
-#endif // BGFX_CONFIG_DEBUG
- /*not used*/ ""
- };
+ const Layer& layer = s_layer[ii];
+
+ if (layer.m_device.m_supported
+ && layer.m_device.m_initialize)
+ {
+ enabledLayer[numEnabledLayers++] = layer.m_name;
+ BX_TRACE("\t%s", layer.m_name);
+ }
+ }
+#if BX_PLATFORM_OSX
+ uint32_t numEnabledExtensions = headless ? 1 : 3;
- const char* enabledExtension[] =
+ const char* enabledExtension[Extension::Count + 3] =
+#else
+ uint32_t numEnabledExtensions = headless ? 1 : 2;
+
+ const char* enabledExtension[Extension::Count + 2] =
+#endif
{
+ VK_KHR_MAINTENANCE1_EXTENSION_NAME,
VK_KHR_SWAPCHAIN_EXTENSION_NAME,
-// "VK_LUNARG_DEBUG_MARKER",
- /*not used*/ ""
+#if BX_PLATFORM_OSX
+ "VK_KHR_portability_subset",
+#endif
};
+ for (uint32_t ii = 0; ii < Extension::Count; ++ii)
+ {
+ const Extension& extension = s_extension[ii];
+
+ bool layerEnabled = extension.m_layer == Layer::Count ||
+ (s_layer[extension.m_layer].m_device.m_supported &&
+ s_layer[extension.m_layer].m_device.m_initialize);
+
+ if (extension.m_supported
+ && extension.m_initialize
+ && !extension.m_instanceExt
+ && layerEnabled)
+ {
+ enabledExtension[numEnabledExtensions++] = extension.m_name;
+ }
+ }
+
+ BX_TRACE("Enabled device extensions:");
+
+ for (uint32_t ii = 0; ii < numEnabledExtensions; ++ii)
+ {
+ BX_TRACE("\t%s", enabledExtension[ii]);
+ }
+
float queuePriorities[1] = { 0.0f };
VkDeviceQueueCreateInfo dcqi;
dcqi.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
dcqi.pNext = NULL;
dcqi.flags = 0;
- dcqi.queueFamilyIndex = m_qfiGraphics;
+ dcqi.queueFamilyIndex = m_globalQueueFamily;
dcqi.queueCount = 1;
dcqi.pQueuePriorities = queuePriorities;
VkDeviceCreateInfo dci;
dci.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
- dci.pNext = NULL;
+ dci.pNext = nextFeatures;
dci.flags = 0;
dci.queueCreateInfoCount = 1;
dci.pQueueCreateInfos = &dcqi;
- dci.enabledLayerCount = BX_COUNTOF(enabledLayerNames) - 1;
- dci.ppEnabledLayerNames = enabledLayerNames;
- dci.enabledExtensionCount = BX_COUNTOF(enabledExtension) - 1;
+ dci.enabledLayerCount = numEnabledLayers;
+ dci.ppEnabledLayerNames = enabledLayer;
+ dci.enabledExtensionCount = numEnabledExtensions;
dci.ppEnabledExtensionNames = enabledExtension;
- dci.pEnabledFeatures = NULL;
+ dci.pEnabledFeatures = &m_deviceFeatures;
- result = vkCreateDevice(m_physicalDevice
- , &dci
- , m_allocatorCb
- , &m_device
- );
+ result = vkCreateDevice(
+ m_physicalDevice
+ , &dci
+ , m_allocatorCb
+ , &m_device
+ );
if (VK_SUCCESS != result)
{
@@ -1172,9 +1880,9 @@ VK_IMPORT_INSTANCE
errorState = ErrorState::DeviceCreated;
BX_TRACE("Device functions:");
-#define VK_IMPORT_DEVICE_FUNC(_optional, _func) \
+#define VK_IMPORT_DEVICE_FUNC(_optional, _func) \
_func = (PFN_##_func)vkGetDeviceProcAddr(m_device, #_func); \
- BX_TRACE("\t%p " #_func, _func); \
+ BX_TRACE("\t%p " #_func, _func); \
imported &= _optional || NULL != _func
VK_IMPORT_DEVICE
#undef VK_IMPORT_DEVICE_FUNC
@@ -1185,537 +1893,83 @@ VK_IMPORT_DEVICE
goto error;
}
- vkGetDeviceQueue(m_device, m_qfiGraphics, 0, &m_queueGraphics);
- vkGetDeviceQueue(m_device, m_qfiCompute, 0, &m_queueCompute);
-
- m_backBufferDepthStencilFormat =
- VK_FORMAT_D32_SFLOAT_S8_UINT
-// VK_FORMAT_D24_UNORM_S8_UINT
- ;
-
- {
- m_sci.imageFormat = VK_FORMAT_B8G8R8A8_UNORM;
-
- VkAttachmentDescription ad[2];
- ad[0].flags = 0;
- ad[0].format = m_sci.imageFormat;
- ad[0].samples = VK_SAMPLE_COUNT_1_BIT;
- ad[0].loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
- ad[0].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
- ad[0].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
- ad[0].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
- ad[0].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
- ad[0].finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
- ad[1].flags = 0;
- ad[1].format = m_backBufferDepthStencilFormat;
- ad[1].samples = VK_SAMPLE_COUNT_1_BIT;
- ad[1].loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
- ad[1].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
- ad[1].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
- ad[1].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
- ad[1].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
- ad[1].finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
-
- VkAttachmentReference colorAr[1];
- colorAr[0].attachment = 0;
- colorAr[0].layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
-
- VkAttachmentReference resolveAr[1];
- resolveAr[0].attachment = VK_ATTACHMENT_UNUSED;
- resolveAr[0].layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
-
- VkAttachmentReference depthAr[1];
- depthAr[0].attachment = 1;
- depthAr[0].layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
-
- VkSubpassDescription sd[1];
- sd[0].flags = 0;
- sd[0].pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
- sd[0].inputAttachmentCount = 0;
- sd[0].pInputAttachments = NULL;
- sd[0].colorAttachmentCount = BX_COUNTOF(colorAr);
- sd[0].pColorAttachments = colorAr;
- sd[0].pResolveAttachments = resolveAr;
- sd[0].pDepthStencilAttachment = depthAr;
- sd[0].preserveAttachmentCount = 0;
- sd[0].pPreserveAttachments = NULL;
-
- VkRenderPassCreateInfo rpi;
- rpi.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
- rpi.pNext = NULL;
- rpi.flags = 0;
- rpi.attachmentCount = BX_COUNTOF(ad);
- rpi.pAttachments = ad;
- rpi.subpassCount = BX_COUNTOF(sd);
- rpi.pSubpasses = sd;
- rpi.dependencyCount = 0;
- rpi.pDependencies = NULL;
-
- result = vkCreateRenderPass(m_device, &rpi, m_allocatorCb, &m_renderPass);
-
- if (VK_SUCCESS != result)
- {
- BX_TRACE("Init error: vkCreateRenderPass failed %d: %s.", result, getName(result) );
- goto error;
- }
- }
-
- errorState = ErrorState::RenderPassCreated;
-
-#if BX_PLATFORM_WINDOWS
- {
- VkWin32SurfaceCreateInfoKHR sci;
- sci.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
- sci.pNext = NULL;
- sci.flags = 0;
- sci.hinstance = (HINSTANCE)GetModuleHandle(NULL);
- sci.hwnd = (HWND)g_platformData.nwh;
- result = vkCreateWin32SurfaceKHR(m_instance, &sci, m_allocatorCb, &m_surface);
- }
-#elif BX_PLATFORM_ANDROID
- {
- VkAndroidSurfaceCreateInfoKHR sci;
- sci.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
- sci.pNext = NULL;
- sci.flags = 0;
- result = vkCreateAndroidSurfaceKHR(m_instance, &sci, m_allocatorCb, &m_surface);
- }
-#elif BX_PLATFORM_LINUX
- {
- if (NULL != vkCreateXlibSurfaceKHR)
- {
- VkXlibSurfaceCreateInfoKHR sci;
- sci.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
- sci.pNext = NULL;
- sci.flags = 0;
- sci.dpy = (Display*)g_platformData.ndt;
- sci.window = (Window)g_platformData.nwh;
- result = vkCreateXlibSurfaceKHR(m_instance, &sci, m_allocatorCb, &m_surface);
- }
- else
- {
- result = VK_RESULT_MAX_ENUM;
- }
-
- if (VK_SUCCESS != result)
- {
- void* xcbdll = bx::dlopen("libX11-xcb.so.1");
- if (NULL != xcbdll)
- {
- typedef xcb_connection_t* (*PFN_XGETXCBCONNECTION)(Display*);
- PFN_XGETXCBCONNECTION XGetXCBConnection = (PFN_XGETXCBCONNECTION)bx::dlsym(xcbdll, "XGetXCBConnection");
-
- VkXcbSurfaceCreateInfoKHR sci;
- sci.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
- sci.pNext = NULL;
- sci.flags = 0;
- sci.connection = XGetXCBConnection( (Display*)g_platformData.ndt);
- union { void* ptr; xcb_window_t window; } cast = { g_platformData.nwh };
- sci.window = cast.window;
- result = vkCreateXcbSurfaceKHR(m_instance, &sci, m_allocatorCb, &m_surface);
-
- bx::dlclose(xcbdll);
- }
- }
- }
-#else
-# error "Figure out KHR surface..."
-#endif // BX_PLATFORM_
-
- if (VK_SUCCESS != result)
- {
- BX_TRACE("Init error: vkCreateSurfaceKHR failed %d: %s.", result, getName(result) );
- goto error;
- }
-
- errorState = ErrorState::SurfaceCreated;
+ vkGetDeviceQueue(m_device, m_globalQueueFamily, 0, &m_globalQueue);
{
- VkBool32 surfaceSupported;
- result = vkGetPhysicalDeviceSurfaceSupportKHR(m_physicalDevice, m_qfiGraphics, m_surface, &surfaceSupported);
-
- if (VK_SUCCESS != result)
- {
- BX_TRACE("Init error: vkGetPhysicalDeviceSurfaceSupportKHR failed %d: %s.", result, getName(result) );
- goto error;
- }
-
- VkSurfaceCapabilitiesKHR surfaceCapabilities;
- result = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(m_physicalDevice, m_surface, &surfaceCapabilities);
-
- if (VK_SUCCESS != result)
- {
- BX_TRACE("Init error: vkGetPhysicalDeviceSurfaceCapabilitiesKHR failed %d: %s.", result, getName(result) );
- goto error;
- }
-
- uint32_t numSurfaceFormats;
- result = vkGetPhysicalDeviceSurfaceFormatsKHR(m_physicalDevice, m_surface, &numSurfaceFormats, NULL);
-
- if (VK_SUCCESS != result)
- {
- BX_TRACE("Init error: vkGetPhysicalDeviceSurfaceFormatsKHR failed %d: %s.", result, getName(result) );
- goto error;
- }
-
- VkSurfaceFormatKHR surfaceFormats[10];
- numSurfaceFormats = bx::uint32_min(numSurfaceFormats, BX_COUNTOF(surfaceFormats) );
- vkGetPhysicalDeviceSurfaceFormatsKHR(m_physicalDevice, m_surface, &numSurfaceFormats, surfaceFormats);
-
- // find the best match...
- uint32_t surfaceFormatIdx = 0;
-
- uint32_t numPresentModes;
- result = vkGetPhysicalDeviceSurfacePresentModesKHR(m_physicalDevice, m_surface, &numPresentModes, NULL);
- if (VK_SUCCESS != result)
- {
- BX_TRACE("Init error: vkGetPhysicalDeviceSurfacePresentModesKHR failed %d: %s.", result, getName(result) );
- goto error;
- }
-
- VkPresentModeKHR presentModes[10];
- numPresentModes = bx::uint32_min(numPresentModes, BX_COUNTOF(presentModes) );
- vkGetPhysicalDeviceSurfacePresentModesKHR(m_physicalDevice, m_surface, &numPresentModes, presentModes);
-
- // find the best match...
- uint32_t presentModeIdx = 0;
-
- m_sci.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
- m_sci.pNext = NULL;
- m_sci.flags = 0;
- m_sci.surface = m_surface;
- m_sci.minImageCount = BX_COUNTOF(m_backBufferColorImage);
- m_sci.imageFormat = surfaceFormats[surfaceFormatIdx].format;
- m_sci.imageColorSpace = surfaceFormats[surfaceFormatIdx].colorSpace;
- m_sci.imageExtent.width = _init.resolution.width;
- m_sci.imageExtent.height = _init.resolution.height;
- m_sci.imageArrayLayers = 1;
- m_sci.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
- m_sci.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
- m_sci.queueFamilyIndexCount = 0;
- m_sci.pQueueFamilyIndices = NULL;
- m_sci.preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
- m_sci.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
- m_sci.presentMode = presentModes[presentModeIdx];
- m_sci.clipped = VK_TRUE;
- m_sci.oldSwapchain = VK_NULL_HANDLE;
- result = vkCreateSwapchainKHR(m_device, &m_sci, m_allocatorCb, &m_swapchain);
-
- if (VK_SUCCESS != result)
- {
- BX_TRACE("Init error: vkCreateSwapchainKHR failed %d: %s.", result, getName(result) );
- goto error;
- }
-
- uint32_t numSwapchainImages;
- result = vkGetSwapchainImagesKHR(m_device, m_swapchain, &numSwapchainImages, NULL);
-
- if (VK_SUCCESS != result)
- {
- BX_TRACE("Init error: vkGetSwapchainImagesKHR failed %d: %s.", result, getName(result) );
- goto error;
- }
-
- if (numSwapchainImages < m_sci.minImageCount)
- {
- BX_TRACE("Init error: vkGetSwapchainImagesKHR: numSwapchainImages %d, minImageCount %d."
- , numSwapchainImages
- , m_sci.minImageCount
- );
- goto error;
- }
-
- numSwapchainImages = m_sci.minImageCount;
- result = vkGetSwapchainImagesKHR(m_device, m_swapchain, &numSwapchainImages, &m_backBufferColorImage[0]);
-
- if (VK_SUCCESS != result)
- {
- BX_TRACE("Init error: vkGetSwapchainImagesKHR failed %d: %s.", result, getName(result) );
- goto error;
- }
-
- for (uint32_t ii = 0; ii < BX_COUNTOF(m_backBufferColorImageView); ++ii)
- {
- m_backBufferColorImageView[ii] = VK_NULL_HANDLE;
- m_backBufferColor[ii] = VK_NULL_HANDLE;
- }
-
- VkImageCreateInfo ici;
- ici.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
- ici.pNext = NULL;
- ici.flags = 0;
- ici.imageType = VK_IMAGE_TYPE_2D;
- ici.format = m_backBufferDepthStencilFormat;
- ici.extent.width = m_sci.imageExtent.width;
- ici.extent.height = m_sci.imageExtent.height;
- ici.extent.depth = 1;
- ici.mipLevels = 1;
- ici.arrayLayers = 1;
- ici.samples = VK_SAMPLE_COUNT_1_BIT;
- ici.tiling = VK_IMAGE_TILING_OPTIMAL;
- ici.usage = 0
- | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
- | VK_IMAGE_USAGE_TRANSFER_SRC_BIT
+ m_numFramesInFlight = _init.resolution.maxFrameLatency == 0
+ ? BGFX_CONFIG_MAX_FRAME_LATENCY
+ : _init.resolution.maxFrameLatency
;
- ici.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
- ici.queueFamilyIndexCount = 0; //m_sci.queueFamilyIndexCount;
- ici.pQueueFamilyIndices = NULL; //m_sci.pQueueFamilyIndices;
- ici.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
- result = vkCreateImage(m_device, &ici, m_allocatorCb, &m_backBufferDepthStencilImage);
-
- if (VK_SUCCESS != result)
- {
- BX_TRACE("Init error: vkCreateImage failed %d: %s.", result, getName(result) );
- goto error;
- }
-
- VkMemoryRequirements mr;
- vkGetImageMemoryRequirements(m_device, m_backBufferDepthStencilImage, &mr);
- VkMemoryAllocateInfo ma;
- ma.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
- ma.pNext = NULL;
- ma.allocationSize = mr.size;
- ma.memoryTypeIndex = selectMemoryType(mr.memoryTypeBits
- , VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
- );
- result = vkAllocateMemory(m_device
- , &ma
- , m_allocatorCb
- , &m_backBufferDepthStencilMemory
- );
+ result = m_cmd.init(m_globalQueueFamily, m_globalQueue, m_numFramesInFlight);
if (VK_SUCCESS != result)
{
- BX_TRACE("Init error: vkAllocateMemory failed %d: %s.", result, getName(result) );
+ BX_TRACE("Init error: creating command queue failed %d: %s.", result, getName(result) );
goto error;
}
- result = vkBindImageMemory(m_device, m_backBufferDepthStencilImage, m_backBufferDepthStencilMemory, 0);
+ result = m_cmd.alloc(&m_commandBuffer);
if (VK_SUCCESS != result)
{
- BX_TRACE("Init error: vkBindImageMemory failed %d: %s.", result, getName(result) );
+ BX_TRACE("Init error: allocating command buffer failed %d: %s.", result, getName(result) );
goto error;
}
+ }
- VkImageViewCreateInfo ivci;
- ivci.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
- ivci.pNext = NULL;
- ivci.flags = 0;
- ivci.image = m_backBufferDepthStencilImage;
- ivci.viewType = VK_IMAGE_VIEW_TYPE_2D;
- ivci.format = m_backBufferDepthStencilFormat;
- ivci.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
- ivci.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
- ivci.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
- ivci.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
- ivci.subresourceRange.aspectMask = 0
- | VK_IMAGE_ASPECT_DEPTH_BIT
- | VK_IMAGE_ASPECT_STENCIL_BIT
- ;
- ivci.subresourceRange.baseMipLevel = 0;
- ivci.subresourceRange.levelCount = 1;
- ivci.subresourceRange.baseArrayLayer = 0;
- ivci.subresourceRange.layerCount = 1;
- result = vkCreateImageView(m_device, &ivci, m_allocatorCb, &m_backBufferDepthStencilImageView);
+ errorState = ErrorState::CommandQueueCreated;
- if (VK_SUCCESS != result)
- {
- BX_TRACE("Init error: vkCreateImageView failed %d: %s.", result, getName(result) );
- goto error;
- }
+ m_presentElapsed = 0;
- ::VkImageView attachments[] =
- {
- VK_NULL_HANDLE,
- m_backBufferDepthStencilImageView,
- };
+ {
+ m_resolution = _init.resolution;
+ m_resolution.reset &= ~BGFX_RESET_INTERNAL_FORCE;
- VkFramebufferCreateInfo fci;
- fci.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
- fci.pNext = NULL;
- fci.flags = 0;
- fci.renderPass = m_renderPass;
- fci.attachmentCount = BX_COUNTOF(attachments);
- fci.pAttachments = attachments;
- fci.width = m_sci.imageExtent.width;
- fci.height = m_sci.imageExtent.height;
- fci.layers = 1;
-
- VkSemaphoreCreateInfo sci;
- sci.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
- sci.pNext = NULL;
- sci.flags = 0;
+ m_numWindows = 0;
- for (uint32_t ii = 0; ii < numSwapchainImages; ++ii)
+ if (!headless)
{
- ivci.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
- ivci.pNext = NULL;
- ivci.flags = 0;
- ivci.image = m_backBufferColorImage[ii];
- ivci.viewType = VK_IMAGE_VIEW_TYPE_2D;
- ivci.format = m_sci.imageFormat;
- ivci.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
- ivci.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
- ivci.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
- ivci.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
- ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
- ivci.subresourceRange.baseMipLevel = 0;
- ivci.subresourceRange.levelCount = 1;
- ivci.subresourceRange.baseArrayLayer = 0;
- ivci.subresourceRange.layerCount = 1;
-
- result = vkCreateImageView(m_device, &ivci, m_allocatorCb, &m_backBufferColorImageView[ii]);
+ m_textVideoMem.resize(false, _init.resolution.width, _init.resolution.height);
+ m_textVideoMem.clear();
- if (VK_SUCCESS != result)
+ for (uint8_t ii = 0; ii < BX_COUNTOF(m_swapchainFormats); ++ii)
{
- BX_TRACE("Init error: vkCreateImageView failed %d: %s.", result, getName(result) );
- goto error;
+ m_swapchainFormats[ii] = TextureFormat::Enum(ii);
}
- attachments[0] = m_backBufferColorImageView[ii];
- result = vkCreateFramebuffer(m_device, &fci, m_allocatorCb, &m_backBufferColor[ii]);
+ result = m_backBuffer.create(UINT16_MAX, g_platformData.nwh, m_resolution.width, m_resolution.height, m_resolution.format);
if (VK_SUCCESS != result)
{
- BX_TRACE("Init error: vkCreateFramebuffer failed %d: %s.", result, getName(result) );
+ BX_TRACE("Init error: creating swap chain failed %d: %s.", result, getName(result) );
goto error;
}
- result = vkCreateSemaphore(m_device, &sci, m_allocatorCb, &m_presentDone[ii]);
+ m_windows[0] = BGFX_INVALID_HANDLE;
+ m_numWindows++;
- if (VK_SUCCESS != result)
- {
- BX_TRACE("Init error: vkCreateSemaphore failed %d: %s.", result, getName(result) );
- goto error;
- }
-
- sci.flags = 0;
+ postReset();
}
}
- errorState = ErrorState::SwapchainCreated;
-
- {
- VkFenceCreateInfo fci;
- fci.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
- fci.pNext = NULL;
- fci.flags = 0;
- result = vkCreateFence(m_device, &fci, m_allocatorCb, &m_fence);
-
- if (VK_SUCCESS != result)
- {
- BX_TRACE("Init error: vkCreateFence failed %d: %s.", result, getName(result) );
- goto error;
- }
-
- VkCommandPoolCreateInfo cpci;
- cpci.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
- cpci.pNext = NULL;
- cpci.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
- cpci.queueFamilyIndex = m_qfiGraphics;
- result = vkCreateCommandPool(m_device, &cpci, m_allocatorCb, &m_commandPool);
-
- if (VK_SUCCESS != result)
- {
- vkDestroy(m_fence);
- BX_TRACE("Init error: vkCreateCommandPool failed %d: %s.", result, getName(result) );
- goto error;
- }
-
- VkCommandBufferAllocateInfo cbai;
- cbai.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
- cbai.pNext = NULL;
- cbai.commandPool = m_commandPool;
- cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
- cbai.commandBufferCount = BX_COUNTOF(m_commandBuffers);
-
- result = vkAllocateCommandBuffers(m_device, &cbai, m_commandBuffers);
-
- if (VK_SUCCESS != result)
- {
- vkDestroy(m_commandPool);
- vkDestroy(m_fence);
- BX_TRACE("Init error: vkAllocateCommandBuffers failed %d: %s.", result, getName(result) );
- goto error;
- }
-
- VkCommandBufferBeginInfo cbbi;
- cbbi.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
- cbbi.pNext = NULL;
- cbbi.flags = 0;
- cbbi.pInheritanceInfo = NULL;
-
- VkCommandBuffer commandBuffer = m_commandBuffers[0];
- VK_CHECK(vkBeginCommandBuffer(commandBuffer, &cbbi) );
-
- VkRenderPassBeginInfo rpbi;
- rpbi.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
- rpbi.pNext = NULL;
- rpbi.renderPass = m_renderPass;
- rpbi.renderArea.offset.x = 0;
- rpbi.renderArea.offset.y = 0;
- rpbi.renderArea.extent = m_sci.imageExtent;
- rpbi.clearValueCount = 0;
- rpbi.pClearValues = NULL;
-
- setImageMemoryBarrier(commandBuffer
- , m_backBufferDepthStencilImage
- , VK_IMAGE_LAYOUT_UNDEFINED
- , VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
- );
-
- for (uint32_t ii = 0; ii < BX_COUNTOF(m_backBufferColorImage); ++ii)
- {
- setImageMemoryBarrier(commandBuffer
- , m_backBufferColorImage[ii]
- , VK_IMAGE_LAYOUT_UNDEFINED
- , VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
- );
-
- rpbi.framebuffer = m_backBufferColor[ii];
- vkCmdBeginRenderPass(commandBuffer, &rpbi, VK_SUBPASS_CONTENTS_INLINE);
- vkCmdEndRenderPass(commandBuffer);
-
- setImageMemoryBarrier(commandBuffer
- , m_backBufferColorImage[ii]
- , VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
- , VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
- );
- }
-
- VK_CHECK(vkEndCommandBuffer(commandBuffer) );
- m_backBufferColorIdx = 0;
-
- kick();
- finishAll();
-
- VK_CHECK(vkResetCommandPool(m_device, m_commandPool, 0) );
- }
-
- errorState = ErrorState::CommandBuffersCreated;
+ errorState = ErrorState::SwapChainCreated;
{
VkDescriptorPoolSize dps[] =
{
-// { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, BGFX_CONFIG_MAX_TEXTURE_SAMPLERS },
- { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 10<<10 },
-// { VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, BGFX_CONFIG_MAX_TEXTURE_SAMPLERS },
- };
-
- VkDescriptorSetLayoutBinding dslb[] =
- {
-// { DslBinding::CombinedImageSampler, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, BGFX_CONFIG_MAX_TEXTURE_SAMPLERS, VK_SHADER_STAGE_ALL, NULL },
- { DslBinding::UniformBuffer, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, VK_SHADER_STAGE_ALL, NULL },
-// { DslBinding::StorageBuffer, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, BGFX_CONFIG_MAX_TEXTURE_SAMPLERS, VK_SHADER_STAGE_ALL, NULL },
+ { VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, MAX_DESCRIPTOR_SETS * BGFX_CONFIG_MAX_TEXTURE_SAMPLERS },
+ { VK_DESCRIPTOR_TYPE_SAMPLER, MAX_DESCRIPTOR_SETS * BGFX_CONFIG_MAX_TEXTURE_SAMPLERS },
+ { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, MAX_DESCRIPTOR_SETS * 2 },
+ { VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, MAX_DESCRIPTOR_SETS * BGFX_CONFIG_MAX_TEXTURE_SAMPLERS },
+ { VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, MAX_DESCRIPTOR_SETS * BGFX_CONFIG_MAX_TEXTURE_SAMPLERS },
};
VkDescriptorPoolCreateInfo dpci;
dpci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
dpci.pNext = NULL;
dpci.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
- dpci.maxSets = 10<<10;
+ dpci.maxSets = MAX_DESCRIPTOR_SETS;
dpci.poolSizeCount = BX_COUNTOF(dps);
dpci.pPoolSizes = dps;
@@ -1727,36 +1981,6 @@ VK_IMPORT_DEVICE
goto error;
}
- VkDescriptorSetLayoutCreateInfo dsl;
- dsl.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
- dsl.pNext = NULL;
- dsl.flags = 0;
- dsl.bindingCount = BX_COUNTOF(dslb);
- dsl.pBindings = dslb;
- result = vkCreateDescriptorSetLayout(m_device, &dsl, m_allocatorCb, &m_descriptorSetLayout);
-
- if (VK_SUCCESS != result)
- {
- BX_TRACE("Init error: vkCreateDescriptorSetLayout failed %d: %s.", result, getName(result) );
- goto error;
- }
-
- VkPipelineLayoutCreateInfo pl;
- pl.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
- pl.pNext = NULL;
- pl.flags = 0;
- pl.setLayoutCount = 1;
- pl.pSetLayouts = &m_descriptorSetLayout;
- pl.pushConstantRangeCount = 0;
- pl.pPushConstantRanges = NULL;
- result = vkCreatePipelineLayout(m_device, &pl, m_allocatorCb, &m_pipelineLayout);
-
- if (VK_SUCCESS != result)
- {
- BX_TRACE("Init error: vkCreatePipelineLayout failed %d: %s.", result, getName(result) );
- goto error;
- }
-
VkPipelineCacheCreateInfo pcci;
pcci.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
pcci.pNext = NULL;
@@ -1772,61 +1996,91 @@ VK_IMPORT_DEVICE
}
}
- for (uint32_t ii = 0; ii < BX_COUNTOF(m_scratchBuffer); ++ii)
{
- m_scratchBuffer[ii].create(BGFX_CONFIG_MAX_DRAW_CALLS*1024
- , 1024 //BGFX_CONFIG_MAX_TEXTURES + BGFX_CONFIG_MAX_SHADERS + BGFX_CONFIG_MAX_DRAW_CALLS
- );
+ const uint32_t size = 128;
+ const uint32_t count = BGFX_CONFIG_MAX_DRAW_CALLS;
+ for (uint32_t ii = 0; ii < m_numFramesInFlight; ++ii)
+ {
+ BX_TRACE("Create scratch buffer %d", ii);
+ m_scratchBuffer[ii].create(size, count);
+ }
}
errorState = ErrorState::DescriptorCreated;
+ if (NULL == vkSetDebugUtilsObjectNameEXT)
+ {
+ vkSetDebugUtilsObjectNameEXT = stubSetDebugUtilsObjectNameEXT;
+ }
+
+ if (NULL == vkCmdBeginDebugUtilsLabelEXT
+ || NULL == vkCmdEndDebugUtilsLabelEXT)
+ {
+ vkCmdBeginDebugUtilsLabelEXT = stubCmdBeginDebugUtilsLabelEXT;
+ vkCmdEndDebugUtilsLabelEXT = stubCmdEndDebugUtilsLabelEXT;
+ }
+
+ if (NULL == vkCmdInsertDebugUtilsLabelEXT)
+ {
+ vkCmdInsertDebugUtilsLabelEXT = stubCmdInsertDebugUtilsLabelEXT;
+ }
+
+ // Init reserved part of view name.
+ for (uint32_t ii = 0; ii < BGFX_CONFIG_MAX_VIEWS; ++ii)
+ {
+ bx::snprintf(s_viewName[ii], BGFX_CONFIG_MAX_VIEW_NAME_RESERVED+1, "%3d ", ii);
+ }
+
+ if (m_timerQuerySupport)
+ {
+ result = m_gpuTimer.init();
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Init error: creating GPU timer failed %d: %s.", result, getName(result) );
+ goto error;
+ }
+ }
+
+ errorState = ErrorState::TimerQueryCreated;
+
+ result = m_occlusionQuery.init();
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Init error: creating occlusion query failed %d: %s.", result, getName(result) );
+ goto error;
+ }
+
+ g_internalData.context = m_device;
return true;
error:
BX_TRACE("errorState %d", errorState);
switch (errorState)
{
- case ErrorState::DescriptorCreated:
- vkDestroy(m_pipelineCache);
- vkDestroy(m_pipelineLayout);
- vkDestroy(m_descriptorSetLayout);
- vkDestroy(m_descriptorPool);
- BX_FALLTHROUGH;
-
- case ErrorState::CommandBuffersCreated:
- vkFreeCommandBuffers(m_device, m_commandPool, BX_COUNTOF(m_commandBuffers), m_commandBuffers);
- vkDestroy(m_commandPool);
- vkDestroy(m_fence);
+ case ErrorState::TimerQueryCreated:
+ if (m_timerQuerySupport)
+ {
+ m_gpuTimer.shutdown();
+ }
BX_FALLTHROUGH;
- case ErrorState::SwapchainCreated:
- for (uint32_t ii = 0; ii < BX_COUNTOF(m_backBufferColorImageView); ++ii)
+ case ErrorState::DescriptorCreated:
+ for (uint32_t ii = 0; ii < m_numFramesInFlight; ++ii)
{
- if (VK_NULL_HANDLE != m_backBufferColorImageView[ii])
- {
- vkDestroy(m_backBufferColorImageView[ii]);
- }
-
- if (VK_NULL_HANDLE != m_backBufferColor[ii])
- {
- vkDestroy(m_backBufferColor[ii]);
- }
-
- if (VK_NULL_HANDLE != m_presentDone[ii])
- {
- vkDestroy(m_presentDone[ii]);
- }
+ m_scratchBuffer[ii].destroy();
}
- vkDestroy(m_swapchain);
+ vkDestroy(m_pipelineCache);
+ vkDestroy(m_descriptorPool);
BX_FALLTHROUGH;
- case ErrorState::SurfaceCreated:
- vkDestroySurfaceKHR(m_instance, m_surface, m_allocatorCb);
+ case ErrorState::SwapChainCreated:
+ m_backBuffer.destroy();
BX_FALLTHROUGH;
- case ErrorState::RenderPassCreated:
- vkDestroy(m_renderPass);
+ case ErrorState::CommandQueueCreated:
+ m_cmd.shutdown();
BX_FALLTHROUGH;
case ErrorState::DeviceCreated:
@@ -1853,18 +2107,29 @@ VK_IMPORT_DEVICE
break;
};
- BX_CHECK(false, "Failed to initialize Vulkan.");
return false;
}
void shutdown()
{
- VK_CHECK(vkQueueWaitIdle(m_queueGraphics) );
VK_CHECK(vkDeviceWaitIdle(m_device) );
+ if (m_timerQuerySupport)
+ {
+ m_gpuTimer.shutdown();
+ }
+ m_occlusionQuery.shutdown();
+
+ preReset();
+
m_pipelineStateCache.invalidate();
+ m_descriptorSetLayoutCache.invalidate();
+ m_renderPassCache.invalidate();
+ m_samplerCache.invalidate();
+ m_samplerBorderColorCache.invalidate();
+ m_imageViewCache.invalidate();
- for (uint32_t ii = 0; ii < BX_COUNTOF(m_scratchBuffer); ++ii)
+ for (uint32_t ii = 0; ii < m_numFramesInFlight; ++ii)
{
m_scratchBuffer[ii].destroy();
}
@@ -1894,41 +2159,12 @@ VK_IMPORT_DEVICE
m_textures[ii].destroy();
}
- vkDestroy(m_pipelineCache);
- vkDestroy(m_pipelineLayout);
- vkDestroy(m_descriptorSetLayout);
- vkDestroy(m_descriptorPool);
-
- vkFreeCommandBuffers(m_device, m_commandPool, BX_COUNTOF(m_commandBuffers), m_commandBuffers);
- vkDestroy(m_commandPool);
- vkDestroy(m_fence);
-
- for (uint32_t ii = 0; ii < BX_COUNTOF(m_backBufferColorImageView); ++ii)
- {
- if (VK_NULL_HANDLE != m_backBufferColorImageView[ii])
- {
- vkDestroy(m_backBufferColorImageView[ii]);
- }
-
- if (VK_NULL_HANDLE != m_backBufferColor[ii])
- {
- vkDestroy(m_backBufferColor[ii]);
- }
-
- if (VK_NULL_HANDLE != m_presentDone[ii])
- {
- vkDestroy(m_presentDone[ii]);
- }
- }
- vkDestroy(m_swapchain);
+ m_backBuffer.destroy();
- vkDestroy(m_backBufferDepthStencilImageView);
- vkFreeMemory(m_device, m_backBufferDepthStencilMemory, m_allocatorCb);
- vkDestroy(m_backBufferDepthStencilImage);
+ m_cmd.shutdown();
- vkDestroySurfaceKHR(m_instance, m_surface, m_allocatorCb);
-
- vkDestroy(m_renderPass);
+ vkDestroy(m_pipelineCache);
+ vkDestroy(m_descriptorPool);
vkDestroyDevice(m_device, m_allocatorCb);
@@ -1962,24 +2198,26 @@ VK_IMPORT_DEVICE
void flip() override
{
- if (VK_NULL_HANDLE != m_swapchain)
+ int64_t start = bx::getHPCounter();
+
+ for (uint16_t ii = 0; ii < m_numWindows; ++ii)
{
- VkPresentInfoKHR pi;
- pi.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
- pi.pNext = NULL;
- pi.waitSemaphoreCount = 0;
- pi.pWaitSemaphores = NULL; //&m_presentDone[0];
- pi.swapchainCount = 1;
- pi.pSwapchains = &m_swapchain;
- pi.pImageIndices = &m_backBufferColorIdx;
- pi.pResults = NULL;
- VK_CHECK(vkQueuePresentKHR(m_queueGraphics, &pi) );
+ FrameBufferVK& fb = isValid(m_windows[ii])
+ ? m_frameBuffers[m_windows[ii].idx]
+ : m_backBuffer
+ ;
+
+ fb.present();
}
+
+ int64_t now = bx::getHPCounter();
+
+ m_presentElapsed += now - start;
}
void createIndexBuffer(IndexBufferHandle _handle, const Memory* _mem, uint16_t _flags) override
{
- m_indexBuffers[_handle.idx].create(_mem->size, _mem->data, _flags, false);
+ m_indexBuffers[_handle.idx].create(m_commandBuffer, _mem->size, _mem->data, _flags, false);
}
void destroyIndexBuffer(IndexBufferHandle _handle) override
@@ -1987,20 +2225,20 @@ VK_IMPORT_DEVICE
m_indexBuffers[_handle.idx].destroy();
}
- void createVertexDecl(VertexDeclHandle _handle, const VertexDecl& _decl) override
+ void createVertexLayout(VertexLayoutHandle _handle, const VertexLayout& _layout) override
{
- VertexDecl& decl = m_vertexDecls[_handle.idx];
- bx::memCopy(&decl, &_decl, sizeof(VertexDecl) );
- dump(decl);
+ VertexLayout& layout = m_vertexLayouts[_handle.idx];
+ bx::memCopy(&layout, &_layout, sizeof(VertexLayout) );
+ dump(layout);
}
- void destroyVertexDecl(VertexDeclHandle /*_handle*/) override
+ void destroyVertexLayout(VertexLayoutHandle /*_handle*/) override
{
}
- void createVertexBuffer(VertexBufferHandle _handle, const Memory* _mem, VertexDeclHandle _declHandle, uint16_t _flags) override
+ void createVertexBuffer(VertexBufferHandle _handle, const Memory* _mem, VertexLayoutHandle _layoutHandle, uint16_t _flags) override
{
- m_vertexBuffers[_handle.idx].create(_mem->size, _mem->data, _declHandle, _flags);
+ m_vertexBuffers[_handle.idx].create(m_commandBuffer, _mem->size, _mem->data, _layoutHandle, _flags);
}
void destroyVertexBuffer(VertexBufferHandle _handle) override
@@ -2010,13 +2248,12 @@ VK_IMPORT_DEVICE
void createDynamicIndexBuffer(IndexBufferHandle _handle, uint32_t _size, uint16_t _flags) override
{
- m_indexBuffers[_handle.idx].create(_size, NULL, _flags, false);
+ m_indexBuffers[_handle.idx].create(m_commandBuffer, _size, NULL, _flags, false);
}
void updateDynamicIndexBuffer(IndexBufferHandle _handle, uint32_t _offset, uint32_t _size, const Memory* _mem) override
{
- BX_UNUSED(_handle, _offset, _size, _mem);
-// m_indexBuffers[_handle.idx].update(m_commandBuffer, _offset, bx::uint32_min(_size, _mem->size), _mem->data);
+ m_indexBuffers[_handle.idx].update(m_commandBuffer, _offset, bx::min<uint32_t>(_size, _mem->size), _mem->data);
}
void destroyDynamicIndexBuffer(IndexBufferHandle _handle) override
@@ -2026,14 +2263,13 @@ VK_IMPORT_DEVICE
void createDynamicVertexBuffer(VertexBufferHandle _handle, uint32_t _size, uint16_t _flags) override
{
- VertexDeclHandle decl = BGFX_INVALID_HANDLE;
- m_vertexBuffers[_handle.idx].create(_size, NULL, decl, _flags);
+ VertexLayoutHandle layoutHandle = BGFX_INVALID_HANDLE;
+ m_vertexBuffers[_handle.idx].create(m_commandBuffer, _size, NULL, layoutHandle, _flags);
}
void updateDynamicVertexBuffer(VertexBufferHandle _handle, uint32_t _offset, uint32_t _size, const Memory* _mem) override
{
- BX_UNUSED(_handle, _offset, _size, _mem);
-// m_vertexBuffers[_handle.idx].update(m_commandBuffer, _offset, bx::uint32_min(_size, _mem->size), _mem->data);
+ m_vertexBuffers[_handle.idx].update(m_commandBuffer, _offset, bx::min<uint32_t>(_size, _mem->size), _mem->data);
}
void destroyDynamicVertexBuffer(VertexBufferHandle _handle) override
@@ -2061,29 +2297,81 @@ VK_IMPORT_DEVICE
m_program[_handle.idx].destroy();
}
- void* createTexture(TextureHandle /*_handle*/, const Memory* /*_mem*/, uint64_t /*_flags*/, uint8_t /*_skip*/) override
+ void* createTexture(TextureHandle _handle, const Memory* _mem, uint64_t _flags, uint8_t _skip) override
{
- return NULL;
+ return m_textures[_handle.idx].create(m_commandBuffer, _mem, _flags, _skip);
}
void updateTextureBegin(TextureHandle /*_handle*/, uint8_t /*_side*/, uint8_t /*_mip*/) 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*/) 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) override
{
+ m_textures[_handle.idx].update(m_commandBuffer, _side, _mip, _rect, _z, _depth, _pitch, _mem);
}
void updateTextureEnd() override
{
}
- void readTexture(TextureHandle /*_handle*/, void* /*_data*/, uint8_t /*_mip*/) override
+ void readTexture(TextureHandle _handle, void* _data, uint8_t _mip) override
{
+ TextureVK& texture = m_textures[_handle.idx];
+
+ uint32_t height = bx::uint32_max(1, texture.m_height >> _mip);
+ uint32_t pitch = texture.m_readback.pitch(_mip);
+ uint32_t size = height * pitch;
+
+ VkDeviceMemory stagingMemory;
+ VkBuffer stagingBuffer;
+ VK_CHECK(createReadbackBuffer(size, &stagingBuffer, &stagingMemory) );
+
+ texture.m_readback.copyImageToBuffer(
+ m_commandBuffer
+ , stagingBuffer
+ , texture.m_currentImageLayout
+ , texture.m_aspectMask
+ , _mip
+ );
+
+ kick(true);
+
+ texture.m_readback.readback(stagingMemory, 0, _data, _mip);
+
+ vkDestroy(stagingBuffer);
+ vkDestroy(stagingMemory);
}
- void resizeTexture(TextureHandle /*_handle*/, uint16_t /*_width*/, uint16_t /*_height*/, uint8_t /*_numMips*/, uint16_t /*_numLayers*/) override
+ void resizeTexture(TextureHandle _handle, uint16_t _width, uint16_t _height, uint8_t _numMips, uint16_t _numLayers) override
{
+ const TextureVK& texture = m_textures[_handle.idx];
+
+ const TextureFormat::Enum format = TextureFormat::Enum(texture.m_requestedFormat);
+ const uint64_t flags = texture.m_flags;
+
+ const 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, bx::ErrorAssert{});
+
+ TextureCreate tc;
+ tc.m_width = _width;
+ tc.m_height = _height;
+ tc.m_depth = 0;
+ tc.m_numLayers = _numLayers;
+ tc.m_numMips = _numMips;
+ tc.m_format = format;
+ tc.m_cubeMap = false;
+ tc.m_mem = NULL;
+ bx::write(&writer, tc, bx::ErrorAssert{});
+
+ destroyTexture(_handle);
+ createTexture(_handle, mem, flags, 0);
+
+ bgfx::release(mem);
}
void overrideInternal(TextureHandle /*_handle*/, uintptr_t /*_ptr*/) override
@@ -2095,20 +2383,58 @@ VK_IMPORT_DEVICE
return 0;
}
- void destroyTexture(TextureHandle /*_handle*/) override
+ void destroyTexture(TextureHandle _handle) override
{
+ m_imageViewCache.invalidateWithParent(_handle.idx);
+ m_textures[_handle.idx].destroy();
}
- void createFrameBuffer(FrameBufferHandle /*_handle*/, uint8_t /*_num*/, const Attachment* /*_attachment*/) override
+ void createFrameBuffer(FrameBufferHandle _handle, uint8_t _num, const Attachment* _attachment) override
{
+ m_frameBuffers[_handle.idx].create(_num, _attachment);
}
- void createFrameBuffer(FrameBufferHandle /*_handle*/, void* /*_nwh*/, uint32_t /*_width*/, uint32_t /*_height*/, TextureFormat::Enum /*_format*/, TextureFormat::Enum /*_depthFormat*/) override
+ void createFrameBuffer(FrameBufferHandle _handle, void* _nwh, uint32_t _width, uint32_t _height, TextureFormat::Enum _format, TextureFormat::Enum _depthFormat) override
{
+ for (uint32_t ii = 0, num = m_numWindows; ii < num; ++ii)
+ {
+ FrameBufferHandle handle = m_windows[ii];
+ if (isValid(handle)
+ && m_frameBuffers[handle.idx].m_nwh == _nwh)
+ {
+ destroyFrameBuffer(handle);
+ }
+ }
+
+ uint16_t denseIdx = m_numWindows++;
+ m_windows[denseIdx] = _handle;
+ VK_CHECK(m_frameBuffers[_handle.idx].create(denseIdx, _nwh, _width, _height, _format, _depthFormat) );
}
- void destroyFrameBuffer(FrameBufferHandle /*_handle*/) override
+ void destroyFrameBuffer(FrameBufferHandle _handle) override
{
+ FrameBufferVK& frameBuffer = m_frameBuffers[_handle.idx];
+
+ if (_handle.idx == m_fbh.idx)
+ {
+ setFrameBuffer(BGFX_INVALID_HANDLE, false);
+ }
+
+ uint16_t denseIdx = frameBuffer.destroy();
+ if (UINT16_MAX != denseIdx)
+ {
+ --m_numWindows;
+ if (m_numWindows > 1)
+ {
+ FrameBufferHandle handle = m_windows[m_numWindows];
+ m_windows[m_numWindows] = {kInvalidHandle};
+ if (m_numWindows != denseIdx)
+ {
+ m_windows[denseIdx] = handle;
+ m_frameBuffers[handle.idx].m_denseIdx = denseIdx;
+ }
+ }
+ }
}
void createUniform(UniformHandle _handle, UniformType::Enum _type, uint16_t _num, const char* _name) override
@@ -2118,7 +2444,7 @@ VK_IMPORT_DEVICE
BX_FREE(g_allocator, m_uniforms[_handle.idx]);
}
- uint32_t size = BX_ALIGN_16(g_uniformTypeSize[_type] * _num);
+ const uint32_t size = bx::alignUp(g_uniformTypeSize[_type] * _num, 16);
void* data = BX_ALLOC(g_allocator, size);
bx::memSet(data, 0, size);
m_uniforms[_handle.idx] = data;
@@ -2131,8 +2457,45 @@ VK_IMPORT_DEVICE
m_uniforms[_handle.idx] = NULL;
}
- void requestScreenShot(FrameBufferHandle /*_handle*/, const char* /*_filePath*/) override
+ void requestScreenShot(FrameBufferHandle _fbh, const char* _filePath) override
{
+ const FrameBufferVK& frameBuffer = isValid(_fbh)
+ ? m_frameBuffers[_fbh.idx]
+ : m_backBuffer
+ ;
+ const SwapChainVK& swapChain = frameBuffer.m_swapChain;
+
+ if (!isSwapChainReadable(swapChain) )
+ {
+ BX_TRACE("Unable to capture screenshot %s.", _filePath);
+ return;
+ }
+
+ auto callback = [](void* _src, uint32_t _width, uint32_t _height, uint32_t _pitch, const void* _userData)
+ {
+ const char* filePath = (const char*)_userData;
+ g_callback->screenShot(
+ filePath
+ , _width
+ , _height
+ , _pitch
+ , _src
+ , _height * _pitch
+ , false
+ );
+ };
+
+ const uint8_t bpp = bimg::getBitsPerPixel(bimg::TextureFormat::Enum(swapChain.m_colorFormat) );
+ const uint32_t size = frameBuffer.m_width * frameBuffer.m_height * bpp / 8;
+
+ VkDeviceMemory stagingMemory;
+ VkBuffer stagingBuffer;
+ VK_CHECK(createReadbackBuffer(size, &stagingBuffer, &stagingMemory) );
+
+ readSwapChain(swapChain, stagingBuffer, stagingMemory, callback, _filePath);
+
+ vkDestroy(stagingBuffer);
+ vkDestroy(stagingMemory);
}
void updateViewName(ViewId _id, const char* _name) override
@@ -2148,44 +2511,260 @@ VK_IMPORT_DEVICE
bx::memCopy(m_uniforms[_loc], _data, _size);
}
- void setMarker(const char* /*_marker*/, uint32_t /*_size*/) override
+ void invalidateOcclusionQuery(OcclusionQueryHandle _handle) override
{
+ m_occlusionQuery.invalidate(_handle);
}
- void invalidateOcclusionQuery(OcclusionQueryHandle _handle) override
+ void setMarker(const char* _marker, uint16_t _len) override
{
- BX_UNUSED(_handle);
+ if (BX_ENABLED(BGFX_CONFIG_DEBUG_ANNOTATION) )
+ {
+ BX_UNUSED(_len);
+
+ const uint32_t abgr = kColorMarker;
+
+ VkDebugUtilsLabelEXT dul;
+ dul.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT;
+ dul.pNext = NULL;
+ dul.pLabelName = _marker;
+ dul.color[0] = ((abgr >> 24) & 0xff) / 255.0f;
+ dul.color[1] = ((abgr >> 16) & 0xff) / 255.0f;
+ dul.color[2] = ((abgr >> 8) & 0xff) / 255.0f;
+ dul.color[3] = ((abgr >> 0) & 0xff) / 255.0f;
+
+ vkCmdInsertDebugUtilsLabelEXT(m_commandBuffer, &dul);
+ }
}
- virtual void setName(Handle _handle, const char* _name) override
+ virtual void setName(Handle _handle, const char* _name, uint16_t _len) override
{
- BX_UNUSED(_handle, _name)
+ switch (_handle.type)
+ {
+ case Handle::IndexBuffer:
+ setDebugObjectName(m_device, m_indexBuffers[_handle.idx].m_buffer, "%.*s", _len, _name);
+ break;
+
+ case Handle::Shader:
+ setDebugObjectName(m_device, m_shaders[_handle.idx].m_module, "%.*s", _len, _name);
+ break;
+
+ case Handle::Texture:
+ setDebugObjectName(m_device, m_textures[_handle.idx].m_textureImage, "%.*s", _len, _name);
+
+ if (VK_NULL_HANDLE != m_textures[_handle.idx].m_singleMsaaImage)
+ {
+ setDebugObjectName(m_device, m_textures[_handle.idx].m_singleMsaaImage, "%.*s", _len, _name);
+ }
+ break;
+
+ case Handle::VertexBuffer:
+ setDebugObjectName(m_device, m_vertexBuffers[_handle.idx].m_buffer, "%.*s", _len, _name);
+ break;
+
+ default:
+ BX_ASSERT(false, "Invalid handle type?! %d", _handle.type);
+ break;
+ }
+ }
+
+ template<typename Ty>
+ void release(Ty& _object)
+ {
+ if (VK_NULL_HANDLE != _object)
+ {
+ m_cmd.release(uint64_t(_object.vk), getType<Ty>() );
+ _object = VK_NULL_HANDLE;
+ }
}
void submitBlit(BlitState& _bs, uint16_t _view);
void submit(Frame* _render, ClearQuad& _clearQuad, TextVideoMemBlitter& _textVideoMemBlitter) override;
- void blitSetup(TextVideoMemBlitter& /*_blitter*/) override
+ void blitSetup(TextVideoMemBlitter& _blitter) override
{
+ const uint32_t width = m_backBuffer.m_width;
+ const uint32_t height = m_backBuffer.m_height;
+
+ setFrameBuffer(BGFX_INVALID_HANDLE);
+
+ VkViewport vp;
+ vp.x = 0.0f;
+ vp.y = float(height);
+ vp.width = float(width);
+ vp.height = -float(height);
+ vp.minDepth = 0.0f;
+ vp.maxDepth = 1.0f;
+ vkCmdSetViewport(m_commandBuffer, 0, 1, &vp);
+
+ VkRect2D rc;
+ rc.offset.x = 0;
+ rc.offset.y = 0;
+ rc.extent.width = width;
+ rc.extent.height = height;
+ vkCmdSetScissor(m_commandBuffer, 0, 1, &rc);
+
+ const uint64_t state = 0
+ | BGFX_STATE_WRITE_RGB
+ | BGFX_STATE_WRITE_A
+ | BGFX_STATE_DEPTH_TEST_ALWAYS
+ | BGFX_STATE_MSAA
+ ;
+
+ const VertexLayout* layout = &m_vertexLayouts[_blitter.m_vb->layoutHandle.idx];
+ VkPipeline pso = getPipeline(state
+ , packStencil(BGFX_STENCIL_DEFAULT, BGFX_STENCIL_DEFAULT)
+ , 1
+ , &layout
+ , _blitter.m_program
+ , 0
+ );
+ vkCmdBindPipeline(m_commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pso);
+
+ ProgramVK& program = m_program[_blitter.m_program.idx];
+ float proj[16];
+ bx::mtxOrtho(proj, 0.0f, (float)width, (float)height, 0.0f, 0.0f, 1000.0f, 0.0f, false);
+
+ PredefinedUniform& predefined = m_program[_blitter.m_program.idx].m_predefined[0];
+ uint8_t flags = predefined.m_type;
+ setShaderUniform(flags, predefined.m_loc, proj, 4);
+
+ UniformBuffer* vcb = program.m_vsh->m_constantBuffer;
+
+ if (NULL != vcb)
+ {
+ commit(*vcb);
+ }
+
+ ScratchBufferVK& scratchBuffer = m_scratchBuffer[m_cmd.m_currentFrameInFlight];
+ const uint32_t bufferOffset = scratchBuffer.write(m_vsScratch, program.m_vsh->m_size);
+
+ const TextureVK& texture = m_textures[_blitter.m_texture.idx];
+
+ RenderBind bind;
+ bind.clear();
+ bind.m_bind[0].m_type = Binding::Texture;
+ bind.m_bind[0].m_idx = _blitter.m_texture.idx;
+ bind.m_bind[0].m_samplerFlags = (uint32_t)(texture.m_flags & BGFX_SAMPLER_BITS_MASK);
+
+ const VkDescriptorSet descriptorSet = getDescriptorSet(program, bind, scratchBuffer, NULL);
+
+ vkCmdBindDescriptorSets(
+ m_commandBuffer
+ , VK_PIPELINE_BIND_POINT_GRAPHICS
+ , program.m_pipelineLayout
+ , 0
+ , 1
+ , &descriptorSet
+ , 1
+ , &bufferOffset
+ );
+
+ const VertexBufferVK& vb = m_vertexBuffers[_blitter.m_vb->handle.idx];
+ const VkDeviceSize offset = 0;
+ vkCmdBindVertexBuffers(m_commandBuffer, 0, 1, &vb.m_buffer, &offset);
+
+ const BufferVK& ib = m_indexBuffers[_blitter.m_ib->handle.idx];
+ vkCmdBindIndexBuffer(
+ m_commandBuffer
+ , ib.m_buffer
+ , 0
+ , VK_INDEX_TYPE_UINT16
+ );
+ }
+
+ void blitRender(TextVideoMemBlitter& _blitter, uint32_t _numIndices) override
+ {
+ const uint32_t numVertices = _numIndices*4/6;
+ if (0 < numVertices && m_backBuffer.isRenderable() )
+ {
+ m_indexBuffers[_blitter.m_ib->handle.idx].update(m_commandBuffer, 0, _numIndices*2, _blitter.m_ib->data);
+ m_vertexBuffers[_blitter.m_vb->handle.idx].update(m_commandBuffer, 0, numVertices*_blitter.m_layout.m_stride, _blitter.m_vb->data, true);
+
+
+ VkRenderPassBeginInfo rpbi;
+ rpbi.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
+ rpbi.pNext = NULL;
+ rpbi.renderPass = m_backBuffer.m_renderPass;
+ rpbi.framebuffer = m_backBuffer.m_currentFramebuffer;
+ rpbi.renderArea.offset.x = 0;
+ rpbi.renderArea.offset.y = 0;
+ rpbi.renderArea.extent.width = m_backBuffer.m_width;
+ rpbi.renderArea.extent.height = m_backBuffer.m_height;
+ rpbi.clearValueCount = 0;
+ rpbi.pClearValues = NULL;
+
+ vkCmdBeginRenderPass(m_commandBuffer, &rpbi, VK_SUBPASS_CONTENTS_INLINE);
+ vkCmdDrawIndexed(m_commandBuffer, _numIndices, 1, 0, 0, 0);
+
+ vkCmdEndRenderPass(m_commandBuffer);
+ }
}
- void blitRender(TextVideoMemBlitter& /*_blitter*/, uint32_t /*_numIndices*/) override
+ void preReset()
{
+ for (uint32_t ii = 0; ii < BX_COUNTOF(m_frameBuffers); ++ii)
+ {
+ m_frameBuffers[ii].preReset();
+ }
+
+ if (m_captureSize > 0)
+ {
+ g_callback->captureEnd();
+
+ release(m_captureBuffer);
+ release(m_captureMemory);
+ m_captureSize = 0;
+ }
}
- void updateResolution(const Resolution& _resolution)
+ void postReset()
{
+ for (uint32_t ii = 0; ii < BX_COUNTOF(m_frameBuffers); ++ii)
+ {
+ m_frameBuffers[ii].postReset();
+ }
+
+ if (m_resolution.reset & BGFX_RESET_CAPTURE)
+ {
+ const uint8_t bpp = bimg::getBitsPerPixel(bimg::TextureFormat::Enum(m_backBuffer.m_swapChain.m_colorFormat) );
+ const uint32_t captureSize = m_backBuffer.m_width * m_backBuffer.m_height * bpp / 8;
+
+ const uint8_t dstBpp = bimg::getBitsPerPixel(bimg::TextureFormat::BGRA8);
+ const uint32_t dstPitch = m_backBuffer.m_width * dstBpp / 8;
+
+ if (captureSize > m_captureSize)
+ {
+ release(m_captureBuffer);
+ release(m_captureMemory);
+
+ m_captureSize = captureSize;
+ VK_CHECK(createReadbackBuffer(m_captureSize, &m_captureBuffer, &m_captureMemory) );
+ }
+
+ g_callback->captureBegin(m_resolution.width, m_resolution.height, dstPitch, TextureFormat::BGRA8, false);
+ }
+ }
+
+ bool updateResolution(const Resolution& _resolution)
+ {
+ const bool suspended = !!(_resolution.reset & BGFX_RESET_SUSPEND);
+
+ float maxAnisotropy = 1.0f;
if (!!(_resolution.reset & BGFX_RESET_MAXANISOTROPY) )
{
- m_maxAnisotropy = UINT32_MAX;
+ maxAnisotropy = m_deviceProperties.limits.maxSamplerAnisotropy;
}
- else
+
+ if (m_maxAnisotropy != maxAnisotropy)
{
- m_maxAnisotropy = 1;
+ m_maxAnisotropy = maxAnisotropy;
+ m_samplerCache.invalidate();
+ m_samplerBorderColorCache.invalidate();
}
- bool depthClamp = !!(_resolution.reset & BGFX_RESET_DEPTH_CLAMP);
+ bool depthClamp = m_deviceFeatures.depthClamp && !!(_resolution.reset & BGFX_RESET_DEPTH_CLAMP);
if (m_depthClamp != depthClamp)
{
@@ -2193,15 +2772,38 @@ VK_IMPORT_DEVICE
m_pipelineStateCache.invalidate();
}
- uint32_t flags = _resolution.reset & ~(BGFX_RESET_MAXANISOTROPY | BGFX_RESET_DEPTH_CLAMP);
+ if (NULL == m_backBuffer.m_nwh)
+ {
+ return suspended;
+ }
+
+ //BX_TRACE("updateResolution(%d, %d) m_resolution=(%d, %d)"
+ // , _resolution.width
+ // , _resolution.height
+ // , m_resolution.width
+ // , m_resolution.height
+ // );
+
+ uint32_t flags = _resolution.reset & ~(0
+ | BGFX_RESET_SUSPEND
+ | BGFX_RESET_MAXANISOTROPY
+ | BGFX_RESET_DEPTH_CLAMP
+ );
- if (m_resolution.width != _resolution.width
+ if (false
+ || m_resolution.format != _resolution.format
+ || m_resolution.width != _resolution.width
|| m_resolution.height != _resolution.height
- || m_resolution.reset != flags)
+ || m_resolution.reset != flags
+ || m_backBuffer.m_swapChain.m_needToRecreateSurface
+ || m_backBuffer.m_swapChain.m_needToRecreateSwapchain)
{
flags &= ~BGFX_RESET_INTERNAL_FORCE;
- bool resize = (m_resolution.reset&BGFX_RESET_MSAA_MASK) == (_resolution.reset&BGFX_RESET_MSAA_MASK);
+ if (m_backBuffer.m_nwh != g_platformData.nwh)
+ {
+ m_backBuffer.m_nwh = g_platformData.nwh;
+ }
m_resolution = _resolution;
m_resolution.reset = flags;
@@ -2209,62 +2811,29 @@ VK_IMPORT_DEVICE
m_textVideoMem.resize(false, _resolution.width, _resolution.height);
m_textVideoMem.clear();
-#if 1
- BX_UNUSED(resize);
-#else
- 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_resolution.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.");
- }
+ m_backBuffer.update(m_commandBuffer, m_resolution);
+ // Update the resolution again here, as the actual width and height
+ // is now final (as it was potentially clamped by the Vulkan driver).
+ m_resolution.width = m_backBuffer.m_width;
+ m_resolution.height = m_backBuffer.m_height;
postReset();
-#endif // 0
}
+
+ return suspended;
}
void setShaderUniform(uint8_t _flags, uint32_t _regIndex, const void* _val, uint32_t _numRegs)
{
- BX_UNUSED(_flags, _regIndex, _val, _numRegs);
- if (_flags&BGFX_UNIFORM_FRAGMENTBIT)
+ if (_flags & kUniformFragmentBit)
{
bx::memCopy(&m_fsScratch[_regIndex], _val, _numRegs*16);
- m_fsChanges += _numRegs;
}
else
{
bx::memCopy(&m_vsScratch[_regIndex], _val, _numRegs*16);
- m_vsChanges += _numRegs;
}
}
@@ -2278,133 +2847,99 @@ VK_IMPORT_DEVICE
setShaderUniform(_flags, _regIndex, _val, _numRegs);
}
- void commitShaderUniforms(VkCommandBuffer _commandBuffer, uint16_t _programIdx)
+ void setFrameBuffer(FrameBufferHandle _fbh, bool _acquire = true)
{
- const ProgramVK& program = m_program[_programIdx];
- VkDescriptorBufferInfo descriptorBufferInfo;
- uint32_t total = 0
- + program.m_vsh->m_size
- + (NULL != program.m_fsh ? program.m_fsh->m_size : 0)
- ;
- if (0 < total)
- {
- uint8_t* data = (uint8_t*)m_scratchBuffer[m_backBufferColorIdx].allocUbv(descriptorBufferInfo, total);
-
- uint32_t size = program.m_vsh->m_size;
- bx::memCopy(data, m_vsScratch, size);
- data += size;
-
- if (NULL != program.m_fsh)
- {
- bx::memCopy(data, m_fsScratch, program.m_fsh->m_size);
- }
-
- vkCmdBindDescriptorSets(_commandBuffer
- , VK_PIPELINE_BIND_POINT_GRAPHICS
- , m_pipelineLayout
- , 0
- , 1
- , &m_scratchBuffer[m_backBufferColorIdx].m_descriptorSet
- [m_scratchBuffer[m_backBufferColorIdx].m_currentDs - 1]
- , 0
- , NULL
- );
- }
+ BX_ASSERT(false
+ || isValid(_fbh)
+ || NULL != m_backBuffer.m_nwh
+ , "Rendering to backbuffer in headless mode."
+ );
- m_vsChanges = 0;
- m_fsChanges = 0;
- }
+ FrameBufferVK& newFrameBuffer = isValid(_fbh)
+ ? m_frameBuffers[_fbh.idx]
+ : m_backBuffer
+ ;
- void setFrameBuffer(FrameBufferHandle _fbh, bool _msaa = true)
- {
- BX_UNUSED(_msaa);
+ FrameBufferVK& oldFrameBuffer = isValid(m_fbh)
+ ? m_frameBuffers[m_fbh.idx]
+ : m_backBuffer
+ ;
- if (isValid(m_fbh)
+ if (NULL == oldFrameBuffer.m_nwh
&& m_fbh.idx != _fbh.idx)
{
- const FrameBufferVK& frameBuffer = m_frameBuffers[m_fbh.idx];
- BX_UNUSED(frameBuffer);
-
-// for (uint8_t ii = 0, num = frameBuffer.m_num; ii < num; ++ii)
-// {
-// TextureVK& texture = m_textures[frameBuffer.m_texture[ii].idx];
-// texture.setState(m_commandList, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE);
-// }
-//
-// if (isValid(frameBuffer.m_depth) )
-// {
-// TextureVK& texture = m_textures[frameBuffer.m_depth.idx];
-// const bool writeOnly = 0 != (texture.m_flags&BGFX_TEXTURE_RT_WRITE_ONLY);
-// if (!writeOnly)
-// {
-// 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 FrameBufferVK& frameBuffer = m_frameBuffers[_fbh.idx];
- BX_UNUSED(frameBuffer);
+ oldFrameBuffer.resolve();
- 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
+ for (uint8_t ii = 0, num = oldFrameBuffer.m_num; ii < num; ++ii)
{
-// m_currentColor = NULL;
+ TextureVK& texture = m_textures[oldFrameBuffer.m_texture[ii].idx];
+ texture.setImageMemoryBarrier(m_commandBuffer, texture.m_sampledLayout);
+ if (VK_NULL_HANDLE != texture.m_singleMsaaImage)
+ {
+ texture.setImageMemoryBarrier(m_commandBuffer, texture.m_sampledLayout, true);
+ }
}
- if (isValid(frameBuffer.m_depth) )
+ if (isValid(oldFrameBuffer.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;
+ TextureVK& texture = m_textures[oldFrameBuffer.m_depth.idx];
+ const bool writeOnly = 0 != (texture.m_flags&BGFX_TEXTURE_RT_WRITE_ONLY);
+
+ if (!writeOnly)
+ {
+ texture.setImageMemoryBarrier(m_commandBuffer, texture.m_sampledLayout);
+ }
}
- else
+ }
+
+ if (NULL == newFrameBuffer.m_nwh)
+ {
+ for (uint8_t ii = 0, num = newFrameBuffer.m_num; ii < num; ++ii)
{
-// m_currentDepthStencil = NULL;
+ TextureVK& texture = m_textures[newFrameBuffer.m_texture[ii].idx];
+ texture.setImageMemoryBarrier(
+ m_commandBuffer
+ , VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
+ );
}
- for (uint8_t ii = 0, num = frameBuffer.m_num; ii < num; ++ii)
+ if (isValid(newFrameBuffer.m_depth) )
{
- TextureVK& texture = m_textures[frameBuffer.m_texture[ii].idx];
- BX_UNUSED(texture);
-// texture.setState(m_commandList, D3D12_RESOURCE_STATE_RENDER_TARGET);
+ TextureVK& texture = m_textures[newFrameBuffer.m_depth.idx];
+ texture.setImageMemoryBarrier(
+ m_commandBuffer
+ , VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
+ );
}
- if (isValid(frameBuffer.m_depth) )
+ newFrameBuffer.acquire(m_commandBuffer);
+ }
+
+ if (_acquire)
+ {
+ int64_t start = bx::getHPCounter();
+
+ newFrameBuffer.acquire(m_commandBuffer);
+
+ int64_t now = bx::getHPCounter();
+
+ if (NULL != newFrameBuffer.m_nwh)
{
- TextureVK& texture = m_textures[frameBuffer.m_depth.idx];
- BX_UNUSED(texture);
-// texture.setState(m_commandList, D3D12_RESOURCE_STATE_DEPTH_WRITE);
+ m_presentElapsed += now - start;
}
-
-// m_commandList->OMSetRenderTargets(frameBuffer.m_num
-// , m_currentColor
-// , true
-// , m_currentDepthStencil
-// );
}
m_fbh = _fbh;
-// m_rtMsaa = _msaa;
+ }
+
+ void setDebugWireframe(bool _wireframe)
+ {
+ const bool wireframe = m_deviceFeatures.fillModeNonSolid && _wireframe;
+ if (m_wireframe != wireframe)
+ {
+ m_wireframe = wireframe;
+ m_pipelineStateCache.invalidate();
+ }
}
void setBlendState(VkPipelineColorBlendStateCreateInfo& _desc, uint64_t _state, uint32_t _rgba = 0)
@@ -2442,14 +2977,18 @@ VK_IMPORT_DEVICE
bas->colorWriteMask = writeMask;
}
- uint32_t numAttachments = 1;
- if (isValid(m_fbh) )
- {
- const FrameBufferVK& frameBuffer = m_frameBuffers[m_fbh.idx];
- numAttachments = frameBuffer.m_num;
- }
+ const FrameBufferVK& frameBuffer = isValid(m_fbh)
+ ? m_frameBuffers[m_fbh.idx]
+ : m_backBuffer
+ ;
- if (!!(BGFX_STATE_BLEND_INDEPENDENT & _state) )
+ const uint32_t numAttachments = NULL == frameBuffer.m_nwh
+ ? frameBuffer.m_num
+ : 1
+ ;
+
+ if (!!(BGFX_STATE_BLEND_INDEPENDENT & _state)
+ && m_deviceFeatures.independentBlend )
{
for (uint32_t ii = 1, rgba = _rgba; ii < numAttachments; ++ii, rgba >>= 11)
{
@@ -2498,14 +3037,14 @@ VK_IMPORT_DEVICE
_desc.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
_desc.pNext = NULL;
_desc.flags = 0;
- _desc.depthClampEnable = m_depthClamp;
+ _desc.depthClampEnable = m_deviceFeatures.depthClamp && m_depthClamp;
_desc.rasterizerDiscardEnable = VK_FALSE;
- _desc.polygonMode = _wireframe
+ _desc.polygonMode = m_deviceFeatures.fillModeNonSolid && _wireframe
? VK_POLYGON_MODE_LINE
: VK_POLYGON_MODE_FILL
;
_desc.cullMode = s_cullMode[cull];
- _desc.frontFace = VK_FRONT_FACE_CLOCKWISE;
+ _desc.frontFace = (_state&BGFX_STATE_FRONT_CCW) ? VK_FRONT_FACE_COUNTER_CLOCKWISE : VK_FRONT_FACE_CLOCKWISE;
_desc.depthBiasEnable = VK_FALSE;
_desc.depthBiasConstantFactor = 0.0f;
_desc.depthBiasClamp = 0.0f;
@@ -2513,6 +3052,31 @@ VK_IMPORT_DEVICE
_desc.lineWidth = 1.0f;
}
+ void setConservativeRasterizerState(VkPipelineRasterizationConservativeStateCreateInfoEXT& _desc, uint64_t _state)
+ {
+ _desc.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT;
+ _desc.pNext = NULL;
+ _desc.flags = 0;
+ _desc.conservativeRasterizationMode = (_state&BGFX_STATE_CONSERVATIVE_RASTER)
+ ? VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT
+ : VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT
+ ;
+ _desc.extraPrimitiveOverestimationSize = 0.0f;
+ }
+
+ void setLineRasterizerState(VkPipelineRasterizationLineStateCreateInfoEXT& _desc, uint64_t _state)
+ {
+ _desc.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT;
+ _desc.pNext = NULL;
+ _desc.lineRasterizationMode = (_state & BGFX_STATE_LINEAA)
+ ? VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT
+ : VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT
+ ;
+ _desc.stippledLineEnable = VK_FALSE;
+ _desc.lineStippleFactor = 0;
+ _desc.lineStipplePattern = 0;
+ }
+
void setDepthStencilState(VkPipelineDepthStencilStateCreateInfo& _desc, uint64_t _state, uint64_t _stencil = 0)
{
const uint32_t fstencil = unpackStencil(0, _stencil);
@@ -2552,95 +3116,503 @@ VK_IMPORT_DEVICE
_desc.maxDepthBounds = 1.0f;
}
- uint32_t setInputLayout(VkPipelineVertexInputStateCreateInfo& _vertexInputState, const VertexDecl& _vertexDecl, const ProgramVK& _program, uint8_t _numInstanceData)
+ void setInputLayout(VkPipelineVertexInputStateCreateInfo& _vertexInputState, uint8_t _numStream, const VertexLayout** _layout, const ProgramVK& _program, uint8_t _numInstanceData)
{
_vertexInputState.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
_vertexInputState.pNext = NULL;
_vertexInputState.flags = 0;
- VertexDecl decl;
- bx::memCopy(&decl, &_vertexDecl, sizeof(VertexDecl) );
- const uint16_t* attrMask = _program.m_vsh->m_attrMask;
+ _vertexInputState.vertexBindingDescriptionCount = 0;
+ _vertexInputState.vertexAttributeDescriptionCount = 0;
+
+ uint16_t unsettedAttr[Attrib::Count];
+ bx::memCopy(unsettedAttr, _program.m_vsh->m_attrMask, sizeof(uint16_t) * Attrib::Count);
+
+ for (uint8_t stream = 0; stream < _numStream; ++stream)
+ {
+ VertexLayout layout;
+ bx::memCopy(&layout, _layout[stream], sizeof(VertexLayout) );
+ 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 = (layout.m_attributes[ii] & mask);
+ layout.m_attributes[ii] = attr == 0 || attr == UINT16_MAX ? UINT16_MAX : attr;
+
+ if (unsettedAttr[ii] && attr != UINT16_MAX)
+ {
+ unsettedAttr[ii] = 0;
+ }
+ }
+
+ fillVertexLayout(_program.m_vsh, _vertexInputState, layout);
+ }
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;
+ if (0 < unsettedAttr[ii])
+ {
+ uint32_t numAttribs = _vertexInputState.vertexAttributeDescriptionCount;
+ VkVertexInputAttributeDescription* inputAttrib = const_cast<VkVertexInputAttributeDescription*>(_vertexInputState.pVertexAttributeDescriptions + numAttribs);
+ inputAttrib->location = _program.m_vsh->m_attrRemap[ii];
+ inputAttrib->binding = 0;
+ inputAttrib->format = VK_FORMAT_R32G32B32_SFLOAT;
+ inputAttrib->offset = 0;
+ _vertexInputState.vertexAttributeDescriptionCount++;
+ }
}
- uint32_t num = fillVertexDecl(_program.m_vsh, _vertexInputState, decl);
+ if (0 < _numInstanceData)
+ {
+ fillInstanceBinding(_program.m_vsh, _vertexInputState, _numInstanceData);
+ }
+ }
+
+ VkResult getRenderPass(uint8_t _num, const VkFormat* _formats, const VkImageAspectFlags* _aspects, const bool* _resolve, VkSampleCountFlagBits _samples, ::VkRenderPass* _renderPass)
+ {
+ VkResult result = VK_SUCCESS;
+
+ if (VK_SAMPLE_COUNT_1_BIT == _samples)
+ {
+ _resolve = NULL;
+ }
+
+ bx::HashMurmur2A hash;
+ hash.begin();
+ hash.add(_samples);
+ hash.add(_formats, sizeof(VkFormat) * _num);
+ if (NULL != _resolve)
+ {
+ hash.add(_resolve, sizeof(bool) * _num);
+ }
+ uint32_t hashKey = hash.end();
+
+ VkRenderPass renderPass = m_renderPassCache.find(hashKey);
+
+ if (VK_NULL_HANDLE != renderPass)
+ {
+ *_renderPass = renderPass;
+ return result;
+ }
+
+ VkAttachmentDescription ad[BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS * 2];
+
+ for (uint8_t ii = 0; ii < (_num * 2); ++ii)
+ {
+ ad[ii].flags = 0;
+ ad[ii].format = VK_FORMAT_UNDEFINED;
+ ad[ii].samples = _samples;
+ ad[ii].loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
+ ad[ii].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+ ad[ii].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+ ad[ii].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+ ad[ii].initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+ ad[ii].finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+ }
+
+ VkAttachmentReference colorAr[BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS];
+ VkAttachmentReference resolveAr[BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS];
+ VkAttachmentReference depthAr;
+ uint32_t numColorAr = 0;
+ uint32_t numResolveAr = 0;
+
+ colorAr[0].attachment = VK_ATTACHMENT_UNUSED;
+ colorAr[0].layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+ resolveAr[0].attachment = VK_ATTACHMENT_UNUSED;
+ resolveAr[0].layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+ depthAr.attachment = VK_ATTACHMENT_UNUSED;
+ depthAr.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+
+ for (uint8_t ii = 0; ii < _num; ++ii)
+ {
+ ad[ii].format = _formats[ii];
+
+ if (_aspects[ii] & VK_IMAGE_ASPECT_COLOR_BIT)
+ {
+ colorAr[numColorAr].layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+ colorAr[numColorAr].attachment = ii;
+
+ resolveAr[numColorAr].layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+ resolveAr[numColorAr].attachment = VK_ATTACHMENT_UNUSED;
+ if (NULL != _resolve
+ && _resolve[ii])
+ {
+ const uint32_t resolve = _num + numResolveAr;
+
+ ad[resolve].format = _formats[ii];
+ ad[resolve].samples = VK_SAMPLE_COUNT_1_BIT;
+ ad[resolve].loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+
+ resolveAr[numColorAr].attachment = resolve;
+ numResolveAr++;
+ }
+
+ numColorAr++;
+ }
+ else if (_aspects[ii] & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) )
+ {
+ ad[ii].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
+ ad[ii].stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE;
+ ad[ii].initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+ ad[ii].finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+
+ depthAr.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+ depthAr.attachment = ii;
+ }
+ }
+
+ VkSubpassDescription sd[1];
+ sd[0].flags = 0;
+ sd[0].pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
+ sd[0].inputAttachmentCount = 0;
+ sd[0].pInputAttachments = NULL;
+ sd[0].colorAttachmentCount = bx::max<uint32_t>(numColorAr, 1);
+ sd[0].pColorAttachments = colorAr;
+ sd[0].pResolveAttachments = resolveAr;
+ sd[0].pDepthStencilAttachment = &depthAr;
+ sd[0].preserveAttachmentCount = 0;
+ sd[0].pPreserveAttachments = NULL;
+
+ const VkPipelineStageFlags graphicsStages = 0
+ | VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT
+ | VK_PIPELINE_STAGE_VERTEX_INPUT_BIT
+ | VK_PIPELINE_STAGE_VERTEX_SHADER_BIT
+ | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
+ | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
+ | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT
+ | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
+ ;
+ const VkPipelineStageFlags outsideStages = 0
+ | graphicsStages
+ | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT
+ | VK_PIPELINE_STAGE_TRANSFER_BIT
+ ;
+
+ VkSubpassDependency dep[2];
+
+ dep[0].srcSubpass = VK_SUBPASS_EXTERNAL;
+ dep[0].dstSubpass = 0;
+ dep[0].srcStageMask = outsideStages;
+ dep[0].dstStageMask = graphicsStages;
+ dep[0].srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT;
+ dep[0].dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT;
+ dep[0].dependencyFlags = 0;
+
+ dep[1].srcSubpass = BX_COUNTOF(sd)-1;
+ dep[1].dstSubpass = VK_SUBPASS_EXTERNAL;
+ dep[1].srcStageMask = graphicsStages;
+ dep[1].dstStageMask = outsideStages;
+ dep[1].srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT;
+ dep[1].dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT;
+ dep[1].dependencyFlags = 0;
+
+ VkRenderPassCreateInfo rpi;
+ rpi.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+ rpi.pNext = NULL;
+ rpi.flags = 0;
+ rpi.attachmentCount = _num + numResolveAr;
+ rpi.pAttachments = ad;
+ rpi.subpassCount = BX_COUNTOF(sd);
+ rpi.pSubpasses = sd;
+ rpi.dependencyCount = BX_COUNTOF(dep);
+ rpi.pDependencies = dep;
+
+ result = vkCreateRenderPass(m_device, &rpi, m_allocatorCb, &renderPass);
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create render pass error: vkCreateRenderPass failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ m_renderPassCache.add(hashKey, renderPass);
+
+ *_renderPass = renderPass;
+
+ return result;
+ }
+
+ VkResult getRenderPass(uint8_t _num, const Attachment* _attachments, ::VkRenderPass* _renderPass)
+ {
+ VkFormat formats[BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS];
+ VkImageAspectFlags aspects[BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS];
+ VkSampleCountFlagBits samples = VK_SAMPLE_COUNT_1_BIT;
+
+ for (uint8_t ii = 0; ii < _num; ++ii)
+ {
+ const TextureVK& texture = m_textures[_attachments[ii].handle.idx];
+ formats[ii] = texture.m_format;
+ aspects[ii] = texture.m_aspectMask;
+ samples = texture.m_sampler.Sample;
+ }
+
+ return getRenderPass(_num, formats, aspects, NULL, samples, _renderPass);
+ }
+
+ VkResult getRenderPass(const SwapChainVK& swapChain, ::VkRenderPass* _renderPass)
+ {
+ const VkFormat formats[2] =
+ {
+ swapChain.m_sci.imageFormat,
+ swapChain.m_backBufferDepthStencil.m_format
+ };
+ const VkImageAspectFlags aspects[2] =
+ {
+ VK_IMAGE_ASPECT_COLOR_BIT,
+ swapChain.m_backBufferDepthStencil.m_aspectMask
+ };
+ const bool resolve[2] =
+ {
+ swapChain.m_supportsManualResolve ? false : true,
+ false
+ };
+ const VkSampleCountFlagBits samples = swapChain.m_sampler.Sample;
+
+ return getRenderPass(BX_COUNTOF(formats), formats, aspects, resolve, samples, _renderPass);
+ }
+
+ VkSampler getSampler(uint32_t _flags, VkFormat _format, const float _palette[][4])
+ {
+ uint32_t index = ((_flags & BGFX_SAMPLER_BORDER_COLOR_MASK) >> BGFX_SAMPLER_BORDER_COLOR_SHIFT);
+ index = bx::min<uint32_t>(BGFX_CONFIG_MAX_COLOR_PALETTE - 1, index);
+
+ _flags &= BGFX_SAMPLER_BITS_MASK;
+ _flags &= ~(m_deviceFeatures.samplerAnisotropy ? 0 : (BGFX_SAMPLER_MIN_ANISOTROPIC | BGFX_SAMPLER_MAG_ANISOTROPIC) );
-// const D3D12_INPUT_ELEMENT_DESC inst = { "TEXCOORD", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA, 1 };
+ // Force both min+max anisotropic, can't be set individually.
+ _flags |= 0 != (_flags & (BGFX_SAMPLER_MIN_ANISOTROPIC|BGFX_SAMPLER_MAG_ANISOTROPIC) )
+ ? BGFX_SAMPLER_MIN_ANISOTROPIC|BGFX_SAMPLER_MAG_ANISOTROPIC
+ : 0
+ ;
+
+ const float* rgba = NULL == _palette
+ ? NULL
+ : _palette[index]
+ ;
- // VK_VERTEX_INPUT_RATE_INSTANCE
+ const bool needColor = true
+ && needBorderColor(_flags)
+ && NULL != rgba
+ && m_borderColorSupport
+ ;
- for (uint32_t ii = 0; ii < _numInstanceData; ++ii)
+ uint32_t hashKey;
+ VkSampler sampler = VK_NULL_HANDLE;
+ if (!needColor)
+ {
+ bx::HashMurmur2A hash;
+ hash.begin();
+ hash.add(_flags);
+ hash.add(-1);
+ hash.add(VK_FORMAT_UNDEFINED);
+ hashKey = hash.end();
+
+ sampler = m_samplerCache.find(hashKey);
+ }
+ else
{
- uint32_t index = 7 - ii; // TEXCOORD7 = i_data0, TEXCOORD6 = i_data1, etc.
+ bx::HashMurmur2A hash;
+ hash.begin();
+ hash.add(_flags);
+ hash.add(index);
+ hash.add(_format);
+ hashKey = hash.end();
+
+ const uint32_t colorHashKey = m_samplerBorderColorCache.find(hashKey);
+ const uint32_t newColorHashKey = bx::hash<bx::HashMurmur2A>(rgba, sizeof(float) * 4);
+ if (newColorHashKey == colorHashKey)
+ {
+ sampler = m_samplerCache.find(hashKey);
+ }
+ else
+ {
+ m_samplerBorderColorCache.add(hashKey, newColorHashKey);
+ }
+ }
- BX_UNUSED(index);
-// bx::memCopy(curr, &inst, sizeof(D3D12_INPUT_ELEMENT_DESC) );
-// curr->InputSlot = 1;
-// curr->SemanticIndex = index;
-// curr->AlignedByteOffset = ii*16;
+ if (VK_NULL_HANDLE != sampler)
+ {
+ return sampler;
}
- _vertexInputState.vertexAttributeDescriptionCount = num;
- return num;
+ const uint32_t cmpFunc = (_flags&BGFX_SAMPLER_COMPARE_MASK)>>BGFX_SAMPLER_COMPARE_SHIFT;
+
+ const float maxLodBias = m_deviceProperties.limits.maxSamplerLodBias;
+ const float lodBias = bx::clamp(float(BGFX_CONFIG_MIP_LOD_BIAS), -maxLodBias, maxLodBias);
+
+ VkSamplerCreateInfo sci;
+ sci.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
+ sci.pNext = NULL;
+ sci.flags = 0;
+ sci.magFilter = _flags & BGFX_SAMPLER_MAG_POINT ? VK_FILTER_NEAREST : VK_FILTER_LINEAR;
+ sci.minFilter = _flags & BGFX_SAMPLER_MIN_POINT ? VK_FILTER_NEAREST : VK_FILTER_LINEAR;
+ sci.mipmapMode = _flags & BGFX_SAMPLER_MIP_POINT ? VK_SAMPLER_MIPMAP_MODE_NEAREST : VK_SAMPLER_MIPMAP_MODE_LINEAR;
+ sci.addressModeU = s_textureAddress[(_flags&BGFX_SAMPLER_U_MASK)>>BGFX_SAMPLER_U_SHIFT];
+ sci.addressModeV = s_textureAddress[(_flags&BGFX_SAMPLER_V_MASK)>>BGFX_SAMPLER_V_SHIFT];
+ sci.addressModeW = s_textureAddress[(_flags&BGFX_SAMPLER_W_MASK)>>BGFX_SAMPLER_W_SHIFT];
+ sci.mipLodBias = lodBias;
+ sci.anisotropyEnable = !!(_flags & (BGFX_SAMPLER_MIN_ANISOTROPIC | BGFX_SAMPLER_MAG_ANISOTROPIC) );
+ sci.maxAnisotropy = m_maxAnisotropy;
+ sci.compareEnable = 0 != cmpFunc;
+ sci.compareOp = s_cmpFunc[cmpFunc];
+ sci.minLod = 0.0f;
+ sci.maxLod = VK_LOD_CLAMP_NONE;
+ sci.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK;
+ sci.unnormalizedCoordinates = VK_FALSE;
+
+ VkSamplerCustomBorderColorCreateInfoEXT cbcci;
+ if (needColor)
+ {
+ cbcci.sType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT;
+ cbcci.pNext = NULL;
+ cbcci.format = _format;
+ bx::memCopy(cbcci.customBorderColor.float32, rgba, sizeof(cbcci.customBorderColor.float32) );
+
+ sci.pNext = &cbcci;
+ sci.borderColor = VK_BORDER_COLOR_FLOAT_CUSTOM_EXT;
+ }
+
+ VK_CHECK(vkCreateSampler(m_device, &sci, m_allocatorCb, &sampler) );
+
+ m_samplerCache.add(hashKey, sampler);
+ return sampler;
}
- VkPipeline getPipeline(uint16_t _programIdx)
+ VkImageView getCachedImageView(TextureHandle _handle, uint32_t _mip, uint32_t _numMips, VkImageViewType _type, bool _stencil = false)
{
- BX_UNUSED(_programIdx);
- // vkCreateComputePipelines
- return VK_NULL_HANDLE;
+ const TextureVK& texture = m_textures[_handle.idx];
+
+ _stencil = _stencil && !!(texture.m_aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT);
+
+ bx::HashMurmur2A hash;
+ hash.begin();
+ hash.add(_handle.idx);
+ hash.add(_mip);
+ hash.add(_numMips);
+ hash.add(_type);
+ hash.add(_stencil);
+ uint32_t hashKey = hash.end();
+
+ VkImageView* viewCached = m_imageViewCache.find(hashKey);
+
+ if (NULL != viewCached)
+ {
+ return *viewCached;
+ }
+
+ const VkImageAspectFlags aspectMask = 0
+ | VK_IMAGE_ASPECT_COLOR_BIT
+ | ( _stencil ? VK_IMAGE_ASPECT_STENCIL_BIT : VK_IMAGE_ASPECT_DEPTH_BIT)
+ ;
+
+ VkImageView view;
+ VK_CHECK(texture.createView(0, texture.m_numSides, _mip, _numMips, _type, aspectMask, false, &view) );
+ m_imageViewCache.add(hashKey, view, _handle.idx);
+
+ return view;
}
- VkPipeline getPipeline(uint64_t _state, uint64_t _stencil, uint16_t _declIdx, uint16_t _programIdx, uint8_t _numInstanceData)
+ VkPipeline getPipeline(ProgramHandle _program)
{
- ProgramVK& program = m_program[_programIdx];
+ ProgramVK& program = m_program[_program.idx];
+
+ bx::HashMurmur2A murmur;
+ murmur.begin();
+ murmur.add(program.m_vsh->m_hash);
+ const uint32_t hash = murmur.end();
+
+ VkPipeline pipeline = m_pipelineStateCache.find(hash);
+
+ if (VK_NULL_HANDLE != pipeline)
+ {
+ return pipeline;
+ }
+
+ VkComputePipelineCreateInfo cpci;
+ cpci.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
+ cpci.pNext = NULL;
+ cpci.flags = 0;
+
+ cpci.stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+ cpci.stage.pNext = NULL;
+ cpci.stage.flags = 0;
+ cpci.stage.stage = VK_SHADER_STAGE_COMPUTE_BIT;
+ cpci.stage.module = program.m_vsh->m_module;
+ cpci.stage.pName = "main";
+ cpci.stage.pSpecializationInfo = NULL;
+
+ cpci.layout = program.m_pipelineLayout;
+ cpci.basePipelineHandle = VK_NULL_HANDLE;
+ cpci.basePipelineIndex = 0;
+
+ VK_CHECK(vkCreateComputePipelines(m_device, m_pipelineCache, 1, &cpci, m_allocatorCb, &pipeline) );
+
+ m_pipelineStateCache.add(hash, pipeline);
+
+ return pipeline;
+ }
+
+ VkPipeline getPipeline(uint64_t _state, uint64_t _stencil, uint8_t _numStreams, const VertexLayout** _layouts, ProgramHandle _program, uint8_t _numInstanceData)
+ {
+ ProgramVK& program = m_program[_program.idx];
_state &= 0
- | BGFX_STATE_WRITE_RGB
- | BGFX_STATE_WRITE_A
- | BGFX_STATE_WRITE_Z
+ | BGFX_STATE_WRITE_MASK
| BGFX_STATE_DEPTH_TEST_MASK
| BGFX_STATE_BLEND_MASK
| BGFX_STATE_BLEND_EQUATION_MASK
- | BGFX_STATE_BLEND_INDEPENDENT
+ | (g_caps.supported & BGFX_CAPS_BLEND_INDEPENDENT ? BGFX_STATE_BLEND_INDEPENDENT : 0)
| BGFX_STATE_BLEND_ALPHA_TO_COVERAGE
| BGFX_STATE_CULL_MASK
+ | BGFX_STATE_FRONT_CCW
| BGFX_STATE_MSAA
- | BGFX_STATE_LINEAA
- | BGFX_STATE_CONSERVATIVE_RASTER
+ | (m_lineAASupport ? BGFX_STATE_LINEAA : 0)
+ | (g_caps.supported & BGFX_CAPS_CONSERVATIVE_RASTER ? BGFX_STATE_CONSERVATIVE_RASTER : 0)
| BGFX_STATE_PT_MASK
;
_stencil &= packStencil(~BGFX_STENCIL_FUNC_REF_MASK, ~BGFX_STENCIL_FUNC_REF_MASK);
- VertexDecl decl;
- bx::memCopy(&decl, &m_vertexDecls[_declIdx], sizeof(VertexDecl) );
- const uint16_t* attrMask = program.m_vsh->m_attrMask;
-
- for (uint32_t ii = 0; ii < Attrib::Count; ++ii)
+ VertexLayout layout;
+ if (0 < _numStreams)
{
- 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::memCopy(&layout, _layouts[0], sizeof(VertexLayout) );
+ 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 = (layout.m_attributes[ii] & mask);
+ layout.m_attributes[ii] = attr == 0 ? UINT16_MAX : attr == UINT16_MAX ? 0 : attr;
+ }
}
+ const FrameBufferVK& frameBuffer = isValid(m_fbh)
+ ? m_frameBuffers[m_fbh.idx]
+ : m_backBuffer
+ ;
+
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);
+
+ if (NULL != program.m_fsh)
+ {
+ murmur.add(program.m_fsh->m_hash);
+ }
+
+ for (uint8_t ii = 0; ii < _numStreams; ++ii)
+ {
+ murmur.add(_layouts[ii]->m_hash);
+ }
+
+ murmur.add(layout.m_attributes, sizeof(layout.m_attributes) );
murmur.add(_numInstanceData);
+ murmur.add(frameBuffer.m_renderPass);
const uint32_t hash = murmur.end();
VkPipeline pipeline = m_pipelineStateCache.find(hash);
@@ -2663,18 +3635,36 @@ VK_IMPORT_DEVICE
inputAssemblyState.primitiveRestartEnable = VK_FALSE;
VkPipelineRasterizationStateCreateInfo rasterizationState;
- setRasterizerState(rasterizationState, _state);
+ setRasterizerState(rasterizationState, _state, m_wireframe);
+
+ VkBaseInStructure* nextRasterizationState = (VkBaseInStructure*)&rasterizationState;
+
+ VkPipelineRasterizationConservativeStateCreateInfoEXT conservativeRasterizationState;
+ if (s_extension[Extension::EXT_conservative_rasterization].m_supported)
+ {
+ nextRasterizationState->pNext = (VkBaseInStructure*)&conservativeRasterizationState;
+ nextRasterizationState = (VkBaseInStructure*)&conservativeRasterizationState;
+ setConservativeRasterizerState(conservativeRasterizationState, _state);
+ }
+
+ VkPipelineRasterizationLineStateCreateInfoEXT lineRasterizationState;
+ if (m_lineAASupport)
+ {
+ nextRasterizationState->pNext = (VkBaseInStructure*)&lineRasterizationState;
+ nextRasterizationState = (VkBaseInStructure*)&lineRasterizationState;
+ setLineRasterizerState(lineRasterizationState, _state);
+ }
VkPipelineDepthStencilStateCreateInfo depthStencilState;
setDepthStencilState(depthStencilState, _state, _stencil);
- VkVertexInputBindingDescription inputBinding[Attrib::Count + 1 + BGFX_CONFIG_MAX_INSTANCE_DATA_COUNT];
- VkVertexInputAttributeDescription inputAttrib[Attrib::Count + 1 + BGFX_CONFIG_MAX_INSTANCE_DATA_COUNT];
+ VkVertexInputBindingDescription inputBinding[BGFX_CONFIG_MAX_VERTEX_STREAMS + 1];
+ VkVertexInputAttributeDescription inputAttrib[Attrib::Count + BGFX_CONFIG_MAX_INSTANCE_DATA_COUNT];
VkPipelineVertexInputStateCreateInfo vertexInputState;
vertexInputState.pVertexBindingDescriptions = inputBinding;
vertexInputState.pVertexAttributeDescriptions = inputAttrib;
- setInputLayout(vertexInputState, m_vertexDecls[_declIdx], program, _numInstanceData);
+ setInputLayout(vertexInputState, _numStreams, _layouts, program, _numInstanceData);
const VkDynamicState dynamicStates[] =
{
@@ -2683,6 +3673,7 @@ VK_IMPORT_DEVICE
VK_DYNAMIC_STATE_BLEND_CONSTANTS,
VK_DYNAMIC_STATE_STENCIL_REFERENCE,
};
+
VkPipelineDynamicStateCreateInfo dynamicState;
dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
dynamicState.pNext = NULL;
@@ -2698,13 +3689,17 @@ VK_IMPORT_DEVICE
shaderStages[0].module = program.m_vsh->m_module;
shaderStages[0].pName = "main";
shaderStages[0].pSpecializationInfo = NULL;
- shaderStages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
- shaderStages[1].pNext = NULL;
- shaderStages[1].flags = 0;
- shaderStages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
- shaderStages[1].module = program.m_fsh->m_module;
- shaderStages[1].pName = "main";
- shaderStages[1].pSpecializationInfo = NULL;
+
+ if (NULL != program.m_fsh)
+ {
+ shaderStages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+ shaderStages[1].pNext = NULL;
+ shaderStages[1].flags = 0;
+ shaderStages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
+ shaderStages[1].module = program.m_fsh->m_module;
+ shaderStages[1].pName = "main";
+ shaderStages[1].pSpecializationInfo = NULL;
+ }
VkPipelineViewportStateCreateInfo viewportState;
viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
@@ -2719,9 +3714,9 @@ VK_IMPORT_DEVICE
multisampleState.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
multisampleState.pNext = NULL;
multisampleState.flags = 0;
- multisampleState.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
+ multisampleState.rasterizationSamples = frameBuffer.m_sampler.Sample;
multisampleState.sampleShadingEnable = VK_FALSE;
- multisampleState.minSampleShading = !!(BGFX_STATE_CONSERVATIVE_RASTER & _state) ? 1.0f : 0.0f;
+ multisampleState.minSampleShading = 0.0f;
multisampleState.pSampleMask = NULL;
multisampleState.alphaToCoverageEnable = !!(BGFX_STATE_BLEND_ALPHA_TO_COVERAGE & _state);
multisampleState.alphaToOneEnable = VK_FALSE;
@@ -2730,7 +3725,7 @@ VK_IMPORT_DEVICE
graphicsPipeline.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
graphicsPipeline.pNext = NULL;
graphicsPipeline.flags = 0;
- graphicsPipeline.stageCount = BX_COUNTOF(shaderStages);
+ graphicsPipeline.stageCount = NULL == program.m_fsh ? 1 : 2;
graphicsPipeline.pStages = shaderStages;
graphicsPipeline.pVertexInputState = &vertexInputState;
graphicsPipeline.pInputAssemblyState = &inputAssemblyState;
@@ -2741,8 +3736,8 @@ VK_IMPORT_DEVICE
graphicsPipeline.pDepthStencilState = &depthStencilState;
graphicsPipeline.pColorBlendState = &colorBlendState;
graphicsPipeline.pDynamicState = &dynamicState;
- graphicsPipeline.layout = m_pipelineLayout;
- graphicsPipeline.renderPass = m_renderPass;
+ graphicsPipeline.layout = program.m_pipelineLayout;
+ graphicsPipeline.renderPass = frameBuffer.m_renderPass;
graphicsPipeline.subpass = 0;
graphicsPipeline.basePipelineHandle = VK_NULL_HANDLE;
graphicsPipeline.basePipelineIndex = 0;
@@ -2775,7 +3770,8 @@ VK_IMPORT_DEVICE
VkPipelineCache cache;
VK_CHECK(vkCreatePipelineCache(m_device, &pcci, m_allocatorCb, &cache) );
- VK_CHECK(vkCreateGraphicsPipelines(m_device
+ VK_CHECK(vkCreateGraphicsPipelines(
+ m_device
, cache
, 1
, &graphicsPipeline
@@ -2793,6 +3789,7 @@ VK_IMPORT_DEVICE
{
cachedData = BX_REALLOC(g_allocator, cachedData, dataSize);
}
+
VK_CHECK(vkGetPipelineCacheData(m_device, cache, &dataSize, cachedData) );
g_callback->cacheWrite(hash, cachedData, (uint32_t)dataSize);
}
@@ -2808,6 +3805,321 @@ VK_IMPORT_DEVICE
return pipeline;
}
+ VkDescriptorSet getDescriptorSet(const ProgramVK& program, const RenderBind& renderBind, const ScratchBufferVK& scratchBuffer, const float _palette[][4])
+ {
+ VkDescriptorSet descriptorSet;
+
+ VkDescriptorSetAllocateInfo dsai;
+ dsai.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
+ dsai.pNext = NULL;
+ dsai.descriptorPool = m_descriptorPool;
+ dsai.descriptorSetCount = 1;
+ dsai.pSetLayouts = &program.m_descriptorSetLayout;
+
+ VK_CHECK(vkAllocateDescriptorSets(m_device, &dsai, &descriptorSet) );
+
+ VkDescriptorImageInfo imageInfo[BGFX_CONFIG_MAX_TEXTURE_SAMPLERS];
+ VkDescriptorBufferInfo bufferInfo[BGFX_CONFIG_MAX_TEXTURE_SAMPLERS];
+
+ constexpr uint32_t kMaxDescriptorSets = 2 * BGFX_CONFIG_MAX_TEXTURE_SAMPLERS + 2;
+ VkWriteDescriptorSet wds[kMaxDescriptorSets] = {};
+
+ uint32_t wdsCount = 0;
+ uint32_t bufferCount = 0;
+ uint32_t imageCount = 0;
+
+ for (uint32_t stage = 0; stage < BGFX_CONFIG_MAX_TEXTURE_SAMPLERS; ++stage)
+ {
+ const Binding& bind = renderBind.m_bind[stage];
+ const BindInfo& bindInfo = program.m_bindInfo[stage];
+
+ if (kInvalidHandle != bind.m_idx
+ && isValid(bindInfo.uniformHandle) )
+ {
+ switch (bind.m_type)
+ {
+ case Binding::Image:
+ {
+ const bool isImageDescriptor = BindType::Image == bindInfo.type;
+
+ wds[wdsCount].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+ wds[wdsCount].pNext = NULL;
+ wds[wdsCount].dstSet = descriptorSet;
+ wds[wdsCount].dstBinding = bindInfo.binding;
+ wds[wdsCount].dstArrayElement = 0;
+ wds[wdsCount].descriptorCount = 1;
+ wds[wdsCount].descriptorType = isImageDescriptor
+ ? VK_DESCRIPTOR_TYPE_STORAGE_IMAGE
+ : VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE
+ ;
+ wds[wdsCount].pImageInfo = NULL;
+ wds[wdsCount].pBufferInfo = NULL;
+ wds[wdsCount].pTexelBufferView = NULL;
+
+ const TextureVK& texture = m_textures[bind.m_idx];
+
+ VkImageViewType type = texture.m_type;
+ if (UINT32_MAX != bindInfo.index)
+ {
+ type = program.m_textures[bindInfo.index].type;
+ }
+ else if (type == VK_IMAGE_VIEW_TYPE_CUBE
+ || type == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY)
+ {
+ type = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
+ }
+
+ BX_ASSERT(
+ texture.m_currentImageLayout == texture.m_sampledLayout
+ , "Mismatching image layout. Texture currently used as a framebuffer attachment?"
+ );
+
+ imageInfo[imageCount].imageLayout = texture.m_sampledLayout;
+ imageInfo[imageCount].sampler = VK_NULL_HANDLE;
+ imageInfo[imageCount].imageView = getCachedImageView(
+ { bind.m_idx }
+ , bind.m_mip
+ , 1
+ , type
+ );
+ wds[wdsCount].pImageInfo = &imageInfo[imageCount];
+ ++imageCount;
+
+ ++wdsCount;
+ }
+ break;
+
+ case Binding::VertexBuffer:
+ case Binding::IndexBuffer:
+ {
+ wds[wdsCount].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+ wds[wdsCount].pNext = NULL;
+ wds[wdsCount].dstSet = descriptorSet;
+ wds[wdsCount].dstBinding = bindInfo.binding;
+ wds[wdsCount].dstArrayElement = 0;
+ wds[wdsCount].descriptorCount = 1;
+ wds[wdsCount].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+ wds[wdsCount].pImageInfo = NULL;
+ wds[wdsCount].pBufferInfo = NULL;
+ wds[wdsCount].pTexelBufferView = NULL;
+
+ const BufferVK& sb = bind.m_type == Binding::VertexBuffer
+ ? m_vertexBuffers[bind.m_idx]
+ : m_indexBuffers[bind.m_idx]
+ ;
+
+ bufferInfo[bufferCount].buffer = sb.m_buffer;
+ bufferInfo[bufferCount].offset = 0;
+ bufferInfo[bufferCount].range = sb.m_size;
+ wds[wdsCount].pBufferInfo = &bufferInfo[bufferCount];
+ ++bufferCount;
+
+ ++wdsCount;
+ }
+ break;
+
+ case Binding::Texture:
+ {
+ TextureVK& texture = m_textures[bind.m_idx];
+ const uint32_t samplerFlags = 0 == (BGFX_SAMPLER_INTERNAL_DEFAULT & bind.m_samplerFlags)
+ ? bind.m_samplerFlags
+ : (uint32_t)texture.m_flags
+ ;
+ const bool sampleStencil = !!(samplerFlags & BGFX_SAMPLER_SAMPLE_STENCIL);
+ VkSampler sampler = getSampler(samplerFlags, texture.m_format, _palette);
+
+ const VkImageViewType type = UINT32_MAX == bindInfo.index
+ ? texture.m_type
+ : program.m_textures[bindInfo.index].type
+ ;
+
+ BX_ASSERT(
+ texture.m_currentImageLayout == texture.m_sampledLayout
+ , "Mismatching image layout. Texture currently used as a framebuffer attachment?"
+ );
+
+ imageInfo[imageCount].imageLayout = texture.m_sampledLayout;
+ imageInfo[imageCount].sampler = sampler;
+ imageInfo[imageCount].imageView = getCachedImageView(
+ { bind.m_idx }
+ , 0
+ , texture.m_numMips
+ , type
+ , sampleStencil
+ );
+
+ wds[wdsCount].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+ wds[wdsCount].pNext = NULL;
+ wds[wdsCount].dstSet = descriptorSet;
+ wds[wdsCount].dstBinding = bindInfo.binding;
+ wds[wdsCount].dstArrayElement = 0;
+ wds[wdsCount].descriptorCount = 1;
+ wds[wdsCount].descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
+ wds[wdsCount].pImageInfo = &imageInfo[imageCount];
+ wds[wdsCount].pBufferInfo = NULL;
+ wds[wdsCount].pTexelBufferView = NULL;
+ ++wdsCount;
+
+ wds[wdsCount].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+ wds[wdsCount].pNext = NULL;
+ wds[wdsCount].dstSet = descriptorSet;
+ wds[wdsCount].dstBinding = bindInfo.samplerBinding;
+ wds[wdsCount].dstArrayElement = 0;
+ wds[wdsCount].descriptorCount = 1;
+ wds[wdsCount].descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER;
+ wds[wdsCount].pImageInfo = &imageInfo[imageCount];
+ wds[wdsCount].pBufferInfo = NULL;
+ wds[wdsCount].pTexelBufferView = NULL;
+ ++wdsCount;
+
+ ++imageCount;
+ }
+ break;
+ }
+ }
+ }
+
+ const uint32_t vsize = program.m_vsh->m_size;
+ const uint32_t fsize = NULL != program.m_fsh ? program.m_fsh->m_size : 0;
+
+ if (vsize > 0)
+ {
+ bufferInfo[bufferCount].buffer = scratchBuffer.m_buffer;
+ bufferInfo[bufferCount].offset = 0;
+ bufferInfo[bufferCount].range = vsize;
+
+ wds[wdsCount].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+ wds[wdsCount].pNext = NULL;
+ wds[wdsCount].dstSet = descriptorSet;
+ wds[wdsCount].dstBinding = program.m_vsh->m_uniformBinding;
+ wds[wdsCount].dstArrayElement = 0;
+ wds[wdsCount].descriptorCount = 1;
+ wds[wdsCount].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
+ wds[wdsCount].pImageInfo = NULL;
+ wds[wdsCount].pBufferInfo = &bufferInfo[bufferCount];
+ wds[wdsCount].pTexelBufferView = NULL;
+ ++wdsCount;
+ ++bufferCount;
+ }
+
+ if (fsize > 0)
+ {
+ bufferInfo[bufferCount].buffer = scratchBuffer.m_buffer;
+ bufferInfo[bufferCount].offset = 0;
+ bufferInfo[bufferCount].range = fsize;
+
+ wds[wdsCount].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+ wds[wdsCount].pNext = NULL;
+ wds[wdsCount].dstSet = descriptorSet;
+ wds[wdsCount].dstBinding = program.m_fsh->m_uniformBinding;
+ wds[wdsCount].dstArrayElement = 0;
+ wds[wdsCount].descriptorCount = 1;
+ wds[wdsCount].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
+ wds[wdsCount].pImageInfo = NULL;
+ wds[wdsCount].pBufferInfo = &bufferInfo[bufferCount];
+ wds[wdsCount].pTexelBufferView = NULL;
+ ++wdsCount;
+ ++bufferCount;
+ }
+
+ vkUpdateDescriptorSets(m_device, wdsCount, wds, 0, NULL);
+
+ VkDescriptorSet temp = descriptorSet;
+ release(temp);
+
+ return descriptorSet;
+ }
+
+ bool isSwapChainReadable(const SwapChainVK& _swapChain)
+ {
+ return true
+ && NULL != _swapChain.m_nwh
+ && _swapChain.m_needPresent
+ && _swapChain.m_supportsReadback
+ && bimg::imageConvert(bimg::TextureFormat::BGRA8, bimg::TextureFormat::Enum(_swapChain.m_colorFormat) )
+ ;
+ }
+
+ typedef void (*SwapChainReadFunc)(void* /*src*/, uint32_t /*width*/, uint32_t /*height*/, uint32_t /*pitch*/, const void* /*userData*/);
+
+ bool readSwapChain(const SwapChainVK& _swapChain, VkBuffer _buffer, VkDeviceMemory _memory, SwapChainReadFunc _func, const void* _userData = NULL)
+ {
+ if (isSwapChainReadable(_swapChain) )
+ {
+ // source for the copy is the last rendered swapchain image
+ const VkImage image = _swapChain.m_backBufferColorImage[_swapChain.m_backBufferColorIdx];
+ const VkImageLayout layout = _swapChain.m_backBufferColorImageLayout[_swapChain.m_backBufferColorIdx];
+
+ const uint32_t width = _swapChain.m_sci.imageExtent.width;
+ const uint32_t height = _swapChain.m_sci.imageExtent.height;
+
+ ReadbackVK readback;
+ readback.create(image, width, height, _swapChain.m_colorFormat);
+ const uint32_t pitch = readback.pitch();
+
+ readback.copyImageToBuffer(m_commandBuffer, _buffer, layout, VK_IMAGE_ASPECT_COLOR_BIT);
+
+ // stall for commandbuffer to finish
+ kick(true);
+
+ uint8_t* src;
+ VK_CHECK(vkMapMemory(m_device, _memory, 0, VK_WHOLE_SIZE, 0, (void**)&src) );
+
+ if (_swapChain.m_colorFormat == TextureFormat::RGBA8)
+ {
+ bimg::imageSwizzleBgra8(src, pitch, width, height, src, pitch);
+ _func(src, width, height, pitch, _userData);
+ }
+ else if (_swapChain.m_colorFormat == TextureFormat::BGRA8)
+ {
+ _func(src, width, height, pitch, _userData);
+ }
+ else
+ {
+ const uint8_t dstBpp = bimg::getBitsPerPixel(bimg::TextureFormat::BGRA8);
+ const uint32_t dstPitch = width * dstBpp / 8;
+ const uint32_t dstSize = height * dstPitch;
+
+ void* dst = BX_ALLOC(g_allocator, dstSize);
+
+ bimg::imageConvert(g_allocator, dst, bimg::TextureFormat::BGRA8, src, bimg::TextureFormat::Enum(_swapChain.m_colorFormat), width, height, 1);
+
+ _func(dst, width, height, dstPitch, _userData);
+
+ BX_FREE(g_allocator, dst);
+ }
+
+ vkUnmapMemory(m_device, _memory);
+
+ readback.destroy();
+
+ return true;
+ }
+
+ return false;
+ }
+
+ void capture()
+ {
+ if (m_captureSize > 0)
+ {
+ m_backBuffer.resolve();
+
+ auto callback = [](void* _src, uint32_t /*_width*/, uint32_t _height, uint32_t _pitch, const void* /*_userData*/)
+ {
+ const uint32_t size = _height * _pitch;
+ g_callback->captureFrame(_src, size);
+ };
+
+ readSwapChain(m_backBuffer.m_swapChain, m_captureBuffer, m_captureMemory, callback);
+ }
+ }
+
+ bool isVisible(Frame* _render, OcclusionQueryHandle _handle, bool _visible)
+ {
+ return _visible == (0 != _render->m_occlusion[_handle.idx]);
+ }
+
void commit(UniformBuffer& _uniformBuffer)
{
_uniformBuffer.reset();
@@ -2839,22 +4151,14 @@ VK_IMPORT_DEVICE
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:
- {
+ case UniformType::Mat3|kUniformFragmentBit:
+ {
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];
@@ -2873,9 +4177,19 @@ VK_IMPORT_DEVICE
}
break;
- CASE_IMPLEMENT_UNIFORM(Int1, I, int);
- CASE_IMPLEMENT_UNIFORM(Vec4, F, float);
- CASE_IMPLEMENT_UNIFORM(Mat4, F, float);
+ case UniformType::Sampler:
+ case UniformType::Sampler|kUniformFragmentBit:
+ // do nothing, but VkDescriptorSetImageInfo would be set before drawing
+ break;
+
+ case UniformType::Vec4:
+ case UniformType::Vec4 | kUniformFragmentBit:
+ case UniformType::Mat4:
+ case UniformType::Mat4 | kUniformFragmentBit:
+ {
+ setShaderUniform(uint8_t(type), loc, data, num);
+ }
+ break;
case UniformType::End:
break;
@@ -2884,7 +4198,6 @@ VK_IMPORT_DEVICE
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
}
}
@@ -2898,189 +4211,307 @@ VK_IMPORT_DEVICE
rect[0].baseArrayLayer = 0;
rect[0].layerCount = 1;
- uint32_t numMrt = 1;
-// FrameBufferHandle fbh = m_fbh;
-// if (isValid(fbh) )
-// {
-// const FrameBufferVK& fb = m_frameBuffers[fbh.idx];
-// numMrt = bx::uint32_max(1, fb.m_num);
-// }
+ uint32_t numMrt;
+ bgfx::TextureFormat::Enum mrtFormat[BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS];
+ VkImageAspectFlags depthAspectMask;
- VkClearAttachment attachments[BGFX_CONFIG_MAX_FRAME_BUFFERS];
- uint32_t mrt = 0;
+ const FrameBufferVK& fb = isValid(m_fbh)
+ ? m_frameBuffers[m_fbh.idx]
+ : m_backBuffer
+ ;
- if (true //NULL != m_currentColor
- && BGFX_CLEAR_COLOR & _clear.m_flags)
+ if (NULL == fb.m_nwh)
{
- if (BGFX_CLEAR_COLOR_USE_PALETTE & _clear.m_flags)
+ numMrt = fb.m_num;
+ for (uint8_t ii = 0; ii < fb.m_num; ++ii)
{
- for (uint32_t ii = 0; ii < numMrt; ++ii)
- {
- attachments[mrt].colorAttachment = mrt;
- attachments[mrt].aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
- uint8_t index = (uint8_t)bx::uint32_min(BGFX_CONFIG_MAX_COLOR_PALETTE-1, _clear.m_index[ii]);
- bx::memCopy(&attachments[mrt].clearValue.color.float32, _palette[index], 16);
- ++mrt;
- }
+ mrtFormat[ii] = bgfx::TextureFormat::Enum(m_textures[fb.m_texture[ii].idx].m_requestedFormat);
}
- else
+ depthAspectMask = isValid(fb.m_depth) ? m_textures[fb.m_depth.idx].m_aspectMask : 0;
+ rect[0].layerCount = fb.m_attachment[0].numLayers;
+ }
+ else
+ {
+ numMrt = 1;
+ mrtFormat[0] = fb.m_swapChain.m_colorFormat;
+ depthAspectMask = fb.m_swapChain.m_backBufferDepthStencil.m_aspectMask;
+ }
+
+ VkClearAttachment attachments[BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS + 1];
+ uint32_t mrt = 0;
+
+ if (BGFX_CLEAR_COLOR & _clear.m_flags)
+ {
+ for (uint32_t ii = 0; ii < numMrt; ++ii)
{
- float frgba[4] =
+ attachments[mrt].colorAttachment = mrt;
+ attachments[mrt].aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+
+ VkClearColorValue& clearValue = attachments[mrt].clearValue.color;
+
+ const bimg::ImageBlockInfo& blockInfo = bimg::getBlockInfo(bimg::TextureFormat::Enum(mrtFormat[ii]) );
+ const bx::EncodingType::Enum type = bx::EncodingType::Enum(blockInfo.encoding);
+
+ if (BGFX_CLEAR_COLOR_USE_PALETTE & _clear.m_flags)
{
- _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,
- };
+ const uint8_t index = bx::min<uint8_t>(BGFX_CONFIG_MAX_COLOR_PALETTE-1, _clear.m_index[ii]);
- for (uint32_t ii = 0; ii < numMrt; ++ii)
+ switch (type)
+ {
+ case bx::EncodingType::Int:
+ case bx::EncodingType::Uint:
+ clearValue.int32[0] = int32_t(_palette[index][0]);
+ clearValue.int32[1] = int32_t(_palette[index][1]);
+ clearValue.int32[2] = int32_t(_palette[index][2]);
+ clearValue.int32[3] = int32_t(_palette[index][3]);
+ break;
+ default:
+ bx::memCopy(&clearValue.float32, _palette[index], sizeof(clearValue.float32) );
+ break;
+ }
+ }
+ else
{
- attachments[mrt].colorAttachment = mrt;
- attachments[mrt].aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
- bx::memCopy(&attachments[mrt].clearValue.color.float32, frgba, 16);
- ++mrt;
+ switch (type)
+ {
+ case bx::EncodingType::Int:
+ case bx::EncodingType::Uint:
+ clearValue.uint32[0] = _clear.m_index[0];
+ clearValue.uint32[1] = _clear.m_index[1];
+ clearValue.uint32[2] = _clear.m_index[2];
+ clearValue.uint32[3] = _clear.m_index[3];
+ break;
+ default:
+ bx::unpackRgba8(clearValue.float32, _clear.m_index);
+ break;
+ }
}
+
+ ++mrt;
}
}
- if (true //NULL != m_currentDepthStencil
- && (BGFX_CLEAR_DEPTH | BGFX_CLEAR_STENCIL) & _clear.m_flags)
- {
- attachments[mrt].colorAttachment = mrt;
- attachments[mrt].aspectMask = 0;
- attachments[mrt].aspectMask |= (_clear.m_flags & BGFX_CLEAR_DEPTH ) ? VK_IMAGE_ASPECT_DEPTH_BIT : 0;
- attachments[mrt].aspectMask |= (_clear.m_flags & BGFX_CLEAR_STENCIL) ? VK_IMAGE_ASPECT_STENCIL_BIT : 0;
+ depthAspectMask &= 0
+ | (_clear.m_flags & BGFX_CLEAR_DEPTH ? VK_IMAGE_ASPECT_DEPTH_BIT : 0)
+ | (_clear.m_flags & BGFX_CLEAR_STENCIL ? VK_IMAGE_ASPECT_STENCIL_BIT : 0)
+ ;
+ if (0 != depthAspectMask)
+ {
+ attachments[mrt].aspectMask = depthAspectMask;
attachments[mrt].clearValue.depthStencil.stencil = _clear.m_stencil;
attachments[mrt].clearValue.depthStencil.depth = _clear.m_depth;
++mrt;
}
- vkCmdClearAttachments(m_commandBuffer
- , mrt
- , attachments
- , BX_COUNTOF(rect)
- , rect
- );
+ if (mrt > 0)
+ {
+ vkCmdClearAttachments(m_commandBuffer, mrt, attachments, BX_COUNTOF(rect), rect);
+ }
}
- uint64_t kick(VkSemaphore _wait = VK_NULL_HANDLE, VkSemaphore _signal = VK_NULL_HANDLE)
+ void kick(bool _finishAll = false)
{
- VkPipelineStageFlags stageFlags = 0
- | VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT
- ;
-
- VkSubmitInfo si;
- si.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
- si.pNext = NULL;
- si.waitSemaphoreCount = VK_NULL_HANDLE != _wait;
- si.pWaitSemaphores = &_wait;
- si.pWaitDstStageMask = &stageFlags;
- si.commandBufferCount = 1;
- si.pCommandBuffers = &m_commandBuffers[m_backBufferColorIdx];
- si.signalSemaphoreCount = VK_NULL_HANDLE != _signal;
- si.pSignalSemaphores = &_signal;
-
-// VK_CHECK(vkResetFences(m_device, 1, &m_fence) );
- VK_CHECK(vkQueueSubmit(m_queueGraphics, 1, &si, VK_NULL_HANDLE) );
- return 0;
+ m_cmd.kick(_finishAll);
+ VK_CHECK(m_cmd.alloc(&m_commandBuffer) );
+ m_cmd.finish(_finishAll);
}
- void finish()
+ int32_t selectMemoryType(uint32_t _memoryTypeBits, uint32_t _propertyFlags, int32_t _startIndex = 0) const
{
- finishAll();
+ for (int32_t ii = _startIndex, num = m_memoryProperties.memoryTypeCount; ii < num; ++ii)
+ {
+ const VkMemoryType& memType = m_memoryProperties.memoryTypes[ii];
+ if ( (0 != ( (1<<ii) & _memoryTypeBits) )
+ && ( (memType.propertyFlags & _propertyFlags) == _propertyFlags) )
+ {
+ return ii;
+ }
+ }
+
+ BX_TRACE("Failed to find memory that supports flags 0x%08x.", _propertyFlags);
+ return -1;
}
- void finishAll()
+ VkResult allocateMemory(const VkMemoryRequirements* requirements, VkMemoryPropertyFlags propertyFlags, ::VkDeviceMemory* memory) const
{
- VK_CHECK(vkQueueWaitIdle(m_queueGraphics) );
-// VK_CHECK(vkWaitForFences(m_device, 1, &m_fence, true, INT64_MAX) );
+ VkMemoryAllocateInfo ma;
+ ma.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
+ ma.pNext = NULL;
+ ma.allocationSize = requirements->size;
+
+ VkResult result = VK_ERROR_UNKNOWN;
+ int32_t searchIndex = -1;
+ do
+ {
+ searchIndex++;
+ searchIndex = selectMemoryType(requirements->memoryTypeBits, propertyFlags, searchIndex);
+
+ if (searchIndex >= 0)
+ {
+ ma.memoryTypeIndex = searchIndex;
+ result = vkAllocateMemory(m_device, &ma, m_allocatorCb, memory);
+ }
+ }
+ while (result != VK_SUCCESS
+ && searchIndex >= 0);
+
+ return result;
}
- uint32_t selectMemoryType(uint32_t _memoryTypeBits, uint32_t _propertyFlags) const
+ VkResult createHostBuffer(uint32_t _size, VkMemoryPropertyFlags _flags, ::VkBuffer* _buffer, ::VkDeviceMemory* _memory, const void* _data = NULL)
{
- for (uint32_t ii = 0, num = m_memoryProperties.memoryTypeCount; ii < num; ++ii)
+ VkResult result = VK_SUCCESS;
+
+ VkBufferCreateInfo bci;
+ bci.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+ bci.pNext = NULL;
+ bci.flags = 0;
+ bci.size = _size;
+ bci.queueFamilyIndexCount = 0;
+ bci.pQueueFamilyIndices = NULL;
+ bci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+ bci.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+
+ result = vkCreateBuffer(m_device, &bci, m_allocatorCb, _buffer);
+ if (VK_SUCCESS != result)
{
- const VkMemoryType& memType = m_memoryProperties.memoryTypes[ii];
- if ( (0 != ( (1<<ii) & _memoryTypeBits) )
- && ( (memType.propertyFlags & _propertyFlags) == _propertyFlags) )
+ BX_TRACE("Create host buffer error: vkCreateBuffer failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ VkMemoryRequirements mr;
+ vkGetBufferMemoryRequirements(m_device, *_buffer, &mr);
+
+ result = allocateMemory(&mr, _flags, _memory);
+
+ if (VK_SUCCESS != result
+ && (_flags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT) )
+ {
+ result = allocateMemory(&mr, _flags & ~VK_MEMORY_PROPERTY_HOST_CACHED_BIT, _memory);
+ }
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create host buffer error: vkAllocateMemory failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ result = vkBindBufferMemory(m_device, *_buffer, *_memory, 0);
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create host buffer error: vkBindBufferMemory failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ if (_data != NULL)
+ {
+ void* dst;
+ result = vkMapMemory(m_device, *_memory, 0, _size, 0, &dst);
+ if (VK_SUCCESS != result)
{
- return ii;
+ BX_TRACE("Create host buffer error: vkMapMemory failed %d: %s.", result, getName(result) );
+ return result;
}
+
+ bx::memCopy(dst, _data, _size);
+ vkUnmapMemory(m_device, *_memory);
}
- BX_TRACE("Failed to find memory that supports flags 0x%08x.", _propertyFlags);
- return 0;
+ return result;
+ }
+
+ VkResult createStagingBuffer(uint32_t _size, ::VkBuffer* _buffer, ::VkDeviceMemory* _memory, const void* _data = NULL)
+ {
+ const VkMemoryPropertyFlags flags = 0
+ | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
+ | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
+ ;
+ return createHostBuffer(_size, flags, _buffer, _memory, _data);
+ }
+
+ VkResult createReadbackBuffer(uint32_t _size, ::VkBuffer* _buffer, ::VkDeviceMemory* _memory)
+ {
+ const VkMemoryPropertyFlags flags = 0
+ | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
+ | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
+ | VK_MEMORY_PROPERTY_HOST_CACHED_BIT
+ ;
+ return createHostBuffer(_size, flags, _buffer, _memory, NULL);
}
VkAllocationCallbacks* m_allocatorCb;
VkDebugReportCallbackEXT m_debugReportCallback;
VkInstance m_instance;
VkPhysicalDevice m_physicalDevice;
+ uint32_t m_instanceApiVersion;
VkPhysicalDeviceProperties m_deviceProperties;
VkPhysicalDeviceMemoryProperties m_memoryProperties;
+ VkPhysicalDeviceFeatures m_deviceFeatures;
- VkSwapchainCreateInfoKHR m_sci;
- VkSurfaceKHR m_surface;
- VkSwapchainKHR m_swapchain;
- VkImage m_backBufferColorImage[4];
- VkImageView m_backBufferColorImageView[4];
- VkFramebuffer m_backBufferColor[4];
- VkCommandBuffer m_commandBuffers[4];
- VkCommandBuffer m_commandBuffer;
+ bool m_lineAASupport;
+ bool m_borderColorSupport;
+ bool m_timerQuerySupport;
- VkFormat m_backBufferDepthStencilFormat;
- VkDeviceMemory m_backBufferDepthStencilMemory;
- VkImage m_backBufferDepthStencilImage;
- VkImageView m_backBufferDepthStencilImageView;
+ FrameBufferVK m_backBuffer;
+ TextureFormat::Enum m_swapchainFormats[TextureFormat::Count];
- ScratchBufferVK m_scratchBuffer[4];
- VkSemaphore m_presentDone[4];
+ uint16_t m_numWindows;
+ FrameBufferHandle m_windows[BGFX_CONFIG_MAX_FRAME_BUFFERS];
+ int64_t m_presentElapsed;
- uint32_t m_qfiGraphics;
- uint32_t m_qfiCompute;
+ ScratchBufferVK m_scratchBuffer[BGFX_CONFIG_MAX_FRAME_LATENCY];
+
+ uint32_t m_numFramesInFlight;
+ CommandQueueVK m_cmd;
+ VkCommandBuffer m_commandBuffer;
VkDevice m_device;
- VkQueue m_queueGraphics;
- VkQueue m_queueCompute;
- VkFence m_fence;
- VkRenderPass m_renderPass;
+ uint32_t m_globalQueueFamily;
+ VkQueue m_globalQueue;
VkDescriptorPool m_descriptorPool;
- VkDescriptorSetLayout m_descriptorSetLayout;
- VkPipelineLayout m_pipelineLayout;
- VkPipelineCache m_pipelineCache;
- VkCommandPool m_commandPool;
+ VkPipelineCache m_pipelineCache;
+
+ TimerQueryVK m_gpuTimer;
+ OcclusionQueryVK m_occlusionQuery;
void* m_renderDocDll;
void* m_vulkan1Dll;
- IndexBufferVK m_indexBuffers[BGFX_CONFIG_MAX_INDEX_BUFFERS];
+ IndexBufferVK m_indexBuffers[BGFX_CONFIG_MAX_INDEX_BUFFERS];
VertexBufferVK m_vertexBuffers[BGFX_CONFIG_MAX_VERTEX_BUFFERS];
- ShaderVK m_shaders[BGFX_CONFIG_MAX_SHADERS];
- ProgramVK m_program[BGFX_CONFIG_MAX_PROGRAMS];
- TextureVK m_textures[BGFX_CONFIG_MAX_TEXTURES];
- VertexDecl m_vertexDecls[BGFX_CONFIG_MAX_VERTEX_DECLS];
- FrameBufferVK m_frameBuffers[BGFX_CONFIG_MAX_FRAME_BUFFERS];
+ ShaderVK m_shaders[BGFX_CONFIG_MAX_SHADERS];
+ ProgramVK m_program[BGFX_CONFIG_MAX_PROGRAMS];
+ TextureVK m_textures[BGFX_CONFIG_MAX_TEXTURES];
+ VertexLayout m_vertexLayouts[BGFX_CONFIG_MAX_VERTEX_LAYOUTS];
+ FrameBufferVK m_frameBuffers[BGFX_CONFIG_MAX_FRAME_BUFFERS];
+
void* m_uniforms[BGFX_CONFIG_MAX_UNIFORMS];
Matrix4 m_predefinedUniforms[PredefinedUniform::Count];
UniformRegistry m_uniformReg;
StateCacheT<VkPipeline> m_pipelineStateCache;
+ StateCacheT<VkDescriptorSetLayout> m_descriptorSetLayoutCache;
+ StateCacheT<VkRenderPass> m_renderPassCache;
+ StateCacheT<VkSampler> m_samplerCache;
+ StateCacheT<uint32_t> m_samplerBorderColorCache;
+ StateCacheLru<VkImageView, 1024> m_imageViewCache;
Resolution m_resolution;
- uint32_t m_maxAnisotropy;
+ float m_maxAnisotropy;
bool m_depthClamp;
bool m_wireframe;
+ VkBuffer m_captureBuffer;
+ VkDeviceMemory m_captureMemory;
+ uint32_t m_captureSize;
+
TextVideoMem m_textVideoMem;
uint8_t m_fsScratch[64<<10];
uint8_t m_vsScratch[64<<10];
- uint32_t m_fsChanges;
- uint32_t m_vsChanges;
- uint32_t m_backBufferColorIdx;
FrameBufferHandle m_fbh;
};
@@ -3104,245 +4535,168 @@ VK_IMPORT_DEVICE
s_renderVK = NULL;
}
-#define VK_DESTROY_FUNC(_name) \
- void vkDestroy(Vk##_name& _obj) \
- { \
- if (VK_NULL_HANDLE != _obj) \
- { \
- vkDestroy##_name(s_renderVK->m_device, _obj, s_renderVK->m_allocatorCb); \
- _obj = VK_NULL_HANDLE; \
- } \
- }
+#define VK_DESTROY_FUNC(_name) \
+ void vkDestroy(Vk##_name& _obj) \
+ { \
+ if (VK_NULL_HANDLE != _obj) \
+ { \
+ vkDestroy##_name(s_renderVK->m_device, _obj.vk, s_renderVK->m_allocatorCb); \
+ _obj = VK_NULL_HANDLE; \
+ } \
+ } \
+ void release(Vk##_name& _obj) \
+ { \
+ s_renderVK->release(_obj); \
+ }
VK_DESTROY
#undef VK_DESTROY_FUNC
- void ScratchBufferVK::create(uint32_t _size, uint32_t _maxDescriptors)
+ void vkDestroy(VkDeviceMemory& _obj)
{
- m_maxDescriptors = _maxDescriptors;
- m_descriptorSet = (VkDescriptorSet*)BX_ALLOC(g_allocator, _maxDescriptors * sizeof(VkDescriptorSet) );
+ if (VK_NULL_HANDLE != _obj)
+ {
+ vkFreeMemory(s_renderVK->m_device, _obj.vk, s_renderVK->m_allocatorCb);
+ _obj = VK_NULL_HANDLE;
+ }
+ }
- VkAllocationCallbacks* allocatorCb = s_renderVK->m_allocatorCb;
- VkDevice device = s_renderVK->m_device;
+ void vkDestroy(VkSurfaceKHR& _obj)
+ {
+ if (VK_NULL_HANDLE != _obj)
+ {
+ vkDestroySurfaceKHR(s_renderVK->m_instance, _obj.vk, s_renderVK->m_allocatorCb);
+ _obj = VK_NULL_HANDLE;
+ }
+ }
- VkDescriptorSetAllocateInfo dsai;
- dsai.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
- dsai.pNext = NULL;
- dsai.descriptorPool = s_renderVK->m_descriptorPool;
- dsai.descriptorSetCount = 1;
- dsai.pSetLayouts = &s_renderVK->m_descriptorSetLayout;
- for (uint32_t ii = 0, num = m_maxDescriptors; ii < num; ++ii)
+ void vkDestroy(VkDescriptorSet& _obj)
+ {
+ if (VK_NULL_HANDLE != _obj)
{
- VK_CHECK(vkAllocateDescriptorSets(device, &dsai, &m_descriptorSet[ii]) );
+ vkFreeDescriptorSets(s_renderVK->m_device, s_renderVK->m_descriptorPool, 1, &_obj);
+ _obj = VK_NULL_HANDLE;
}
+ }
+
+ void release(VkDeviceMemory& _obj)
+ {
+ s_renderVK->release(_obj);
+ }
+
+ void release(VkSurfaceKHR& _obj)
+ {
+ s_renderVK->release(_obj);
+ }
+
+ void release(VkDescriptorSet& _obj)
+ {
+ s_renderVK->release(_obj);
+ }
+
+ void ScratchBufferVK::create(uint32_t _size, uint32_t _count)
+ {
+ const VkAllocationCallbacks* allocatorCb = s_renderVK->m_allocatorCb;
+ const VkDevice device = s_renderVK->m_device;
+ const VkPhysicalDeviceLimits& deviceLimits = s_renderVK->m_deviceProperties.limits;
+
+ const uint32_t align = uint32_t(deviceLimits.minUniformBufferOffsetAlignment);
+ const uint32_t entrySize = bx::strideAlign(_size, align);
+ const uint32_t totalSize = entrySize * _count;
VkBufferCreateInfo bci;
bci.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
bci.pNext = NULL;
bci.flags = 0;
- bci.size = _size;
- bci.usage = 0
- | VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
-// | VK_BUFFER_USAGE_TRANSFER_DST_BIT
- ;
- bci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+ bci.size = totalSize;
+ bci.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
+ bci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
bci.queueFamilyIndexCount = 0;
bci.pQueueFamilyIndices = NULL;
- VK_CHECK(vkCreateBuffer(device
+ VK_CHECK(vkCreateBuffer(
+ device
, &bci
, allocatorCb
, &m_buffer
) );
VkMemoryRequirements mr;
- vkGetBufferMemoryRequirements(device
+ vkGetBufferMemoryRequirements(
+ device
, m_buffer
, &mr
);
- VkMemoryAllocateInfo ma;
- ma.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
- ma.pNext = NULL;
- ma.allocationSize = mr.size;
- ma.memoryTypeIndex = s_renderVK->selectMemoryType(mr.memoryTypeBits
- , VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
- );
- VK_CHECK(vkAllocateMemory(device
- , &ma
- , allocatorCb
- , &m_deviceMem
- ) );
+ VkMemoryPropertyFlags flags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+ VkResult result = s_renderVK->allocateMemory(&mr, flags, &m_deviceMem);
+
+ if (VK_SUCCESS != result)
+ {
+ flags &= ~VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+ VK_CHECK(s_renderVK->allocateMemory(&mr, flags, &m_deviceMem) );
+ }
m_size = (uint32_t)mr.size;
m_pos = 0;
VK_CHECK(vkBindBufferMemory(device, m_buffer, m_deviceMem, 0) );
- VK_CHECK(vkMapMemory(device, m_deviceMem, 0, ma.allocationSize, 0, (void**)&m_data) );
+ VK_CHECK(vkMapMemory(device, m_deviceMem, 0, m_size, 0, (void**)&m_data) );
}
void ScratchBufferVK::destroy()
{
- VkAllocationCallbacks* allocatorCb = s_renderVK->m_allocatorCb;
- VkDevice device = s_renderVK->m_device;
-
- vkFreeDescriptorSets(device, s_renderVK->m_descriptorPool, m_maxDescriptors, m_descriptorSet);
- BX_FREE(g_allocator, m_descriptorSet);
-
- vkUnmapMemory(device, m_deviceMem);
+ reset();
- vkDestroy(m_buffer);
+ vkUnmapMemory(s_renderVK->m_device, m_deviceMem);
- vkFreeMemory(device
- , m_deviceMem
- , allocatorCb
- );
+ s_renderVK->release(m_buffer);
+ s_renderVK->release(m_deviceMem);
}
- void ScratchBufferVK::reset(VkDescriptorBufferInfo& /*_descriptorBufferInfo*/)
+ void ScratchBufferVK::reset()
{
m_pos = 0;
- m_currentDs = 0;
}
- void* ScratchBufferVK::allocUbv(VkDescriptorBufferInfo& _descriptorBufferInfo, uint32_t _size)
+ uint32_t ScratchBufferVK::write(const void* _data, uint32_t _size)
{
- uint32_t total = bx::strideAlign(_size
- , uint32_t(s_renderVK->m_deviceProperties.limits.minUniformBufferOffsetAlignment)
- );
- _descriptorBufferInfo.buffer = m_buffer;
- _descriptorBufferInfo.offset = m_pos;
- _descriptorBufferInfo.range = total;
-
- VkWriteDescriptorSet wds[1];
- wds[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
- wds[0].pNext = NULL;
- wds[0].dstSet = m_descriptorSet[m_currentDs];
- wds[0].dstBinding = DslBinding::UniformBuffer;
- wds[0].dstArrayElement = 0;
- wds[0].descriptorCount = 1;
- wds[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
- wds[0].pImageInfo = NULL;
- wds[0].pBufferInfo = &_descriptorBufferInfo;
- wds[0].pTexelBufferView = NULL;
- vkUpdateDescriptorSets(s_renderVK->m_device, BX_COUNTOF(wds), wds, 0, NULL);
-
- void* data = &m_data[m_pos];
- m_pos += total;
- ++m_currentDs;
-
- return data;
- }
-
- VkResult ImageVK::create(VkFormat _format, const VkExtent3D& _extent)
- {
- VkResult result;
-
- VkAllocationCallbacks* allocatorCb = s_renderVK->m_allocatorCb;
- VkDevice device = s_renderVK->m_device;
-
- VkImageCreateInfo ici;
- ici.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
- ici.pNext = NULL;
- ici.flags = 0;
- ici.imageType = VK_IMAGE_TYPE_2D;
- ici.format = _format;
- ici.extent = _extent;
- ici.mipLevels = 1;
- ici.arrayLayers = 1;
- ici.samples = VK_SAMPLE_COUNT_1_BIT;
- ici.tiling = VK_IMAGE_TILING_OPTIMAL;
- ici.usage = 0
- | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
- | VK_IMAGE_USAGE_TRANSFER_SRC_BIT
- ;
- ici.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
- ici.queueFamilyIndexCount = 0;
- ici.pQueueFamilyIndices = 0;
- ici.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
- result = vkCreateImage(device, &ici, allocatorCb, &m_image);
-
- if (VK_SUCCESS != result)
- {
- BX_TRACE("vkCreateImage failed %d: %s.", result, getName(result) );
- return result;
- }
+ BX_ASSERT(m_pos < m_size, "Out of scratch buffer memory");
- VkMemoryRequirements mr;
- vkGetImageMemoryRequirements(device, m_image, &mr);
-
- VkMemoryAllocateInfo ma;
- ma.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
- ma.pNext = NULL;
- ma.allocationSize = mr.size;
- ma.memoryTypeIndex = s_renderVK->selectMemoryType(mr.memoryTypeBits
- , VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
- );
- result = vkAllocateMemory(device
- , &ma
- , allocatorCb
- , &m_memory
- );
+ const uint32_t offset = m_pos;
- if (VK_SUCCESS != result)
+ if (_size > 0)
{
- BX_TRACE("vkAllocateMemory failed %d: %s.", result, getName(result) );
- destroy();
- return result;
- }
+ bx::memCopy(&m_data[m_pos], _data, _size);
- result = vkBindImageMemory(device, m_image, m_memory, 0);
+ const VkPhysicalDeviceLimits& deviceLimits = s_renderVK->m_deviceProperties.limits;
+ const uint32_t align = uint32_t(deviceLimits.minUniformBufferOffsetAlignment);
+ const uint32_t alignedSize = bx::strideAlign(_size, align);
- if (VK_SUCCESS != result)
- {
- BX_TRACE("vkBindImageMemory failed %d: %s.", result, getName(result) );
- destroy();
- return result;
+ m_pos += alignedSize;
}
- VkImageViewCreateInfo ivci;
- ivci.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
- ivci.pNext = NULL;
- ivci.flags = 0;
- ivci.image = m_image;
- ivci.viewType = VK_IMAGE_VIEW_TYPE_2D;
- ivci.format = _format;
- ivci.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
- ivci.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
- ivci.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
- ivci.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
- ivci.subresourceRange.aspectMask = 0
- | VK_IMAGE_ASPECT_DEPTH_BIT
- | VK_IMAGE_ASPECT_STENCIL_BIT
- ;
- ivci.subresourceRange.baseMipLevel = 0;
- ivci.subresourceRange.levelCount = 1;
- ivci.subresourceRange.baseArrayLayer = 0;
- ivci.subresourceRange.layerCount = 1;
- result = vkCreateImageView(device, &ivci, allocatorCb, &m_imageView);
-
- if (VK_SUCCESS != result)
- {
- BX_TRACE("vkCreateImageView failed %d: %s.", result, getName(result) );
- destroy();
- return result;
- }
-
- return VK_SUCCESS;
+ return offset;
}
- void ImageVK::destroy()
+ void ScratchBufferVK::flush()
{
- vkDestroy(m_imageView);
- vkDestroy(m_image);
- if (VK_NULL_HANDLE != m_memory)
- {
- vkFreeMemory(s_renderVK->m_device, m_memory, s_renderVK->m_allocatorCb);
- m_memory = VK_NULL_HANDLE;
- }
+ const VkPhysicalDeviceLimits& deviceLimits = s_renderVK->m_deviceProperties.limits;
+ VkDevice device = s_renderVK->m_device;
+
+ const uint32_t align = uint32_t(deviceLimits.nonCoherentAtomSize);
+ const uint32_t size = bx::min(bx::strideAlign(m_pos, align), m_size);
+
+ VkMappedMemoryRange range;
+ range.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
+ range.pNext = NULL;
+ range.memory = m_deviceMem;
+ range.offset = 0;
+ range.size = size;
+ VK_CHECK(vkFlushMappedMemoryRanges(device, 1, &range) );
}
- void BufferVK::create(uint32_t _size, void* _data, uint16_t _flags, bool _vertex, uint32_t _stride)
+ void BufferVK::create(VkCommandBuffer _commandBuffer, uint32_t _size, void* _data, uint16_t _flags, bool _vertex, uint32_t _stride)
{
BX_UNUSED(_stride);
@@ -3350,93 +4704,92 @@ VK_DESTROY
m_flags = _flags;
m_dynamic = NULL == _data;
+ const bool storage = m_flags & BGFX_BUFFER_COMPUTE_READ_WRITE;
+ const bool indirect = m_flags & BGFX_BUFFER_DRAW_INDIRECT;
+
VkBufferCreateInfo bci;
bci.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
bci.pNext = NULL;
bci.flags = 0;
bci.size = _size;
bci.usage = 0
- | (m_dynamic ? VK_BUFFER_USAGE_TRANSFER_DST_BIT : 0)
- | (_vertex ? VK_BUFFER_USAGE_VERTEX_BUFFER_BIT : VK_BUFFER_USAGE_INDEX_BUFFER_BIT)
+ | (_vertex ? VK_BUFFER_USAGE_VERTEX_BUFFER_BIT : VK_BUFFER_USAGE_INDEX_BUFFER_BIT)
+ | (storage || indirect ? VK_BUFFER_USAGE_STORAGE_BUFFER_BIT : 0)
+ | (indirect ? VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT : 0)
+ | VK_BUFFER_USAGE_TRANSFER_DST_BIT
;
bci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
bci.queueFamilyIndexCount = 0;
bci.pQueueFamilyIndices = NULL;
- VkAllocationCallbacks* allocatorCb = s_renderVK->m_allocatorCb;
- VkDevice device = s_renderVK->m_device;
- VK_CHECK(vkCreateBuffer(device
- , &bci
- , allocatorCb
- , &m_buffer
- ) );
+ const VkAllocationCallbacks* allocatorCb = s_renderVK->m_allocatorCb;
+ const VkDevice device = s_renderVK->m_device;
+ VK_CHECK(vkCreateBuffer(device, &bci, allocatorCb, &m_buffer) );
VkMemoryRequirements mr;
- vkGetBufferMemoryRequirements(device
- , m_buffer
- , &mr
- );
+ vkGetBufferMemoryRequirements(device, m_buffer, &mr);
- VkMemoryAllocateInfo ma;
- ma.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
- ma.pNext = NULL;
- ma.allocationSize = mr.size;
- ma.memoryTypeIndex = s_renderVK->selectMemoryType(mr.memoryTypeBits
- , VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
- );
- VK_CHECK(vkAllocateMemory(device
- , &ma
- , allocatorCb
- , &m_deviceMem
- ) );
+ VK_CHECK(s_renderVK->allocateMemory(&mr, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &m_deviceMem) );
+
+ VK_CHECK(vkBindBufferMemory(device, m_buffer, m_deviceMem, 0) );
if (!m_dynamic)
{
- void* dst;
- VK_CHECK(vkMapMemory(device, m_deviceMem, 0, ma.allocationSize, 0, &dst) );
- bx::memCopy(dst, _data, _size);
- vkUnmapMemory(device, m_deviceMem);
+ update(_commandBuffer, 0, _size, _data);
}
-
- VK_CHECK(vkBindBufferMemory(device, m_buffer, m_deviceMem, 0) );
}
void BufferVK::update(VkCommandBuffer _commandBuffer, uint32_t _offset, uint32_t _size, void* _data, bool _discard)
{
- BX_UNUSED(_commandBuffer, _offset, _size, _data, _discard);
+ BX_UNUSED(_discard);
+
+ VkBuffer stagingBuffer;
+ VkDeviceMemory stagingMem;
+ VK_CHECK(s_renderVK->createStagingBuffer(_size, &stagingBuffer, &stagingMem, _data) );
+
+ VkBufferCopy region;
+ region.srcOffset = 0;
+ region.dstOffset = _offset;
+ region.size = _size;
+ vkCmdCopyBuffer(_commandBuffer, stagingBuffer, m_buffer, 1, &region);
+
+ setMemoryBarrier(
+ _commandBuffer
+ , VK_PIPELINE_STAGE_TRANSFER_BIT
+ , VK_PIPELINE_STAGE_TRANSFER_BIT
+ );
+
+ s_renderVK->release(stagingBuffer);
+ s_renderVK->release(stagingMem);
}
void BufferVK::destroy()
{
if (VK_NULL_HANDLE != m_buffer)
{
- VkAllocationCallbacks* allocatorCb = s_renderVK->m_allocatorCb;
- VkDevice device = s_renderVK->m_device;
+ s_renderVK->release(m_buffer);
+ s_renderVK->release(m_deviceMem);
- vkDestroy(m_buffer);
- vkFreeMemory(device
- , m_deviceMem
- , allocatorCb
- );
m_dynamic = false;
}
}
- void VertexBufferVK::create(uint32_t _size, void* _data, VertexDeclHandle _declHandle, uint16_t _flags)
+ void VertexBufferVK::create(VkCommandBuffer _commandBuffer, uint32_t _size, void* _data, VertexLayoutHandle _layoutHandle, uint16_t _flags)
{
- BufferVK::create(_size, _data, _flags, true);
- m_decl = _declHandle;
+ BufferVK::create(_commandBuffer, _size, _data, _flags, true);
+ m_layoutHandle = _layoutHandle;
}
void ShaderVK::create(const Memory* _mem)
{
bx::MemoryReader reader(_mem->data, _mem->size);
+ bx::ErrorAssert err;
+
uint32_t magic;
- bx::read(&reader, magic);
+ bx::read(&reader, magic, &err);
- VkShaderStageFlagBits shaderStage;
- BX_UNUSED(shaderStage);
+ VkShaderStageFlagBits shaderStage = VK_SHADER_STAGE_ALL;
if (isShaderType(magic, 'C') )
{
@@ -3454,7 +4807,7 @@ VK_DESTROY
const bool fragment = isShaderType(magic, 'F');
uint32_t hashIn;
- bx::read(&reader, hashIn);
+ bx::read(&reader, hashIn, &err);
uint32_t hashOut;
@@ -3464,84 +4817,195 @@ VK_DESTROY
}
else
{
- bx::read(&reader, hashOut);
+ bx::read(&reader, hashOut, &err);
}
uint16_t count;
- bx::read(&reader, count);
+ bx::read(&reader, count, &err);
m_numPredefined = 0;
- m_numUniforms = count;
+ m_numUniforms = count;
+ m_numTextures = 0;
+
+ m_oldBindingModel = isShaderVerLess(magic, 11);
BX_TRACE("%s Shader consts %d"
, getShaderTypeName(magic)
, count
);
- uint8_t fragmentBit = fragment ? BGFX_UNIFORM_FRAGMENTBIT : 0;
+ uint8_t fragmentBit = fragment ? kUniformFragmentBit : 0;
+
+ for (uint32_t ii = 0; ii < BGFX_CONFIG_MAX_TEXTURE_SAMPLERS; ++ii)
+ {
+ m_bindInfo[ii].uniformHandle = BGFX_INVALID_HANDLE;
+ m_bindInfo[ii].type = BindType::Count;
+ m_bindInfo[ii].binding = 0;
+ m_bindInfo[ii].samplerBinding = 0;
+ m_bindInfo[ii].index = UINT32_MAX;
+ }
if (0 < count)
{
for (uint32_t ii = 0; ii < count; ++ii)
{
uint8_t nameSize = 0;
- bx::read(&reader, nameSize);
+ bx::read(&reader, nameSize, &err);
char name[256];
- bx::read(&reader, &name, nameSize);
+ bx::read(&reader, &name, nameSize, &err);
name[nameSize] = '\0';
uint8_t type = 0;
- bx::read(&reader, type);
+ bx::read(&reader, type, &err);
uint8_t num;
- bx::read(&reader, num);
+ bx::read(&reader, num, &err);
uint16_t regIndex;
- bx::read(&reader, regIndex);
+ bx::read(&reader, regIndex, &err);
uint16_t regCount;
- bx::read(&reader, regCount);
+ bx::read(&reader, regCount, &err);
- const char* kind = "invalid";
+ const bool hasTexData = !isShaderVerLess(magic, 8);
+ const bool hasTexFormat = !isShaderVerLess(magic, 10);
+ uint8_t texComponent = 0;
+ uint8_t texDimension = 0;
+ uint16_t texFormat = 0;
- PredefinedUniform::Enum predefined = nameToPredefinedUniformEnum(name);
- if (PredefinedUniform::Count != predefined)
+ if (hasTexData)
{
- 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++;
+ bx::read(&reader, texComponent, &err);
+ bx::read(&reader, texDimension, &err);
}
- else if (0 == (BGFX_UNIFORM_SAMPLERBIT & type) )
+
+ if (hasTexFormat)
{
- const UniformRegInfo* info = s_renderVK->m_uniformReg.find(name);
- BX_CHECK(NULL != info, "User defined uniform '%s' is not found, it won't be set.", name);
+ bx::read(&reader, texFormat, &err);
+ }
+
+ const char* kind = "invalid";
+
+ BX_UNUSED(num, texComponent, texFormat);
- if (NULL != info)
+ auto textureDimensionToViewType = [](TextureDimension::Enum dimension)
+ {
+ switch (dimension)
+ {
+ case TextureDimension::Dimension1D: return VK_IMAGE_VIEW_TYPE_1D;
+ case TextureDimension::Dimension2D: return VK_IMAGE_VIEW_TYPE_2D;
+ case TextureDimension::Dimension2DArray: return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
+ case TextureDimension::DimensionCube: return VK_IMAGE_VIEW_TYPE_CUBE;
+ case TextureDimension::DimensionCubeArray: return VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
+ case TextureDimension::Dimension3D: return VK_IMAGE_VIEW_TYPE_3D;
+ default: return VK_IMAGE_VIEW_TYPE_MAX_ENUM;
+ }
+ };
+
+ if (UINT16_MAX != regIndex)
+ {
+ PredefinedUniform::Enum predefined = nameToPredefinedUniformEnum(name);
+ if (PredefinedUniform::Count != predefined)
{
- if (NULL == m_constantBuffer)
+ 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 (UniformType::End == (~kUniformMask & type) )
+ {
+ // regCount is used for descriptor type
+ const bool isBuffer = idToDescriptorType(regCount) == DescriptorType::StorageBuffer;
+ if (0 == regIndex)
+ {
+ continue;
+ }
+
+ const uint8_t reverseShift = m_oldBindingModel
+ ? (fragment ? kSpirvOldFragmentShift : 0) + (isBuffer ? kSpirvOldBufferShift : kSpirvOldImageShift)
+ : kSpirvBindShift;
+
+ const uint16_t stage = regIndex - reverseShift; // regIndex is used for buffer binding index
+
+ m_bindInfo[stage].type = isBuffer ? BindType::Buffer : BindType::Image;
+ m_bindInfo[stage].uniformHandle = { 0 };
+ m_bindInfo[stage].binding = regIndex;
+
+ if (!isBuffer)
{
- m_constantBuffer = UniformBuffer::create(1024);
+ const VkImageViewType viewType = hasTexData
+ ? textureDimensionToViewType(idToTextureDimension(texDimension) )
+ : VK_IMAGE_VIEW_TYPE_MAX_ENUM
+ ;
+
+ if (VK_IMAGE_VIEW_TYPE_MAX_ENUM != viewType)
+ {
+ m_bindInfo[stage].index = m_numTextures;
+ m_textures[m_numTextures].type = viewType;
+ m_numTextures++;
+ }
}
- kind = "user";
- m_constantBuffer->writeUniformHandle( (UniformType::Enum)(type|fragmentBit), regIndex, info->m_handle, regCount);
+ kind = "storage";
+ }
+ else if (UniformType::Sampler == (~kUniformMask & type) )
+ {
+ const uint8_t reverseShift = m_oldBindingModel
+ ? (fragment ? kSpirvOldFragmentShift : 0) + kSpirvOldTextureShift
+ : kSpirvBindShift;
+
+ const uint16_t stage = regIndex - reverseShift; // regIndex is used for image/sampler binding index
+
+ const UniformRegInfo* info = s_renderVK->m_uniformReg.find(name);
+ BX_ASSERT(NULL != info, "User defined uniform '%s' is not found, it won't be set.", name);
+
+ m_bindInfo[stage].uniformHandle = info->m_handle;
+ m_bindInfo[stage].type = BindType::Sampler;
+ m_bindInfo[stage].binding = regIndex;
+ m_bindInfo[stage].samplerBinding = regIndex + kSpirvSamplerShift;
+
+ const VkImageViewType viewType = hasTexData
+ ? textureDimensionToViewType(idToTextureDimension(texDimension) )
+ : VK_IMAGE_VIEW_TYPE_MAX_ENUM
+ ;
+
+ if (VK_IMAGE_VIEW_TYPE_MAX_ENUM != viewType)
+ {
+ m_bindInfo[stage].index = m_numTextures;
+ m_textures[m_numTextures].type = viewType;
+ m_numTextures++;
+ }
+
+ kind = "sampler";
+ }
+ else
+ {
+ const UniformRegInfo* info = s_renderVK->m_uniformReg.find(name);
+ BX_ASSERT(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"
+ BX_TRACE("\t%s: %s (%s), r.index %3d, r.count %2d, r.texComponent %1d, r.texDimension %1d"
, kind
, name
- , getUniformTypeName(UniformType::Enum(type&~BGFX_UNIFORM_MASK) )
- , num
+ , getUniformTypeName(UniformType::Enum(type&~kUniformMask) )
, regIndex
, regCount
+ , texComponent
+ , texDimension
);
BX_UNUSED(kind);
}
@@ -3553,23 +5017,23 @@ VK_DESTROY
}
uint32_t shaderSize;
- bx::read(&reader, shaderSize);
+ bx::read(&reader, shaderSize, &err);
const void* code = reader.getDataPtr();
bx::skip(&reader, shaderSize+1);
m_code = alloc(shaderSize);
- bx::memCopy(m_code->data
- , code
- , shaderSize
- );
+ bx::memCopy(m_code->data, code, shaderSize);
VkShaderModuleCreateInfo smci;
- smci.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
- smci.pNext = NULL;
- smci.flags = 0;
+ smci.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+ smci.pNext = NULL;
+ smci.flags = 0;
smci.codeSize = m_code->size;
smci.pCode = (const uint32_t*)m_code->data;
+
+// disassemble(bx::getDebugOut(), m_code->data, m_code->size);
+
VK_CHECK(vkCreateShaderModule(
s_renderVK->m_device
, &smci
@@ -3580,12 +5044,12 @@ VK_DESTROY
bx::memSet(m_attrMask, 0, sizeof(m_attrMask) );
bx::memSet(m_attrRemap, 0, sizeof(m_attrRemap) );
- bx::read(&reader, m_numAttrs);
+ bx::read(&reader, m_numAttrs, &err);
for (uint8_t ii = 0; ii < m_numAttrs; ++ii)
{
uint16_t id;
- bx::read(&reader, id);
+ bx::read(&reader, id, &err);
Attrib::Enum attr = idToAttrib(id);
@@ -3606,7 +5070,69 @@ VK_DESTROY
murmur.add(m_attrRemap, m_numAttrs);
m_hash = murmur.end();
- bx::read(&reader, m_size);
+ bx::read(&reader, m_size, &err);
+
+ // fill binding description with uniform information
+ uint16_t bidx = 0;
+ if (m_size > 0)
+ {
+ m_uniformBinding = fragment ? (m_oldBindingModel ? kSpirvOldFragmentBinding : kSpirvFragmentBinding) : 0;
+
+ VkDescriptorSetLayoutBinding& binding = m_bindings[bidx];
+ binding.stageFlags = shaderStage;
+ binding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
+ binding.binding = m_uniformBinding;
+ binding.pImmutableSamplers = NULL;
+ binding.descriptorCount = 1;
+ bidx++;
+ }
+
+ for (uint32_t ii = 0; ii < BX_COUNTOF(m_bindInfo); ++ii)
+ {
+ switch (m_bindInfo[ii].type)
+ {
+ case BindType::Buffer:
+ case BindType::Image:
+ {
+ VkDescriptorSetLayoutBinding& binding = m_bindings[bidx];
+ binding.stageFlags = shaderStage;
+ binding.descriptorType = BindType::Buffer == m_bindInfo[ii].type
+ ? VK_DESCRIPTOR_TYPE_STORAGE_BUFFER
+ : VK_DESCRIPTOR_TYPE_STORAGE_IMAGE
+ ;
+ binding.binding = m_bindInfo[ii].binding;
+ binding.pImmutableSamplers = NULL;
+ binding.descriptorCount = 1;
+ bidx++;
+ }
+ break;
+
+ case BindType::Sampler:
+ {
+ VkDescriptorSetLayoutBinding& textureBinding = m_bindings[bidx];
+ textureBinding.stageFlags = shaderStage;
+ textureBinding.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
+ textureBinding.binding = m_bindInfo[ii].binding;
+ textureBinding.pImmutableSamplers = NULL;
+ textureBinding.descriptorCount = 1;
+ bidx++;
+
+ VkDescriptorSetLayoutBinding& samplerBinding = m_bindings[bidx];
+ samplerBinding.stageFlags = shaderStage;
+ samplerBinding.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER;
+ samplerBinding.binding = m_bindInfo[ii].samplerBinding;
+ samplerBinding.pImmutableSamplers = NULL;
+ samplerBinding.descriptorCount = 1;
+ bidx++;
+ }
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ m_numBindings = bidx;
}
void ShaderVK::destroy()
@@ -3632,44 +5158,3043 @@ VK_DESTROY
}
}
+ void ProgramVK::create(const ShaderVK* _vsh, const ShaderVK* _fsh)
+ {
+ BX_ASSERT(NULL != _vsh->m_code, "Vertex shader doesn't exist.");
+ m_vsh = _vsh;
+ bx::memCopy(
+ &m_predefined[0]
+ , _vsh->m_predefined
+ , _vsh->m_numPredefined * sizeof(PredefinedUniform)
+ );
+ m_numPredefined = _vsh->m_numPredefined;
+
+ if (NULL != _fsh)
+ {
+ BX_ASSERT(NULL != _fsh->m_code, "Fragment shader doesn't exist.");
+ m_fsh = _fsh;
+ bx::memCopy(
+ &m_predefined[m_numPredefined]
+ , _fsh->m_predefined
+ , _fsh->m_numPredefined * sizeof(PredefinedUniform)
+ );
+ m_numPredefined += _fsh->m_numPredefined;
+ }
+
+ m_numTextures = 0;
+
+ for (uint8_t stage = 0; stage < BX_COUNTOF(m_bindInfo); ++stage)
+ {
+ const ShaderVK* shader = NULL;
+ if (isValid(m_vsh->m_bindInfo[stage].uniformHandle) )
+ {
+ shader = _vsh;
+
+ BX_ASSERT(false
+ || NULL == m_fsh
+ || !isValid(m_fsh->m_bindInfo[stage].uniformHandle)
+ || !(m_vsh->m_oldBindingModel || m_fsh->m_oldBindingModel)
+ , "Shared vertex/fragment bindings require shader binary version >= 11."
+ );
+ }
+ else if (NULL != m_fsh
+ && isValid(m_fsh->m_bindInfo[stage].uniformHandle) )
+ {
+ shader = _fsh;
+ }
+
+ if (NULL != shader)
+ {
+ m_bindInfo[stage] = shader->m_bindInfo[stage];
+ uint32_t& index = m_bindInfo[stage].index;
+ if (UINT32_MAX != index)
+ {
+ m_textures[m_numTextures] = shader->m_textures[index];
+ index = m_numTextures;
+ m_numTextures++;
+ }
+ }
+ }
+
+ // create exact pipeline layout
+ m_descriptorSetLayout = VK_NULL_HANDLE;
+
+ uint32_t numBindings = m_vsh->m_numBindings + (m_fsh ? m_fsh->m_numBindings : 0);
+ if (0 < numBindings)
+ {
+ // generate descriptor set layout hash
+ bx::HashMurmur2A murmur;
+ murmur.begin();
+ murmur.add(m_vsh->m_bindings, sizeof(VkDescriptorSetLayoutBinding) * m_vsh->m_numBindings);
+
+ if (NULL != m_fsh)
+ {
+ murmur.add(m_fsh->m_bindings, sizeof(VkDescriptorSetLayoutBinding) * m_fsh->m_numBindings);
+ }
+
+ uint32_t descriptorSetLayoutHash = murmur.end();
+
+ m_descriptorSetLayout = s_renderVK->m_descriptorSetLayoutCache.find(descriptorSetLayoutHash);
+
+ if (VK_NULL_HANDLE == m_descriptorSetLayout)
+ {
+ VkDescriptorSetLayoutBinding bindings[2 * BX_COUNTOF(ShaderVK::m_bindings)];
+
+ bx::memCopy(
+ bindings
+ , m_vsh->m_bindings
+ , sizeof(VkDescriptorSetLayoutBinding) * m_vsh->m_numBindings
+ );
+
+ numBindings = m_vsh->m_numBindings;
+
+ if (NULL != m_fsh)
+ {
+ for (uint16_t ii = 0; ii < m_fsh->m_numBindings; ii++)
+ {
+ const VkDescriptorSetLayoutBinding& fsBinding = m_fsh->m_bindings[ii];
+ uint16_t vsBindingIdx = UINT16_MAX;
+ for (uint16_t jj = 0; jj < m_vsh->m_numBindings; jj++)
+ {
+ if (fsBinding.binding == bindings[jj].binding)
+ {
+ vsBindingIdx = jj;
+ break;
+ }
+ }
+ if (UINT16_MAX != vsBindingIdx)
+ {
+ BX_ASSERT(
+ bindings[vsBindingIdx].descriptorType == fsBinding.descriptorType
+ , "Mismatching descriptor types. Shaders compiled with different versions of shaderc?"
+ );
+ bindings[vsBindingIdx].stageFlags |= fsBinding.stageFlags;
+ }
+ else
+ {
+ bindings[numBindings] = fsBinding;
+ numBindings++;
+ }
+ }
+ }
+
+ VkDescriptorSetLayoutCreateInfo dslci;
+ dslci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+ dslci.pNext = NULL;
+ dslci.flags = 0;
+ dslci.bindingCount = numBindings;
+ dslci.pBindings = bindings;
+
+ VK_CHECK(vkCreateDescriptorSetLayout(
+ s_renderVK->m_device
+ , &dslci
+ , s_renderVK->m_allocatorCb
+ , &m_descriptorSetLayout
+ ) );
+
+ s_renderVK->m_descriptorSetLayoutCache.add(descriptorSetLayoutHash, m_descriptorSetLayout);
+ }
+ }
+
+ VkPipelineLayoutCreateInfo plci;
+ plci.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+ plci.pNext = NULL;
+ plci.flags = 0;
+ plci.pushConstantRangeCount = 0;
+ plci.pPushConstantRanges = NULL;
+ plci.setLayoutCount = (m_descriptorSetLayout == VK_NULL_HANDLE ? 0 : 1);
+ plci.pSetLayouts = &m_descriptorSetLayout;
+
+ VK_CHECK(vkCreatePipelineLayout(
+ s_renderVK->m_device
+ , &plci
+ , s_renderVK->m_allocatorCb
+ , &m_pipelineLayout
+ ) );
+ }
+
+ void ProgramVK::destroy()
+ {
+ s_renderVK->release(m_pipelineLayout);
+ m_numPredefined = 0;
+ m_vsh = NULL;
+ m_fsh = NULL;
+ }
+
+ VkResult TimerQueryVK::init()
+ {
+ VkResult result = VK_SUCCESS;
+
+ const VkDevice device = s_renderVK->m_device;
+ const VkCommandBuffer commandBuffer = s_renderVK->m_commandBuffer;
+
+ const uint32_t count = m_control.m_size * 2;
+
+ VkQueryPoolCreateInfo qpci;
+ qpci.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
+ qpci.pNext = NULL;
+ qpci.flags = 0;
+ qpci.queryType = VK_QUERY_TYPE_TIMESTAMP;
+ qpci.queryCount = count;
+ qpci.pipelineStatistics = 0;
+
+ result = vkCreateQueryPool(device, &qpci, s_renderVK->m_allocatorCb, &m_queryPool);
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create timer query error: vkCreateQueryPool failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ vkCmdResetQueryPool(commandBuffer, m_queryPool, 0, count);
+
+ const uint32_t size = count * sizeof(uint64_t);
+ result = s_renderVK->createReadbackBuffer(size, &m_readback, &m_readbackMemory);
+
+ if (VK_SUCCESS != result)
+ {
+ return result;
+ }
+
+ result = vkMapMemory(device, m_readbackMemory, 0, VK_WHOLE_SIZE, 0, (void**)&m_queryResult);
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create timer query error: vkMapMemory failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ m_frequency = uint64_t(1000000000.0 / double(s_renderVK->m_deviceProperties.limits.timestampPeriod) );
+
+ for (uint32_t ii = 0; ii < BX_COUNTOF(m_result); ++ii)
+ {
+ m_result[ii].reset();
+ }
+
+ m_control.reset();
+
+ return result;
+ }
+
+ void TimerQueryVK::shutdown()
+ {
+ vkDestroy(m_queryPool);
+ vkDestroy(m_readback);
+ vkUnmapMemory(s_renderVK->m_device, m_readbackMemory);
+ vkDestroy(m_readbackMemory);
+ }
+
+ uint32_t TimerQueryVK::begin(uint32_t _resultIdx, uint32_t _frameNum)
+ {
+ while (0 == m_control.reserve(1) )
+ {
+ m_control.consume(1);
+ }
+
+ Result& result = m_result[_resultIdx];
+ ++result.m_pending;
+
+ const uint32_t idx = m_control.m_current;
+ Query& query = m_query[idx];
+ query.m_resultIdx = _resultIdx;
+ query.m_ready = false;
+ query.m_frameNum = _frameNum;
+
+ const VkCommandBuffer commandBuffer = s_renderVK->m_commandBuffer;
+ const uint32_t offset = idx * 2 + 0;
+
+ vkCmdResetQueryPool(commandBuffer, m_queryPool, offset, 2);
+ vkCmdWriteTimestamp(commandBuffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, m_queryPool, offset + 0);
+
+ m_control.commit(1);
+
+ return idx;
+ }
+
+ void TimerQueryVK::end(uint32_t _idx)
+ {
+ Query& query = m_query[_idx];
+ query.m_ready = true;
+ query.m_completed = s_renderVK->m_cmd.m_submitted + s_renderVK->m_cmd.m_numFramesInFlight;
+
+ const VkCommandBuffer commandBuffer = s_renderVK->m_commandBuffer;
+ const uint32_t offset = _idx * 2 + 0;
+
+ vkCmdWriteTimestamp(commandBuffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, m_queryPool, offset + 1);
+
+ vkCmdCopyQueryPoolResults(
+ commandBuffer
+ , m_queryPool
+ , offset
+ , 2
+ , m_readback
+ , offset * sizeof(uint64_t)
+ , sizeof(uint64_t)
+ , VK_QUERY_RESULT_WAIT_BIT | VK_QUERY_RESULT_64_BIT
+ );
+
+ setMemoryBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT);
+
+ while (update() )
+ {
+ }
+ }
+
+ bool TimerQueryVK::update()
+ {
+ if (0 != m_control.available() )
+ {
+ uint32_t idx = m_control.m_read;
+ Query& query = m_query[idx];
+
+ if (!query.m_ready)
+ {
+ return false;
+ }
+
+ if (query.m_completed > s_renderVK->m_cmd.m_submitted)
+ {
+ return false;
+ }
+
+ m_control.consume(1);
+
+ Result& result = m_result[query.m_resultIdx];
+ --result.m_pending;
+ result.m_frameNum = query.m_frameNum;
+
+ uint32_t offset = idx * 2;
+ result.m_begin = m_queryResult[offset+0];
+ result.m_end = m_queryResult[offset+1];
+
+ return true;
+ }
+
+ return false;
+ }
+
+ VkResult OcclusionQueryVK::init()
+ {
+ VkResult result = VK_SUCCESS;
+
+ const VkDevice device = s_renderVK->m_device;
+ const VkCommandBuffer commandBuffer = s_renderVK->m_commandBuffer;
+
+ const uint32_t count = BX_COUNTOF(m_handle);
+
+ VkQueryPoolCreateInfo qpci;
+ qpci.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
+ qpci.pNext = NULL;
+ qpci.flags = 0;
+ qpci.queryType = VK_QUERY_TYPE_OCCLUSION;
+ qpci.queryCount = count;
+ qpci.pipelineStatistics = 0;
+
+ result = vkCreateQueryPool(device, &qpci, s_renderVK->m_allocatorCb, &m_queryPool);
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create occlusion query error: vkCreateQueryPool failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ vkCmdResetQueryPool(commandBuffer, m_queryPool, 0, count);
+
+ const uint32_t size = count * sizeof(uint32_t);
+ result = s_renderVK->createReadbackBuffer(size, &m_readback, &m_readbackMemory);
+
+ if (VK_SUCCESS != result)
+ {
+ return result;
+ }
+
+ result = vkMapMemory(device, m_readbackMemory, 0, VK_WHOLE_SIZE, 0, (void**)&m_queryResult);
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create occlusion query error: vkMapMemory failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ m_control.reset();
+
+ return result;
+ }
+
+ void OcclusionQueryVK::shutdown()
+ {
+ vkDestroy(m_queryPool);
+ vkDestroy(m_readback);
+ vkUnmapMemory(s_renderVK->m_device, m_readbackMemory);
+ vkDestroy(m_readbackMemory);
+ }
+
+ void OcclusionQueryVK::begin(OcclusionQueryHandle _handle)
+ {
+ m_control.reserve(1);
+
+ const VkCommandBuffer commandBuffer = s_renderVK->m_commandBuffer;
+
+ m_handle[m_control.m_current] = _handle;
+ vkCmdBeginQuery(commandBuffer, m_queryPool, _handle.idx, 0);
+ }
+
+ void OcclusionQueryVK::end()
+ {
+ const VkCommandBuffer commandBuffer = s_renderVK->m_commandBuffer;
+
+ const OcclusionQueryHandle handle = m_handle[m_control.m_current];
+ vkCmdEndQuery(commandBuffer, m_queryPool, handle.idx);
+
+ m_control.commit(1);
+ }
+
+ void OcclusionQueryVK::flush(Frame* _render)
+ {
+ if (0 < m_control.available() )
+ {
+ VkCommandBuffer commandBuffer = s_renderVK->m_commandBuffer;
+
+ const uint32_t size = m_control.m_size;
+
+ // need to copy each result individually because VK_QUERY_RESULT_WAIT_BIT causes
+ // vkWaitForFences to hang indefinitely if we copy all results (including unavailable ones)
+ for (uint32_t ii = 0, num = m_control.available(); ii < num; ++ii)
+ {
+ const OcclusionQueryHandle& handle = m_handle[(m_control.m_read + ii) % size];
+ if (isValid(handle) )
+ {
+ vkCmdCopyQueryPoolResults(
+ commandBuffer
+ , m_queryPool
+ , handle.idx
+ , 1
+ , m_readback
+ , handle.idx * sizeof(uint32_t)
+ , sizeof(uint32_t)
+ , VK_QUERY_RESULT_WAIT_BIT
+ );
+ }
+ }
+
+ setMemoryBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT);
+ s_renderVK->kick(true);
+
+ commandBuffer = s_renderVK->m_commandBuffer;
+
+ // resetting in the new command buffer prevents a false positive validation layer error
+ const uint32_t count = BX_COUNTOF(m_handle);
+ vkCmdResetQueryPool(commandBuffer, m_queryPool, 0, count);
+
+ resolve(_render);
+ }
+ }
+
+ void OcclusionQueryVK::resolve(Frame* _render)
+ {
+ while (0 != m_control.available() )
+ {
+ OcclusionQueryHandle handle = m_handle[m_control.m_read];
+ if (isValid(handle) )
+ {
+ _render->m_occlusion[handle.idx] = m_queryResult[handle.idx];
+ }
+ m_control.consume(1);
+ }
+ }
+
+ void OcclusionQueryVK::invalidate(OcclusionQueryHandle _handle)
+ {
+ const uint32_t size = m_control.m_size;
+
+ for (uint32_t ii = 0, num = m_control.available(); ii < num; ++ii)
+ {
+ OcclusionQueryHandle& handle = m_handle[(m_control.m_read + ii) % size];
+ if (handle.idx == _handle.idx)
+ {
+ handle.idx = bgfx::kInvalidHandle;
+ }
+ }
+ }
+
+ void ReadbackVK::create(VkImage _image, uint32_t _width, uint32_t _height, TextureFormat::Enum _format)
+ {
+ m_image = _image;
+ m_width = _width;
+ m_height = _height;
+ m_format = _format;
+ }
+
+ void ReadbackVK::destroy()
+ {
+ m_image = VK_NULL_HANDLE;
+ }
+
+ uint32_t ReadbackVK::pitch(uint8_t _mip) const
+ {
+ uint32_t mipWidth = bx::uint32_max(1, m_width >> _mip);
+ uint8_t bpp = bimg::getBitsPerPixel(bimg::TextureFormat::Enum(m_format) );
+ return mipWidth * bpp / 8;
+ }
+
+ void ReadbackVK::copyImageToBuffer(VkCommandBuffer _commandBuffer, VkBuffer _buffer, VkImageLayout _layout, VkImageAspectFlags _aspect, uint8_t _mip) const
+ {
+ uint32_t mipWidth = bx::uint32_max(1, m_width >> _mip);
+ uint32_t mipHeight = bx::uint32_max(1, m_height >> _mip);
+
+ setImageMemoryBarrier(
+ _commandBuffer
+ , m_image
+ , _aspect
+ , _layout
+ , VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL
+ , _mip
+ , 1
+ , 0
+ , 1
+ );
+
+ VkBufferImageCopy bic;
+ bic.bufferOffset = 0;
+ bic.bufferRowLength = mipWidth;
+ bic.bufferImageHeight = mipHeight;
+ bic.imageSubresource.aspectMask = _aspect;
+ bic.imageSubresource.mipLevel = _mip;
+ bic.imageSubresource.baseArrayLayer = 0;
+ bic.imageSubresource.layerCount = 1;
+ bic.imageOffset = { 0, 0, 0 };
+ bic.imageExtent = { mipWidth, mipHeight, 1 };
+
+ vkCmdCopyImageToBuffer(
+ _commandBuffer
+ , m_image
+ , VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL
+ , _buffer
+ , 1
+ , &bic
+ );
+
+ // Make changes to the buffer visible to the host
+ setMemoryBarrier(
+ _commandBuffer
+ , VK_PIPELINE_STAGE_TRANSFER_BIT
+ , VK_PIPELINE_STAGE_HOST_BIT
+ );
+
+ setImageMemoryBarrier(
+ _commandBuffer
+ , m_image
+ , _aspect
+ , VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL
+ , _layout
+ , _mip
+ , 1
+ , 0
+ , 1
+ );
+ }
+
+ void ReadbackVK::readback(VkDeviceMemory _memory, VkDeviceSize _offset, void* _data, uint8_t _mip) const
+ {
+ if (m_image == VK_NULL_HANDLE)
+ {
+ return;
+ }
+
+ uint32_t mipHeight = bx::uint32_max(1, m_height >> _mip);
+ uint32_t rowPitch = pitch(_mip);
+
+ uint8_t* src;
+ VK_CHECK(vkMapMemory(s_renderVK->m_device, _memory, 0, VK_WHOLE_SIZE, 0, (void**)&src) );
+ src += _offset;
+ uint8_t* dst = (uint8_t*)_data;
+
+ for (uint32_t yy = 0; yy < mipHeight; ++yy)
+ {
+ bx::memCopy(dst, src, rowPitch);
+ src += rowPitch;
+ dst += rowPitch;
+ }
+
+ vkUnmapMemory(s_renderVK->m_device, _memory);
+ }
+
+ VkResult TextureVK::create(VkCommandBuffer _commandBuffer, uint32_t _width, uint32_t _height, uint64_t _flags, VkFormat _format)
+ {
+ BX_ASSERT(0 != (_flags & BGFX_TEXTURE_RT_MASK), "");
+ _flags |= BGFX_TEXTURE_RT_WRITE_ONLY;
+
+ m_flags = _flags;
+ m_width = _width;
+ m_height = _height;
+ m_depth = 1;
+ m_numLayers = 1;
+ m_requestedFormat = uint8_t(bimg::TextureFormat::Count);
+ m_textureFormat = uint8_t(bimg::TextureFormat::Count);
+ m_format = _format;
+ m_components = { VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY };
+ m_aspectMask = getAspectMask(m_format);
+ m_sampler = s_msaa[bx::uint32_satsub( (m_flags & BGFX_TEXTURE_RT_MSAA_MASK) >> BGFX_TEXTURE_RT_MSAA_SHIFT, 1)];
+ m_type = VK_IMAGE_VIEW_TYPE_2D;
+ m_numMips = 1;
+ m_numSides = 1;
+
+ VkResult result = createImages(_commandBuffer);
+
+ if (VK_SUCCESS == result)
+ {
+ const VkImageLayout layout = 0 != (m_aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) )
+ ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
+ : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
+ ;
+ setImageMemoryBarrier(_commandBuffer, layout);
+ }
+
+ return result;
+ }
+
+ VkResult TextureVK::createImages(VkCommandBuffer _commandBuffer)
+ {
+ VkResult result = VK_SUCCESS;
+
+ const VkAllocationCallbacks* allocatorCb = s_renderVK->m_allocatorCb;
+ const VkDevice device = s_renderVK->m_device;
+
+ if (m_sampler.Count > 1)
+ {
+ BX_ASSERT(VK_IMAGE_VIEW_TYPE_3D != m_type, "Can't create multisample 3D image.");
+ BX_ASSERT(m_numMips <= 1, "Can't create multisample image with mip chain.");
+ }
+
+ // create texture and allocate its device memory
+ VkImageCreateInfo ici;
+ ici.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+ ici.pNext = NULL;
+ ici.flags = 0
+ | (VK_IMAGE_VIEW_TYPE_CUBE == m_type
+ ? VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT
+ : 0
+ )
+ | (VK_IMAGE_VIEW_TYPE_3D == m_type
+ ? VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR
+ : 0
+ )
+ ;
+ ici.pQueueFamilyIndices = NULL;
+ ici.queueFamilyIndexCount = 0;
+ ici.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+ ici.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+ ici.usage = 0
+ | VK_IMAGE_USAGE_TRANSFER_SRC_BIT
+ | VK_IMAGE_USAGE_TRANSFER_DST_BIT
+ | VK_IMAGE_USAGE_SAMPLED_BIT
+ | (m_flags & BGFX_TEXTURE_RT_MASK
+ ? (m_aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)
+ ? VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
+ : VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
+ : 0
+ )
+ | (m_flags & BGFX_TEXTURE_COMPUTE_WRITE ? VK_IMAGE_USAGE_STORAGE_BIT : 0)
+ ;
+ ici.format = m_format;
+ ici.samples = m_sampler.Sample;
+ ici.mipLevels = m_numMips;
+ ici.arrayLayers = m_numSides;
+ ici.extent.width = m_width;
+ ici.extent.height = m_height;
+ ici.extent.depth = m_depth;
+ ici.imageType = VK_IMAGE_VIEW_TYPE_3D == m_type
+ ? VK_IMAGE_TYPE_3D
+ : VK_IMAGE_TYPE_2D
+ ;
+ ici.tiling = VK_IMAGE_TILING_OPTIMAL;
+
+ result = vkCreateImage(device, &ici, allocatorCb, &m_textureImage);
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create texture image error: vkCreateImage failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ VkMemoryRequirements imageMemReq;
+ vkGetImageMemoryRequirements(device, m_textureImage, &imageMemReq);
+
+ result = s_renderVK->allocateMemory(&imageMemReq, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &m_textureDeviceMem);
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create texture image error: allocateMemory failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ result = vkBindImageMemory(device, m_textureImage, m_textureDeviceMem, 0);
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create texture image error: vkBindImageMemory failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ m_sampledLayout = m_flags & BGFX_TEXTURE_COMPUTE_WRITE
+ ? VK_IMAGE_LAYOUT_GENERAL
+ : VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
+ ;
+
+ const bool needResolve = true
+ && 1 < m_sampler.Count
+ && 0 != (ici.usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
+ && 0 == (m_flags & BGFX_TEXTURE_MSAA_SAMPLE)
+ && 0 == (m_flags & BGFX_TEXTURE_RT_WRITE_ONLY)
+ ;
+
+ if (needResolve)
+ {
+ VkImageCreateInfo ici_resolve = ici;
+ ici_resolve.samples = s_msaa[0].Sample;
+ ici_resolve.usage &= ~VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+ ici_resolve.flags &= ~VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
+
+ result = vkCreateImage(device, &ici_resolve, allocatorCb, &m_singleMsaaImage);
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create texture image error: vkCreateImage failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ VkMemoryRequirements imageMemReq_resolve;
+ vkGetImageMemoryRequirements(device, m_singleMsaaImage, &imageMemReq_resolve);
+
+ result = s_renderVK->allocateMemory(&imageMemReq_resolve, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &m_singleMsaaDeviceMem);
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create texture image error: allocateMemory failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ result = vkBindImageMemory(device, m_singleMsaaImage, m_singleMsaaDeviceMem, 0);
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create texture image error: vkBindImageMemory failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ setImageMemoryBarrier(_commandBuffer, m_sampledLayout, true);
+ }
+
+ return result;
+ }
+
+ void* TextureVK::create(VkCommandBuffer _commandBuffer, const Memory* _mem, uint64_t _flags, uint8_t _skip)
+ {
+ bimg::ImageContainer imageContainer;
+
+ if (bimg::imageParse(imageContainer, _mem->data, _mem->size) )
+ {
+ const bimg::ImageBlockInfo& blockInfo = bimg::getBlockInfo(imageContainer.m_format);
+ const uint8_t startLod = bx::min<uint8_t>(_skip, imageContainer.m_numMips - 1);
+
+ bimg::TextureInfo ti;
+ bimg::imageGetSize(
+ &ti
+ , uint16_t(imageContainer.m_width >> startLod)
+ , uint16_t(imageContainer.m_height >> startLod)
+ , uint16_t(imageContainer.m_depth >> startLod)
+ , imageContainer.m_cubeMap
+ , 1 < imageContainer.m_numMips
+ , imageContainer.m_numLayers
+ , imageContainer.m_format
+ );
+
+ ti.numMips = bx::min<uint8_t>(imageContainer.m_numMips - startLod, ti.numMips);
+
+ m_flags = _flags;
+ m_width = ti.width;
+ m_height = ti.height;
+ m_depth = ti.depth;
+ m_numLayers = ti.numLayers;
+ m_requestedFormat = uint8_t(imageContainer.m_format);
+ m_textureFormat = uint8_t(getViableTextureFormat(imageContainer) );
+ m_format = bimg::isDepth(bimg::TextureFormat::Enum(m_textureFormat) )
+ ? s_textureFormat[m_textureFormat].m_fmtDsv
+ : (m_flags & BGFX_TEXTURE_SRGB) ? s_textureFormat[m_textureFormat].m_fmtSrgb : s_textureFormat[m_textureFormat].m_fmt
+ ;
+ m_components = s_textureFormat[m_textureFormat].m_mapping;
+
+ const bool convert = m_textureFormat != m_requestedFormat;
+ const uint8_t bpp = bimg::getBitsPerPixel(bimg::TextureFormat::Enum(m_textureFormat) );
+
+ m_aspectMask = getAspectMask(m_format);
+ m_sampler = s_msaa[bx::uint32_satsub( (m_flags & BGFX_TEXTURE_RT_MSAA_MASK) >> BGFX_TEXTURE_RT_MSAA_SHIFT, 1)];
+
+ if (imageContainer.m_cubeMap)
+ {
+ m_type = imageContainer.m_numLayers > 1
+ ? VK_IMAGE_VIEW_TYPE_CUBE_ARRAY
+ : VK_IMAGE_VIEW_TYPE_CUBE
+ ;
+ }
+ else if (imageContainer.m_depth > 1)
+ {
+ m_type = VK_IMAGE_VIEW_TYPE_3D;
+ }
+ else if (imageContainer.m_numLayers > 1)
+ {
+ m_type = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
+ }
+ else
+ {
+ m_type = VK_IMAGE_VIEW_TYPE_2D;
+ }
+
+ m_numMips = ti.numMips;
+ m_numSides = ti.numLayers * (imageContainer.m_cubeMap ? 6 : 1);
+ const uint16_t numSides = ti.numLayers * (imageContainer.m_cubeMap ? 6 : 1);
+ const uint32_t numSrd = numSides * ti.numMips;
+
+ uint32_t kk = 0;
+
+ const bool compressed = bimg::isCompressed(bimg::TextureFormat::Enum(m_textureFormat) );
+ const bool swizzle = TextureFormat::BGRA8 == m_textureFormat && 0 != (m_flags & BGFX_TEXTURE_COMPUTE_WRITE);
+
+ const bool writeOnly = 0 != (m_flags & BGFX_TEXTURE_RT_WRITE_ONLY);
+ const bool computeWrite = 0 != (m_flags & BGFX_TEXTURE_COMPUTE_WRITE);
+ const bool renderTarget = 0 != (m_flags & BGFX_TEXTURE_RT_MASK);
+ const bool blit = 0 != (m_flags & BGFX_TEXTURE_BLIT_DST);
+
+ BX_UNUSED(swizzle, writeOnly, computeWrite, renderTarget, blit);
+
+ BX_TRACE(
+ "Texture %3d: %s (requested: %s), %dx%dx%d%s RT[%c], BO[%c], CW[%c]%s."
+ , (int)(this - s_renderVK->m_textures)
+ , getName( (TextureFormat::Enum)m_textureFormat)
+ , getName( (TextureFormat::Enum)m_requestedFormat)
+ , ti.width
+ , ti.height
+ , ti.depth
+ , imageContainer.m_cubeMap ? "x6" : ""
+ , renderTarget ? 'x' : ' '
+ , writeOnly ? 'x' : ' '
+ , computeWrite ? 'x' : ' '
+ , swizzle ? " (swizzle BGRA8 -> RGBA8)" : ""
+ );
+
+ VK_CHECK(createImages(_commandBuffer) );
+
+ // decode images
+ struct ImageInfo
+ {
+ uint8_t* data;
+ uint32_t width;
+ uint32_t height;
+ uint32_t depth;
+ uint32_t pitch;
+ uint32_t slice;
+ uint32_t size;
+ uint8_t mipLevel;
+ uint8_t layer;
+ };
+
+ ImageInfo* imageInfos = (ImageInfo*)BX_ALLOC(g_allocator, sizeof(ImageInfo) * numSrd);
+ bx::memSet(imageInfos, 0, sizeof(ImageInfo) * numSrd);
+ uint32_t alignment = 1; // tightly aligned buffer
+
+ for (uint8_t side = 0; side < numSides; ++side)
+ {
+ for (uint8_t lod = 0; lod < ti.numMips; ++lod)
+ {
+ bimg::ImageMip mip;
+
+ if (bimg::imageGetRawData(imageContainer, side, lod + startLod, _mem->data, _mem->size, mip) )
+ {
+ if (convert)
+ {
+ const uint32_t pitch = bx::strideAlign(bx::max<uint32_t>(mip.m_width, 4) * bpp / 8, alignment);
+ const uint32_t slice = bx::strideAlign(bx::max<uint32_t>(mip.m_height, 4) * pitch, alignment);
+ const uint32_t size = slice * mip.m_depth;
+
+ uint8_t* temp = (uint8_t*)BX_ALLOC(g_allocator, size);
+ bimg::imageDecodeToBgra8(
+ g_allocator
+ , temp
+ , mip.m_data
+ , mip.m_width
+ , mip.m_height
+ , pitch
+ , mip.m_format
+ );
+
+ imageInfos[kk].data = temp;
+ imageInfos[kk].width = mip.m_width;
+ imageInfos[kk].height = mip.m_height;
+ imageInfos[kk].depth = mip.m_depth;
+ imageInfos[kk].pitch = pitch;
+ imageInfos[kk].slice = slice;
+ imageInfos[kk].size = size;
+ imageInfos[kk].mipLevel = lod;
+ imageInfos[kk].layer = side;
+ }
+ else if (compressed)
+ {
+ const uint32_t pitch = bx::strideAlign( (mip.m_width / blockInfo.blockWidth) * mip.m_blockSize, alignment);
+ const uint32_t slice = bx::strideAlign( (mip.m_height / blockInfo.blockHeight) * pitch, alignment);
+ const uint32_t size = slice * mip.m_depth;
+
+ uint8_t* temp = (uint8_t*)BX_ALLOC(g_allocator, size);
+ bimg::imageCopy(
+ temp
+ , mip.m_height / blockInfo.blockHeight
+ , (mip.m_width / blockInfo.blockWidth) * mip.m_blockSize
+ , mip.m_depth
+ , mip.m_data
+ , pitch
+ );
+
+ imageInfos[kk].data = temp;
+ imageInfos[kk].width = mip.m_width;
+ imageInfos[kk].height = mip.m_height;
+ imageInfos[kk].depth = mip.m_depth;
+ imageInfos[kk].pitch = pitch;
+ imageInfos[kk].slice = slice;
+ imageInfos[kk].size = size;
+ imageInfos[kk].mipLevel = lod;
+ imageInfos[kk].layer = side;
+ }
+ else
+ {
+ const uint32_t pitch = bx::strideAlign(mip.m_width * mip.m_bpp / 8, alignment);
+ const uint32_t slice = bx::strideAlign(mip.m_height * pitch, alignment);
+ const uint32_t size = slice * mip.m_depth;
+
+ uint8_t* temp = (uint8_t*)BX_ALLOC(g_allocator, size);
+ bimg::imageCopy(
+ temp
+ , mip.m_height
+ , mip.m_width * mip.m_bpp / 8
+ , mip.m_depth
+ , mip.m_data
+ , pitch
+ );
+
+ imageInfos[kk].data = temp;
+ imageInfos[kk].width = mip.m_width;
+ imageInfos[kk].height = mip.m_height;
+ imageInfos[kk].depth = mip.m_depth;
+ imageInfos[kk].pitch = pitch;
+ imageInfos[kk].slice = slice;
+ imageInfos[kk].size = size;
+ imageInfos[kk].mipLevel = lod;
+ imageInfos[kk].layer = side;
+ }
+ }
+ ++kk;
+ }
+ }
+
+ uint32_t totalMemSize = 0;
+ VkBufferImageCopy* bufferCopyInfo = (VkBufferImageCopy*)BX_ALLOC(g_allocator, sizeof(VkBufferImageCopy) * numSrd);
+
+ for (uint32_t ii = 0; ii < numSrd; ++ii)
+ {
+ const uint32_t idealWidth = bx::max<uint32_t>(1, m_width >> imageInfos[ii].mipLevel);
+ const uint32_t idealHeight = bx::max<uint32_t>(1, m_height >> imageInfos[ii].mipLevel);
+ bufferCopyInfo[ii].bufferOffset = totalMemSize;
+ bufferCopyInfo[ii].bufferRowLength = 0; // assume that image data are tightly aligned
+ bufferCopyInfo[ii].bufferImageHeight = 0; // assume that image data are tightly aligned
+ bufferCopyInfo[ii].imageSubresource.aspectMask = m_aspectMask;
+ bufferCopyInfo[ii].imageSubresource.mipLevel = imageInfos[ii].mipLevel;
+ bufferCopyInfo[ii].imageSubresource.baseArrayLayer = imageInfos[ii].layer;
+ bufferCopyInfo[ii].imageSubresource.layerCount = 1;
+ bufferCopyInfo[ii].imageOffset = { 0, 0, 0 };
+ bufferCopyInfo[ii].imageExtent = { idealWidth, idealHeight, imageInfos[ii].depth };
+ totalMemSize += imageInfos[ii].size;
+ }
+
+ if (totalMemSize > 0)
+ {
+ const VkDevice device = s_renderVK->m_device;
+
+ VkBuffer stagingBuffer;
+ VkDeviceMemory stagingDeviceMem;
+ VK_CHECK(s_renderVK->createStagingBuffer(totalMemSize, &stagingBuffer, &stagingDeviceMem) );
+
+ uint8_t* mappedMemory;
+ VK_CHECK(vkMapMemory(
+ device
+ , stagingDeviceMem
+ , 0
+ , totalMemSize
+ , 0
+ , (void**)&mappedMemory
+ ) );
+
+ // copy image to staging buffer
+ for (uint32_t ii = 0; ii < numSrd; ++ii)
+ {
+ bx::memCopy(mappedMemory, imageInfos[ii].data, imageInfos[ii].size);
+ mappedMemory += imageInfos[ii].size;
+ }
+
+ vkUnmapMemory(device, stagingDeviceMem);
+
+ copyBufferToTexture(_commandBuffer, stagingBuffer, numSrd, bufferCopyInfo);
+
+ s_renderVK->release(stagingBuffer);
+ s_renderVK->release(stagingDeviceMem);
+ }
+ else
+ {
+ setImageMemoryBarrier(_commandBuffer, m_sampledLayout);
+ }
+
+ BX_FREE(g_allocator, bufferCopyInfo);
+
+ for (uint32_t ii = 0; ii < numSrd; ++ii)
+ {
+ BX_FREE(g_allocator, imageInfos[ii].data);
+ }
+
+ BX_FREE(g_allocator, imageInfos);
+
+ m_readback.create(m_textureImage, m_width, m_height, TextureFormat::Enum(m_textureFormat) );
+ }
+
+ return m_directAccessPtr;
+ }
+
void TextureVK::destroy()
{
+ m_readback.destroy();
+
+ if (VK_NULL_HANDLE != m_textureImage)
+ {
+ s_renderVK->release(m_textureImage);
+ s_renderVK->release(m_textureDeviceMem);
+ }
+
+ if (VK_NULL_HANDLE != m_singleMsaaImage)
+ {
+ s_renderVK->release(m_singleMsaaImage);
+ s_renderVK->release(m_singleMsaaDeviceMem);
+ }
+
+ m_currentImageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+ m_currentSingleMsaaImageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+ }
+
+ void TextureVK::update(VkCommandBuffer _commandBuffer, uint8_t _side, uint8_t _mip, const Rect& _rect, uint16_t _z, uint16_t _depth, uint16_t _pitch, const Memory* _mem)
+ {
+ const uint32_t bpp = bimg::getBitsPerPixel(bimg::TextureFormat::Enum(m_textureFormat) );
+ uint32_t rectpitch = _rect.m_width * bpp / 8;
+ uint32_t slicepitch = rectpitch * _rect.m_height;
+ if (bimg::isCompressed(bimg::TextureFormat::Enum(m_textureFormat) ) )
+ {
+ const bimg::ImageBlockInfo& blockInfo = bimg::getBlockInfo(bimg::TextureFormat::Enum(m_textureFormat) );
+ rectpitch = (_rect.m_width / blockInfo.blockWidth ) * blockInfo.blockSize;
+ slicepitch = (_rect.m_height / blockInfo.blockHeight) * rectpitch;
+ }
+ const uint32_t srcpitch = UINT16_MAX == _pitch ? rectpitch : _pitch;
+ const uint32_t size = UINT16_MAX == _pitch ? slicepitch * _depth: _rect.m_height * _pitch * _depth;
+ const bool convert = m_textureFormat != m_requestedFormat;
+
+ VkBufferImageCopy region;
+ region.bufferOffset = 0;
+ region.bufferRowLength = (_pitch == UINT16_MAX ? 0 : _pitch * 8 / bpp);
+ region.bufferImageHeight = 0;
+ region.imageSubresource.aspectMask = m_aspectMask;
+ region.imageSubresource.mipLevel = _mip;
+ region.imageSubresource.baseArrayLayer = 0;
+ region.imageSubresource.layerCount = 1;
+ region.imageOffset = { _rect.m_x, _rect.m_y, 0 };
+ region.imageExtent = { _rect.m_width, _rect.m_height, _depth };
+
+ uint8_t* data = _mem->data;
+ uint8_t* temp = NULL;
+
+ if (convert)
+ {
+ temp = (uint8_t*)BX_ALLOC(g_allocator, slicepitch);
+ bimg::imageDecodeToBgra8(g_allocator, temp, data, _rect.m_width, _rect.m_height, srcpitch, bimg::TextureFormat::Enum(m_requestedFormat));
+ data = temp;
+
+ region.imageExtent =
+ {
+ bx::max(1u, m_width >> _mip),
+ bx::max(1u, m_height >> _mip),
+ _depth,
+ };
+ }
+
+ VkBuffer stagingBuffer = VK_NULL_HANDLE;
+ VkDeviceMemory stagingDeviceMem = VK_NULL_HANDLE;
+ VK_CHECK(s_renderVK->createStagingBuffer(size, &stagingBuffer, &stagingDeviceMem, data) );
+
+ if (VK_IMAGE_VIEW_TYPE_3D == m_type)
+ {
+ region.imageOffset.z = _z;
+ }
+ else if (VK_IMAGE_VIEW_TYPE_CUBE == m_type
+ || VK_IMAGE_VIEW_TYPE_CUBE_ARRAY == m_type)
+ {
+ region.imageSubresource.baseArrayLayer = _z * 6 + _side;
+ }
+ else
+ {
+ region.imageSubresource.baseArrayLayer = _z;
+ }
+
+ copyBufferToTexture(_commandBuffer, stagingBuffer, 1, &region);
+
+ s_renderVK->release(stagingBuffer);
+ s_renderVK->release(stagingDeviceMem);
+
+ if (NULL != temp)
+ {
+ BX_FREE(g_allocator, temp);
+ }
+ }
+
+ void TextureVK::resolve(VkCommandBuffer _commandBuffer, uint8_t _resolve, uint32_t _layer, uint32_t _numLayers, uint32_t _mip)
+ {
+ const bool needResolve = VK_NULL_HANDLE != m_singleMsaaImage;
+
+ const bool needMipGen = true
+ && !needResolve
+ && 0 != (m_flags & BGFX_TEXTURE_RT_MASK)
+ && 0 == (m_flags & BGFX_TEXTURE_RT_WRITE_ONLY)
+ && (_mip + 1) < m_numMips
+ && 0 != (_resolve & BGFX_RESOLVE_AUTO_GEN_MIPS);
+
+ const VkImageLayout oldLayout = m_currentImageLayout;
+ const VkImageLayout oldSingleMsaaLayout = m_currentSingleMsaaImageLayout;
+
+ if (needResolve)
+ {
+ setImageMemoryBarrier(_commandBuffer, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
+ setImageMemoryBarrier(_commandBuffer, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, true);
+
+ VkImageResolve resolve;
+ resolve.srcOffset.x = 0;
+ resolve.srcOffset.y = 0;
+ resolve.srcOffset.z = 0;
+ resolve.dstOffset.x = 0;
+ resolve.dstOffset.y = 0;
+ resolve.dstOffset.z = 0;
+ resolve.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+ resolve.srcSubresource.mipLevel = _mip;
+ resolve.srcSubresource.baseArrayLayer = _layer;
+ resolve.srcSubresource.layerCount = _numLayers;
+ resolve.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+ resolve.dstSubresource.mipLevel = _mip;
+ resolve.dstSubresource.baseArrayLayer = _layer;
+ resolve.dstSubresource.layerCount = _numLayers;
+ resolve.extent.width = m_width;
+ resolve.extent.height = m_height;
+ resolve.extent.depth = 1;
+
+ vkCmdResolveImage(
+ _commandBuffer
+ , m_textureImage
+ , VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL
+ , m_singleMsaaImage
+ , VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
+ , 1
+ , &resolve
+ );
+ }
+
+ if (needMipGen)
+ {
+ setImageMemoryBarrier(_commandBuffer, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+
+ int32_t mipWidth = bx::max<int32_t>(int32_t(m_width) >> _mip, 1);
+ int32_t mipHeight = bx::max<int32_t>(int32_t(m_height) >> _mip, 1);
+
+ const VkFilter filter = bimg::isDepth(bimg::TextureFormat::Enum(m_textureFormat) )
+ ? VK_FILTER_NEAREST
+ : VK_FILTER_LINEAR
+ ;
+
+ VkImageBlit blit;
+ blit.srcOffsets[0] = { 0, 0, 0 };
+ blit.srcOffsets[1] = { mipWidth, mipHeight, 1 };
+ blit.srcSubresource.aspectMask = m_aspectMask;
+ blit.srcSubresource.mipLevel = 0;
+ blit.srcSubresource.baseArrayLayer = _layer;
+ blit.srcSubresource.layerCount = _numLayers;
+ blit.dstOffsets[0] = { 0, 0, 0 };
+ blit.dstOffsets[1] = { mipWidth, mipHeight, 1 };
+ blit.dstSubresource.aspectMask = m_aspectMask;
+ blit.dstSubresource.mipLevel = 0;
+ blit.dstSubresource.baseArrayLayer = _layer;
+ blit.dstSubresource.layerCount = _numLayers;
+
+ for (uint32_t i = _mip + 1; i < m_numMips; i++)
+ {
+ blit.srcOffsets[1] = { mipWidth, mipHeight, 1 };
+ blit.srcSubresource.mipLevel = i - 1;
+
+ mipWidth = bx::uint32_max(mipWidth >> 1, 1);
+ mipHeight = bx::uint32_max(mipHeight >> 1, 1);
+
+ blit.dstOffsets[1] = { mipWidth, mipHeight, 1 };
+ blit.dstSubresource.mipLevel = i;
+
+ vk::setImageMemoryBarrier(
+ _commandBuffer
+ , m_textureImage
+ , m_aspectMask
+ , VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
+ , VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL
+ , blit.srcSubresource.mipLevel
+ , 1
+ , _layer
+ , _numLayers
+ );
+
+ vkCmdBlitImage(
+ _commandBuffer
+ , m_textureImage
+ , VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL
+ , m_textureImage
+ , VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
+ , 1
+ , &blit
+ , filter
+ );
+ }
+
+ vk::setImageMemoryBarrier(
+ _commandBuffer
+ , m_textureImage
+ , m_aspectMask
+ , VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL
+ , VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
+ , _mip
+ , m_numMips - _mip - 1
+ , _layer
+ , _numLayers
+ );
+ }
+
+ setImageMemoryBarrier(_commandBuffer, oldLayout);
+ setImageMemoryBarrier(_commandBuffer, oldSingleMsaaLayout, true);
+ }
+
+ void TextureVK::copyBufferToTexture(VkCommandBuffer _commandBuffer, VkBuffer _stagingBuffer, uint32_t _bufferImageCopyCount, VkBufferImageCopy* _bufferImageCopy)
+ {
+ const VkImageLayout oldLayout = m_currentImageLayout == VK_IMAGE_LAYOUT_UNDEFINED
+ ? m_sampledLayout
+ : m_currentImageLayout
+ ;
+
+ setImageMemoryBarrier(_commandBuffer, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+
+ vkCmdCopyBufferToImage(
+ _commandBuffer
+ , _stagingBuffer
+ , m_textureImage
+ , VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
+ , _bufferImageCopyCount
+ , _bufferImageCopy
+ );
+
+ setImageMemoryBarrier(_commandBuffer, oldLayout);
+ }
+
+ VkImageLayout TextureVK::setImageMemoryBarrier(VkCommandBuffer _commandBuffer, VkImageLayout _newImageLayout, bool _singleMsaaImage)
+ {
+ if (_singleMsaaImage && VK_NULL_HANDLE == m_singleMsaaImage)
+ {
+ return VK_IMAGE_LAYOUT_UNDEFINED;
+ }
+
+ VkImageLayout& currentLayout = _singleMsaaImage
+ ? m_currentSingleMsaaImageLayout
+ : m_currentImageLayout
+ ;
+
+ const VkImageLayout oldLayout = currentLayout;
+
+ if (currentLayout == _newImageLayout)
+ {
+ return oldLayout;
+ }
+
+ const VkImage image = _singleMsaaImage
+ ? m_singleMsaaImage
+ : m_textureImage
+ ;
+
+ vk::setImageMemoryBarrier(
+ _commandBuffer
+ , image
+ , m_aspectMask
+ , currentLayout
+ , _newImageLayout
+ );
+
+ currentLayout = _newImageLayout;
+ return oldLayout;
+ }
+
+ VkResult TextureVK::createView(uint32_t _layer, uint32_t _numLayers, uint32_t _mip, uint32_t _numMips, VkImageViewType _type, VkImageAspectFlags _aspectMask, bool _renderTarget, ::VkImageView* _view) const
+ {
+ VkResult result = VK_SUCCESS;
+
+ if (VK_IMAGE_VIEW_TYPE_3D == m_type)
+ {
+ BX_ASSERT(false
+ || !_renderTarget
+ || !(m_aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) )
+ , "3D image can't be a depth attachment"
+ );
+ }
+
+ if (VK_IMAGE_VIEW_TYPE_CUBE == _type
+ || VK_IMAGE_VIEW_TYPE_CUBE_ARRAY == _type)
+ {
+ BX_ASSERT(_numLayers % 6 == 0, "");
+ BX_ASSERT(
+ VK_IMAGE_VIEW_TYPE_3D != m_type
+ , "3D image can't be aliased as a cube texture"
+ );
+ }
+
+ VkImageViewCreateInfo viewInfo;
+ viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+ viewInfo.pNext = NULL;
+ viewInfo.flags = 0;
+ viewInfo.image = ((VK_NULL_HANDLE != m_singleMsaaImage) && !_renderTarget)
+ ? m_singleMsaaImage
+ : m_textureImage
+ ;
+ viewInfo.viewType = _type;
+ viewInfo.format = m_format;
+ viewInfo.components = m_components;
+ viewInfo.subresourceRange.aspectMask = m_aspectMask & _aspectMask;
+ viewInfo.subresourceRange.baseMipLevel = _mip;
+ viewInfo.subresourceRange.levelCount = _numMips;
+ viewInfo.subresourceRange.baseArrayLayer = _layer;
+ viewInfo.subresourceRange.layerCount = 1;
+
+ if (VK_IMAGE_VIEW_TYPE_2D != _type
+ && VK_IMAGE_VIEW_TYPE_3D != _type)
+ {
+ viewInfo.subresourceRange.layerCount = VK_IMAGE_VIEW_TYPE_CUBE == _type
+ ? 6
+ : _numLayers
+ ;
+ }
+
+ VkImageView view = VK_NULL_HANDLE;
+
+ result = vkCreateImageView(
+ s_renderVK->m_device
+ , &viewInfo
+ , s_renderVK->m_allocatorCb
+ , &view
+ );
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create texture view error: vkCreateImageView failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ *_view = view;
+
+ return result;
+ }
+
+ VkImageAspectFlags TextureVK::getAspectMask(VkFormat _format)
+ {
+ switch (_format)
+ {
+ case VK_FORMAT_S8_UINT:
+ return VK_IMAGE_ASPECT_STENCIL_BIT;
+ break;
+ case VK_FORMAT_D16_UNORM:
+ case VK_FORMAT_X8_D24_UNORM_PACK32:
+ case VK_FORMAT_D32_SFLOAT:
+ return VK_IMAGE_ASPECT_DEPTH_BIT;
+ case VK_FORMAT_D16_UNORM_S8_UINT:
+ case VK_FORMAT_D24_UNORM_S8_UINT:
+ case VK_FORMAT_D32_SFLOAT_S8_UINT:
+ return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
+ default:
+ return VK_IMAGE_ASPECT_COLOR_BIT;
+ }
+ }
+
+ VkResult SwapChainVK::create(VkCommandBuffer _commandBuffer, void* _nwh, const Resolution& _resolution, TextureFormat::Enum _depthFormat)
+ {
+ struct ErrorState
+ {
+ enum Enum
+ {
+ Default,
+ SurfaceCreated,
+ SwapChainCreated,
+ AttachmentsCreated
+ };
+ };
+
+ ErrorState::Enum errorState = ErrorState::Default;
+
+ VkResult result = VK_SUCCESS;
+
+ if (NULL == _nwh)
+ {
+ return result;
+ }
+
+ m_nwh = _nwh;
+ m_resolution = _resolution;
+ m_depthFormat = TextureFormat::Count == _depthFormat ? TextureFormat::D24S8 : _depthFormat;
+
+ m_queue = s_renderVK->m_globalQueue;
+
+ result = createSurface();
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create swap chain error: creating surface failed %d: %s.", result, getName(result) );
+ goto error;
+ }
+
+ errorState = ErrorState::SurfaceCreated;
+
+ {
+ m_sci.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
+ m_sci.pNext = NULL;
+ m_sci.flags = 0;
+ m_sci.imageArrayLayers = 1;
+ m_sci.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
+ m_sci.queueFamilyIndexCount = 0;
+ m_sci.pQueueFamilyIndices = NULL;
+ m_sci.preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
+ m_sci.oldSwapchain = VK_NULL_HANDLE;
+
+ for (uint32_t ii = 0; ii < BX_COUNTOF(m_backBufferColorImageView); ++ii)
+ {
+ m_backBufferColorImage[ii] = VK_NULL_HANDLE;
+ m_backBufferColorImageView[ii] = VK_NULL_HANDLE;
+ m_backBufferFrameBuffer[ii] = VK_NULL_HANDLE;
+ m_backBufferFence[ii] = VK_NULL_HANDLE;
+ m_presentDoneSemaphore[ii] = VK_NULL_HANDLE;
+ m_renderDoneSemaphore[ii] = VK_NULL_HANDLE;
+ }
+
+ m_lastImageRenderedSemaphore = VK_NULL_HANDLE;
+ m_lastImageAcquiredSemaphore = VK_NULL_HANDLE;
+
+ result = createSwapChain();
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create swap chain error: creating swapchain and image views failed %d: %s", result, getName(result) );
+ goto error;
+ }
+ }
+
+ errorState = ErrorState::SwapChainCreated;
+
+ {
+ result = createAttachments(_commandBuffer);
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create swap chain error: creating MSAA/depth attachments failed %d: %s.", result, getName(result) );
+ goto error;
+ }
+ }
+
+ errorState = ErrorState::AttachmentsCreated;
+
+ {
+ result = createFrameBuffer();
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create swap chain error: creating frame buffers failed %d: %s.", result, getName(result) );
+ goto error;
+ }
+ }
+
+ return VK_SUCCESS;
+
+ error:
+ BX_TRACE("errorState %d", errorState);
+ switch (errorState)
+ {
+ case ErrorState::AttachmentsCreated:
+ releaseAttachments();
+ BX_FALLTHROUGH;
+
+ case ErrorState::SwapChainCreated:
+ releaseSwapChain();
+ BX_FALLTHROUGH;
+
+ case ErrorState::SurfaceCreated:
+ releaseSurface();
+ BX_FALLTHROUGH;
+
+ case ErrorState::Default:
+ break;
+ };
+
+ return VK_SUCCESS != result
+ ? result
+ : VK_ERROR_INITIALIZATION_FAILED
+ ;
+ }
+
+ void SwapChainVK::destroy()
+ {
+ if (VK_NULL_HANDLE != m_swapchain)
+ {
+ releaseFrameBuffer();
+ releaseAttachments();
+ releaseSwapChain();
+ releaseSurface();
+
+ // can't delay-delete the surface, since there can only be one swapchain per surface
+ // new framebuffer with the same window would get an error at swapchain creation
+ s_renderVK->kick(true);
+ }
+
+ m_nwh = NULL;
+ }
+
+ void SwapChainVK::update(VkCommandBuffer _commandBuffer, void* _nwh, const Resolution& _resolution)
+ {
+ const VkPhysicalDevice physicalDevice = s_renderVK->m_physicalDevice;
+
+ m_lastImageRenderedSemaphore = VK_NULL_HANDLE;
+ m_lastImageAcquiredSemaphore = VK_NULL_HANDLE;
+
+ const uint64_t recreateSurfaceMask = BGFX_RESET_HIDPI;
+ const uint64_t recreateSwapchainMask = BGFX_RESET_VSYNC | BGFX_RESET_SRGB_BACKBUFFER;
+ const uint64_t recreateAttachmentsMask = BGFX_RESET_MSAA_MASK;
+
+ const bool recreateSurface = false
+ || m_needToRecreateSurface
+ || m_nwh != _nwh
+ || (m_resolution.reset & recreateSurfaceMask) != (_resolution.reset & recreateSurfaceMask)
+ ;
+
+ const bool recreateSwapchain = false
+ || m_needToRecreateSwapchain
+ || m_resolution.format != _resolution.format
+ || m_resolution.width != _resolution.width
+ || m_resolution.height != _resolution.height
+ || (m_resolution.reset & recreateSwapchainMask) != (_resolution.reset & recreateSwapchainMask)
+ || recreateSurface
+ ;
+
+ const bool recreateAttachments = false
+ || (m_resolution.reset & recreateAttachmentsMask) != (_resolution.reset & recreateAttachmentsMask)
+ || recreateSwapchain
+ ;
+
+ m_nwh = _nwh;
+ m_resolution = _resolution;
+
+ if (recreateAttachments)
+ {
+ releaseFrameBuffer();
+ releaseAttachments();
+
+ if (recreateSwapchain)
+ {
+ releaseSwapChain();
+
+ if (recreateSurface)
+ {
+ m_sci.oldSwapchain = VK_NULL_HANDLE;
+ releaseSurface();
+ s_renderVK->kick(true);
+ _commandBuffer = s_renderVK->m_commandBuffer;
+
+ VkResult result = createSurface();
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Surface lost.");
+ return;
+ }
+ }
+
+ VkSurfaceCapabilitiesKHR surfaceCapabilities;
+ VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, m_surface, &surfaceCapabilities) );
+
+ const uint32_t width = bx::clamp<uint32_t>(
+ m_resolution.width
+ , surfaceCapabilities.minImageExtent.width
+ , surfaceCapabilities.maxImageExtent.width
+ );
+ const uint32_t height = bx::clamp<uint32_t>(
+ m_resolution.height
+ , surfaceCapabilities.minImageExtent.height
+ , surfaceCapabilities.maxImageExtent.height
+ );
+
+ // swapchain can't have size 0
+ // on some platforms this happens when minimized
+ if (width == 0
+ || height == 0)
+ {
+ m_sci.oldSwapchain = VK_NULL_HANDLE;
+ s_renderVK->kick(true);
+ return;
+ }
+
+ VK_CHECK(createSwapChain() );
+ }
+
+ VK_CHECK(createAttachments(_commandBuffer) );
+ VK_CHECK(createFrameBuffer() );
+ }
+ }
+
+ VkResult SwapChainVK::createSurface()
+ {
+ VkResult result = VK_ERROR_INITIALIZATION_FAILED;
+
+ const VkInstance instance = s_renderVK->m_instance;
+ const VkAllocationCallbacks* allocatorCb = s_renderVK->m_allocatorCb;
+
+#if BX_PLATFORM_WINDOWS
+ {
+ if (NULL != vkCreateWin32SurfaceKHR)
+ {
+ VkWin32SurfaceCreateInfoKHR sci;
+ sci.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
+ sci.pNext = NULL;
+ sci.flags = 0;
+ sci.hinstance = (HINSTANCE)GetModuleHandle(NULL);
+ sci.hwnd = (HWND)m_nwh;
+ result = vkCreateWin32SurfaceKHR(instance, &sci, allocatorCb, &m_surface);
+ }
+ }
+#elif BX_PLATFORM_ANDROID
+ {
+ if (NULL != vkCreateAndroidSurfaceKHR)
+ {
+ VkAndroidSurfaceCreateInfoKHR sci;
+ sci.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
+ sci.pNext = NULL;
+ sci.flags = 0;
+ sci.window = (ANativeWindow*)m_nwh;
+ result = vkCreateAndroidSurfaceKHR(instance, &sci, allocatorCb, &m_surface);
+ }
+ }
+#elif BX_PLATFORM_LINUX
+ {
+ if (g_platformData.type == bgfx::NativeWindowHandleType::Wayland)
+ {
+ BGFX_FATAL(s_extension[Extension::KHR_wayland_surface].m_supported, Fatal::UnableToInitialize, VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME " not supported");
+ BGFX_FATAL(NULL != vkCreateWaylandSurfaceKHR, Fatal::UnableToInitialize, "vkCreateWaylandSurfaceKHR == 0");
+ BX_TRACE("Attempting Wayland surface creation.");
+ VkWaylandSurfaceCreateInfoKHR sci;
+ sci.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR;
+ sci.pNext = NULL;
+ sci.flags = 0;
+ sci.display = (wl_display*)g_platformData.ndt;
+ sci.surface = (wl_surface*)m_nwh;
+ result = vkCreateWaylandSurfaceKHR(instance, &sci, allocatorCb, &m_surface);
+ }
+ else
+ {
+ if (s_extension[Extension::KHR_xlib_surface].m_supported)
+ {
+ BGFX_FATAL(NULL != vkCreateXlibSurfaceKHR, Fatal::UnableToInitialize, "vkCreateXlibSurfaceKHR == 0")
+ BX_TRACE("Attempting Xlib surface creation.");
+ VkXlibSurfaceCreateInfoKHR sci;
+ sci.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
+ sci.pNext = NULL;
+ sci.flags = 0;
+ sci.dpy = (Display*)g_platformData.ndt;
+ sci.window = (Window)m_nwh;
+ result = vkCreateXlibSurfaceKHR(instance, &sci, allocatorCb, &m_surface);
+ }
+
+ if (VK_SUCCESS != result && s_extension[Extension::KHR_xcb_surface].m_supported)
+ {
+ void* xcbdll = bx::dlopen("libX11-xcb.so.1");
+
+ if (NULL != xcbdll
+ && NULL != vkCreateXcbSurfaceKHR)
+ {
+ typedef xcb_connection_t* (*PFN_XGETXCBCONNECTION)(Display*);
+ PFN_XGETXCBCONNECTION XGetXCBConnection = (PFN_XGETXCBCONNECTION)bx::dlsym(xcbdll, "XGetXCBConnection");
+
+ union { void* ptr; xcb_window_t window; } cast = { m_nwh };
+
+ BGFX_FATAL(NULL != vkCreateXcbSurfaceKHR, Fatal::UnableToInitialize, "vkCreateXcbSurfaceKHR == 0")
+
+ VkXcbSurfaceCreateInfoKHR sci;
+ sci.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
+ sci.pNext = NULL;
+ sci.flags = 0;
+ sci.connection = XGetXCBConnection( (Display*)g_platformData.ndt);
+ sci.window = cast.window;
+ result = vkCreateXcbSurfaceKHR(instance, &sci, allocatorCb, &m_surface);
+
+ bx::dlclose(xcbdll);
+ }
+ }
+ }
+ }
+
+#elif BX_PLATFORM_OSX
+ {
+ if (NULL != vkCreateMacOSSurfaceMVK)
+ {
+ NSWindow* window = (NSWindow*)(m_nwh);
+ NSView* contentView = (NSView*)window.contentView;
+ CAMetalLayer* layer = [CAMetalLayer layer];
+
+ if (m_resolution.reset & BGFX_RESET_HIDPI)
+ {
+ layer.contentsScale = [window backingScaleFactor];
+ }
+
+ [contentView setWantsLayer : YES];
+ [contentView setLayer : layer];
+
+ VkMacOSSurfaceCreateInfoMVK sci;
+ sci.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
+ sci.pNext = NULL;
+ sci.flags = 0;
+ sci.pView = (__bridge void*)layer;
+ result = vkCreateMacOSSurfaceMVK(instance, &sci, allocatorCb, &m_surface);
+ }
+ }
+#else
+# error "Figure out KHR surface..."
+#endif // BX_PLATFORM_
+
+ m_needToRecreateSurface = false;
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create surface error: vkCreate[Platform]SurfaceKHR failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ const VkPhysicalDevice physicalDevice = s_renderVK->m_physicalDevice;
+ const uint32_t queueFamily = s_renderVK->m_globalQueueFamily;
+
+ VkBool32 surfaceSupported;
+ result = vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamily, m_surface, &surfaceSupported);
+
+ if (VK_SUCCESS != result
+ || !surfaceSupported)
+ {
+ BX_TRACE("Create surface error: Presentation to the given surface not supported.");
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+
+ return result;
+ }
+
+ void SwapChainVK::releaseSurface()
+ {
+ release(m_surface);
+ }
+
+ VkResult SwapChainVK::createSwapChain()
+ {
+ VkResult result = VK_SUCCESS;
+
+ const VkPhysicalDevice physicalDevice = s_renderVK->m_physicalDevice;
+ const VkDevice device = s_renderVK->m_device;
+ const VkAllocationCallbacks* allocatorCb = s_renderVK->m_allocatorCb;
+
+ VkSurfaceCapabilitiesKHR surfaceCapabilities;
+ result = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, m_surface, &surfaceCapabilities);
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create swapchain error: vkGetPhysicalDeviceSurfaceCapabilitiesKHR failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ const uint32_t minSwapBufferCount = bx::max<uint32_t>(surfaceCapabilities.minImageCount, 2);
+ const uint32_t maxSwapBufferCount = surfaceCapabilities.maxImageCount == 0
+ ? kMaxBackBuffers
+ : bx::min<uint32_t>(surfaceCapabilities.maxImageCount, kMaxBackBuffers)
+ ;
+
+ if (minSwapBufferCount > maxSwapBufferCount)
+ {
+ BX_TRACE("Create swapchain error: Incompatible swapchain image count (min: %d, max: %d, MaxBackBuffers: %d)."
+ , minSwapBufferCount
+ , maxSwapBufferCount
+ , kMaxBackBuffers
+ );
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+
+ const uint32_t swapBufferCount = bx::clamp<uint32_t>(m_resolution.numBackBuffers, minSwapBufferCount, maxSwapBufferCount);
+
+ const VkColorSpaceKHR surfaceColorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
+
+ const bool srgb = !!(m_resolution.reset & BGFX_RESET_SRGB_BACKBUFFER);
+ m_colorFormat = findSurfaceFormat(m_resolution.format, surfaceColorSpace, srgb);
+
+ if (TextureFormat::Count == m_colorFormat)
+ {
+ BX_TRACE("Create swapchain error: Unable to find surface format (srgb: %d).", srgb);
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+
+ const VkFormat surfaceFormat = srgb
+ ? s_textureFormat[m_colorFormat].m_fmtSrgb
+ : s_textureFormat[m_colorFormat].m_fmt
+ ;
+
+ const uint32_t width = bx::clamp<uint32_t>(
+ m_resolution.width
+ , surfaceCapabilities.minImageExtent.width
+ , surfaceCapabilities.maxImageExtent.width
+ );
+ const uint32_t height = bx::clamp<uint32_t>(
+ m_resolution.height
+ , surfaceCapabilities.minImageExtent.height
+ , surfaceCapabilities.maxImageExtent.height
+ );
+ if (width != m_resolution.width || height != m_resolution.height)
+ {
+ BX_TRACE("Clamped swapchain resolution from %dx%d to %dx%d"
+ , m_resolution.width
+ , m_resolution.height
+ , width
+ , height
+ );
+ }
+
+ VkCompositeAlphaFlagBitsKHR compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
+
+ if (surfaceCapabilities.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR)
+ {
+ compositeAlpha = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;
+ }
+ else if (surfaceCapabilities.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR)
+ {
+ compositeAlpha = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR;
+ }
+ else if (surfaceCapabilities.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR)
+ {
+ compositeAlpha = VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR;
+ }
+
+ const VkImageUsageFlags imageUsageMask = 0
+ | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
+ | VK_IMAGE_USAGE_TRANSFER_SRC_BIT
+ | VK_IMAGE_USAGE_TRANSFER_DST_BIT
+ ;
+ const VkImageUsageFlags imageUsage = surfaceCapabilities.supportedUsageFlags & imageUsageMask;
+
+ m_supportsReadback = 0 != (imageUsage & VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
+ m_supportsManualResolve = 0 != (imageUsage & VK_IMAGE_USAGE_TRANSFER_DST_BIT);
+
+ const bool vsync = !!(m_resolution.reset & BGFX_RESET_VSYNC);
+ uint32_t presentModeIdx = findPresentMode(vsync);
+ if (UINT32_MAX == presentModeIdx)
+ {
+ BX_TRACE("Create swapchain error: Unable to find present mode (vsync: %d).", vsync);
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+
+ m_sci.surface = m_surface;
+ m_sci.minImageCount = swapBufferCount;
+ m_sci.imageFormat = surfaceFormat;
+ m_sci.imageColorSpace = surfaceColorSpace;
+ m_sci.imageExtent.width = width;
+ m_sci.imageExtent.height = height;
+ m_sci.imageUsage = imageUsage;
+ m_sci.compositeAlpha = compositeAlpha;
+ m_sci.presentMode = s_presentMode[presentModeIdx].mode;
+ m_sci.clipped = VK_FALSE;
+
+ result = vkCreateSwapchainKHR(device, &m_sci, allocatorCb, &m_swapchain);
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create swapchain error: vkCreateSwapchainKHR failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ m_sci.oldSwapchain = m_swapchain;
+
+ result = vkGetSwapchainImagesKHR(device, m_swapchain, &m_numSwapchainImages, NULL);
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create swapchain error: vkGetSwapchainImagesKHR failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ if (m_numSwapchainImages < m_sci.minImageCount)
+ {
+ BX_TRACE("Create swapchain error: vkGetSwapchainImagesKHR: numSwapchainImages %d < minImageCount %d."
+ , m_numSwapchainImages
+ , m_sci.minImageCount
+ );
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+
+ if (m_numSwapchainImages > BX_COUNTOF(m_backBufferColorImage) )
+ {
+ BX_TRACE("Create swapchain error: vkGetSwapchainImagesKHR: numSwapchainImages %d > countof(m_backBufferColorImage) %d."
+ , m_numSwapchainImages
+ , BX_COUNTOF(m_backBufferColorImage)
+ );
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+
+ result = vkGetSwapchainImagesKHR(device, m_swapchain, &m_numSwapchainImages, &m_backBufferColorImage[0]);
+ if (VK_SUCCESS != result && VK_INCOMPLETE != result)
+ {
+ BX_TRACE("Create swapchain error: vkGetSwapchainImagesKHR failed %d: %s."
+ , result
+ , getName(result)
+ );
+ return result;
+ }
+
+ VkImageViewCreateInfo ivci;
+ ivci.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+ ivci.pNext = NULL;
+ ivci.flags = 0;
+ ivci.viewType = VK_IMAGE_VIEW_TYPE_2D;
+ ivci.format = m_sci.imageFormat;
+ ivci.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
+ ivci.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
+ ivci.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
+ ivci.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
+ ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+ ivci.subresourceRange.baseMipLevel = 0;
+ ivci.subresourceRange.levelCount = 1;
+ ivci.subresourceRange.baseArrayLayer = 0;
+ ivci.subresourceRange.layerCount = 1;
+
+ for (uint32_t ii = 0; ii < m_numSwapchainImages; ++ii)
+ {
+ ivci.image = m_backBufferColorImage[ii];
+
+ result = vkCreateImageView(device, &ivci, allocatorCb, &m_backBufferColorImageView[ii]);
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create swapchain error: vkCreateImageView failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ m_backBufferColorImageLayout[ii] = VK_IMAGE_LAYOUT_UNDEFINED;
+ }
+
+ BX_TRACE("Succesfully created swapchain (%dx%d) with %d images.", width, height, m_numSwapChainImages);
+
+ VkSemaphoreCreateInfo sci;
+ sci.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
+ sci.pNext = NULL;
+ sci.flags = 0;
+
+ for (uint32_t ii = 0; ii < m_numSwapchainImages; ++ii)
+ {
+ if (VK_SUCCESS != vkCreateSemaphore(device, &sci, allocatorCb, &m_presentDoneSemaphore[ii])
+ || VK_SUCCESS != vkCreateSemaphore(device, &sci, allocatorCb, &m_renderDoneSemaphore[ii]) )
+ {
+ BX_TRACE("Create swapchain error: vkCreateSemaphore failed %d: %s.", result, getName(result) );
+ return result;
+ }
+ }
+
+ m_backBufferColorIdx = 0;
+ m_currentSemaphore = 0;
+
+ m_needPresent = false;
+ m_needToRecreateSwapchain = false;
+
+ return result;
+ }
+
+ void SwapChainVK::releaseSwapChain()
+ {
+ for (uint32_t ii = 0; ii < BX_COUNTOF(m_backBufferColorImageView); ++ii)
+ {
+ release(m_backBufferColorImageView[ii]);
+
+ m_backBufferFence[ii] = VK_NULL_HANDLE;
+
+ release(m_presentDoneSemaphore[ii]);
+ release(m_renderDoneSemaphore[ii]);
+ }
+
+ release(m_swapchain);
+ }
+
+ VkResult SwapChainVK::createAttachments(VkCommandBuffer _commandBuffer)
+ {
+ VkResult result = VK_SUCCESS;
+
+ const uint32_t samplerIndex = (m_resolution.reset & BGFX_RESET_MSAA_MASK) >> BGFX_RESET_MSAA_SHIFT;
+ const uint64_t textureFlags = (uint64_t(samplerIndex + 1) << BGFX_TEXTURE_RT_MSAA_SHIFT) | BGFX_TEXTURE_RT | BGFX_TEXTURE_RT_WRITE_ONLY;
+ m_sampler = s_msaa[samplerIndex];
+
+ const uint16_t requiredCaps = m_sampler.Count > 1
+ ? BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER_MSAA
+ : BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER
+ ;
+
+ // the spec guarantees that at least one of D24S8 and D32FS8 is supported
+ VkFormat depthFormat = VK_FORMAT_D32_SFLOAT_S8_UINT;
+
+ if (g_caps.formats[m_depthFormat] & requiredCaps)
+ {
+ depthFormat = s_textureFormat[m_depthFormat].m_fmtDsv;
+ }
+ else if (g_caps.formats[TextureFormat::D24S8] & requiredCaps)
+ {
+ depthFormat = s_textureFormat[TextureFormat::D24S8].m_fmtDsv;
+ }
+
+ result = m_backBufferDepthStencil.create(
+ _commandBuffer
+ , m_sci.imageExtent.width
+ , m_sci.imageExtent.height
+ , textureFlags
+ , depthFormat
+ );
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create swapchain error: creating depth stencil image failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ result = m_backBufferDepthStencil.createView(0, 1, 0, 1, VK_IMAGE_VIEW_TYPE_2D, m_backBufferDepthStencil.m_aspectMask, true, &m_backBufferDepthStencilImageView);
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create swapchain error: creating depth stencil image view failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ if (m_sampler.Count > 1)
+ {
+ result = m_backBufferColorMsaa.create(
+ _commandBuffer
+ , m_sci.imageExtent.width
+ , m_sci.imageExtent.height
+ , textureFlags
+ , m_sci.imageFormat
+ );
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create swapchain error: creating MSAA color image failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ result = m_backBufferColorMsaa.createView(0, 1, 0, 1, VK_IMAGE_VIEW_TYPE_2D, m_backBufferColorMsaa.m_aspectMask, true, &m_backBufferColorMsaaImageView);
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create swapchain error: creating MSAA color image view failed %d: %s.", result, getName(result) );
+ return result;
+ }
+ }
+
+ return result;
+ }
+
+ void SwapChainVK::releaseAttachments()
+ {
+ release(m_backBufferDepthStencilImageView);
+ release(m_backBufferColorMsaaImageView);
+
+ m_backBufferDepthStencil.destroy();
+ m_backBufferColorMsaa.destroy();
+ }
+
+ VkResult SwapChainVK::createFrameBuffer()
+ {
+ VkResult result = VK_SUCCESS;
+
+ const VkDevice device = s_renderVK->m_device;
+ const VkAllocationCallbacks* allocatorCb = s_renderVK->m_allocatorCb;
+
+ VkRenderPass renderPass;
+ result = s_renderVK->getRenderPass(*this, &renderPass);
+
+ if (VK_SUCCESS != result)
+ {
+ return result;
+ }
+
+ for (uint32_t ii = 0; ii < m_numSwapchainImages; ++ii)
+ {
+ uint32_t numAttachments = 2;
+ ::VkImageView attachments[3] =
+ {
+ m_sampler.Count > 1
+ ? m_backBufferColorMsaaImageView
+ : m_backBufferColorImageView[ii],
+ m_backBufferDepthStencilImageView,
+ };
+
+ if (m_sampler.Count > 1 && !m_supportsManualResolve)
+ {
+ attachments[numAttachments++] = m_backBufferColorImageView[ii];
+ }
+
+ VkFramebufferCreateInfo fci;
+ fci.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+ fci.pNext = NULL;
+ fci.flags = 0;
+ fci.renderPass = renderPass;
+ fci.attachmentCount = numAttachments;
+ fci.pAttachments = attachments;
+ fci.width = m_sci.imageExtent.width;
+ fci.height = m_sci.imageExtent.height;
+ fci.layers = 1;
+
+ result = vkCreateFramebuffer(device, &fci, allocatorCb, &m_backBufferFrameBuffer[ii]);
+
+ if (VK_SUCCESS != result)
+ {
+ return result;
+ }
+ }
+
+ return result;
+ }
+
+ void SwapChainVK::releaseFrameBuffer()
+ {
+ for (uint32_t ii = 0; ii < BX_COUNTOF(m_backBufferColorImageView); ++ii)
+ {
+ release(m_backBufferFrameBuffer[ii]);
+ }
+ }
+
+ uint32_t SwapChainVK::findPresentMode(bool _vsync)
+ {
+ VkResult result = VK_SUCCESS;
+
+ const VkPhysicalDevice physicalDevice = s_renderVK->m_physicalDevice;
+
+ uint32_t numPresentModes;
+ result = vkGetPhysicalDeviceSurfacePresentModesKHR(
+ physicalDevice
+ , m_surface
+ , &numPresentModes
+ , NULL
+ );
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("findPresentMode error: vkGetPhysicalDeviceSurfacePresentModesKHR failed %d: %s.", result, getName(result) );
+ return UINT32_MAX;
+ }
+
+ VkPresentModeKHR presentModes[16];
+ numPresentModes = bx::min<uint32_t>(numPresentModes, BX_COUNTOF(presentModes) );
+ result = vkGetPhysicalDeviceSurfacePresentModesKHR(
+ physicalDevice
+ , m_surface
+ , &numPresentModes
+ , presentModes
+ );
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("findPresentMode error: vkGetPhysicalDeviceSurfacePresentModesKHR failed %d: %s.", result, getName(result) );
+ return UINT32_MAX;
+ }
+
+ uint32_t idx = UINT32_MAX;
+
+ for (uint32_t ii = 0; ii < BX_COUNTOF(s_presentMode) && UINT32_MAX == idx; ++ii)
+ {
+ for (uint32_t jj = 0; jj < numPresentModes; ++jj)
+ {
+ const PresentMode& pm = s_presentMode[ii];
+
+ if (pm.mode == presentModes[jj]
+ && pm.vsync == _vsync)
+ {
+ idx = ii;
+ break;
+ }
+ }
+ }
+
+ if (UINT32_MAX == idx)
+ {
+ idx = 0;
+ BX_TRACE("Present mode not found! Defaulting to %s.", s_presentMode[idx].name);
+ }
+
+ return idx;
+ }
+
+ TextureFormat::Enum SwapChainVK::findSurfaceFormat(TextureFormat::Enum _format, VkColorSpaceKHR _colorSpace, bool _srgb)
+ {
+ VkResult result = VK_SUCCESS;
+
+ TextureFormat::Enum selectedFormat = TextureFormat::Count;
+
+ const VkPhysicalDevice physicalDevice = s_renderVK->m_physicalDevice;
+
+ uint32_t numSurfaceFormats;
+ result = vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, m_surface, &numSurfaceFormats, NULL);
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("findSurfaceFormat error: vkGetPhysicalDeviceSurfaceFormatsKHR failed %d: %s.", result, getName(result) );
+ return selectedFormat;
+ }
+
+ VkSurfaceFormatKHR* surfaceFormats = (VkSurfaceFormatKHR*)BX_ALLOC(g_allocator, numSurfaceFormats * sizeof(VkSurfaceFormatKHR) );
+ result = vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, m_surface, &numSurfaceFormats, surfaceFormats);
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("findSurfaceFormat error: vkGetPhysicalDeviceSurfaceFormatsKHR failed %d: %s.", result, getName(result) );
+ BX_FREE(g_allocator, surfaceFormats);
+ return selectedFormat;
+ }
+
+ const TextureFormat::Enum requestedFormats[] =
+ {
+ _format,
+ TextureFormat::BGRA8,
+ TextureFormat::RGBA8,
+ };
+
+ for (uint32_t ii = 0; ii < BX_COUNTOF(requestedFormats) && TextureFormat::Count == selectedFormat; ii++)
+ {
+ const TextureFormat::Enum requested = requestedFormats[ii];
+ const VkFormat requestedVkFormat = _srgb
+ ? s_textureFormat[requested].m_fmtSrgb
+ : s_textureFormat[requested].m_fmt
+ ;
+
+ for (uint32_t jj = 0; jj < numSurfaceFormats; jj++)
+ {
+ if (_colorSpace == surfaceFormats[jj].colorSpace
+ && requestedVkFormat == surfaceFormats[jj].format)
+ {
+ selectedFormat = requested;
+ if (0 != ii
+ && s_renderVK->m_swapchainFormats[_format] != selectedFormat)
+ {
+ s_renderVK->m_swapchainFormats[_format] = selectedFormat;
+ BX_TRACE(
+ "findSurfaceFormat: Surface format %s not found! Defaulting to %s."
+ , bimg::getName(bimg::TextureFormat::Enum(_format) )
+ , bimg::getName(bimg::TextureFormat::Enum(selectedFormat) )
+ );
+ }
+ break;
+ }
+ }
+ }
+
+ BX_FREE(g_allocator, surfaceFormats);
+
+ if (TextureFormat::Count == selectedFormat)
+ {
+ BX_TRACE("findSurfaceFormat error: No supported surface format found.");
+ }
+
+ return selectedFormat;
+ }
+
+ bool SwapChainVK::acquire(VkCommandBuffer _commandBuffer)
+ {
+ if (VK_NULL_HANDLE == m_swapchain
+ || m_needToRecreateSwapchain)
+ {
+ return false;
+ }
+
+ if (!m_needPresent)
+ {
+ const VkDevice device = s_renderVK->m_device;
+
+ m_lastImageAcquiredSemaphore = m_presentDoneSemaphore[m_currentSemaphore];
+ m_lastImageRenderedSemaphore = m_renderDoneSemaphore[m_currentSemaphore];
+ m_currentSemaphore = (m_currentSemaphore + 1) % m_numSwapchainImages;
+
+ VkResult result = vkAcquireNextImageKHR(
+ device
+ , m_swapchain
+ , UINT64_MAX
+ , m_lastImageAcquiredSemaphore
+ , VK_NULL_HANDLE
+ , &m_backBufferColorIdx
+ );
+
+ if (result != VK_SUCCESS)
+ {
+ BX_TRACE("vkAcquireNextImageKHR(...): result = %s", getName(result));
+ }
+
+ switch (result)
+ {
+ case VK_SUCCESS:
+ break;
+
+ case VK_ERROR_SURFACE_LOST_KHR:
+ m_needToRecreateSurface = true;
+ m_needToRecreateSwapchain = true;
+ return false;
+
+ case VK_ERROR_OUT_OF_DATE_KHR:
+ case VK_SUBOPTIMAL_KHR:
+ m_needToRecreateSwapchain = true;
+ return false;
+
+ default:
+ BX_ASSERT(VK_SUCCESS == result, "vkAcquireNextImageKHR(...); VK error 0x%x: %s", result, getName(result) );
+ return false;
+ }
+
+ if (VK_NULL_HANDLE != m_backBufferFence[m_backBufferColorIdx])
+ {
+ VK_CHECK(vkWaitForFences(
+ device
+ , 1
+ , &m_backBufferFence[m_backBufferColorIdx]
+ , VK_TRUE
+ , UINT64_MAX
+ ) );
+ }
+
+ transitionImage(_commandBuffer);
+
+ m_needPresent = true;
+ }
+
+ return true;
+ }
+
+ void SwapChainVK::present()
+ {
+ if (VK_NULL_HANDLE != m_swapchain
+ && m_needPresent)
+ {
+ VkPresentInfoKHR pi;
+ pi.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
+ pi.pNext = NULL;
+ pi.waitSemaphoreCount = 1;
+ pi.pWaitSemaphores = &m_lastImageRenderedSemaphore;
+ pi.swapchainCount = 1;
+ pi.pSwapchains = &m_swapchain;
+ pi.pImageIndices = &m_backBufferColorIdx;
+ pi.pResults = NULL;
+ VkResult result = vkQueuePresentKHR(m_queue, &pi);
+
+ if (result != VK_SUCCESS)
+ {
+ BX_TRACE("vkQueuePresentKHR(...): result = %s", getName(result));
+ }
+
+ switch (result)
+ {
+ case VK_ERROR_SURFACE_LOST_KHR:
+ m_needToRecreateSurface = true;
+ m_needToRecreateSwapchain = true;
+ break;
+
+ case VK_ERROR_OUT_OF_DATE_KHR:
+ case VK_SUBOPTIMAL_KHR:
+ m_needToRecreateSwapchain = true;
+ break;
+
+ default:
+ BX_ASSERT(VK_SUCCESS == result, "vkQueuePresentKHR(...); VK error 0x%x: %s", result, getName(result) );
+ break;
+ }
+
+ m_needPresent = false;
+ m_lastImageRenderedSemaphore = VK_NULL_HANDLE;
+ }
+ }
+
+ void SwapChainVK::transitionImage(VkCommandBuffer _commandBuffer)
+ {
+ VkImageLayout& layout = m_backBufferColorImageLayout[m_backBufferColorIdx];
+
+ const bool toPresent = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL == layout;
+
+ const VkImageLayout newLayout = toPresent
+ ? VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
+ : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
+ ;
+
+ layout = toPresent ? layout : VK_IMAGE_LAYOUT_UNDEFINED;
+
+ setImageMemoryBarrier(
+ _commandBuffer
+ , m_backBufferColorImage[m_backBufferColorIdx]
+ , VK_IMAGE_ASPECT_COLOR_BIT
+ , layout
+ , newLayout
+ );
+
+ layout = newLayout;
+ }
+
+ void FrameBufferVK::create(uint8_t _num, const Attachment* _attachment)
+ {
+ m_numTh = _num;
+ bx::memCopy(m_attachment, _attachment, sizeof(Attachment) * _num);
+
+ postReset();
+ }
+
+ VkResult FrameBufferVK::create(uint16_t _denseIdx, void* _nwh, uint32_t _width, uint32_t _height, TextureFormat::Enum _format, TextureFormat::Enum _depthFormat)
+ {
+ VkResult result = VK_SUCCESS;
+
+ Resolution resolution = s_renderVK->m_resolution;
+ resolution.format = TextureFormat::Count == _format ? resolution.format : _format;
+ resolution.width = _width;
+ resolution.height = _height;
+ if (_denseIdx != UINT16_MAX)
+ {
+ resolution.reset &= ~BGFX_RESET_MSAA_MASK;
+ }
+
+ result = m_swapChain.create(s_renderVK->m_commandBuffer, _nwh, resolution, _depthFormat);
+
+ if (VK_SUCCESS != result)
+ {
+ return result;
+ }
+
+ result = s_renderVK->getRenderPass(m_swapChain, &m_renderPass);
+
+ if (VK_SUCCESS != result)
+ {
+ return result;
+ }
+
+ m_denseIdx = _denseIdx;
+ m_nwh = _nwh;
+ m_width = _width;
+ m_height = _height;
+ m_sampler = m_swapChain.m_sampler;
+
+ return result;
+ }
+
+ void FrameBufferVK::preReset()
+ {
+ if (VK_NULL_HANDLE != m_framebuffer)
+ {
+ s_renderVK->release(m_framebuffer);
+
+ for (uint8_t ii = 0; ii < m_numTh; ++ii)
+ {
+ s_renderVK->release(m_textureImageViews[ii]);
+ }
+ }
+ }
+
+ void FrameBufferVK::postReset()
+ {
+ if (m_numTh > 0)
+ {
+ const VkDevice device = s_renderVK->m_device;
+ const VkAllocationCallbacks* allocatorCb = s_renderVK->m_allocatorCb;
+
+ VK_CHECK(s_renderVK->getRenderPass(m_numTh, m_attachment, &m_renderPass) );
+
+ m_depth = BGFX_INVALID_HANDLE;
+ m_num = 0;
+
+ for (uint8_t ii = 0; ii < m_numTh; ++ii)
+ {
+ const Attachment& at = m_attachment[ii];
+ const TextureVK& texture = s_renderVK->m_textures[at.handle.idx];
+ VK_CHECK(texture.createView(
+ at.layer
+ , at.numLayers
+ , at.mip
+ , 1
+ , at.numLayers > 1 ? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_2D
+ , texture.m_aspectMask
+ , true
+ , &m_textureImageViews[ii]
+ ) );
+
+ if (texture.m_aspectMask & VK_IMAGE_ASPECT_COLOR_BIT)
+ {
+ m_texture[m_num] = at.handle;
+ m_num++;
+ }
+ else if (texture.m_aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) )
+ {
+ m_depth = at.handle;
+ }
+ }
+
+ const TextureVK& firstTexture = s_renderVK->m_textures[m_attachment[0].handle.idx];
+ m_width = bx::uint32_max(firstTexture.m_width >> m_attachment[0].mip, 1);
+ m_height = bx::uint32_max(firstTexture.m_height >> m_attachment[0].mip, 1);
+ m_sampler = firstTexture.m_sampler;
+
+ VkFramebufferCreateInfo fci;
+ fci.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+ fci.pNext = NULL;
+ fci.flags = 0;
+ fci.renderPass = m_renderPass;
+ fci.attachmentCount = m_numTh;
+ fci.pAttachments = &m_textureImageViews[0];
+ fci.width = m_width;
+ fci.height = m_height;
+ fci.layers = m_attachment[0].numLayers;
+
+ VK_CHECK(vkCreateFramebuffer(device, &fci, allocatorCb, &m_framebuffer) );
+
+ m_currentFramebuffer = m_framebuffer;
+ }
+ }
+
+ void FrameBufferVK::update(VkCommandBuffer _commandBuffer, const Resolution& _resolution)
+ {
+ m_swapChain.update(_commandBuffer, m_nwh, _resolution);
+ VK_CHECK(s_renderVK->getRenderPass(m_swapChain, &m_renderPass) );
+ // Don't believe the passed Resolution, as the Vulkan driver might have
+ // specified another resolution, which we had to obey.
+ m_width = m_swapChain.m_sci.imageExtent.width;
+ m_height = m_swapChain.m_sci.imageExtent.height;
+ m_sampler = m_swapChain.m_sampler;
}
- void FrameBufferVK::destroy()
+ void FrameBufferVK::resolve()
{
+ if (!m_needResolve)
+ {
+ return;
+ }
+
+ if (NULL == m_nwh)
+ {
+ for (uint32_t ii = 0; ii < m_numTh; ++ii)
+ {
+ const Attachment& at = m_attachment[ii];
+
+ if (isValid(at.handle) )
+ {
+ TextureVK& texture = s_renderVK->m_textures[at.handle.idx];
+ texture.resolve(s_renderVK->m_commandBuffer, at.resolve, at.layer, at.numLayers, at.mip);
+ }
+ }
+ }
+ else if (isRenderable()
+ && m_sampler.Count > 1
+ && m_swapChain.m_supportsManualResolve)
+ {
+ m_swapChain.m_backBufferColorMsaa.m_singleMsaaImage = m_swapChain.m_backBufferColorImage[m_swapChain.m_backBufferColorIdx];
+ m_swapChain.m_backBufferColorMsaa.m_currentSingleMsaaImageLayout = m_swapChain.m_backBufferColorImageLayout[m_swapChain.m_backBufferColorIdx];
+
+ m_swapChain.m_backBufferColorMsaa.resolve(s_renderVK->m_commandBuffer, 0, 0, 1, 0);
+
+ m_swapChain.m_backBufferColorMsaa.m_singleMsaaImage = VK_NULL_HANDLE;
+ m_swapChain.m_backBufferColorMsaa.m_currentSingleMsaaImageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+ }
+
+ m_needResolve = false;
+ }
+
+ uint16_t FrameBufferVK::destroy()
+ {
+ preReset();
+
+ if (NULL != m_nwh)
+ {
+ m_swapChain.destroy();
+ m_nwh = NULL;
+ m_needPresent = false;
+ }
+
+ m_numTh = 0;
+ m_num = 0;
+ m_depth = BGFX_INVALID_HANDLE;
+
+ m_needResolve = false;
+
+ uint16_t denseIdx = m_denseIdx;
+ m_denseIdx = UINT16_MAX;
+ return denseIdx;
+ }
+
+ bool FrameBufferVK::acquire(VkCommandBuffer _commandBuffer)
+ {
+ bool acquired = true;
+
+ if (NULL != m_nwh)
+ {
+ acquired = m_swapChain.acquire(_commandBuffer);
+ m_needPresent = m_swapChain.m_needPresent;
+ m_currentFramebuffer = m_swapChain.m_backBufferFrameBuffer[m_swapChain.m_backBufferColorIdx];
+ }
+
+ m_needResolve = true;
+
+ return acquired;
+ }
+
+ void FrameBufferVK::present()
+ {
+ m_swapChain.present();
+ m_needPresent = false;
+ }
+
+ bool FrameBufferVK::isRenderable() const
+ {
+ return false
+ || (NULL == m_nwh)
+ || m_swapChain.m_needPresent
+ ;
+ }
+
+ VkResult CommandQueueVK::init(uint32_t _queueFamily, VkQueue _queue, uint32_t _numFramesInFlight)
+ {
+ m_queueFamily = _queueFamily;
+ m_queue = _queue;
+ m_numFramesInFlight = bx::clamp<uint32_t>(_numFramesInFlight, 1, BGFX_CONFIG_MAX_FRAME_LATENCY);
+ m_activeCommandBuffer = VK_NULL_HANDLE;
+
+ return reset();
+ }
+
+ VkResult CommandQueueVK::reset()
+ {
+ shutdown();
+
+ m_currentFrameInFlight = 0;
+ m_consumeIndex = 0;
+
+ m_numSignalSemaphores = 0;
+ m_numWaitSemaphores = 0;
+
+ m_activeCommandBuffer = VK_NULL_HANDLE;
+ m_currentFence = VK_NULL_HANDLE;
+ m_completedFence = VK_NULL_HANDLE;
+
+ m_submitted = 0;
+
+ VkCommandPoolCreateInfo cpci;
+ cpci.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
+ cpci.pNext = NULL;
+ cpci.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT;
+ cpci.queueFamilyIndex = m_queueFamily;
+
+ VkCommandBufferAllocateInfo cbai;
+ cbai.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+ cbai.pNext = NULL;
+ cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+ cbai.commandBufferCount = 1;
+
+ VkFenceCreateInfo fci;
+ fci.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
+ fci.pNext = NULL;
+ fci.flags = VK_FENCE_CREATE_SIGNALED_BIT;
+
+ VkResult result = VK_SUCCESS;
+
+ for (uint32_t ii = 0; ii < m_numFramesInFlight; ++ii)
+ {
+ result = vkCreateCommandPool(
+ s_renderVK->m_device
+ , &cpci
+ , s_renderVK->m_allocatorCb
+ , &m_commandList[ii].m_commandPool
+ );
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create command queue error: vkCreateCommandPool failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ cbai.commandPool = m_commandList[ii].m_commandPool;
+
+ result = vkAllocateCommandBuffers(
+ s_renderVK->m_device
+ , &cbai
+ , &m_commandList[ii].m_commandBuffer
+ );
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create command queue error: vkAllocateCommandBuffers failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ result = vkCreateFence(
+ s_renderVK->m_device
+ , &fci
+ , s_renderVK->m_allocatorCb
+ , &m_commandList[ii].m_fence
+ );
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Create command queue error: vkCreateFence failed %d: %s.", result, getName(result) );
+ return result;
+ }
+ }
+
+ return result;
+ }
+
+ void CommandQueueVK::shutdown()
+ {
+ kick(true);
+ finish(true);
+
+ for (uint32_t ii = 0; ii < m_numFramesInFlight; ++ii)
+ {
+ vkDestroy(m_commandList[ii].m_fence);
+ m_commandList[ii].m_commandBuffer = VK_NULL_HANDLE;
+ vkDestroy(m_commandList[ii].m_commandPool);
+ }
+ }
+
+ VkResult CommandQueueVK::alloc(VkCommandBuffer* _commandBuffer)
+ {
+ VkResult result = VK_SUCCESS;
+
+ if (m_activeCommandBuffer == VK_NULL_HANDLE)
+ {
+ const VkDevice device = s_renderVK->m_device;
+ CommandList& commandList = m_commandList[m_currentFrameInFlight];
+
+ result = vkWaitForFences(device, 1, &commandList.m_fence, VK_TRUE, UINT64_MAX);
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Allocate command buffer error: vkWaitForFences failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ result = vkResetCommandPool(device, commandList.m_commandPool, 0);
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Allocate command buffer error: vkResetCommandPool failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ VkCommandBufferBeginInfo cbi;
+ cbi.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+ cbi.pNext = NULL;
+ cbi.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+ cbi.pInheritanceInfo = NULL;
+
+ result = vkBeginCommandBuffer(commandList.m_commandBuffer, &cbi);
+
+ if (VK_SUCCESS != result)
+ {
+ BX_TRACE("Allocate command buffer error: vkBeginCommandBuffer failed %d: %s.", result, getName(result) );
+ return result;
+ }
+
+ m_activeCommandBuffer = commandList.m_commandBuffer;
+ m_currentFence = commandList.m_fence;
+ }
+
+ if (NULL != _commandBuffer)
+ {
+ *_commandBuffer = m_activeCommandBuffer;
+ }
+
+ return result;
+ }
+
+ void CommandQueueVK::addWaitSemaphore(VkSemaphore _semaphore, VkPipelineStageFlags _waitFlags)
+ {
+ BX_ASSERT(m_numWaitSemaphores < BX_COUNTOF(m_waitSemaphores), "Too many wait semaphores.");
+
+ m_waitSemaphores[m_numWaitSemaphores] = _semaphore;
+ m_waitSemaphoreStages[m_numWaitSemaphores] = _waitFlags;
+ m_numWaitSemaphores++;
+ }
+
+ void CommandQueueVK::addSignalSemaphore(VkSemaphore _semaphore)
+ {
+ BX_ASSERT(m_numSignalSemaphores < BX_COUNTOF(m_signalSemaphores), "Too many signal semaphores.");
+
+ m_signalSemaphores[m_numSignalSemaphores] = _semaphore;
+ m_numSignalSemaphores++;
+ }
+
+ void CommandQueueVK::kick(bool _wait)
+ {
+ if (VK_NULL_HANDLE != m_activeCommandBuffer)
+ {
+ const VkDevice device = s_renderVK->m_device;
+
+ setMemoryBarrier(
+ m_activeCommandBuffer
+ , VK_PIPELINE_STAGE_ALL_COMMANDS_BIT
+ , VK_PIPELINE_STAGE_ALL_COMMANDS_BIT
+ );
+
+ VK_CHECK(vkEndCommandBuffer(m_activeCommandBuffer) );
+
+ m_completedFence = m_currentFence;
+ m_currentFence = VK_NULL_HANDLE;
+
+ VK_CHECK(vkResetFences(device, 1, &m_completedFence) );
+
+ VkSubmitInfo si;
+ si.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+ si.pNext = NULL;
+ si.waitSemaphoreCount = m_numWaitSemaphores;
+ si.pWaitSemaphores = &m_waitSemaphores[0];
+ si.pWaitDstStageMask = m_waitSemaphoreStages;
+ si.commandBufferCount = 1;
+ si.pCommandBuffers = &m_activeCommandBuffer;
+ si.signalSemaphoreCount = m_numSignalSemaphores;
+ si.pSignalSemaphores = &m_signalSemaphores[0];
+
+ m_numWaitSemaphores = 0;
+ m_numSignalSemaphores = 0;
+
+ VK_CHECK(vkQueueSubmit(m_queue, 1, &si, m_completedFence) );
+
+ if (_wait)
+ {
+ VK_CHECK(vkWaitForFences(device, 1, &m_completedFence, VK_TRUE, UINT64_MAX) );
+ }
+
+ m_activeCommandBuffer = VK_NULL_HANDLE;
+
+ m_currentFrameInFlight = (m_currentFrameInFlight + 1) % m_numFramesInFlight;
+ m_submitted++;
+ }
+ }
+
+ void CommandQueueVK::finish(bool _finishAll)
+ {
+ if (_finishAll)
+ {
+ for (uint32_t ii = 0; ii < m_numFramesInFlight; ++ii)
+ {
+ consume();
+ }
+
+ m_consumeIndex = m_currentFrameInFlight;
+ }
+ else
+ {
+ consume();
+ }
+ }
+
+ void CommandQueueVK::release(uint64_t _handle, VkObjectType _type)
+ {
+ Resource resource;
+ resource.m_type = _type;
+ resource.m_handle = _handle;
+ m_release[m_currentFrameInFlight].push_back(resource);
+ }
+
+ void CommandQueueVK::consume()
+ {
+ m_consumeIndex = (m_consumeIndex + 1) % m_numFramesInFlight;
+
+ for (const Resource& resource : m_release[m_consumeIndex])
+ {
+ switch (resource.m_type)
+ {
+ case VK_OBJECT_TYPE_BUFFER: destroy<VkBuffer >(resource.m_handle); break;
+ case VK_OBJECT_TYPE_IMAGE_VIEW: destroy<VkImageView >(resource.m_handle); break;
+ case VK_OBJECT_TYPE_IMAGE: destroy<VkImage >(resource.m_handle); break;
+ case VK_OBJECT_TYPE_FRAMEBUFFER: destroy<VkFramebuffer >(resource.m_handle); break;
+ case VK_OBJECT_TYPE_PIPELINE_LAYOUT: destroy<VkPipelineLayout >(resource.m_handle); break;
+ case VK_OBJECT_TYPE_PIPELINE: destroy<VkPipeline >(resource.m_handle); break;
+ case VK_OBJECT_TYPE_DESCRIPTOR_SET: destroy<VkDescriptorSet >(resource.m_handle); break;
+ case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT: destroy<VkDescriptorSetLayout>(resource.m_handle); break;
+ case VK_OBJECT_TYPE_RENDER_PASS: destroy<VkRenderPass >(resource.m_handle); break;
+ case VK_OBJECT_TYPE_SAMPLER: destroy<VkSampler >(resource.m_handle); break;
+ case VK_OBJECT_TYPE_SEMAPHORE: destroy<VkSemaphore >(resource.m_handle); break;
+ case VK_OBJECT_TYPE_SURFACE_KHR: destroy<VkSurfaceKHR >(resource.m_handle); break;
+ case VK_OBJECT_TYPE_SWAPCHAIN_KHR: destroy<VkSwapchainKHR >(resource.m_handle); break;
+ case VK_OBJECT_TYPE_DEVICE_MEMORY: destroy<VkDeviceMemory >(resource.m_handle); break;
+ default:
+ BX_ASSERT(false, "Invalid resource type: %d", resource.m_type);
+ break;
+ }
+ }
+
+ m_release[m_consumeIndex].clear();
}
void RendererContextVK::submitBlit(BlitState& _bs, uint16_t _view)
{
+ VkImageLayout srcLayouts[BGFX_CONFIG_MAX_BLIT_ITEMS];
+ VkImageLayout dstLayouts[BGFX_CONFIG_MAX_BLIT_ITEMS];
+
+ BlitState bs0 = _bs;
+
+ while (bs0.hasItem(_view) )
+ {
+ uint16_t item = bs0.m_item;
+
+ const BlitItem& blit = bs0.advance();
+
+ TextureVK& src = m_textures[blit.m_src.idx];
+ TextureVK& dst = m_textures[blit.m_dst.idx];
+
+ srcLayouts[item] = VK_NULL_HANDLE != src.m_singleMsaaImage ? src.m_currentSingleMsaaImageLayout : src.m_currentImageLayout;
+ dstLayouts[item] = dst.m_currentImageLayout;
+ }
+
+ bs0 = _bs;
+
+ while (bs0.hasItem(_view) )
+ {
+ const BlitItem& blit = bs0.advance();
+
+ TextureVK& src = m_textures[blit.m_src.idx];
+ TextureVK& dst = m_textures[blit.m_dst.idx];
+
+ src.setImageMemoryBarrier(
+ m_commandBuffer
+ , blit.m_src.idx == blit.m_dst.idx ? VK_IMAGE_LAYOUT_GENERAL : VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL
+ , VK_NULL_HANDLE != src.m_singleMsaaImage
+ );
+
+ if (blit.m_src.idx != blit.m_dst.idx)
+ {
+ dst.setImageMemoryBarrier(m_commandBuffer, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+ }
+
+ const uint16_t srcSamples = VK_NULL_HANDLE != src.m_singleMsaaImage ? 1 : src.m_sampler.Count;
+ const uint16_t dstSamples = dst.m_sampler.Count;
+ BX_UNUSED(srcSamples, dstSamples);
+
+ BX_ASSERT(
+ srcSamples == dstSamples
+ , "Mismatching texture sample count (%d != %d)."
+ , srcSamples
+ , dstSamples
+ );
+
+ VkImageCopy copyInfo;
+ copyInfo.srcSubresource.aspectMask = src.m_aspectMask;
+ copyInfo.srcSubresource.mipLevel = blit.m_srcMip;
+ copyInfo.srcSubresource.baseArrayLayer = 0;
+ copyInfo.srcSubresource.layerCount = 1;
+ copyInfo.srcOffset.x = blit.m_srcX;
+ copyInfo.srcOffset.y = blit.m_srcY;
+ copyInfo.srcOffset.z = 0;
+ copyInfo.dstSubresource.aspectMask = dst.m_aspectMask;
+ copyInfo.dstSubresource.mipLevel = blit.m_dstMip;
+ copyInfo.dstSubresource.baseArrayLayer = 0;
+ copyInfo.dstSubresource.layerCount = 1;
+ copyInfo.dstOffset.x = blit.m_dstX;
+ copyInfo.dstOffset.y = blit.m_dstY;
+ copyInfo.dstOffset.z = 0;
+ copyInfo.extent.width = blit.m_width;
+ copyInfo.extent.height = blit.m_height;
+ copyInfo.extent.depth = 1;
+
+ const uint32_t depth = bx::max<uint32_t>(1, blit.m_depth);
+
+ if (VK_IMAGE_VIEW_TYPE_3D == src.m_type)
+ {
+ BX_ASSERT(VK_IMAGE_VIEW_TYPE_3D == dst.m_type, "Can't blit between 2D and 3D image.");
+
+ copyInfo.srcOffset.z = blit.m_srcZ;
+ copyInfo.dstOffset.z = blit.m_dstZ;
+ copyInfo.extent.depth = depth;
+ }
+ else
+ {
+ copyInfo.srcSubresource.baseArrayLayer = blit.m_srcZ;
+ copyInfo.dstSubresource.baseArrayLayer = blit.m_dstZ;
+ copyInfo.srcSubresource.layerCount = depth;
+ copyInfo.dstSubresource.layerCount = depth;
+ }
+
+ vkCmdCopyImage(
+ m_commandBuffer
+ , VK_NULL_HANDLE != src.m_singleMsaaImage ? src.m_singleMsaaImage : src.m_textureImage
+ , VK_NULL_HANDLE != src.m_singleMsaaImage ? src.m_currentSingleMsaaImageLayout : src.m_currentImageLayout
+ , dst.m_textureImage
+ , dst.m_currentImageLayout
+ , 1
+ , &copyInfo
+ );
+
+ setMemoryBarrier(
+ m_commandBuffer
+ , VK_PIPELINE_STAGE_TRANSFER_BIT
+ , VK_PIPELINE_STAGE_TRANSFER_BIT
+ );
+ }
+
while (_bs.hasItem(_view) )
{
+ uint16_t item = _bs.m_item;
+
const BlitItem& blit = _bs.advance();
- BX_UNUSED(blit);
+
+ TextureVK& src = m_textures[blit.m_src.idx];
+ TextureVK& dst = m_textures[blit.m_dst.idx];
+
+ src.setImageMemoryBarrier(m_commandBuffer, srcLayouts[item], VK_NULL_HANDLE != src.m_singleMsaaImage);
+ dst.setImageMemoryBarrier(m_commandBuffer, dstLayouts[item]);
}
}
void RendererContextVK::submit(Frame* _render, ClearQuad& _clearQuad, TextVideoMemBlitter& _textVideoMemBlitter)
{
- BX_UNUSED(_render, _clearQuad, _textVideoMemBlitter);
+ BX_UNUSED(_clearQuad);
- updateResolution(_render->m_resolution);
+ if (updateResolution(_render->m_resolution) )
+ {
+ return;
+ }
+
+ if (_render->m_capture)
+ {
+ renderDocTriggerCapture();
+ }
+
+ BGFX_VK_PROFILER_BEGIN_LITERAL("rendererSubmit", kColorView);
int64_t timeBegin = bx::getHPCounter();
int64_t captureElapsed = 0;
-// m_gpuTimer.begin(m_commandList);
+ uint32_t frameQueryIdx = UINT32_MAX;
+
+ if (m_timerQuerySupport)
+ {
+ frameQueryIdx = m_gpuTimer.begin(BGFX_CONFIG_MAX_VIEWS, _render->m_frameNum);
+ }
if (0 < _render->m_iboffset)
{
-// TransientIndexBuffer* ib = _render->m_transientIb;
-// m_indexBuffers[ib->handle.idx].update(m_commandList, 0, _render->m_iboffset, ib->data);
+ BGFX_PROFILER_SCOPE("bgfx/Update transient index buffer", kColorResource);
+ TransientIndexBuffer* ib = _render->m_transientIb;
+ m_indexBuffers[ib->handle.idx].update(m_commandBuffer, 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);
+ BGFX_PROFILER_SCOPE("bgfx/Update transient vertex buffer", kColorResource);
+ TransientVertexBuffer* vb = _render->m_transientVb;
+ m_vertexBuffers[vb->handle.idx].update(m_commandBuffer, 0, _render->m_vboffset, vb->data);
}
_render->sort();
@@ -3679,39 +8204,34 @@ VK_DESTROY
currentState.m_stateFlags = BGFX_STATE_NONE;
currentState.m_stencil = packStencil(BGFX_STENCIL_NONE, BGFX_STENCIL_NONE);
- const bool hmdEnabled = false;
- ViewState viewState(_render, hmdEnabled);
- viewState.reset(_render, hmdEnabled);
+ static ViewState viewState;
+ viewState.reset(_render);
-// bool wireframe = !!(_render->m_debug&BGFX_DEBUG_WIREFRAME);
-// setDebugWireframe(wireframe);
+ bool wireframe = !!(_render->m_debug&BGFX_DEBUG_WIREFRAME);
+ setDebugWireframe(wireframe);
- uint16_t currentSamplerStateIdx = kInvalidHandle;
- uint16_t currentProgramIdx = kInvalidHandle;
- uint32_t currentBindHash = 0;
- bool hasPredefined = false;
- bool commandListChanged = false;
+ ProgramHandle currentProgram = BGFX_INVALID_HANDLE;
+ bool hasPredefined = false;
VkPipeline currentPipeline = VK_NULL_HANDLE;
+ VkDescriptorSet currentDescriptorSet = VK_NULL_HANDLE;
+ uint32_t currentBindHash = 0;
+ uint32_t descriptorSetCount = 0;
+ VkIndexType currentIndexFormat = VK_INDEX_TYPE_MAX_ENUM;
SortKey key;
uint16_t view = UINT16_MAX;
FrameBufferHandle fbh = { BGFX_CONFIG_MAX_FRAME_BUFFERS };
BlitState bs(_render);
- 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];
+ uint64_t blendFactor = UINT64_MAX;
- bool wasCompute = false;
+ bool wasCompute = false;
bool viewHasScissor = false;
bool restoreScissor = false;
Rect viewScissorRect;
viewScissorRect.clear();
- const uint32_t maxComputeBindings = g_caps.limits.maxComputeBindings;
- BX_UNUSED(maxComputeBindings);
+ bool isFrameBufferValid = false;
uint32_t statsNumPrimsSubmitted[BX_COUNTOF(s_primInfo)] = {};
uint32_t statsNumPrimsRendered[BX_COUNTOF(s_primInfo)] = {};
@@ -3719,64 +8239,43 @@ VK_DESTROY
uint32_t statsNumIndices = 0;
uint32_t statsKeyType[2] = {};
- VkSemaphore renderWait = m_presentDone[m_backBufferColorIdx];
- VK_CHECK(vkAcquireNextImageKHR(m_device
- , m_swapchain
- , UINT64_MAX
- , renderWait
- , VK_NULL_HANDLE
- , &m_backBufferColorIdx
- ) );
-
- 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);
-
+ const uint64_t f0 = BGFX_STATE_BLEND_FACTOR;
+ const uint64_t f1 = BGFX_STATE_BLEND_INV_FACTOR;
+ const uint64_t f2 = BGFX_STATE_BLEND_FACTOR<<4;
+ const uint64_t f3 = BGFX_STATE_BLEND_INV_FACTOR<<4;
- ScratchBufferVK& scratchBuffer = m_scratchBuffer[m_backBufferColorIdx];
- VkDescriptorBufferInfo descriptorBufferInfo;
- scratchBuffer.reset(descriptorBufferInfo);
-
- VkCommandBufferBeginInfo cbbi;
- cbbi.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
- cbbi.pNext = NULL;
- cbbi.flags = 0
- | VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT
-// | VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT
- ;
- cbbi.pInheritanceInfo = NULL;
+ ScratchBufferVK& scratchBuffer = m_scratchBuffer[m_cmd.m_currentFrameInFlight];
+ scratchBuffer.reset();
- m_commandBuffer = m_commandBuffers[m_backBufferColorIdx];
- VK_CHECK(vkBeginCommandBuffer(m_commandBuffer, &cbbi) );
-
- setImageMemoryBarrier(m_commandBuffer
- , m_backBufferColorImage[m_backBufferColorIdx]
- , VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
- , VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
+ setMemoryBarrier(
+ m_commandBuffer
+ , VK_PIPELINE_STAGE_TRANSFER_BIT
+ , VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT | VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT
);
VkRenderPassBeginInfo rpbi;
rpbi.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
rpbi.pNext = NULL;
- rpbi.renderPass = m_renderPass;
- rpbi.framebuffer = m_backBufferColor[m_backBufferColorIdx];
- rpbi.renderArea.offset.x = 0;
- rpbi.renderArea.offset.y = 0;
- rpbi.renderArea.extent = m_sci.imageExtent;
rpbi.clearValueCount = 0;
rpbi.pClearValues = NULL;
bool beginRenderPass = false;
+ Profiler<TimerQueryVK> profiler(
+ _render
+ , m_gpuTimer
+ , s_viewName
+ , m_timerQuerySupport
+ );
+
+ m_occlusionQuery.flush(_render);
+
if (0 == (_render->m_debug&BGFX_DEBUG_IFH) )
{
-// m_batch.begin();
-
-// uint8_t eye = 0;
-// uint8_t restartState = 0;
viewState.m_rect = _render->m_view[0].m_rect;
int32_t numItems = _render->m_numRenderItems;
- for (int32_t item = 0, restartItem = numItems; item < numItems || restartItem < numItems;)
+ for (int32_t item = 0; item < numItems;)
{
const uint64_t encodedKey = _render->m_sortKeys[item];
const bool isCompute = key.decode(encodedKey, _render->m_viewRemap);
@@ -3800,66 +8299,94 @@ VK_DESTROY
beginRenderPass = false;
}
- VK_CHECK(vkEndCommandBuffer(m_commandBuffer) );
+ view = key.m_view;
+ currentProgram = BGFX_INVALID_HANDLE;
+ hasPredefined = false;
-// m_batch.flush(m_commandList, true);
- kick(renderWait);
- renderWait = VK_NULL_HANDLE;
-finishAll();
+ if (item > 1)
+ {
+ profiler.end();
+ }
- view = key.m_view;
- currentPipeline = VK_NULL_HANDLE;
- currentSamplerStateIdx = kInvalidHandle;
-BX_UNUSED(currentSamplerStateIdx);
- currentProgramIdx = kInvalidHandle;
- hasPredefined = false;
-
- fbh = _render->m_view[view].m_fbh;
- setFrameBuffer(fbh);
-
- viewState.m_rect = _render->m_view[view].m_rect;
- const Rect& rect = _render->m_view[view].m_rect;
- const Rect& scissorRect = _render->m_view[view].m_scissor;
- viewHasScissor = !scissorRect.isZero();
- viewScissorRect = viewHasScissor ? scissorRect : rect;
-
- rpbi.renderArea.offset.x = rect.m_x;
- rpbi.renderArea.offset.y = rect.m_y;
- rpbi.renderArea.extent.width = rect.m_width;
- rpbi.renderArea.extent.height = rect.m_height;
- VK_CHECK(vkBeginCommandBuffer(m_commandBuffer, &cbbi) );
- vkCmdBeginRenderPass(m_commandBuffer, &rpbi, VK_SUBPASS_CONTENTS_INLINE);
- beginRenderPass = true;
+ BGFX_VK_PROFILER_END();
+ setViewType(view, " ");
+ BGFX_VK_PROFILER_BEGIN(view, kColorView);
+
+ profiler.begin(view);
- VkViewport vp;
- vp.x = rect.m_x;
- vp.y = rect.m_y;
- vp.width = rect.m_width;
- vp.height = rect.m_height;
- vp.minDepth = 0.0f;
- vp.maxDepth = 1.0f;
- vkCmdSetViewport(m_commandBuffer, 0, 1, &vp);
-
- VkRect2D rc;
- rc.offset.x = viewScissorRect.m_x;
- rc.offset.y = viewScissorRect.m_y;
- rc.extent.width = viewScissorRect.m_x + viewScissorRect.m_width;
- rc.extent.height = viewScissorRect.m_y + viewScissorRect.m_height;
- vkCmdSetScissor(m_commandBuffer, 0, 1, &rc);
-
- restoreScissor = false;
-
- Clear& clr = _render->m_view[view].m_clear;
- if (BGFX_CLEAR_NONE != clr.m_flags)
+ if (_render->m_view[view].m_fbh.idx != fbh.idx)
{
- Rect clearRect = rect;
- clearRect.setIntersect(rect, viewScissorRect);
- clearQuad(clearRect, clr, _render->m_colorPalette);
+ fbh = _render->m_view[view].m_fbh;
+ setFrameBuffer(fbh);
}
- prim = s_primInfo[Topology::Count]; // Force primitive type update.
+ const FrameBufferVK& fb = isValid(m_fbh)
+ ? m_frameBuffers[m_fbh.idx]
+ : m_backBuffer
+ ;
+
+ isFrameBufferValid = fb.isRenderable();
+
+ if (isFrameBufferValid)
+ {
+ viewState.m_rect = _render->m_view[view].m_rect;
+ Rect rect = _render->m_view[view].m_rect;
+ Rect scissorRect = _render->m_view[view].m_scissor;
+ viewHasScissor = !scissorRect.isZero();
+ viewScissorRect = viewHasScissor ? scissorRect : rect;
+ restoreScissor = false;
+
+ // Clamp the rect to what's valid according to Vulkan.
+ rect.m_width = bx::min(rect.m_width, fb.m_width - rect.m_x);
+ rect.m_height = bx::min(rect.m_height, fb.m_height - rect.m_y);
+ if (_render->m_view[view].m_rect.m_width != rect.m_width
+ || _render->m_view[view].m_rect.m_height != rect.m_height)
+ {
+ BX_TRACE("Clamp render pass from %dx%d to %dx%d"
+ , _render->m_view[view].m_rect.m_width
+ , _render->m_view[view].m_rect.m_height
+ , rect.m_width
+ , rect.m_height
+ );
+ }
+
+ rpbi.framebuffer = fb.m_currentFramebuffer;
+ rpbi.renderPass = fb.m_renderPass;
+ rpbi.renderArea.offset.x = rect.m_x;
+ rpbi.renderArea.offset.y = rect.m_y;
+ rpbi.renderArea.extent.width = rect.m_width;
+ rpbi.renderArea.extent.height = rect.m_height;
+
+ VkViewport vp;
+ vp.x = float(rect.m_x);
+ vp.y = float(rect.m_y + rect.m_height);
+ vp.width = float(rect.m_width);
+ vp.height = -float(rect.m_height);
+ vp.minDepth = 0.0f;
+ vp.maxDepth = 1.0f;
+ vkCmdSetViewport(m_commandBuffer, 0, 1, &vp);
+
+ VkRect2D rc;
+ rc.offset.x = viewScissorRect.m_x;
+ rc.offset.y = viewScissorRect.m_y;
+ rc.extent.width = viewScissorRect.m_width;
+ rc.extent.height = viewScissorRect.m_height;
+ vkCmdSetScissor(m_commandBuffer, 0, 1, &rc);
+
+ const Clear& clr = _render->m_view[view].m_clear;
+ if (BGFX_CLEAR_NONE != clr.m_flags)
+ {
+ vkCmdBeginRenderPass(m_commandBuffer, &rpbi, VK_SUBPASS_CONTENTS_INLINE);
+
+ Rect clearRect = rect;
+ clearRect.setIntersect(rect, viewScissorRect);
+ clearQuad(clearRect, clr, _render->m_colorPalette);
+
+ vkCmdEndRenderPass(m_commandBuffer);
+ }
- submitBlit(bs, view);
+ submitBlit(bs, view);
+ }
}
if (isCompute)
@@ -3867,123 +8394,43 @@ BX_UNUSED(currentSamplerStateIdx);
if (!wasCompute)
{
wasCompute = true;
+ currentBindHash = 0;
-// m_commandList->SetComputeRootSignature(m_rootSignature);
-// ID3D12DescriptorHeap* heaps[] = {
-// m_samplerAllocator.getHeap(),
-// scratchBuffer.getHeap(),
-// };
-// m_commandList->SetDescriptorHeaps(BX_COUNTOF(heaps), heaps);
+ BGFX_VK_PROFILER_END();
+ setViewType(view, "C");
+ BGFX_VK_PROFILER_BEGIN(view, kColorCompute);
}
+ // renderpass external subpass dependencies handle graphics -> compute and compute -> graphics
+ // but not compute -> compute (possibly also across views if they contain no draw calls)
+ setMemoryBarrier(
+ m_commandBuffer
+ , VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT
+ , VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT | VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT
+ );
+
const RenderCompute& compute = renderItem.compute;
- VkPipeline pipeline = getPipeline(key.m_program);
- if (pipeline != currentPipeline)
+ const VkPipeline pipeline = getPipeline(key.m_program);
+
+ if (currentPipeline != pipeline)
{
currentPipeline = pipeline;
vkCmdBindPipeline(m_commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline);
- currentBindHash = 0;
}
-// uint32_t bindHash = bx::hash<bx::HashMurmur2A>(renderBind.m_bind, sizeof(renderBind.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 < maxComputeBindings; ++ii)
-// {
-// const Binding& bind = renderBind.m_bind[ii];
-// if (kInvalidHandle != bind.m_idx)
-// {
-// switch (bind.m_type)
-// {
-// case Binding::Image:
-// {
-// TextureD3D12& texture = m_textures[bind.m_idx];
-//
-// if (Access::Read != bind.m_access)
-// {
-// texture.setState(m_commandList, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
-// scratchBuffer.allocUav(srvHandle[ii], texture, bind.m_mip);
-// }
-// else
-// {
-// texture.setState(m_commandList, D3D12_RESOURCE_STATE_GENERIC_READ);
-// scratchBuffer.allocSrv(srvHandle[ii], texture, bind.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_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, maxComputeBindings, _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_uniformBegin < compute.m_uniformEnd
- || currentProgramIdx != key.m_program)
+ || currentProgram.idx != key.m_program.idx)
{
rendererUpdateUniforms(this, _render->m_uniformBuffer[compute.m_uniformIdx], compute.m_uniformBegin, compute.m_uniformEnd);
- currentProgramIdx = key.m_program;
- ProgramVK& program = m_program[currentProgramIdx];
+ currentProgram = key.m_program;
+ ProgramVK& program = m_program[currentProgram.idx];
UniformBuffer* vcb = program.m_vsh->m_constantBuffer;
+
if (NULL != vcb)
{
commit(*vcb);
@@ -3993,13 +8440,62 @@ BX_UNUSED(currentSamplerStateIdx);
constantsChanged = true;
}
+ const ProgramVK& program = m_program[currentProgram.idx];
+
if (constantsChanged
|| hasPredefined)
{
- ProgramVK& program = m_program[currentProgramIdx];
- viewState.setPredefined<4>(this, view, 0, program, _render, compute);
-// commitShaderConstants(key.m_program, gpuAddress);
-// m_commandList->SetComputeRootConstantBufferView(Rdt::CBV, gpuAddress);
+ viewState.setPredefined<4>(this, view, program, _render, compute);
+ }
+
+ if (VK_NULL_HANDLE != program.m_descriptorSetLayout)
+ {
+ const uint32_t vsize = program.m_vsh->m_size;
+ uint32_t numOffset = 0;
+ uint32_t offset = 0;
+
+ if (constantsChanged
+ || hasPredefined)
+ {
+ if (vsize > 0)
+ {
+ offset = scratchBuffer.write(m_vsScratch, vsize);
+ ++numOffset;
+ }
+ }
+
+ bx::HashMurmur2A hash;
+ hash.begin();
+ hash.add(program.m_descriptorSetLayout);
+ hash.add(renderBind.m_bind, sizeof(renderBind.m_bind) );
+ hash.add(vsize);
+ hash.add(0);
+ const uint32_t bindHash = hash.end();
+
+ if (currentBindHash != bindHash)
+ {
+ currentBindHash = bindHash;
+
+ currentDescriptorSet = getDescriptorSet(
+ program
+ , renderBind
+ , scratchBuffer
+ , _render->m_colorPalette
+ );
+
+ descriptorSetCount++;
+ }
+
+ vkCmdBindDescriptorSets(
+ m_commandBuffer
+ , VK_PIPELINE_BIND_POINT_COMPUTE
+ , program.m_pipelineLayout
+ , 0
+ , 1
+ , &currentDescriptorSet
+ , numOffset
+ , &offset
+ );
}
if (isValid(compute.m_indirectBuffer) )
@@ -4014,13 +8510,13 @@ BX_UNUSED(currentSamplerStateIdx);
uint32_t args = compute.m_startIndirect * BGFX_CONFIG_DRAW_INDIRECT_STRIDE;
for (uint32_t ii = 0; ii < numDrawIndirect; ++ii)
{
-// m_commandList->ExecuteIndirect(ptr, args);
+ vkCmdDispatchIndirect(m_commandBuffer, vb.m_buffer, args);
args += BGFX_CONFIG_DRAW_INDIRECT_STRIDE;
}
}
else
{
-// m_commandList->Dispatch(compute.m_numX, compute.m_numY, compute.m_numZ);
+ vkCmdDispatch(m_commandBuffer, compute.m_numX, compute.m_numY, compute.m_numZ);
}
continue;
@@ -4028,189 +8524,154 @@ BX_UNUSED(currentSamplerStateIdx);
const RenderDraw& draw = renderItem.draw;
- const bool hasOcclusionQuery = false; //0 != (draw.m_stateFlags & BGFX_STATE_INTERNAL_OCCLUSION_QUERY);
+ rendererUpdateUniforms(this, _render->m_uniformBuffer[draw.m_uniformIdx], draw.m_uniformBegin, draw.m_uniformEnd);
+
+ const bool hasOcclusionQuery = 0 != (draw.m_stateFlags & BGFX_STATE_INTERNAL_OCCLUSION_QUERY);
{
- const bool occluded = false //true
-// && isValid(draw.m_occlusionQuery)
-// && !hasOcclusionQuery
-// && !isVisible(_render, draw.m_occlusionQuery, 0 != (draw.m_submitFlags&BGFX_SUBMIT_INTERNAL_OCCLUSION_VISIBLE) )
+ const bool occluded = true
+ && isValid(draw.m_occlusionQuery)
+ && !hasOcclusionQuery
+ && !isVisible(_render, draw.m_occlusionQuery, 0 != (draw.m_submitFlags & BGFX_SUBMIT_INTERNAL_OCCLUSION_VISIBLE) )
;
if (occluded
+ || !isFrameBufferValid
+ || 0 == draw.m_streamMask
|| _render->m_frameCache.isZeroArea(viewScissorRect, draw.m_scissor) )
{
-// if (resetState)
-// {
-// currentState.clear();
-// currentState.m_scissor = !draw.m_scissor;
-// currentBind.clear();
-// }
-
continue;
}
}
- const uint64_t newFlags = draw.m_stateFlags;
- uint64_t changedFlags = currentState.m_stateFlags ^ draw.m_stateFlags;
- currentState.m_stateFlags = newFlags;
+ const uint64_t changedFlags = currentState.m_stateFlags ^ draw.m_stateFlags;
+ currentState.m_stateFlags = draw.m_stateFlags;
- 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 (!beginRenderPass)
{
if (wasCompute)
{
wasCompute = false;
+ currentBindHash = 0;
}
- if (BX_ENABLED(BGFX_CONFIG_DEBUG_PIX) )
- {
- BX_UNUSED(s_viewName);
-// wchar_t* viewNameW = s_viewNameW[view];
-// viewNameW[3] = L' ';
-// PIX_ENDEVENT();
-// PIX_BEGINEVENT(toRgba8(0xff, 0x00, 0x00, 0xff), viewNameW);
- }
+ BGFX_VK_PROFILER_END();
+ setViewType(view, " ");
+ BGFX_VK_PROFILER_BEGIN(view, kColorDraw);
- commandListChanged = true;
- }
+ vkCmdBeginRenderPass(m_commandBuffer, &rpbi, VK_SUBPASS_CONTENTS_INLINE);
+ beginRenderPass = true;
- if (commandListChanged)
- {
- commandListChanged = false;
-
-// m_commandList->SetGraphicsRootSignature(m_rootSignature);
-// ID3D12DescriptorHeap* heaps[] = {
-// m_samplerAllocator.getHeap(),
-// scratchBuffer.getHeap(),
-// };
-// m_commandList->SetDescriptorHeaps(BX_COUNTOF(heaps), heaps);
-
- currentPipeline = VK_NULL_HANDLE;
- currentBindHash = 0;
- currentSamplerStateIdx = kInvalidHandle;
- currentProgramIdx = kInvalidHandle;
- currentState.clear();
+ currentProgram = BGFX_INVALID_HANDLE;
currentState.m_scissor = !draw.m_scissor;
- changedFlags = BGFX_STATE_MASK;
- changedStencil = packStencil(BGFX_STENCIL_MASK, BGFX_STENCIL_MASK);
- currentState.m_stateFlags = 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_uniformIdx], draw.m_uniformBegin, draw.m_uniformEnd);
-
- if (isValid(draw.m_stream[0].m_handle) )
+ if (0 != draw.m_streamMask)
{
- const uint64_t state = draw.m_stateFlags;
- bool hasFactor = 0
- || f0 == (state & f0)
- || f1 == (state & f1)
- ;
+ const bool bindAttribs = hasVertexStreamChanged(currentState, draw);
+
+ currentState.m_streamMask = draw.m_streamMask;
+ currentState.m_instanceDataBuffer = draw.m_instanceDataBuffer;
+ currentState.m_instanceDataOffset = draw.m_instanceDataOffset;
+ currentState.m_instanceDataStride = draw.m_instanceDataStride;
+
+ const VertexLayout* layouts[BGFX_CONFIG_MAX_VERTEX_STREAMS];
+ VkBuffer streamBuffers[BGFX_CONFIG_MAX_VERTEX_STREAMS + 1];
+ VkDeviceSize streamOffsets[BGFX_CONFIG_MAX_VERTEX_STREAMS + 1];
+ uint8_t numStreams = 0;
+ uint32_t numVertices = draw.m_numVertices;
+ if (UINT8_MAX != draw.m_streamMask)
+ {
+ for (uint32_t idx = 0, streamMask = draw.m_streamMask
+ ; 0 != streamMask
+ ; streamMask >>= 1, idx += 1, ++numStreams
+ )
+ {
+ const uint32_t ntz = bx::uint32_cnttz(streamMask);
+ streamMask >>= ntz;
+ idx += ntz;
+
+ currentState.m_stream[idx] = draw.m_stream[idx];
+
+ const VertexBufferHandle handle = draw.m_stream[idx].m_handle;
+ const VertexBufferVK& vb = m_vertexBuffers[handle.idx];
+ const uint16_t decl = isValid(draw.m_stream[idx].m_layoutHandle)
+ ? draw.m_stream[idx].m_layoutHandle.idx
+ : vb.m_layoutHandle.idx
+ ;
+ const VertexLayout& layout = m_vertexLayouts[decl];
+ const uint32_t stride = layout.m_stride;
+
+ streamBuffers[numStreams] = m_vertexBuffers[handle.idx].m_buffer;
+ streamOffsets[numStreams] = draw.m_stream[idx].m_startVertex * stride;
+ layouts[numStreams] = &layout;
+
+ numVertices = bx::uint32_min(UINT32_MAX == draw.m_numVertices
+ ? vb.m_size/stride
+ : draw.m_numVertices
+ , numVertices
+ );
+ }
+ }
+
+ if (bindAttribs)
+ {
+ uint32_t numVertexBuffers = numStreams;
+
+ if (isValid(draw.m_instanceDataBuffer) )
+ {
+ streamOffsets[numVertexBuffers] = draw.m_instanceDataOffset;
+ streamBuffers[numVertexBuffers] = m_vertexBuffers[draw.m_instanceDataBuffer.idx].m_buffer;
+ numVertexBuffers++;
+ }
- const VertexBufferVK& vb = m_vertexBuffers[draw.m_stream[0].m_handle.idx];
- uint16_t declIdx = !isValid(vb.m_decl) ? draw.m_stream[0].m_decl.idx : vb.m_decl.idx;
+ if (0 < numVertexBuffers)
+ {
+ vkCmdBindVertexBuffers(
+ m_commandBuffer
+ , 0
+ , numVertexBuffers
+ , &streamBuffers[0]
+ , streamOffsets
+ );
+ }
+ }
- VkPipeline pipeline =
- getPipeline(state
+ const VkPipeline pipeline =
+ getPipeline(draw.m_stateFlags
, draw.m_stencil
- , declIdx
+ , numStreams
+ , layouts
, key.m_program
, uint8_t(draw.m_instanceDataStride/16)
);
- uint16_t scissor = draw.m_scissor;
- uint32_t bindHash = bx::hash<bx::HashMurmur2A>(renderBind.m_bind, sizeof(renderBind.m_bind) );
- if (currentBindHash != bindHash
- || 0 != changedStencil
- || (hasFactor && blendFactor != draw.m_rgba)
- || (0 != (BGFX_STATE_PT_MASK & changedFlags)
- || prim.m_topology != s_primInfo[primIndex].m_topology)
- || currentState.m_scissor != scissor
- || pipeline != currentPipeline
- || hasOcclusionQuery)
+ if (currentPipeline != pipeline)
{
-// m_batch.flush(m_commandList);
+ currentPipeline = pipeline;
+ vkCmdBindPipeline(m_commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
}
-// 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 = renderBind.m_bind[stage];
-// if (kInvalidHandle != 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_TEXTURE_INTERNAL_DEFAULT_SAMPLER & bind.m_textureFlags)
-// ? bind.m_textureFlags
-// : texture.m_flags
-// ) & (BGFX_TEXTURE_SAMPLER_BITS_MASK|BGFX_TEXTURE_BORDER_COLOR_MASK)
-// ;
-// }
-// else
-// {
-// bx::memCopy(&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 (pipeline != currentPipeline
- || 0 != changedStencil)
+ const bool hasStencil = 0 != draw.m_stencil;
+
+ if (hasStencil
+ && currentState.m_stencil != draw.m_stencil)
{
+ currentState.m_stencil = draw.m_stencil;
+
const uint32_t fstencil = unpackStencil(0, draw.m_stencil);
const uint32_t ref = (fstencil&BGFX_STENCIL_FUNC_REF_MASK)>>BGFX_STENCIL_FUNC_REF_SHIFT;
vkCmdSetStencilReference(m_commandBuffer, VK_STENCIL_FRONT_AND_BACK, ref);
}
- if (pipeline != currentPipeline
- || (hasFactor && blendFactor != draw.m_rgba) )
+ const bool hasFactor = 0
+ || f0 == (draw.m_stateFlags & f0)
+ || f1 == (draw.m_stateFlags & f1)
+ || f2 == (draw.m_stateFlags & f2)
+ || f3 == (draw.m_stateFlags & f3)
+ ;
+
+ if (hasFactor
+ && blendFactor != draw.m_rgba)
{
blendFactor = draw.m_rgba;
@@ -4222,14 +8683,7 @@ BX_UNUSED(currentSamplerStateIdx);
vkCmdSetBlendConstants(m_commandBuffer, bf);
}
- if (0 != (BGFX_STATE_PT_MASK & changedFlags)
- || prim.m_topology != s_primInfo[primIndex].m_topology)
- {
- 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_topology);
- }
+ const uint16_t scissor = draw.m_scissor;
if (currentState.m_scissor != scissor)
{
@@ -4244,8 +8698,8 @@ BX_UNUSED(currentSamplerStateIdx);
VkRect2D rc;
rc.offset.x = viewScissorRect.m_x;
rc.offset.y = viewScissorRect.m_y;
- rc.extent.width = viewScissorRect.m_x + viewScissorRect.m_width;
- rc.extent.height = viewScissorRect.m_y + viewScissorRect.m_height;
+ rc.extent.width = viewScissorRect.m_width;
+ rc.extent.height = viewScissorRect.m_height;
vkCmdSetScissor(m_commandBuffer, 0, 1, &rc);
}
}
@@ -4258,25 +8712,19 @@ BX_UNUSED(currentSamplerStateIdx);
VkRect2D rc;
rc.offset.x = scissorRect.m_x;
rc.offset.y = scissorRect.m_y;
- rc.extent.width = scissorRect.m_x + scissorRect.m_width;
- rc.extent.height = scissorRect.m_y + scissorRect.m_height;
+ rc.extent.width = scissorRect.m_width;
+ rc.extent.height = scissorRect.m_height;
vkCmdSetScissor(m_commandBuffer, 0, 1, &rc);
}
}
- if (pipeline != currentPipeline)
- {
- currentPipeline = pipeline;
- vkCmdBindPipeline(m_commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
- }
-
bool constantsChanged = false;
if (draw.m_uniformBegin < draw.m_uniformEnd
- || currentProgramIdx != key.m_program
+ || currentProgram.idx != key.m_program.idx
|| BGFX_STATE_ALPHA_REF_MASK & changedFlags)
{
- currentProgramIdx = key.m_program;
- ProgramVK& program = m_program[currentProgramIdx];
+ currentProgram = key.m_program;
+ ProgramVK& program = m_program[currentProgram.idx];
UniformBuffer* vcb = program.m_vsh->m_constantBuffer;
if (NULL != vcb)
@@ -4284,83 +8732,222 @@ BX_UNUSED(currentSamplerStateIdx);
commit(*vcb);
}
- UniformBuffer* fcb = program.m_fsh->m_constantBuffer;
- if (NULL != fcb)
+ if (NULL != program.m_fsh)
{
- commit(*fcb);
+ UniformBuffer* fcb = program.m_fsh->m_constantBuffer;
+ if (NULL != fcb)
+ {
+ commit(*fcb);
+ }
}
hasPredefined = 0 < program.m_numPredefined;
constantsChanged = true;
}
- if (constantsChanged
- || hasPredefined)
+ const ProgramVK& program = m_program[currentProgram.idx];
+
+ if (hasPredefined)
{
- ProgramVK& 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);
- commitShaderUniforms(m_commandBuffer, key.m_program); //, gpuAddress);
+ uint32_t ref = (draw.m_stateFlags & BGFX_STATE_ALPHA_REF_MASK) >> BGFX_STATE_ALPHA_REF_SHIFT;
+ viewState.m_alphaRef = ref / 255.0f;
+ viewState.setPredefined<4>(this, view, program, _render, draw);
}
+ if (VK_NULL_HANDLE != program.m_descriptorSetLayout)
+ {
+ const uint32_t vsize = program.m_vsh->m_size;
+ const uint32_t fsize = NULL != program.m_fsh ? program.m_fsh->m_size : 0;
+ uint32_t numOffset = 0;
+ uint32_t offsets[2] = { 0, 0 };
-// vb.setState(_commandList, D3D12_RESOURCE_STATE_GENERIC_READ);
+ if (constantsChanged
+ || hasPredefined)
+ {
+ if (vsize > 0)
+ {
+ offsets[numOffset++] = scratchBuffer.write(m_vsScratch, vsize);
+ }
- const VertexDecl& vertexDecl = m_vertexDecls[declIdx];
- uint32_t numIndices = 0;
+ if (fsize > 0)
+ {
+ offsets[numOffset++] = scratchBuffer.write(m_fsScratch, fsize);
+ }
+ }
- VkDeviceSize offset = 0;
- vkCmdBindVertexBuffers(m_commandBuffer
- , 0
- , 1
- , &vb.m_buffer
- , &offset
- );
+ bx::HashMurmur2A hash;
+ hash.begin();
+ hash.add(program.m_descriptorSetLayout);
+ hash.add(renderBind.m_bind, sizeof(renderBind.m_bind) );
+ hash.add(vsize);
+ hash.add(fsize);
+ const uint32_t bindHash = hash.end();
- if (!isValid(draw.m_indexBuffer) )
- {
- const uint32_t numVertices = UINT32_MAX == draw.m_numVertices
- ? vb.m_size / vertexDecl.m_stride
- : draw.m_numVertices
- ;
- vkCmdDraw(m_commandBuffer
- , numVertices
- , draw.m_numInstances
- , draw.m_stream[0].m_startVertex
+ if (currentBindHash != bindHash)
+ {
+ currentBindHash = bindHash;
+
+ currentDescriptorSet = getDescriptorSet(
+ program
+ , renderBind
+ , scratchBuffer
+ , _render->m_colorPalette
+ );
+
+ descriptorSetCount++;
+ }
+
+ vkCmdBindDescriptorSets(
+ m_commandBuffer
+ , VK_PIPELINE_BIND_POINT_GRAPHICS
+ , program.m_pipelineLayout
, 0
+ , 1
+ , &currentDescriptorSet
+ , numOffset
+ , offsets
);
}
- else
+
+ VkBuffer bufferIndirect = VK_NULL_HANDLE;
+ VkBuffer bufferNumIndirect = VK_NULL_HANDLE;
+ uint32_t numDrawIndirect = 0;
+ uint32_t bufferOffsetIndirect = 0;
+ uint32_t bufferNumOffsetIndirect = 0;
+ if (isValid(draw.m_indirectBuffer) )
+ {
+ const VertexBufferVK& vb = m_vertexBuffers[draw.m_indirectBuffer.idx];
+ bufferIndirect = vb.m_buffer;
+ numDrawIndirect = UINT16_MAX == draw.m_numIndirect
+ ? vb.m_size / BGFX_CONFIG_DRAW_INDIRECT_STRIDE
+ : draw.m_numIndirect
+ ;
+ bufferOffsetIndirect = draw.m_startIndirect * BGFX_CONFIG_DRAW_INDIRECT_STRIDE;
+
+ if (isValid(draw.m_numIndirectBuffer) )
+ {
+ bufferNumIndirect = m_indexBuffers[draw.m_numIndirectBuffer.idx].m_buffer;
+ bufferNumOffsetIndirect = draw.m_numIndirectIndex * sizeof(uint32_t);
+ }
+ }
+
+ if (hasOcclusionQuery)
{
- BufferVK& ib = m_indexBuffers[draw.m_indexBuffer.idx];
-// ib.setState(_commandList, D3D12_RESOURCE_STATE_GENERIC_READ);
+ m_occlusionQuery.begin(draw.m_occlusionQuery);
+ }
- const bool hasIndex16 = 0 == (ib.m_flags & BGFX_BUFFER_INDEX32);
- const uint32_t indexSize = hasIndex16 ? 2 : 4;
+ const uint8_t primIndex = uint8_t((draw.m_stateFlags & BGFX_STATE_PT_MASK) >> BGFX_STATE_PT_SHIFT);
+ const PrimInfo& prim = s_primInfo[primIndex];
+
+ uint32_t numPrimsSubmitted = 0;
+ uint32_t numIndices = 0;
+
+ if (!isValid(draw.m_indexBuffer) )
+ {
+ numPrimsSubmitted = numVertices / prim.m_div - prim.m_sub;
+
+ if (isValid(draw.m_indirectBuffer) )
+ {
+ if (isValid(draw.m_numIndirectBuffer) )
+ {
+ vkCmdDrawIndirectCountKHR(
+ m_commandBuffer
+ , bufferIndirect
+ , bufferOffsetIndirect
+ , bufferNumIndirect
+ , bufferNumOffsetIndirect
+ , numDrawIndirect
+ , BGFX_CONFIG_DRAW_INDIRECT_STRIDE
+ );
+ }
+ else
+ {
+ vkCmdDrawIndirect(
+ m_commandBuffer
+ , bufferIndirect
+ , bufferOffsetIndirect
+ , numDrawIndirect
+ , BGFX_CONFIG_DRAW_INDIRECT_STRIDE
+ );
+ }
+ }
+ else
+ {
+ vkCmdDraw(
+ m_commandBuffer
+ , numVertices
+ , draw.m_numInstances
+ , 0
+ , 0
+ );
+ }
+ }
+ else
+ {
+ const bool isIndex16 = draw.isIndex16();
+ const uint32_t indexSize = isIndex16 ? 2 : 4;
+ const VkIndexType indexFormat = isIndex16 ? VK_INDEX_TYPE_UINT16 : VK_INDEX_TYPE_UINT32;
+ const BufferVK& ib = m_indexBuffers[draw.m_indexBuffer.idx];
numIndices = UINT32_MAX == draw.m_numIndices
? ib.m_size / indexSize
: draw.m_numIndices
;
- vkCmdBindIndexBuffer(m_commandBuffer
- , ib.m_buffer
- , 0
- , hasIndex16
- ? VK_INDEX_TYPE_UINT16
- : VK_INDEX_TYPE_UINT32
- );
- vkCmdDrawIndexed(m_commandBuffer
- , numIndices
- , draw.m_numInstances
- , draw.m_startIndex
- , draw.m_stream[0].m_startVertex
- , 0
- );
+ numPrimsSubmitted = numIndices / prim.m_div - prim.m_sub;
+
+ if (currentState.m_indexBuffer.idx != draw.m_indexBuffer.idx
+ || currentIndexFormat != indexFormat)
+ {
+ currentState.m_indexBuffer = draw.m_indexBuffer;
+ currentIndexFormat = indexFormat;
+
+ vkCmdBindIndexBuffer(
+ m_commandBuffer
+ , m_indexBuffers[draw.m_indexBuffer.idx].m_buffer
+ , 0
+ , indexFormat
+ );
+ }
+
+ if (isValid(draw.m_indirectBuffer) )
+ {
+ if (isValid(draw.m_numIndirectBuffer) )
+ {
+ vkCmdDrawIndexedIndirectCountKHR(
+ m_commandBuffer
+ , bufferIndirect
+ , bufferOffsetIndirect
+ , bufferNumIndirect
+ , bufferNumOffsetIndirect
+ , numDrawIndirect
+ , BGFX_CONFIG_DRAW_INDIRECT_STRIDE
+ );
+ }
+ else
+ {
+ vkCmdDrawIndexedIndirect(
+ m_commandBuffer
+ , bufferIndirect
+ , bufferOffsetIndirect
+ , numDrawIndirect
+ , BGFX_CONFIG_DRAW_INDIRECT_STRIDE
+ );
+ }
+ }
+ else
+ {
+ vkCmdDrawIndexed(
+ m_commandBuffer
+ , numIndices
+ , draw.m_numInstances
+ , draw.m_startIndex
+ , 0
+ , 0
+ );
+ }
}
- uint32_t numPrimsSubmitted = numIndices / prim.m_div - prim.m_sub;
uint32_t numPrimsRendered = numPrimsSubmitted*draw.m_numInstances;
statsNumPrimsSubmitted[primIndex] += numPrimsSubmitted;
@@ -4370,18 +8957,38 @@ BX_UNUSED(currentSamplerStateIdx);
if (hasOcclusionQuery)
{
-// m_occlusionQuery.begin(m_commandList, _render, draw.m_occlusionQuery);
-// m_batch.flush(m_commandList);
-// m_occlusionQuery.end(m_commandList);
+ m_occlusionQuery.end();
}
}
}
+ if (beginRenderPass)
+ {
+ vkCmdEndRenderPass(m_commandBuffer);
+ beginRenderPass = false;
+ }
+
+ if (wasCompute)
+ {
+ setViewType(view, "C");
+ BGFX_VK_PROFILER_END();
+ BGFX_VK_PROFILER_BEGIN(view, kColorCompute);
+ }
+
submitBlit(bs, BGFX_CONFIG_MAX_VIEWS);
-// m_batch.end(m_commandList);
+ if (0 < _render->m_numRenderItems)
+ {
+ captureElapsed = -bx::getHPCounter();
+ capture();
+ captureElapsed += bx::getHPCounter();
+
+ profiler.end();
+ }
}
+ BGFX_VK_PROFILER_END();
+
int64_t timeEnd = bx::getHPCounter();
int64_t frameTime = timeEnd - timeBegin;
@@ -4393,46 +9000,77 @@ BX_UNUSED(currentSamplerStateIdx);
static uint32_t maxGpuLatency = 0;
static double maxGpuElapsed = 0.0f;
double elapsedGpuMs = 0.0;
-BX_UNUSED(maxGpuLatency, maxGpuElapsed, elapsedGpuMs);
- static int64_t presentMin = 0; //m_presentElapsed;
- static int64_t presentMax = 0; //m_presentElapsed;
-BX_UNUSED(presentMin, presentMax);
-// presentMin = bx::min<int64_t>(presentMin, m_presentElapsed);
-// presentMax = bx::max<int64_t>(presentMax, m_presentElapsed);
+ static int64_t presentMin = m_presentElapsed;
+ static int64_t presentMax = m_presentElapsed;
+ presentMin = bx::min<int64_t>(presentMin, m_presentElapsed);
+ presentMax = bx::max<int64_t>(presentMax, m_presentElapsed);
+
+ if (UINT32_MAX != frameQueryIdx)
+ {
+ m_gpuTimer.end(frameQueryIdx);
+
+ const TimerQueryVK::Result& result = m_gpuTimer.m_result[BGFX_CONFIG_MAX_VIEWS];
+ double toGpuMs = 1000.0 / double(m_gpuTimer.m_frequency);
+ elapsedGpuMs = (result.m_end - result.m_begin) * toGpuMs;
+ maxGpuElapsed = elapsedGpuMs > maxGpuElapsed ? elapsedGpuMs : maxGpuElapsed;
-// m_gpuTimer.end(m_commandList);
+ maxGpuLatency = bx::uint32_imax(maxGpuLatency, result.m_pending-1);
+ }
-// while (m_gpuTimer.get() )
-// {
-// double toGpuMs = 1000.0 / double(m_gpuTimer.m_frequency);
-// elapsedGpuMs = m_gpuTimer.m_elapsed * toGpuMs;
-// maxGpuElapsed = elapsedGpuMs > maxGpuElapsed ? elapsedGpuMs : maxGpuElapsed;
-// }
-// maxGpuLatency = bx::uint32_imax(maxGpuLatency, m_gpuTimer.m_control.available()-1);
+ maxGpuLatency = bx::uint32_imax(maxGpuLatency, m_gpuTimer.m_control.available()-1);
const int64_t timerFreq = bx::getHPFrequency();
+ VkPhysicalDeviceMemoryBudgetPropertiesEXT dmbp;
+ dmbp.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
+ dmbp.pNext = NULL;
+
+ int64_t gpuMemoryAvailable = -INT64_MAX;
+ int64_t gpuMemoryUsed = -INT64_MAX;
+
+ if (s_extension[Extension::EXT_memory_budget].m_supported)
+ {
+ VkPhysicalDeviceMemoryProperties2 pdmp2;
+ pdmp2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
+ pdmp2.pNext = &dmbp;
+
+ vkGetPhysicalDeviceMemoryProperties2KHR(m_physicalDevice, &pdmp2);
+
+ gpuMemoryAvailable = 0;
+ gpuMemoryUsed = 0;
+
+ for (uint32_t ii = 0; ii < m_memoryProperties.memoryHeapCount; ++ii)
+ {
+ if (!!(m_memoryProperties.memoryHeaps[ii].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) )
+ {
+ gpuMemoryAvailable += dmbp.heapBudget[ii];
+ gpuMemoryUsed += dmbp.heapUsage[ii];
+ }
+ }
+ }
+
Stats& perfStats = _render->m_perfStats;
perfStats.cpuTimeBegin = timeBegin;
perfStats.cpuTimeEnd = timeEnd;
perfStats.cpuTimerFreq = timerFreq;
-// perfStats.gpuTimeBegin = m_gpuTimer.m_begin;
-// perfStats.gpuTimeEnd = m_gpuTimer.m_end;
-// perfStats.gpuTimerFreq = m_gpuTimer.m_frequency;
-// perfStats.numDraw = statsKeyType[0];
-// perfStats.numCompute = statsKeyType[1];
+ const TimerQueryVK::Result& result = m_gpuTimer.m_result[BGFX_CONFIG_MAX_VIEWS];
+ perfStats.gpuTimeBegin = result.m_begin;
+ perfStats.gpuTimeEnd = result.m_end;
+ perfStats.gpuTimerFreq = m_gpuTimer.m_frequency;
+ perfStats.numDraw = statsKeyType[0];
+ perfStats.numCompute = statsKeyType[1];
perfStats.numBlit = _render->m_numBlitItems;
-// perfStats.maxGpuLatency = maxGpuLatency;
+ perfStats.maxGpuLatency = maxGpuLatency;
+ perfStats.gpuFrameNum = result.m_frameNum;
bx::memCopy(perfStats.numPrims, statsNumPrimsRendered, sizeof(perfStats.numPrims) );
- perfStats.gpuMemoryMax = -INT64_MAX;
- perfStats.gpuMemoryUsed = -INT64_MAX;
+ perfStats.gpuMemoryMax = gpuMemoryAvailable;
+ perfStats.gpuMemoryUsed = gpuMemoryUsed;
if (_render->m_debug & (BGFX_DEBUG_IFH|BGFX_DEBUG_STATS) )
{
-// PIX_BEGINEVENT(toRgba8(0x40, 0x40, 0x40, 0xff), L"debugstats");
+ BGFX_VK_PROFILER_BEGIN_LITERAL("debugstats", kColorFrame);
-// m_needPresent = true;
TextVideoMem& tvm = m_textVideoMem;
static int64_t next = timeEnd;
@@ -4447,55 +9085,42 @@ BX_UNUSED(presentMin, presentMax);
tvm.clear();
uint16_t pos = 0;
tvm.printf(0, pos++, BGFX_CONFIG_DEBUG ? 0x8c : 0x8f
- , " %s / " BX_COMPILER_NAME " / " BX_CPU_NAME " / " BX_ARCH_NAME " / " BX_PLATFORM_NAME " "
+ , " %s / " BX_COMPILER_NAME
+ " / " BX_CPU_NAME
+ " / " BX_ARCH_NAME
+ " / " BX_PLATFORM_NAME
+ " / Version 1.%d.%d (commit: " BGFX_REV_SHA1 ")"
, getRendererName()
+ , BGFX_API_VERSION
+ , BGFX_REV_NUMBER
);
-// 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
-// );
+ const VkPhysicalDeviceProperties& pdp = m_deviceProperties;
+ tvm.printf(0, pos++, 0x8f, " Device: %s (%s)"
+ , pdp.deviceName
+ , getName(pdp.deviceType)
+ );
+
+ if (0 <= gpuMemoryAvailable && 0 <= gpuMemoryUsed)
+ {
+ for (uint32_t ii = 0; ii < m_memoryProperties.memoryHeapCount; ++ii)
+ {
+ char budget[16];
+ bx::prettify(budget, BX_COUNTOF(budget), dmbp.heapBudget[ii]);
+
+ char usage[16];
+ bx::prettify(usage, BX_COUNTOF(usage), dmbp.heapUsage[ii]);
+
+ const bool local = (!!(m_memoryProperties.memoryHeaps[ii].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) );
+
+ tvm.printf(0, pos++, 0x8f, " Memory %d %s - Budget: %12s, Usage: %12s"
+ , ii
+ , local ? "(local) " : "(non-local)"
+ , budget
+ , usage
+ );
+ }
+ }
pos = 10;
tvm.printf(10, pos++, 0x8b, " Frame: % 7.3f, % 7.3f \x1f, % 7.3f \x1e [ms] / % 6.2f FPS "
@@ -4504,11 +9129,11 @@ BX_UNUSED(presentMin, presentMax);
, double(max)*toMs
, freq/frameTime
);
-// tvm.printf(10, pos++, 0x8b, " Present: % 7.3f, % 7.3f \x1f, % 7.3f \x1e [ms] "
-// , double(m_presentElapsed)*toMs
-// , double(presentMin)*toMs
-// , double(presentMax)*toMs
-// );
+ tvm.printf(10, pos++, 0x8b, " Present: % 7.3f, % 7.3f \x1f, % 7.3f \x1e [ms] "
+ , double(m_presentElapsed)*toMs
+ , double(presentMin)*toMs
+ , double(presentMax)*toMs
+ );
const uint32_t msaa = (m_resolution.reset&BGFX_RESET_MSAA_MASK)>>BGFX_RESET_MSAA_SHIFT;
tvm.printf(10, pos++, 0x8b, " Reset flags: [%c] vsync, [%c] MSAAx%d, [%c] MaxAnisotropy "
@@ -4536,22 +9161,10 @@ BX_UNUSED(presentMin, presentMax);
);
}
-// tvm.printf(10, pos++, 0x8b, " 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++, 0x8b, " %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, 0x4f, " [F11 - RenderDoc capture] ");
- }
+ if (NULL != m_renderDocDll)
+ {
+ tvm.printf(tvm.m_width-27, 0, 0x4f, " [F11 - RenderDoc capture] ");
+ }
tvm.printf(10, pos++, 0x8b, " Indices: %7d ", statsNumIndices);
// tvm.printf(10, pos++, 0x8b, " Uniform size: %7d, Max: %7d ", _render->m_uniformEnd, _render->m_uniformMax);
@@ -4559,13 +9172,15 @@ BX_UNUSED(presentMin, presentMax);
tvm.printf(10, pos++, 0x8b, " DIB size: %7d ", _render->m_iboffset);
pos++;
- tvm.printf(10, pos++, 0x8b, " State cache: ");
- tvm.printf(10, pos++, 0x8b, " PSO | Sampler | Bind | Queued ");
- tvm.printf(10, pos++, 0x8b, " %6d " //| %6d | %6d | %6d "
+ tvm.printf(10, pos++, 0x8b, " Occlusion queries: %3d ", m_occlusionQuery.m_control.available() );
+
+ pos++;
+ tvm.printf(10, pos++, 0x8b, " State cache: ");
+ tvm.printf(10, pos++, 0x8b, " PSO | DSL | DS ");
+ tvm.printf(10, pos++, 0x8b, " %6d | %6d | %6d "
, m_pipelineStateCache.getCount()
-// , m_samplerStateCache.getCount()
-// , bindLru.getCount()
-// , m_cmd.m_control.available()
+ , m_descriptorSetLayoutCache.getCount()
+ , descriptorSetCount
);
pos++;
@@ -4580,41 +9195,49 @@ BX_UNUSED(presentMin, presentMax);
min = frameTime;
max = frameTime;
-// presentMin = m_presentElapsed;
-// presentMax = m_presentElapsed;
+ presentMin = m_presentElapsed;
+ presentMax = m_presentElapsed;
}
blit(this, _textVideoMemBlitter, tvm);
-// PIX_ENDEVENT();
+ BGFX_VK_PROFILER_END();
}
else if (_render->m_debug & BGFX_DEBUG_TEXT)
{
-// PIX_BEGINEVENT(toRgba8(0x40, 0x40, 0x40, 0xff), L"debugtext");
+ BGFX_VK_PROFILER_BEGIN_LITERAL("debugtext", kColorFrame);
blit(this, _textVideoMemBlitter, _render->m_textVideoMem);
-// PIX_ENDEVENT();
+ BGFX_VK_PROFILER_END();
}
- if (beginRenderPass)
+ m_presentElapsed = 0;
+
+ scratchBuffer.flush();
+
+ for (uint16_t ii = 0; ii < m_numWindows; ++ii)
{
- vkCmdEndRenderPass(m_commandBuffer);
- beginRenderPass = false;
- }
+ FrameBufferVK& fb = isValid(m_windows[ii])
+ ? m_frameBuffers[m_windows[ii].idx]
+ : m_backBuffer
+ ;
- setImageMemoryBarrier(m_commandBuffer
- , m_backBufferColorImage[m_backBufferColorIdx]
- , VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
- , VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
- );
+ if (fb.m_needPresent)
+ {
+ fb.resolve();
+
+ fb.m_swapChain.transitionImage(m_commandBuffer);
- VK_CHECK(vkEndCommandBuffer(m_commandBuffer) );
+ m_cmd.addWaitSemaphore(fb.m_swapChain.m_lastImageAcquiredSemaphore, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
+ m_cmd.addSignalSemaphore(fb.m_swapChain.m_lastImageRenderedSemaphore);
+ fb.m_swapChain.m_lastImageAcquiredSemaphore = VK_NULL_HANDLE;
- kick(renderWait); //, m_presentDone[m_backBufferColorIdx]);
- finishAll();
+ fb.m_swapChain.m_backBufferFence[fb.m_swapChain.m_backBufferColorIdx] = m_cmd.m_currentFence;
+ }
+ }
- VK_CHECK(vkResetCommandPool(m_device, m_commandPool, 0) );
+ kick();
}
} /* namespace vk */ } // namespace bgfx