diff options
Diffstat (limited to '3rdparty/bgfx/src/renderer_vk.h')
-rw-r--r-- | 3rdparty/bgfx/src/renderer_vk.h | 819 |
1 files changed, 620 insertions, 199 deletions
diff --git a/3rdparty/bgfx/src/renderer_vk.h b/3rdparty/bgfx/src/renderer_vk.h index bd7ea608916..1852ed83123 100644 --- a/3rdparty/bgfx/src/renderer_vk.h +++ b/3rdparty/bgfx/src/renderer_vk.h @@ -1,6 +1,6 @@ /* - * 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 */ #ifndef BGFX_RENDERER_VK_H_HEADER_GUARD @@ -8,27 +8,39 @@ #if BX_PLATFORM_ANDROID # define VK_USE_PLATFORM_ANDROID_KHR -# define KHR_SURFACE_EXTENSION_NAME VK_KHR_ANDROID_SURFACE_EXTENSION_NAME # define VK_IMPORT_INSTANCE_PLATFORM VK_IMPORT_INSTANCE_ANDROID #elif BX_PLATFORM_LINUX -//# define VK_USE_PLATFORM_MIR_KHR +# define VK_USE_PLATFORM_WAYLAND_KHR # define VK_USE_PLATFORM_XLIB_KHR # define VK_USE_PLATFORM_XCB_KHR -//# define VK_USE_PLATFORM_WAYLAND_KHR -# define KHR_SURFACE_EXTENSION_NAME VK_KHR_XCB_SURFACE_EXTENSION_NAME # define VK_IMPORT_INSTANCE_PLATFORM VK_IMPORT_INSTANCE_LINUX #elif BX_PLATFORM_WINDOWS # define VK_USE_PLATFORM_WIN32_KHR -# define KHR_SURFACE_EXTENSION_NAME VK_KHR_WIN32_SURFACE_EXTENSION_NAME # define VK_IMPORT_INSTANCE_PLATFORM VK_IMPORT_INSTANCE_WINDOWS +#elif BX_PLATFORM_OSX +# define VK_USE_PLATFORM_MACOS_MVK +# define VK_IMPORT_INSTANCE_PLATFORM VK_IMPORT_INSTANCE_MACOS #else -# define KHR_SURFACE_EXTENSION_NAME "" # define VK_IMPORT_INSTANCE_PLATFORM #endif // BX_PLATFORM_* #define VK_NO_STDINT_H #define VK_NO_PROTOTYPES -#include <vulkan/vulkan.h> +#include <vulkan-local/vulkan.h> + +// vulkan.h pulls X11 crap... +#if defined(None) +# undef None +#endif // defined(None) + +#if defined(Success) +# undef Success +#endif // defined(Success) + +#if defined(Status) +# undef Status +#endif // defined(Status) + #include "renderer.h" #include "debug_renderdoc.h" @@ -38,24 +50,32 @@ VK_IMPORT_FUNC(false, vkGetDeviceProcAddr); \ VK_IMPORT_FUNC(false, vkEnumerateInstanceExtensionProperties); \ VK_IMPORT_FUNC(false, vkEnumerateInstanceLayerProperties); \ - -#define VK_IMPORT_INSTANCE_ANDROID \ - VK_IMPORT_INSTANCE_FUNC(true, vkCreateAndroidSurfaceKHR); - -#define VK_IMPORT_INSTANCE_LINUX \ - VK_IMPORT_INSTANCE_FUNC(true, vkCreateXlibSurfaceKHR); \ - VK_IMPORT_INSTANCE_FUNC(true, vkGetPhysicalDeviceXlibPresentationSupportKHR); \ - VK_IMPORT_INSTANCE_FUNC(true, vkCreateXcbSurfaceKHR); \ - VK_IMPORT_INSTANCE_FUNC(true, vkGetPhysicalDeviceXcbPresentationSupportKHR); \ - -// VK_IMPORT_INSTANCE_FUNC(true, vkCreateWaylandSurfaceKHR); -// VK_IMPORT_INSTANCE_FUNC(true, vkGetPhysicalDeviceWaylandPresentationSupportKHR); -// VK_IMPORT_INSTANCE_FUNC(true, vkCreateMirSurfaceKHR); -// VK_IMPORT_INSTANCE_FUNC(true, vkGetPhysicalDeviceMirPresentationSupportKHR); - -#define VK_IMPORT_INSTANCE_WINDOWS \ - VK_IMPORT_INSTANCE_FUNC(true, vkCreateWin32SurfaceKHR); \ - VK_IMPORT_INSTANCE_FUNC(true, vkGetPhysicalDeviceWin32PresentationSupportKHR); + /* 1.1 */ \ + VK_IMPORT_FUNC(true, vkEnumerateInstanceVersion); \ + +#define VK_IMPORT_INSTANCE_ANDROID \ + /* VK_KHR_android_surface */ \ + VK_IMPORT_INSTANCE_FUNC(true, vkCreateAndroidSurfaceKHR); \ + +#define VK_IMPORT_INSTANCE_LINUX \ + /* VK_KHR_wayland_surface */ \ + VK_IMPORT_INSTANCE_FUNC(true, vkCreateWaylandSurfaceKHR); \ + VK_IMPORT_INSTANCE_FUNC(true, vkGetPhysicalDeviceWaylandPresentationSupportKHR); \ + /* VK_KHR_xlib_surface */ \ + VK_IMPORT_INSTANCE_FUNC(true, vkCreateXlibSurfaceKHR); \ + VK_IMPORT_INSTANCE_FUNC(true, vkGetPhysicalDeviceXlibPresentationSupportKHR); \ + /* VK_KHR_xcb_surface */ \ + VK_IMPORT_INSTANCE_FUNC(true, vkCreateXcbSurfaceKHR); \ + VK_IMPORT_INSTANCE_FUNC(true, vkGetPhysicalDeviceXcbPresentationSupportKHR); \ + +#define VK_IMPORT_INSTANCE_WINDOWS \ + /* VK_KHR_win32_surface */ \ + VK_IMPORT_INSTANCE_FUNC(true, vkCreateWin32SurfaceKHR); \ + VK_IMPORT_INSTANCE_FUNC(true, vkGetPhysicalDeviceWin32PresentationSupportKHR); \ + +#define VK_IMPORT_INSTANCE_MACOS \ + /* VK_MVK_macos_surface */ \ + VK_IMPORT_INSTANCE_FUNC(true, vkCreateMacOSSurfaceMVK); \ #define VK_IMPORT_INSTANCE \ VK_IMPORT_INSTANCE_FUNC(false, vkDestroyInstance); \ @@ -64,115 +84,133 @@ VK_IMPORT_INSTANCE_FUNC(false, vkEnumerateDeviceLayerProperties); \ VK_IMPORT_INSTANCE_FUNC(false, vkGetPhysicalDeviceProperties); \ VK_IMPORT_INSTANCE_FUNC(false, vkGetPhysicalDeviceFormatProperties); \ + VK_IMPORT_INSTANCE_FUNC(false, vkGetPhysicalDeviceFeatures); \ VK_IMPORT_INSTANCE_FUNC(false, vkGetPhysicalDeviceImageFormatProperties); \ VK_IMPORT_INSTANCE_FUNC(false, vkGetPhysicalDeviceMemoryProperties); \ VK_IMPORT_INSTANCE_FUNC(false, vkGetPhysicalDeviceQueueFamilyProperties); \ - VK_IMPORT_INSTANCE_FUNC(false, vkGetPhysicalDeviceSurfaceCapabilitiesKHR); \ - VK_IMPORT_INSTANCE_FUNC(false, vkGetPhysicalDeviceSurfaceFormatsKHR); \ - VK_IMPORT_INSTANCE_FUNC(false, vkGetPhysicalDeviceSurfacePresentModesKHR); \ - VK_IMPORT_INSTANCE_FUNC(false, vkGetPhysicalDeviceSurfaceSupportKHR); \ VK_IMPORT_INSTANCE_FUNC(false, vkCreateDevice); \ VK_IMPORT_INSTANCE_FUNC(false, vkDestroyDevice); \ - VK_IMPORT_INSTANCE_FUNC(false, vkDestroySurfaceKHR); \ + /* VK_KHR_surface */ \ + VK_IMPORT_INSTANCE_FUNC(true, vkGetPhysicalDeviceSurfaceCapabilitiesKHR); \ + VK_IMPORT_INSTANCE_FUNC(true, vkGetPhysicalDeviceSurfaceFormatsKHR); \ + VK_IMPORT_INSTANCE_FUNC(true, vkGetPhysicalDeviceSurfacePresentModesKHR); \ + VK_IMPORT_INSTANCE_FUNC(true, vkGetPhysicalDeviceSurfaceSupportKHR); \ + VK_IMPORT_INSTANCE_FUNC(true, vkDestroySurfaceKHR); \ + /* VK_KHR_get_physical_device_properties2 */ \ + VK_IMPORT_INSTANCE_FUNC(true, vkGetPhysicalDeviceFeatures2KHR); \ + VK_IMPORT_INSTANCE_FUNC(true, vkGetPhysicalDeviceMemoryProperties2KHR); \ /* VK_EXT_debug_report */ \ VK_IMPORT_INSTANCE_FUNC(true, vkCreateDebugReportCallbackEXT); \ VK_IMPORT_INSTANCE_FUNC(true, vkDestroyDebugReportCallbackEXT); \ - VK_IMPORT_INSTANCE_FUNC(true, vkDebugReportMessageEXT); \ VK_IMPORT_INSTANCE_PLATFORM -#define VK_IMPORT_DEVICE \ - VK_IMPORT_DEVICE_FUNC(false, vkGetDeviceQueue); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateSwapchainKHR); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroySwapchainKHR); \ - VK_IMPORT_DEVICE_FUNC(false, vkGetSwapchainImagesKHR); \ - VK_IMPORT_DEVICE_FUNC(false, vkAcquireNextImageKHR); \ - VK_IMPORT_DEVICE_FUNC(false, vkQueuePresentKHR); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateFence); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyFence); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateSemaphore); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroySemaphore); \ - VK_IMPORT_DEVICE_FUNC(false, vkResetFences); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateCommandPool); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyCommandPool); \ - VK_IMPORT_DEVICE_FUNC(false, vkResetCommandPool); \ - VK_IMPORT_DEVICE_FUNC(false, vkAllocateCommandBuffers); \ - VK_IMPORT_DEVICE_FUNC(false, vkFreeCommandBuffers); \ - VK_IMPORT_DEVICE_FUNC(false, vkGetBufferMemoryRequirements); \ - VK_IMPORT_DEVICE_FUNC(false, vkGetImageMemoryRequirements); \ - VK_IMPORT_DEVICE_FUNC(false, vkAllocateMemory); \ - VK_IMPORT_DEVICE_FUNC(false, vkFreeMemory); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateImage); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyImage); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateImageView); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyImageView); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateBuffer); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyBuffer); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateFramebuffer); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyFramebuffer); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateRenderPass); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyRenderPass); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateShaderModule); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyShaderModule); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreatePipelineCache); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyPipelineCache); \ - VK_IMPORT_DEVICE_FUNC(false, vkGetPipelineCacheData); \ - VK_IMPORT_DEVICE_FUNC(false, vkMergePipelineCaches); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateGraphicsPipelines); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateComputePipelines); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyPipeline); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreatePipelineLayout); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyPipelineLayout); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateSampler); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroySampler); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateDescriptorSetLayout); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyDescriptorSetLayout); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateDescriptorPool); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyDescriptorPool); \ - VK_IMPORT_DEVICE_FUNC(false, vkResetDescriptorPool); \ - VK_IMPORT_DEVICE_FUNC(false, vkAllocateDescriptorSets); \ - VK_IMPORT_DEVICE_FUNC(false, vkFreeDescriptorSets); \ - VK_IMPORT_DEVICE_FUNC(false, vkUpdateDescriptorSets); \ - VK_IMPORT_DEVICE_FUNC(false, vkQueueSubmit); \ - VK_IMPORT_DEVICE_FUNC(false, vkQueueWaitIdle); \ - VK_IMPORT_DEVICE_FUNC(false, vkDeviceWaitIdle); \ - VK_IMPORT_DEVICE_FUNC(false, vkWaitForFences); \ - VK_IMPORT_DEVICE_FUNC(false, vkBeginCommandBuffer); \ - VK_IMPORT_DEVICE_FUNC(false, vkEndCommandBuffer); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdPipelineBarrier); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdBeginRenderPass); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdEndRenderPass); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdSetViewport); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdDraw); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdDrawIndexed); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdDrawIndirect); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdDrawIndexedIndirect); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdDispatch); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdDispatchIndirect); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdBindPipeline); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdSetStencilReference); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdSetBlendConstants); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdSetScissor); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdBindDescriptorSets); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdBindIndexBuffer); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdBindVertexBuffers); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdUpdateBuffer); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdClearColorImage); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdClearDepthStencilImage); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdClearAttachments); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdResolveImage); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdCopyBuffer); \ - VK_IMPORT_DEVICE_FUNC(false, vkMapMemory); \ - VK_IMPORT_DEVICE_FUNC(false, vkUnmapMemory); \ - VK_IMPORT_DEVICE_FUNC(false, vkFlushMappedMemoryRanges); \ - VK_IMPORT_DEVICE_FUNC(false, vkInvalidateMappedMemoryRanges); \ - VK_IMPORT_DEVICE_FUNC(false, vkBindBufferMemory); \ - VK_IMPORT_DEVICE_FUNC(false, vkBindImageMemory); \ - /* VK_EXT_debug_marker */ \ - VK_IMPORT_DEVICE_FUNC(true, vkDebugMarkerSetObjectTagEXT); \ - VK_IMPORT_DEVICE_FUNC(true, vkDebugMarkerSetObjectNameEXT); \ - VK_IMPORT_DEVICE_FUNC(true, vkCmdDebugMarkerBeginEXT); \ - VK_IMPORT_DEVICE_FUNC(true, vkCmdDebugMarkerEndEXT); \ - VK_IMPORT_DEVICE_FUNC(true, vkCmdDebugMarkerInsertEXT); \ +#define VK_IMPORT_DEVICE \ + VK_IMPORT_DEVICE_FUNC(false, vkGetDeviceQueue); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateFence); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyFence); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateSemaphore); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroySemaphore); \ + VK_IMPORT_DEVICE_FUNC(false, vkResetFences); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateCommandPool); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyCommandPool); \ + VK_IMPORT_DEVICE_FUNC(false, vkResetCommandPool); \ + VK_IMPORT_DEVICE_FUNC(false, vkAllocateCommandBuffers); \ + VK_IMPORT_DEVICE_FUNC(false, vkFreeCommandBuffers); \ + VK_IMPORT_DEVICE_FUNC(false, vkGetBufferMemoryRequirements); \ + VK_IMPORT_DEVICE_FUNC(false, vkGetImageMemoryRequirements); \ + VK_IMPORT_DEVICE_FUNC(false, vkGetImageSubresourceLayout); \ + VK_IMPORT_DEVICE_FUNC(false, vkAllocateMemory); \ + VK_IMPORT_DEVICE_FUNC(false, vkFreeMemory); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateImage); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyImage); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateImageView); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyImageView); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateBuffer); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyBuffer); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateFramebuffer); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyFramebuffer); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateRenderPass); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyRenderPass); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateShaderModule); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyShaderModule); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreatePipelineCache); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyPipelineCache); \ + VK_IMPORT_DEVICE_FUNC(false, vkGetPipelineCacheData); \ + VK_IMPORT_DEVICE_FUNC(false, vkMergePipelineCaches); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateGraphicsPipelines); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateComputePipelines); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyPipeline); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreatePipelineLayout); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyPipelineLayout); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateSampler); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroySampler); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateDescriptorSetLayout); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyDescriptorSetLayout); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateDescriptorPool); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyDescriptorPool); \ + VK_IMPORT_DEVICE_FUNC(false, vkResetDescriptorPool); \ + VK_IMPORT_DEVICE_FUNC(false, vkAllocateDescriptorSets); \ + VK_IMPORT_DEVICE_FUNC(false, vkFreeDescriptorSets); \ + VK_IMPORT_DEVICE_FUNC(false, vkUpdateDescriptorSets); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateQueryPool); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyQueryPool); \ + VK_IMPORT_DEVICE_FUNC(false, vkQueueSubmit); \ + VK_IMPORT_DEVICE_FUNC(false, vkQueueWaitIdle); \ + VK_IMPORT_DEVICE_FUNC(false, vkDeviceWaitIdle); \ + VK_IMPORT_DEVICE_FUNC(false, vkWaitForFences); \ + VK_IMPORT_DEVICE_FUNC(false, vkBeginCommandBuffer); \ + VK_IMPORT_DEVICE_FUNC(false, vkEndCommandBuffer); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdPipelineBarrier); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdBeginRenderPass); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdEndRenderPass); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdSetViewport); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdDraw); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdDrawIndexed); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdDrawIndirect); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdDrawIndexedIndirect); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdDispatch); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdDispatchIndirect); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdBindPipeline); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdSetStencilReference); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdSetBlendConstants); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdSetScissor); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdBindDescriptorSets); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdBindIndexBuffer); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdBindVertexBuffers); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdClearColorImage); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdClearDepthStencilImage); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdClearAttachments); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdResolveImage); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdCopyBuffer); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdCopyBufferToImage); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdCopyImage); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdCopyImageToBuffer); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdBlitImage); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdResetQueryPool); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdWriteTimestamp); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdBeginQuery); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdEndQuery); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdCopyQueryPoolResults); \ + VK_IMPORT_DEVICE_FUNC(false, vkMapMemory); \ + VK_IMPORT_DEVICE_FUNC(false, vkUnmapMemory); \ + VK_IMPORT_DEVICE_FUNC(false, vkFlushMappedMemoryRanges); \ + VK_IMPORT_DEVICE_FUNC(false, vkInvalidateMappedMemoryRanges); \ + VK_IMPORT_DEVICE_FUNC(false, vkBindBufferMemory); \ + VK_IMPORT_DEVICE_FUNC(false, vkBindImageMemory); \ + /* VK_KHR_swapchain */ \ + VK_IMPORT_DEVICE_FUNC(true, vkCreateSwapchainKHR); \ + VK_IMPORT_DEVICE_FUNC(true, vkDestroySwapchainKHR); \ + VK_IMPORT_DEVICE_FUNC(true, vkGetSwapchainImagesKHR); \ + VK_IMPORT_DEVICE_FUNC(true, vkAcquireNextImageKHR); \ + VK_IMPORT_DEVICE_FUNC(true, vkQueuePresentKHR); \ + /* VK_EXT_debug_utils */ \ + VK_IMPORT_DEVICE_FUNC(true, vkSetDebugUtilsObjectNameEXT); \ + VK_IMPORT_DEVICE_FUNC(true, vkCmdBeginDebugUtilsLabelEXT); \ + VK_IMPORT_DEVICE_FUNC(true, vkCmdEndDebugUtilsLabelEXT); \ + VK_IMPORT_DEVICE_FUNC(true, vkCmdInsertDebugUtilsLabelEXT); \ + /* VK_KHR_draw_indirect_count */ \ + VK_IMPORT_DEVICE_FUNC(true, vkCmdDrawIndirectCountKHR); \ + VK_IMPORT_DEVICE_FUNC(true, vkCmdDrawIndexedIndirectCountKHR); \ #define VK_DESTROY \ VK_DESTROY_FUNC(Buffer); \ @@ -186,7 +224,9 @@ VK_DESTROY_FUNC(Pipeline); \ VK_DESTROY_FUNC(PipelineCache); \ VK_DESTROY_FUNC(PipelineLayout); \ + VK_DESTROY_FUNC(QueryPool); \ VK_DESTROY_FUNC(RenderPass); \ + VK_DESTROY_FUNC(Sampler); \ VK_DESTROY_FUNC(Semaphore); \ VK_DESTROY_FUNC(ShaderModule); \ VK_DESTROY_FUNC(SwapchainKHR); \ @@ -199,41 +239,79 @@ BX_MACRO_BLOCK_END #if BGFX_CONFIG_DEBUG -# define VK_CHECK(_call) _VK_CHECK(BX_CHECK, _call) +# define VK_CHECK(_call) _VK_CHECK(BX_ASSERT, _call) #else # define VK_CHECK(_call) _call #endif // BGFX_CONFIG_DEBUG +#if BGFX_CONFIG_DEBUG_ANNOTATION +# define BGFX_VK_BEGIN_DEBUG_UTILS_LABEL(_name, _abgr) \ + BX_MACRO_BLOCK_BEGIN \ + VkDebugUtilsLabelEXT dul; \ + dul.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT; \ + dul.pNext = NULL; \ + dul.pLabelName = _name; \ + 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; \ + vkCmdBeginDebugUtilsLabelEXT(m_commandBuffer, &dul); \ + BX_MACRO_BLOCK_END + +# define BGFX_VK_END_DEBUG_UTILS_LABEL() \ + BX_MACRO_BLOCK_BEGIN \ + vkCmdEndDebugUtilsLabelEXT(m_commandBuffer); \ + BX_MACRO_BLOCK_END +#else +# define BGFX_VK_BEGIN_DEBUG_UTILS_LABEL(_view, _abgr) BX_UNUSED(_view, _abgr) +# define BGFX_VK_END_DEBUG_UTILS_LABEL() BX_NOOP() +#endif // BGFX_CONFIG_DEBUG_ANNOTATION + +#define BGFX_VK_PROFILER_BEGIN(_view, _abgr) \ + BX_MACRO_BLOCK_BEGIN \ + BGFX_VK_BEGIN_DEBUG_UTILS_LABEL(s_viewName[view], _abgr); \ + BGFX_PROFILER_BEGIN(s_viewName[view], _abgr); \ + BX_MACRO_BLOCK_END + +#define BGFX_VK_PROFILER_BEGIN_LITERAL(_name, _abgr) \ + BX_MACRO_BLOCK_BEGIN \ + BGFX_VK_BEGIN_DEBUG_UTILS_LABEL(_name, _abgr); \ + BGFX_PROFILER_BEGIN_LITERAL("" _name, _abgr); \ + BX_MACRO_BLOCK_END + +#define BGFX_VK_PROFILER_END() \ + BX_MACRO_BLOCK_BEGIN \ + BGFX_PROFILER_END(); \ + BGFX_VK_END_DEBUG_UTILS_LABEL(); \ + BX_MACRO_BLOCK_END + namespace bgfx { namespace vk { -#define VK_DESTROY_FUNC(_name) \ - struct Vk##_name \ - { \ - ::Vk##_name vk; \ - Vk##_name() {} \ - Vk##_name(::Vk##_name _vk) : vk(_vk) {} \ - operator ::Vk##_name() { return vk; } \ - operator ::Vk##_name() const { return vk; } \ - ::Vk##_name* operator &() { return &vk; } \ - const ::Vk##_name* operator &() const { return &vk; } \ - }; \ - BX_STATIC_ASSERT(sizeof(::Vk##_name) == sizeof(Vk##_name) ); \ - void vkDestroy(Vk##_name&) +#define VK_DESTROY_FUNC(_name) \ + struct Vk##_name \ + { \ + ::Vk##_name vk; \ + Vk##_name() {} \ + Vk##_name(::Vk##_name _vk) : vk(_vk) {} \ + operator ::Vk##_name() { return vk; } \ + operator ::Vk##_name() const { return vk; } \ + ::Vk##_name* operator &() { return &vk; } \ + const ::Vk##_name* operator &() const { return &vk; } \ + }; \ + BX_STATIC_ASSERT(sizeof(::Vk##_name) == sizeof(Vk##_name) ); \ + void vkDestroy(Vk##_name&); \ + void release(Vk##_name&) VK_DESTROY +VK_DESTROY_FUNC(DeviceMemory); +VK_DESTROY_FUNC(SurfaceKHR); +VK_DESTROY_FUNC(DescriptorSet); #undef VK_DESTROY_FUNC - struct DslBinding + template<typename Ty> + void release(Ty) { - enum Enum - { -// CombinedImageSampler, - UniformBuffer, -// StorageBuffer, - - Count - }; - }; + } template<typename Ty> class StateCacheT @@ -261,7 +339,7 @@ VK_DESTROY typename HashMap::iterator it = m_hashMap.find(_key); if (it != m_hashMap.end() ) { - vkDestroy(it->second); + release(it->second); m_hashMap.erase(it); } } @@ -270,7 +348,7 @@ VK_DESTROY { for (typename HashMap::iterator it = m_hashMap.begin(), itEnd = m_hashMap.end(); it != itEnd; ++it) { - vkDestroy(it->second); + release(it->second); } m_hashMap.clear(); @@ -297,36 +375,17 @@ VK_DESTROY { } - void create(uint32_t _size, uint32_t _maxDescriptors); + void create(uint32_t _size, uint32_t _count); void destroy(); - void reset(VkDescriptorBufferInfo& _gpuAddress); - void* allocUbv(VkDescriptorBufferInfo& _gpuAddress, uint32_t _size); + void reset(); + uint32_t write(const void* _data, uint32_t _size); + void flush(); - VkDescriptorSet* m_descriptorSet; VkBuffer m_buffer; VkDeviceMemory m_deviceMem; uint8_t* m_data; uint32_t m_size; uint32_t m_pos; - uint32_t m_currentDs; - uint32_t m_maxDescriptors; - }; - - struct ImageVK - { - ImageVK() - : m_memory(VK_NULL_HANDLE) - , m_image(VK_NULL_HANDLE) - , m_imageView(VK_NULL_HANDLE) - { - } - - VkResult create(VkFormat _format, const VkExtent3D& _extent); - void destroy(); - - VkDeviceMemory m_memory; - VkImage m_image; - VkImageView m_imageView; }; struct BufferVK @@ -340,7 +399,7 @@ VK_DESTROY { } - void create(uint32_t _size, void* _data, uint16_t _flags, bool _vertex, uint32_t _stride = 0); + void create(VkCommandBuffer _commandBuffer, uint32_t _size, void* _data, uint16_t _flags, bool _vertex, uint32_t _stride = 0); void update(VkCommandBuffer _commandBuffer, uint32_t _offset, uint32_t _size, void* _data, bool _discard = false); void destroy(); @@ -353,11 +412,43 @@ VK_DESTROY typedef BufferVK IndexBufferVK; + struct MsaaSamplerVK + { + uint16_t Count; + VkSampleCountFlagBits Sample; + }; + struct VertexBufferVK : public BufferVK { - void create(uint32_t _size, void* _data, VertexDeclHandle _declHandle, uint16_t _flags); + void create(VkCommandBuffer _commandBuffer, uint32_t _size, void* _data, VertexLayoutHandle _layoutHandle, uint16_t _flags); + + VertexLayoutHandle m_layoutHandle; + }; + + struct BindType + { + enum Enum + { + Buffer, + Image, + Sampler, + + Count + }; + }; - VertexDeclHandle m_decl; + struct BindInfo + { + UniformHandle uniformHandle = BGFX_INVALID_HANDLE; + BindType::Enum type; + uint32_t binding; + uint32_t samplerBinding; + uint32_t index; + }; + + struct TextureBindInfo + { + VkImageViewType type; }; struct ShaderVK @@ -369,6 +460,9 @@ VK_DESTROY , m_hash(0) , m_numUniforms(0) , m_numPredefined(0) + , m_uniformBinding(0) + , m_numBindings(0) + , m_oldBindingModel(false) { } @@ -388,6 +482,17 @@ VK_DESTROY uint16_t m_size; uint8_t m_numPredefined; uint8_t m_numAttrs; + + BindInfo m_bindInfo[BGFX_CONFIG_MAX_TEXTURE_SAMPLERS]; + + TextureBindInfo m_textures[BGFX_CONFIG_MAX_TEXTURE_SAMPLERS]; + uint8_t m_numTextures; + + uint32_t m_uniformBinding; + uint16_t m_numBindings; + VkDescriptorSetLayoutBinding m_bindings[2 * BGFX_CONFIG_MAX_TEXTURE_SAMPLERS + 1]; + + bool m_oldBindingModel; }; struct ProgramVK @@ -395,57 +500,373 @@ VK_DESTROY ProgramVK() : m_vsh(NULL) , m_fsh(NULL) + , m_descriptorSetLayout(VK_NULL_HANDLE) + , m_pipelineLayout(VK_NULL_HANDLE) { } - void create(const ShaderVK* _vsh, const ShaderVK* _fsh) + void create(const ShaderVK* _vsh, const ShaderVK* _fsh); + void destroy(); + + const ShaderVK* m_vsh; + const ShaderVK* m_fsh; + + BindInfo m_bindInfo[BGFX_CONFIG_MAX_TEXTURE_SAMPLERS]; + + TextureBindInfo m_textures[BGFX_CONFIG_MAX_TEXTURE_SAMPLERS]; + uint8_t m_numTextures; + + PredefinedUniform m_predefined[PredefinedUniform::Count * 2]; + uint8_t m_numPredefined; + + VkDescriptorSetLayout m_descriptorSetLayout; + VkPipelineLayout m_pipelineLayout; + }; + + struct TimerQueryVK + { + TimerQueryVK() + : m_control(BX_COUNTOF(m_query) ) { - BX_CHECK(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; + } + + VkResult init(); + void shutdown(); + uint32_t begin(uint32_t _resultIdx, uint32_t _frameNum); + void end(uint32_t _idx); + bool update(); - if (NULL != _fsh) + struct Result + { + void reset() { - BX_CHECK(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_begin = 0; + m_end = 0; + m_pending = 0; + m_frameNum = 0; } - } - void destroy() + uint64_t m_begin; + uint64_t m_end; + uint32_t m_pending; + uint32_t m_frameNum; + }; + + struct Query + { + uint32_t m_resultIdx; + uint32_t m_frameNum; + uint64_t m_completed; + bool m_ready; + }; + + uint64_t m_frequency; + + Result m_result[BGFX_CONFIG_MAX_VIEWS+1]; + Query m_query[BGFX_CONFIG_MAX_VIEWS*4]; + + VkBuffer m_readback; + VkDeviceMemory m_readbackMemory; + VkQueryPool m_queryPool; + const uint64_t* m_queryResult; + bx::RingBufferControl m_control; + }; + + struct OcclusionQueryVK + { + OcclusionQueryVK() + : m_control(BX_COUNTOF(m_handle) ) { - m_numPredefined = 0; - m_vsh = NULL; - m_fsh = NULL; } - const ShaderVK* m_vsh; - const ShaderVK* m_fsh; + VkResult init(); + void shutdown(); + void begin(OcclusionQueryHandle _handle); + void end(); + void flush(Frame* _render); + void resolve(Frame* _render); + void invalidate(OcclusionQueryHandle _handle); + + OcclusionQueryHandle m_handle[BGFX_CONFIG_MAX_OCCLUSION_QUERIES]; + + VkBuffer m_readback; + VkDeviceMemory m_readbackMemory; + VkQueryPool m_queryPool; + const uint32_t* m_queryResult; + bx::RingBufferControl m_control; + }; - PredefinedUniform m_predefined[PredefinedUniform::Count * 2]; - uint8_t m_numPredefined; + struct ReadbackVK + { + void create(VkImage _image, uint32_t _width, uint32_t _height, TextureFormat::Enum _format); + void destroy(); + uint32_t pitch(uint8_t _mip = 0) const; + void copyImageToBuffer(VkCommandBuffer _commandBuffer, VkBuffer _buffer, VkImageLayout _layout, VkImageAspectFlags _aspect, uint8_t _mip = 0) const; + void readback(VkDeviceMemory _memory, VkDeviceSize _offset, void* _data, uint8_t _mip = 0) const; + + VkImage m_image; + uint32_t m_width; + uint32_t m_height; + TextureFormat::Enum m_format; }; struct TextureVK { + TextureVK() + : m_directAccessPtr(NULL) + , m_sampler({ 1, VK_SAMPLE_COUNT_1_BIT }) + , m_format(VK_FORMAT_UNDEFINED) + , m_textureImage(VK_NULL_HANDLE) + , m_textureDeviceMem(VK_NULL_HANDLE) + , m_currentImageLayout(VK_IMAGE_LAYOUT_UNDEFINED) + , m_singleMsaaImage(VK_NULL_HANDLE) + , m_singleMsaaDeviceMem(VK_NULL_HANDLE) + , m_currentSingleMsaaImageLayout(VK_IMAGE_LAYOUT_UNDEFINED) + { + } + + void* create(VkCommandBuffer _commandBuffer, const Memory* _mem, uint64_t _flags, uint8_t _skip); + // internal render target + VkResult create(VkCommandBuffer _commandBuffer, uint32_t _width, uint32_t _height, uint64_t _flags, VkFormat _format); + void destroy(); + + void update(VkCommandBuffer _commandBuffer, uint8_t _side, uint8_t _mip, const Rect& _rect, uint16_t _z, uint16_t _depth, uint16_t _pitch, const Memory* _mem); + void resolve(VkCommandBuffer _commandBuffer, uint8_t _resolve, uint32_t _layer, uint32_t _numLayers, uint32_t _mip); + + void copyBufferToTexture(VkCommandBuffer _commandBuffer, VkBuffer _stagingBuffer, uint32_t _bufferImageCopyCount, VkBufferImageCopy* _bufferImageCopy); + VkImageLayout setImageMemoryBarrier(VkCommandBuffer _commandBuffer, VkImageLayout _newImageLayout, bool _singleMsaaImage = false); + + VkResult createView(uint32_t _layer, uint32_t _numLayers, uint32_t _mip, uint32_t _numMips, VkImageViewType _type, VkImageAspectFlags _aspectMask, bool _renderTarget, ::VkImageView* _view) const; + + void* m_directAccessPtr; + uint64_t m_flags; + uint32_t m_width; + uint32_t m_height; + uint32_t m_depth; + uint32_t m_numLayers; + uint32_t m_numSides; + uint8_t m_requestedFormat; + uint8_t m_textureFormat; + uint8_t m_numMips; + + MsaaSamplerVK m_sampler; + + VkImageViewType m_type; + VkFormat m_format; + VkComponentMapping m_components; + VkImageAspectFlags m_aspectMask; + + VkImage m_textureImage; + VkDeviceMemory m_textureDeviceMem; + VkImageLayout m_currentImageLayout; + + VkImage m_singleMsaaImage; + VkDeviceMemory m_singleMsaaDeviceMem; + VkImageLayout m_currentSingleMsaaImageLayout; + + VkImageLayout m_sampledLayout; + + ReadbackVK m_readback; + + private: + VkResult createImages(VkCommandBuffer _commandBuffer); + static VkImageAspectFlags getAspectMask(VkFormat _format); }; - struct FrameBufferVK + constexpr uint32_t kMaxBackBuffers = bx::max(BGFX_CONFIG_MAX_BACK_BUFFERS, 10); + + struct SwapChainVK { + SwapChainVK() + : m_nwh(NULL) + , m_swapchain(VK_NULL_HANDLE) + , m_lastImageRenderedSemaphore(VK_NULL_HANDLE) + , m_lastImageAcquiredSemaphore(VK_NULL_HANDLE) + , m_backBufferColorMsaaImageView(VK_NULL_HANDLE) + { + } + + VkResult create(VkCommandBuffer _commandBuffer, void* _nwh, const Resolution& _resolution, TextureFormat::Enum _depthFormat = TextureFormat::Count); + void destroy(); + void update(VkCommandBuffer _commandBuffer, void* _nwh, const Resolution& _resolution); + + VkResult createSurface(); + VkResult createSwapChain(); + VkResult createAttachments(VkCommandBuffer _commandBuffer); + VkResult createFrameBuffer(); + + void releaseSurface(); + void releaseSwapChain(); + void releaseAttachments(); + void releaseFrameBuffer(); + + uint32_t findPresentMode(bool _vsync); + TextureFormat::Enum findSurfaceFormat(TextureFormat::Enum _format, VkColorSpaceKHR _colorSpace, bool _srgb); + + bool acquire(VkCommandBuffer _commandBuffer); + void present(); + + void transitionImage(VkCommandBuffer _commandBuffer); + + VkQueue m_queue; + VkSwapchainCreateInfoKHR m_sci; + + void* m_nwh; + Resolution m_resolution; + + TextureFormat::Enum m_colorFormat; + TextureFormat::Enum m_depthFormat; + + VkSurfaceKHR m_surface; + VkSwapchainKHR m_swapchain; + uint32_t m_numSwapchainImages; + VkImageLayout m_backBufferColorImageLayout[kMaxBackBuffers]; + VkImage m_backBufferColorImage[kMaxBackBuffers]; + VkImageView m_backBufferColorImageView[kMaxBackBuffers]; + VkFramebuffer m_backBufferFrameBuffer[kMaxBackBuffers]; + VkFence m_backBufferFence[kMaxBackBuffers]; + uint32_t m_backBufferColorIdx; + + VkSemaphore m_presentDoneSemaphore[kMaxBackBuffers]; + VkSemaphore m_renderDoneSemaphore[kMaxBackBuffers]; + uint32_t m_currentSemaphore; + + VkSemaphore m_lastImageRenderedSemaphore; + VkSemaphore m_lastImageAcquiredSemaphore; + + bool m_needPresent; + bool m_needToRecreateSwapchain; + bool m_needToRecreateSurface; + + TextureVK m_backBufferDepthStencil; + VkImageView m_backBufferDepthStencilImageView; + + TextureVK m_backBufferColorMsaa; + VkImageView m_backBufferColorMsaaImageView; + MsaaSamplerVK m_sampler; + + bool m_supportsReadback; + bool m_supportsManualResolve; + }; + + struct FrameBufferVK + { + FrameBufferVK() + : m_depth({ kInvalidHandle }) + , m_width(0) + , m_height(0) + , m_denseIdx(kInvalidHandle) + , m_num(0) + , m_numTh(0) + , m_nwh(NULL) + , m_needPresent(false) + , m_framebuffer(VK_NULL_HANDLE) + { + } + + void create(uint8_t _num, const Attachment* _attachment); + VkResult create(uint16_t _denseIdx, void* _nwh, uint32_t _width, uint32_t _height, TextureFormat::Enum _format = TextureFormat::Count, TextureFormat::Enum _depthFormat = TextureFormat::Count); + uint16_t destroy(); + + void update(VkCommandBuffer _commandBuffer, const Resolution& _resolution); + + void preReset(); + void postReset(); + + void resolve(); + + bool acquire(VkCommandBuffer _commandBuffer); + void present(); + + bool isRenderable() const; + TextureHandle m_texture[BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS]; TextureHandle m_depth; -// IDXGISwapChain* m_swapChain; uint32_t m_width; uint32_t m_height; uint16_t m_denseIdx; uint8_t m_num; uint8_t m_numTh; Attachment m_attachment[BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS]; + + SwapChainVK m_swapChain; + void* m_nwh; + bool m_needPresent; + bool m_needResolve; + + VkImageView m_textureImageViews[BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS]; + VkFramebuffer m_framebuffer; + VkRenderPass m_renderPass; + MsaaSamplerVK m_sampler; + + VkFramebuffer m_currentFramebuffer; + }; + + struct CommandQueueVK + { + VkResult init(uint32_t _queueFamily, VkQueue _queue, uint32_t _numFramesInFlight); + VkResult reset(); + void shutdown(); + + VkResult alloc(VkCommandBuffer* _commandBuffer); + void addWaitSemaphore(VkSemaphore _semaphore, VkPipelineStageFlags _waitFlags = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT); + void addSignalSemaphore(VkSemaphore _semaphore); + void kick(bool _wait = false); + void finish(bool _finishAll = false); + + void release(uint64_t _handle, VkObjectType _type); + void consume(); + + uint32_t m_queueFamily; + VkQueue m_queue; + + uint32_t m_numFramesInFlight; + + uint32_t m_currentFrameInFlight; + uint32_t m_consumeIndex; + + VkCommandBuffer m_activeCommandBuffer; + + VkFence m_currentFence; + VkFence m_completedFence; + + uint64_t m_submitted; + + struct CommandList + { + VkCommandPool m_commandPool = VK_NULL_HANDLE; + VkCommandBuffer m_commandBuffer = VK_NULL_HANDLE; + VkFence m_fence = VK_NULL_HANDLE; + }; + + CommandList m_commandList[BGFX_CONFIG_MAX_FRAME_LATENCY]; + + uint32_t m_numWaitSemaphores; + VkSemaphore m_waitSemaphores[BGFX_CONFIG_MAX_FRAME_BUFFERS]; + VkPipelineStageFlags m_waitSemaphoreStages[BGFX_CONFIG_MAX_FRAME_BUFFERS]; + uint32_t m_numSignalSemaphores; + VkSemaphore m_signalSemaphores[BGFX_CONFIG_MAX_FRAME_BUFFERS]; + + struct Resource + { + VkObjectType m_type; + uint64_t m_handle; + }; + + typedef stl::vector<Resource> ResourceArray; + ResourceArray m_release[BGFX_CONFIG_MAX_FRAME_LATENCY]; + + private: + template<typename Ty> + void destroy(uint64_t _handle) + { + typedef decltype(Ty::vk) vk_t; + Ty obj = vk_t(_handle); + vkDestroy(obj); + } }; } /* namespace bgfx */ } // namespace vk |