diff options
Diffstat (limited to '3rdparty/bgfx/src/renderer_vk.cpp')
-rw-r--r-- | 3rdparty/bgfx/src/renderer_vk.cpp | 8889 |
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, ®ion); + + 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, ®ion); + + 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 + , ©Info + ); + + 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 + , ¤tDescriptorSet + , 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 + , ¤tDescriptorSet + , 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 |