diff options
Diffstat (limited to '3rdparty/bgfx/src/renderer_vk.h')
-rw-r--r-- | 3rdparty/bgfx/src/renderer_vk.h | 449 |
1 files changed, 449 insertions, 0 deletions
diff --git a/3rdparty/bgfx/src/renderer_vk.h b/3rdparty/bgfx/src/renderer_vk.h new file mode 100644 index 00000000000..bb4f0217c33 --- /dev/null +++ b/3rdparty/bgfx/src/renderer_vk.h @@ -0,0 +1,449 @@ +/* + * Copyright 2011-2017 Branimir Karadzic. All rights reserved. + * License: https://github.com/bkaradzic/bgfx#license-bsd-2-clause + */ + +#ifndef BGFX_RENDERER_VK_H_HEADER_GUARD +#define BGFX_RENDERER_VK_H_HEADER_GUARD + +#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_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 +#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 "renderer.h" +#include "debug_renderdoc.h" + +#define VK_IMPORT \ + VK_IMPORT_FUNC(false, vkCreateInstance); \ + VK_IMPORT_FUNC(false, vkGetInstanceProcAddr); \ + 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); + +#define VK_IMPORT_INSTANCE \ + VK_IMPORT_INSTANCE_FUNC(false, vkDestroyInstance); \ + VK_IMPORT_INSTANCE_FUNC(false, vkEnumeratePhysicalDevices); \ + VK_IMPORT_INSTANCE_FUNC(false, vkEnumerateDeviceExtensionProperties); \ + VK_IMPORT_INSTANCE_FUNC(false, vkEnumerateDeviceLayerProperties); \ + VK_IMPORT_INSTANCE_FUNC(false, vkGetPhysicalDeviceProperties); \ + VK_IMPORT_INSTANCE_FUNC(false, vkGetPhysicalDeviceFormatProperties); \ + 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_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, 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_DESTROY \ + VK_DESTROY_FUNC(Buffer); \ + VK_DESTROY_FUNC(CommandPool); \ + VK_DESTROY_FUNC(DescriptorPool); \ + VK_DESTROY_FUNC(DescriptorSetLayout); \ + VK_DESTROY_FUNC(Fence); \ + VK_DESTROY_FUNC(Framebuffer); \ + VK_DESTROY_FUNC(Image); \ + VK_DESTROY_FUNC(ImageView); \ + VK_DESTROY_FUNC(Pipeline); \ + VK_DESTROY_FUNC(PipelineCache); \ + VK_DESTROY_FUNC(PipelineLayout); \ + VK_DESTROY_FUNC(RenderPass); \ + VK_DESTROY_FUNC(Semaphore); \ + VK_DESTROY_FUNC(ShaderModule); \ + VK_DESTROY_FUNC(SwapchainKHR); \ + +#define _VK_CHECK(_check, _call) \ + BX_MACRO_BLOCK_BEGIN \ + /*BX_TRACE(#_call);*/ \ + VkResult vkresult = _call; \ + _check(VK_SUCCESS == vkresult, #_call "; VK error 0x%x: %s", vkresult, getName(vkresult) ); \ + BX_MACRO_BLOCK_END + +#if BGFX_CONFIG_DEBUG +# define VK_CHECK(_call) _VK_CHECK(BX_CHECK, _call) +#else +# define VK_CHECK(_call) _call +#endif // BGFX_CONFIG_DEBUG + +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&) +VK_DESTROY +#undef VK_DESTROY_FUNC + + struct DslBinding + { + enum Enum + { +// CombinedImageSampler, + UniformBuffer, +// StorageBuffer, + + Count + }; + }; + + template<typename Ty> + class StateCacheT + { + public: + void add(uint64_t _key, Ty _value) + { + invalidate(_key); + m_hashMap.insert(stl::make_pair(_key, _value) ); + } + + Ty find(uint64_t _key) + { + typename HashMap::iterator it = m_hashMap.find(_key); + if (it != m_hashMap.end() ) + { + return it->second; + } + + return 0; + } + + void invalidate(uint64_t _key) + { + typename HashMap::iterator it = m_hashMap.find(_key); + if (it != m_hashMap.end() ) + { + vkDestroy(it->second); + m_hashMap.erase(it); + } + } + + void invalidate() + { + for (typename HashMap::iterator it = m_hashMap.begin(), itEnd = m_hashMap.end(); it != itEnd; ++it) + { + vkDestroy(it->second); + } + + m_hashMap.clear(); + } + + uint32_t getCount() const + { + return uint32_t(m_hashMap.size() ); + } + + private: + typedef stl::unordered_map<uint64_t, Ty> HashMap; + HashMap m_hashMap; + }; + + class ScratchBufferVK + { + public: + ScratchBufferVK() + { + } + + ~ScratchBufferVK() + { + } + + void create(uint32_t _size, uint32_t _maxDescriptors); + void destroy(); + void reset(VkDescriptorBufferInfo& _gpuAddress); + void* allocUbv(VkDescriptorBufferInfo& _gpuAddress, uint32_t _size); + + 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 + { + BufferVK() + : m_buffer(VK_NULL_HANDLE) + , m_deviceMem(VK_NULL_HANDLE) + , m_size(0) + , m_flags(BGFX_BUFFER_NONE) + , m_dynamic(false) + { + } + + void create(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(); + + VkBuffer m_buffer; + VkDeviceMemory m_deviceMem; + uint32_t m_size; + uint16_t m_flags; + bool m_dynamic; + }; + + typedef BufferVK IndexBufferVK; + + struct VertexBufferVK : public BufferVK + { + void create(uint32_t _size, void* _data, VertexDeclHandle _declHandle, uint16_t _flags); + + VertexDeclHandle m_decl; + }; + + struct ShaderVK + { + ShaderVK() + : m_code(NULL) + , m_module(VK_NULL_HANDLE) + , m_constantBuffer(NULL) + , m_hash(0) + , m_numUniforms(0) + , m_numPredefined(0) + { + } + + void create(const Memory* _mem); + void destroy(); + + const Memory* m_code; + VkShaderModule m_module; + UniformBuffer* m_constantBuffer; + + PredefinedUniform m_predefined[PredefinedUniform::Count]; + uint16_t m_attrMask[Attrib::Count]; + + uint32_t m_hash; + uint16_t m_numUniforms; + uint16_t m_size; + uint8_t m_numPredefined; + }; + + struct ProgramVK + { + ProgramVK() + : m_vsh(NULL) + , m_fsh(NULL) + { + } + + void create(const ShaderVK* _vsh, const ShaderVK* _fsh) + { + BX_CHECK(NULL != _vsh->m_code, "Vertex shader doesn't exist."); + m_vsh = _vsh; + memcpy(&m_predefined[0], _vsh->m_predefined, _vsh->m_numPredefined*sizeof(PredefinedUniform)); + m_numPredefined = _vsh->m_numPredefined; + + if (NULL != _fsh) + { + BX_CHECK(NULL != _fsh->m_code, "Fragment shader doesn't exist."); + m_fsh = _fsh; + memcpy(&m_predefined[m_numPredefined], _fsh->m_predefined, _fsh->m_numPredefined*sizeof(PredefinedUniform)); + m_numPredefined += _fsh->m_numPredefined; + } + } + + void destroy() + { + m_numPredefined = 0; + m_vsh = NULL; + m_fsh = NULL; + } + + const ShaderVK* m_vsh; + const ShaderVK* m_fsh; + + PredefinedUniform m_predefined[PredefinedUniform::Count * 2]; + uint8_t m_numPredefined; + }; + + struct TextureVK + { + void destroy(); + }; + + struct FrameBufferVK + { + void destroy(); + + 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]; + }; + +} /* namespace bgfx */ } // namespace vk + +#endif // BGFX_RENDERER_VK_H_HEADER_GUARD |