diff options
Diffstat (limited to 'Graphics/GraphicsEngineVulkan')
35 files changed, 1395 insertions, 580 deletions
diff --git a/Graphics/GraphicsEngineVulkan/CMakeLists.txt b/Graphics/GraphicsEngineVulkan/CMakeLists.txt index 6b71a279..2ceabf85 100644 --- a/Graphics/GraphicsEngineVulkan/CMakeLists.txt +++ b/Graphics/GraphicsEngineVulkan/CMakeLists.txt @@ -7,7 +7,6 @@ set(INCLUDE include/BufferViewVkImpl.h include/CommandContext.h include/CommandListVkImpl.h - include/CommandListManager.h include/CommandQueueVkImpl.h include/VulkanResourceBase.h include/VulkanTypeConversions.h @@ -34,8 +33,12 @@ set(INCLUDE ) set(VULKAN_UTILS_INCLUDE + include/VulkanUtilities/VulkanCommandBufferPool.h include/VulkanUtilities/VulkanDebug.h + include/VulkanUtilities/VulkanFencePool.h include/VulkanUtilities/VulkanInstance.h + include/VulkanUtilities/VulkanLogicalDevice.h + include/VulkanUtilities/VulkanObjectWrappers.h include/VulkanUtilities/VulkanPhysicalDevice.h ) @@ -61,7 +64,6 @@ set(SRC src/BufferVkImpl.cpp src/BufferViewVkImpl.cpp src/CommandContext.cpp - src/CommandListManager.cpp src/CommandQueueVkImpl.cpp src/VulkanResourceBase.cpp src/VulkanTypeConversions.cpp @@ -86,8 +88,11 @@ set(SRC ) set(VULKAN_UTILS_SRC + src/VulkanUtilities/VulkanCommandBufferPool.cpp src/VulkanUtilities/VulkanDebug.cpp + src/VulkanUtilities/VulkanFencePool.cpp src/VulkanUtilities/VulkanInstance.cpp + src/VulkanUtilities/VulkanLogicalDevice.cpp src/VulkanUtilities/VulkanPhysicalDevice.cpp ) diff --git a/Graphics/GraphicsEngineVulkan/include/BufferViewVkImpl.h b/Graphics/GraphicsEngineVulkan/include/BufferViewVkImpl.h index ff203851..71506640 100644 --- a/Graphics/GraphicsEngineVulkan/include/BufferViewVkImpl.h +++ b/Graphics/GraphicsEngineVulkan/include/BufferViewVkImpl.h @@ -30,6 +30,7 @@ #include "RenderDeviceVk.h" #include "BufferViewBase.h" #include "DescriptorHeap.h" +#include "VulkanUtilities/VulkanObjectWrappers.h" namespace Diligent { @@ -45,16 +46,17 @@ public: IRenderDevice *pDevice, const BufferViewDesc& ViewDesc, class IBuffer *pBuffer, - VkBufferView vkBuffView, + VulkanUtilities::BufferViewWrapper &&BuffView, bool bIsDefaultView); + ~BufferViewVkImpl(); virtual void QueryInterface( const Diligent::INTERFACE_ID &IID, IObject **ppInterface ); - virtual VkBufferView GetVkBufferView()override final{return m_VkBuffView;} + virtual VkBufferView GetVkBufferView()override final{return m_BuffView;} protected: - VkBufferView m_VkBuffView; + VulkanUtilities::BufferViewWrapper m_BuffView; }; } diff --git a/Graphics/GraphicsEngineVulkan/include/BufferVkImpl.h b/Graphics/GraphicsEngineVulkan/include/BufferVkImpl.h index 2b70c416..31b58787 100644 --- a/Graphics/GraphicsEngineVulkan/include/BufferVkImpl.h +++ b/Graphics/GraphicsEngineVulkan/include/BufferVkImpl.h @@ -32,6 +32,7 @@ #include "BufferViewVkImpl.h" #include "VulkanResourceBase.h" #include "DynamicUploadHeap.h" +#include "VulkanUtilities/VulkanObjectWrappers.h" namespace Diligent { @@ -122,7 +123,7 @@ public: private: virtual void CreateViewInternal( const struct BufferViewDesc &ViewDesc, IBufferView **ppView, bool bIsDefaultView )override; - VkBufferView CreateView(struct BufferViewDesc &ViewDesc); + VulkanUtilities::BufferViewWrapper CreateView(struct BufferViewDesc &ViewDesc); /* DescriptorHeapAllocation m_CBVDescriptorAllocation; #ifdef _DEBUG @@ -132,8 +133,9 @@ private: friend class DeviceContextVkImpl; // Array of dynamic allocations for every device context std::vector<DynamicAllocation, STDAllocatorRawMem<DynamicAllocation> > m_DynamicData;*/ - VkBuffer m_VkBuffer = VK_NULL_HANDLE; - VkDeviceMemory m_BufferMemory = VK_NULL_HANDLE; + + VulkanUtilities::BufferWrapper m_VulkanBuffer; + VulkanUtilities::DeviceMemoryWrapper m_BufferMemory; }; } diff --git a/Graphics/GraphicsEngineVulkan/include/CommandListManager.h b/Graphics/GraphicsEngineVulkan/include/CommandListManager.h deleted file mode 100644 index 461e7116..00000000 --- a/Graphics/GraphicsEngineVulkan/include/CommandListManager.h +++ /dev/null @@ -1,67 +0,0 @@ -/* Copyright 2015-2018 Egor Yusov - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF ANY PROPRIETARY RIGHTS. - * - * In no event and under no legal theory, whether in tort (including negligence), - * contract, or otherwise, unless required by applicable law (such as deliberate - * and grossly negligent acts) or agreed to in writing, shall any Contributor be - * liable for any damages, including any direct, indirect, special, incidental, - * or consequential damages of any character arising as a result of this License or - * out of the use or inability to use the software (including but not limited to damages - * for loss of goodwill, work stoppage, computer failure or malfunction, or any and - * all other commercial damages or losses), even if such Contributor has been advised - * of the possibility of such damages. - */ - -#pragma once - -#include <vector> -#include <deque> -#include <mutex> -#include <stdint.h> - -namespace Diligent -{ - -class CommandListManager -{ -public: - CommandListManager(class RenderDeviceVkImpl *pDeviceVk); - ~CommandListManager(); - - CommandListManager(const CommandListManager&) = delete; - CommandListManager(CommandListManager&&) = delete; - CommandListManager& operator = (const CommandListManager&) = delete; - CommandListManager& operator = (CommandListManager&&) = delete; - - /*void CreateNewCommandList( IVkGraphicsCommandList** ppList, IVkCommandAllocator** ppAllocator ); - - // Discards the allocator. - // FenceValue is the value that was signaled by the command queue after it - // executed the the command list created by the allocator - void DiscardAllocator( Uint64 FenceValue, IVkCommandAllocator* pAllocator ); - - void RequestAllocator(IVkCommandAllocator** ppAllocator); - -private: - // fist - the fence value associated with the command list that was created by the allocator - // second - the allocator to be discarded - typedef std::pair<Uint64, CComPtr<IVkCommandAllocator> > DiscardedAllocatorQueueElemType; - std::deque< DiscardedAllocatorQueueElemType, STDAllocatorRawMem<DiscardedAllocatorQueueElemType> > m_DiscardedAllocators; - - std::mutex m_AllocatorMutex; - RenderDeviceVkImpl *m_pDeviceVk; - - Atomics::AtomicLong m_NumAllocators = 0; // For debug purposes only - */ -}; - -}
\ No newline at end of file diff --git a/Graphics/GraphicsEngineVulkan/include/CommandQueueVkImpl.h b/Graphics/GraphicsEngineVulkan/include/CommandQueueVkImpl.h index c655b67d..bf8a2866 100644 --- a/Graphics/GraphicsEngineVulkan/include/CommandQueueVkImpl.h +++ b/Graphics/GraphicsEngineVulkan/include/CommandQueueVkImpl.h @@ -26,9 +26,13 @@ /// \file /// Declaration of Diligent::CommandQueueVkImpl class +#include <mutex> +#include <deque> #include "vulkan.h" #include "CommandQueueVk.h" #include "ObjectBase.h" +#include "VulkanUtilities/VulkanLogicalDevice.h" +#include "VulkanUtilities/VulkanFencePool.h" namespace Diligent { @@ -39,43 +43,44 @@ class CommandQueueVkImpl : public ObjectBase<ICommandQueueVk> public: typedef ObjectBase<ICommandQueueVk> TBase; - CommandQueueVkImpl(IReferenceCounters *pRefCounters, VkQueue VkNativeCmdQueue, uint32_t QueueFamilyIndex); + CommandQueueVkImpl(IReferenceCounters *pRefCounters, + std::shared_ptr<VulkanUtilities::VulkanLogicalDevice> LogicalDevice, + uint32_t QueueFamilyIndex); ~CommandQueueVkImpl(); virtual void QueryInterface( const Diligent::INTERFACE_ID &IID, IObject **ppInterface )override; // Returns the fence value that will be signaled next time - //virtual UINT64 GetNextFenceValue()override final { return m_NextFenceValue; } + virtual UINT64 GetNextFenceValue()override final { return m_NextFenceValue; } - // Executes a given command list - //virtual UINT64 ExecuteCommandList(IVkGraphicsCommandList* commandList)override final; + // Executes a given command buffer + virtual Uint64 ExecuteCommandBuffer(VkCommandBuffer cmdBuffer)override final; virtual VkQueue GetVkQueue()override final{return m_VkQueue;} virtual uint32_t GetQueueFamilyIndex()override final { return m_QueueFamilyIndex; } + + virtual void IdleGPU()override final; - - //virtual void IdleGPU()override final; - - //virtual Uint64 GetCompletedFenceValue()override final; + virtual Uint64 GetCompletedFenceValue()override final; private: // A value that will be signaled by the command queue next - //Atomics::AtomicInt64 m_NextFenceValue; + Atomics::AtomicInt64 m_NextFenceValue; - // Last fence value completed by the GPU - //volatile Uint64 m_LastCompletedFenceValue = 0; + // Last fence value that is known to be completed by the GPU + volatile Uint64 m_LastCompletedFenceValue = 0; + std::shared_ptr<VulkanUtilities::VulkanLogicalDevice> m_LogicalDevice; + const VkQueue m_VkQueue; const uint32_t m_QueueFamilyIndex; -/* - // The fence is signaled right after the command list has been + VulkanUtilities::VulkanFencePool m_FencePool; + // Queue of fences signaled right after a command buffer has been // submitted to the command queue for execution. - // All command lists with fence value less or equal to the signaled value + // All command buffers with fence value less or equal to the signaled value // are guaranteed to be finished by the GPU - CComPtr<IVkFence> m_VkFence; - - HANDLE m_WaitForGPUEventHandle = {}; - */ + std::deque<std::pair<Uint64, VulkanUtilities::FenceWrapper>> m_PendingFences; + std::mutex m_QueueMutex; }; } diff --git a/Graphics/GraphicsEngineVulkan/include/RenderDeviceVkImpl.h b/Graphics/GraphicsEngineVulkan/include/RenderDeviceVkImpl.h index d46806ae..98275f24 100644 --- a/Graphics/GraphicsEngineVulkan/include/RenderDeviceVkImpl.h +++ b/Graphics/GraphicsEngineVulkan/include/RenderDeviceVkImpl.h @@ -25,17 +25,20 @@ /// \file /// Declaration of Diligent::RenderDeviceVkImpl class +#include <memory> #include "RenderDeviceVk.h" #include "RenderDeviceBase.h" #include "DescriptorHeap.h" -#include "CommandListManager.h" #include "CommandContext.h" #include "DynamicUploadHeap.h" #include "Atomics.h" #include "CommandQueueVk.h" #include "VulkanUtilities/VulkanInstance.h" #include "VulkanUtilities/VulkanPhysicalDevice.h" +#include "VulkanUtilities/VulkanCommandBufferPool.h" +#include "VulkanUtilities/VulkanLogicalDevice.h" +#include "VulkanUtilities/VulkanObjectWrappers.h" /// Namespace for the Direct3D11 implementation of the graphics engine namespace Diligent @@ -53,7 +56,7 @@ public: ICommandQueueVk *pCmdQueue, std::shared_ptr<VulkanUtilities::VulkanInstance> Instance, std::unique_ptr<VulkanUtilities::VulkanPhysicalDevice> PhysicalDevice, - VkDevice vkLogicalDevice, + std::shared_ptr<VulkanUtilities::VulkanLogicalDevice> LogicalDevice, Uint32 NumDeferredContexts ); ~RenderDeviceVkImpl(); @@ -71,7 +74,7 @@ public: virtual void CreateSampler(const SamplerDesc& SamplerDesc, ISampler **ppSampler)override final; - //virtual IVkDevice* GetVkDevice()override final{return m_pVkDevice;} + virtual VkDevice GetVkDevice()override final{ return m_LogicalVkDevice->GetVkDevice();} //virtual void CreateTextureFromD3DResource(IVkResource *pVkTexture, ITexture **ppTexture)override final; @@ -80,7 +83,7 @@ public: /* DescriptorHeapAllocation AllocateDescriptor( Vk_DESCRIPTOR_HEAP_TYPE Type, UINT Count = 1 ); DescriptorHeapAllocation AllocateGPUDescriptors( Vk_DESCRIPTOR_HEAP_TYPE Type, UINT Count = 1 ); - +*/ Uint64 GetCompletedFenceValue(); virtual Uint64 GetNextFenceValue() override final { @@ -89,40 +92,39 @@ public: Uint64 GetCurrentFrameNumber()const {return static_cast<Uint64>(m_FrameNumber);} virtual Bool IsFenceSignaled(Uint64 FenceValue) override final; - */ + ICommandQueueVk *GetCmdQueue(){return m_pCommandQueue;} - /* - void IdleGPU(bool ReleaseStaleObjects); - CommandContext* AllocateCommandContext(const Char *ID = ""); - void CloseAndExecuteCommandContext(CommandContext *pCtx, bool DiscardStaleObjects); - void DisposeCommandContext(CommandContext*); -*/ - void SafeReleaseVkBuffer(VkBuffer vkBuffer); -/* + void IdleGPU(bool ReleaseStaleObjects); + VkCommandBuffer AllocateCommandBuffer(const Char *DebugName = nullptr); + void ExecuteCommandBuffer(VkCommandBuffer CmdBuff, bool DiscardStaleObjects); + void DisposeCommandBuffer(VkCommandBuffer CmdBuff); + + + template<typename VulkanObjectType> + void SafeReleaseVkObject(VulkanUtilities::VulkanObjectWrapper<VulkanObjectType>&& vkObject); + + void FinishFrame(bool ReleaseAllResources); virtual void FinishFrame()override final { FinishFrame(false); } - + /* DynamicUploadHeap* RequestUploadHeap(); void ReleaseUploadHeap(DynamicUploadHeap* pUploadHeap); */ - - std::shared_ptr<VulkanUtilities::VulkanInstance> GetVulkanInstance(){return m_VulkanInstance;} + std::shared_ptr<const VulkanUtilities::VulkanInstance> GetVulkanInstance()const{return m_VulkanInstance;} const VulkanUtilities::VulkanPhysicalDevice &GetPhysicalDevice(){return *m_PhysicalDevice;} - VkDevice GetVkDevice()const{return m_VkDevice;} + const auto &GetLogicalDevice(){return *m_LogicalVkDevice;} private: - virtual void TestTextureFormat( TEXTURE_FORMAT TexFormat ); -#if 0 + virtual void TestTextureFormat( TEXTURE_FORMAT TexFormat )override final; void ProcessReleaseQueue(Uint64 CompletedFenceValue); void DiscardStaleVkObjects(Uint64 CmdListNumber, Uint64 FenceValue); -#endif + std::shared_ptr<VulkanUtilities::VulkanInstance> m_VulkanInstance; std::unique_ptr<VulkanUtilities::VulkanPhysicalDevice> m_PhysicalDevice; - - /// Vk device - VkDevice m_VkDevice = VK_NULL_HANDLE; + std::shared_ptr<VulkanUtilities::VulkanLogicalDevice> m_LogicalVkDevice; + RefCntAutoPtr<ICommandQueueVk> m_pCommandQueue; EngineVkAttribs m_EngineAttribs; @@ -132,12 +134,12 @@ private: // Vk_DESCRIPTOR_HEAP_TYPE_SAMPLER == 1 const Uint32 m_DynamicDescriptorAllocationChunkSize[2]; - +#endif std::mutex m_CmdQueueMutex; Atomics::AtomicInt64 m_FrameNumber; Atomics::AtomicInt64 m_NextCmdListNumber; - +#if 0 // The following basic requirement guarantees correctness of resource deallocation: // // A resource is never released before the last draw command referencing it is invoked on the immediate context @@ -170,18 +172,29 @@ private: typedef std::unique_ptr<CommandContext, STDDeleterRawMem<CommandContext> > ContextPoolElemType; std::vector< ContextPoolElemType, STDAllocatorRawMem<ContextPoolElemType> > m_ContextPool; - - std::deque<CommandContext*, STDAllocatorRawMem<CommandContext*> > m_AvailableContexts; - std::mutex m_ContextAllocationMutex; + std::deque<CommandContext*, STDAllocatorRawMem<CommandContext*> > m_AvailableContexts; +#endif + + VulkanUtilities::VulkanCommandBufferPool m_CmdBufferPool; + std::mutex m_CmdPoolMutex; std::mutex m_ReleaseQueueMutex; - typedef std::pair<Uint64, CComPtr<IVkObject> > ReleaseQueueElemType; + + class StaleVulkanObjectBase + { + public: + virtual ~StaleVulkanObjectBase() = 0 {} + }; + template<typename VulkanObjectType> + class StaleVulkanObject; + + using ReleaseQueueElemType = std::pair<Uint64, std::unique_ptr<StaleVulkanObjectBase> >; std::deque< ReleaseQueueElemType, STDAllocatorRawMem<ReleaseQueueElemType> > m_VkObjReleaseQueue; -#endif + std::mutex m_StaleObjectsMutex; -#if 0 std::deque< ReleaseQueueElemType, STDAllocatorRawMem<ReleaseQueueElemType> > m_StaleVkObjects; +#if 0 std::mutex m_UploadHeapMutex; typedef std::unique_ptr<DynamicUploadHeap, STDDeleterRawMem<DynamicUploadHeap> > UploadHeapPoolElemType; std::vector< UploadHeapPoolElemType, STDAllocatorRawMem<UploadHeapPoolElemType> > m_UploadHeaps; diff --git a/Graphics/GraphicsEngineVulkan/include/SwapChainVkImpl.h b/Graphics/GraphicsEngineVulkan/include/SwapChainVkImpl.h index 7b543619..bad8c1ed 100644 --- a/Graphics/GraphicsEngineVulkan/include/SwapChainVkImpl.h +++ b/Graphics/GraphicsEngineVulkan/include/SwapChainVkImpl.h @@ -64,7 +64,7 @@ public: private: void InitBuffersAndViews(); - std::shared_ptr<VulkanUtilities::VulkanInstance> m_VulkanInstance; + std::shared_ptr<const VulkanUtilities::VulkanInstance> m_VulkanInstance; VkSurfaceKHR m_VkSurface = VK_NULL_HANDLE; VkSwapchainKHR m_VkSwapChain = VK_NULL_HANDLE; VkFormat m_VkColorFormat = VK_FORMAT_UNDEFINED; diff --git a/Graphics/GraphicsEngineVulkan/include/TextureViewVkImpl.h b/Graphics/GraphicsEngineVulkan/include/TextureViewVkImpl.h index 911d1699..78dee56e 100644 --- a/Graphics/GraphicsEngineVulkan/include/TextureViewVkImpl.h +++ b/Graphics/GraphicsEngineVulkan/include/TextureViewVkImpl.h @@ -29,6 +29,7 @@ #include "TextureViewVk.h" #include "RenderDeviceVk.h" #include "TextureViewBase.h" +#include "VulkanUtilities/VulkanObjectWrappers.h" namespace Diligent { @@ -44,18 +45,19 @@ public: IRenderDevice *pDevice, const TextureViewDesc& ViewDesc, class ITexture *pTexture, - VkImageView vkImgView, + VulkanUtilities::ImageViewWrapper &&ImgView, bool bIsDefaultView); + ~TextureViewVkImpl(); virtual void QueryInterface( const Diligent::INTERFACE_ID &IID, IObject **ppInterface )override; void GenerateMips( IDeviceContext *pContext )override; - VkImageView GetVulkanImageView()const{return m_VkImageView;} + VkImageView GetVulkanImageView()const{return m_ImageView;} protected: /// Vulkan image view descriptor handle - VkImageView m_VkImageView; + VulkanUtilities::ImageViewWrapper m_ImageView; }; } diff --git a/Graphics/GraphicsEngineVulkan/include/TextureVkImpl.h b/Graphics/GraphicsEngineVulkan/include/TextureVkImpl.h index 3ca2e580..754a063d 100644 --- a/Graphics/GraphicsEngineVulkan/include/TextureVkImpl.h +++ b/Graphics/GraphicsEngineVulkan/include/TextureVkImpl.h @@ -77,15 +77,15 @@ public: */ void CopyData(IDeviceContext *pContext, - ITexture *pSrcTexture, - Uint32 SrcMipLevel, - Uint32 SrcSlice, - const Box *pSrcBox, - Uint32 DstMipLevel, - Uint32 DstSlice, - Uint32 DstX, - Uint32 DstY, - Uint32 DstZ); + ITexture *pSrcTexture, + Uint32 SrcMipLevel, + Uint32 SrcSlice, + const Box *pSrcBox, + Uint32 DstMipLevel, + Uint32 DstSlice, + Uint32 DstX, + Uint32 DstY, + Uint32 DstZ); /* Vk_CPU_DESCRIPTOR_HANDLE GetMipLevelUAV(Uint32 Mip) { @@ -114,7 +114,8 @@ protected: friend class RenderDeviceVkImpl; */ - VkImage m_VkImage; + VulkanUtilities::ImageWrapper m_VulkanImage; + VulkanUtilities::DeviceMemoryWrapper m_ImageMemory; const bool m_IsExternalHandle; }; diff --git a/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanCommandBufferPool.h b/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanCommandBufferPool.h new file mode 100644 index 00000000..74e6bb35 --- /dev/null +++ b/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanCommandBufferPool.h @@ -0,0 +1,59 @@ +/* Copyright 2015-2018 Egor Yusov +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF ANY PROPRIETARY RIGHTS. +* +* In no event and under no legal theory, whether in tort (including negligence), +* contract, or otherwise, unless required by applicable law (such as deliberate +* and grossly negligent acts) or agreed to in writing, shall any Contributor be +* liable for any damages, including any direct, indirect, special, incidental, +* or consequential damages of any character arising as a result of this License or +* out of the use or inability to use the software (including but not limited to damages +* for loss of goodwill, work stoppage, computer failure or malfunction, or any and +* all other commercial damages or losses), even if such Contributor has been advised +* of the possibility of such damages. +*/ + +#pragma once + +#include <deque> +#include <memory> +#include "vulkan.h" +#include "VulkanLogicalDevice.h" +#include "VulkanObjectWrappers.h" + +namespace VulkanUtilities +{ + class VulkanCommandBufferPool + { + public: + VulkanCommandBufferPool(std::shared_ptr<VulkanUtilities::VulkanLogicalDevice> LogicalDevice, + uint32_t queueFamilyIndex, + VkCommandPoolCreateFlags flags); + VulkanCommandBufferPool(const VulkanCommandBufferPool&) = delete; + VulkanCommandBufferPool(VulkanCommandBufferPool&&) = delete; + VulkanCommandBufferPool& operator = (const VulkanCommandBufferPool&) = delete; + VulkanCommandBufferPool& operator = (VulkanCommandBufferPool&&) = delete; + ~VulkanCommandBufferPool(); + + VkCommandBuffer GetCommandBuffer(uint64_t LastCompletedFence, const char* DebugName = ""); + void DisposeCommandBuffer(VkCommandBuffer CmdBuffer, uint64_t FenceValue); + + private: + // Shared point to logical device must be defined before the command pool + std::shared_ptr<VulkanUtilities::VulkanLogicalDevice> m_LogicalDevice; + CommandPoolWrapper m_CmdPool; + + // fist - the fence value associated with the command buffer when it was executed + // second - the command buffer + typedef std::pair<uint64_t, VkCommandBuffer > QueueElemType; + std::deque< QueueElemType > m_DiscardedCmdBuffers; + }; +} diff --git a/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanDebug.h b/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanDebug.h index bd213544..a68a56f2 100644 --- a/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanDebug.h +++ b/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanDebug.h @@ -60,11 +60,14 @@ namespace VulkanUtilities //void EndRegion(VkCommandBuffer cmdBuffer); // Object specific naming functions + void SetCommandPoolName(VkDevice device, VkCommandPool cmdPool, const char * name); void SetCommandBufferName(VkDevice device, VkCommandBuffer cmdBuffer, const char * name); void SetQueueName(VkDevice device, VkQueue queue, const char * name); void SetImageName(VkDevice device, VkImage image, const char * name); + void SetImageViewName(VkDevice device, VkImageView imageView, const char * name); void SetSamplerName(VkDevice device, VkSampler sampler, const char * name); void SetBufferName(VkDevice device, VkBuffer buffer, const char * name); + void SetBufferViewName(VkDevice device, VkBufferView bufferView, const char * name); void SetDeviceMemoryName(VkDevice device, VkDeviceMemory memory, const char * name); void SetShaderModuleName(VkDevice device, VkShaderModule shaderModule, const char * name); void SetPipelineName(VkDevice device, VkPipeline pipeline, const char * name); diff --git a/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanFencePool.h b/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanFencePool.h new file mode 100644 index 00000000..3e4f5168 --- /dev/null +++ b/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanFencePool.h @@ -0,0 +1,52 @@ +/* Copyright 2015-2018 Egor Yusov +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF ANY PROPRIETARY RIGHTS. +* +* In no event and under no legal theory, whether in tort (including negligence), +* contract, or otherwise, unless required by applicable law (such as deliberate +* and grossly negligent acts) or agreed to in writing, shall any Contributor be +* liable for any damages, including any direct, indirect, special, incidental, +* or consequential damages of any character arising as a result of this License or +* out of the use or inability to use the software (including but not limited to damages +* for loss of goodwill, work stoppage, computer failure or malfunction, or any and +* all other commercial damages or losses), even if such Contributor has been advised +* of the possibility of such damages. +*/ + +#pragma once + +#include <vector> +#include <memory> +#include "vulkan.h" +#include "VulkanLogicalDevice.h" +#include "VulkanUtilities/VulkanObjectWrappers.h" + +namespace VulkanUtilities +{ + class VulkanFencePool + { + public: + VulkanFencePool(std::shared_ptr<const VulkanLogicalDevice> LogicalDevice); + VulkanFencePool(const VulkanFencePool&) = delete; + VulkanFencePool(VulkanFencePool&&) = delete; + VulkanFencePool& operator = (const VulkanFencePool&) = delete; + VulkanFencePool& operator = (VulkanFencePool&&) = delete; + ~VulkanFencePool(); + + VulkanUtilities::FenceWrapper GetFence(); + void DisposeFence(VulkanUtilities::FenceWrapper&& Fence); + + private: + // Shared pointer to logical device must be declared before fences + std::shared_ptr<const VulkanLogicalDevice> m_LogicalDevice; + std::vector<VulkanUtilities::FenceWrapper> m_Fences; + }; +} diff --git a/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanInstance.h b/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanInstance.h index 0320afb9..0a8d67a6 100644 --- a/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanInstance.h +++ b/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanInstance.h @@ -24,19 +24,30 @@ #pragma once #include <vector> +#include <memory> #include "vulkan.h" namespace VulkanUtilities { - class VulkanInstance + class VulkanInstance : private std::enable_shared_from_this<VulkanInstance> { public: - VulkanInstance(bool EnableValidation, - uint32_t GlobalExtensionCount, - const char* const* ppGlobalExtensionNames, - VkAllocationCallbacks* pVkAllocator); + static std::shared_ptr<VulkanInstance> Create(bool EnableValidation, + uint32_t GlobalExtensionCount, + const char* const* ppGlobalExtensionNames, + VkAllocationCallbacks* pVkAllocator); ~VulkanInstance(); + std::shared_ptr<VulkanInstance> GetSharedPtr() + { + return shared_from_this(); + } + + std::shared_ptr<const VulkanInstance> GetSharedPtr()const + { + return shared_from_this(); + } + bool IsLayerAvailable(const char *LayerName)const; bool IsExtensionAvailable(const char *ExtensionName)const; VkPhysicalDevice SelectPhysicalDevice(); @@ -44,6 +55,10 @@ namespace VulkanUtilities VkInstance GetVkInstance()const{return m_VkInstance;} private: + VulkanInstance(bool EnableValidation, + uint32_t GlobalExtensionCount, + const char* const* ppGlobalExtensionNames, + VkAllocationCallbacks* pVkAllocator); bool m_ValidationEnabled = false; VkAllocationCallbacks* const m_pVkAllocator; diff --git a/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanLogicalDevice.h b/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanLogicalDevice.h new file mode 100644 index 00000000..c4b6e480 --- /dev/null +++ b/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanLogicalDevice.h @@ -0,0 +1,104 @@ +/* Copyright 2015-2018 Egor Yusov +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF ANY PROPRIETARY RIGHTS. +* +* In no event and under no legal theory, whether in tort (including negligence), +* contract, or otherwise, unless required by applicable law (such as deliberate +* and grossly negligent acts) or agreed to in writing, shall any Contributor be +* liable for any damages, including any direct, indirect, special, incidental, +* or consequential damages of any character arising as a result of this License or +* out of the use or inability to use the software (including but not limited to damages +* for loss of goodwill, work stoppage, computer failure or malfunction, or any and +* all other commercial damages or losses), even if such Contributor has been advised +* of the possibility of such damages. +*/ + +#pragma once + +#include <memory> +#include "vulkan.h" +#include "VulkanObjectWrappers.h" + +namespace VulkanUtilities +{ + class VulkanLogicalDevice : private std::enable_shared_from_this<VulkanLogicalDevice> + { + public: + static std::shared_ptr<VulkanLogicalDevice> Create(VkPhysicalDevice vkPhysicalDevice, + const VkDeviceCreateInfo &DeviceCI, + const VkAllocationCallbacks* vkAllocator, + bool EnableDebugMarkers); + VulkanLogicalDevice(const VulkanLogicalDevice&) = delete; + VulkanLogicalDevice(VulkanLogicalDevice&&) = delete; + VulkanLogicalDevice& operator = (const VulkanLogicalDevice&) = delete; + VulkanLogicalDevice& operator = (VulkanLogicalDevice&&) = delete; + + ~VulkanLogicalDevice(); + + std::shared_ptr<VulkanLogicalDevice> GetSharedPtr() + { + return shared_from_this(); + } + + std::shared_ptr<const VulkanLogicalDevice> GetSharedPtr()const + { + return shared_from_this(); + } + + VkQueue GetQueue(uint32_t queueFamilyIndex, uint32_t queueIndex); + + VkDevice GetVkDevice()const + { + return m_VkDevice; + } + + void WaitIdle()const; + + CommandPoolWrapper CreateCommandPool (const VkCommandPoolCreateInfo &CmdPoolCI, const char *DebugName = "")const; + BufferWrapper CreateBuffer (const VkBufferCreateInfo &BufferCI, const char *DebugName = "")const; + BufferViewWrapper CreateBufferView (const VkBufferViewCreateInfo &BuffViewCI, const char *DebugName = "")const; + ImageWrapper CreateImage (const VkImageCreateInfo &ImageCI, const char *DebugName = "")const; + ImageViewWrapper CreateImageView (const VkImageViewCreateInfo &ImageViewCI, const char *DebugName = "")const; + FenceWrapper CreateFence (const VkFenceCreateInfo &FenceCI, const char *DebugName = "")const; + DeviceMemoryWrapper AllocateDeviceMemory(const VkMemoryAllocateInfo &AllocInfo, const char *DebugName = "")const; + + VkCommandBuffer AllocateVkCommandBuffer(const VkCommandBufferAllocateInfo &AllocInfo, const char *DebugName = "")const; + + void ReleaseVulkanObject(CommandPoolWrapper&& CmdPool)const; + void ReleaseVulkanObject(BufferWrapper&& Buffer)const; + void ReleaseVulkanObject(BufferViewWrapper&& BufferView)const; + void ReleaseVulkanObject(ImageWrapper&& Image)const; + void ReleaseVulkanObject(ImageViewWrapper&& ImageView)const; + void ReleaseVulkanObject(FenceWrapper&& Fence)const; + void ReleaseVulkanObject(DeviceMemoryWrapper&& Memory)const; + + VkMemoryRequirements GetBufferMemoryRequirements(VkBuffer vkBuffer)const; + VkMemoryRequirements GetImageMemoryRequirements (VkImage vkImage )const; + + VkResult BindBufferMemory(VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)const; + VkResult BindImageMemory (VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)const; + + VkResult MapMemory(VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData)const; + void UnmapMemory(VkDeviceMemory memory)const; + + VkResult GetFenceStatus(VkFence fence)const; + VkResult ResetFence(VkFence fence)const; + + private: + VulkanLogicalDevice(VkPhysicalDevice vkPhysicalDevice, + const VkDeviceCreateInfo &DeviceCI, + const VkAllocationCallbacks* vkAllocator, + bool EnableDebugMarkers); + + VkDevice m_VkDevice = VK_NULL_HANDLE; + const VkAllocationCallbacks* const m_VkAllocator; + }; +} diff --git a/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanObjectWrappers.h b/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanObjectWrappers.h new file mode 100644 index 00000000..00dd44d9 --- /dev/null +++ b/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanObjectWrappers.h @@ -0,0 +1,96 @@ +/* Copyright 2015-2018 Egor Yusov +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF ANY PROPRIETARY RIGHTS. +* +* In no event and under no legal theory, whether in tort (including negligence), +* contract, or otherwise, unless required by applicable law (such as deliberate +* and grossly negligent acts) or agreed to in writing, shall any Contributor be +* liable for any damages, including any direct, indirect, special, incidental, +* or consequential damages of any character arising as a result of this License or +* out of the use or inability to use the software (including but not limited to damages +* for loss of goodwill, work stoppage, computer failure or malfunction, or any and +* all other commercial damages or losses), even if such Contributor has been advised +* of the possibility of such damages. +*/ + +#pragma once + +#include <memory> +#include "vulkan.h" + +namespace VulkanUtilities +{ + class VulkanLogicalDevice; + + template<typename VulkanObjectType> + class VulkanObjectWrapper + { + public: + VulkanObjectWrapper() : + m_pLogicalDevice(nullptr), + m_VkObject(VK_NULL_HANDLE) + {} + VulkanObjectWrapper(std::shared_ptr<const VulkanLogicalDevice> pLogicalDevice, VulkanObjectType vkObject) : + m_pLogicalDevice(pLogicalDevice), + m_VkObject(vkObject) + {} + VulkanObjectWrapper(const VulkanObjectWrapper&) = delete; + VulkanObjectWrapper& operator = (const VulkanObjectWrapper&) = delete; + VulkanObjectWrapper(VulkanObjectWrapper&& rhs) : + m_pLogicalDevice(std::move(rhs.m_pLogicalDevice)), + m_VkObject(rhs.m_VkObject) + { + rhs.m_VkObject = VK_NULL_HANDLE; + } + VulkanObjectWrapper& operator = (VulkanObjectWrapper&& rhs) + { + m_pLogicalDevice = std::move(rhs.m_pLogicalDevice); + m_VkObject = rhs.m_VkObject; + rhs.m_VkObject = VK_NULL_HANDLE; + return *this; + } + + operator VulkanObjectType()const + { + return m_VkObject; + } + + void Release() + { + // For externally managed objects, m_pLogicalDevice is null + if(m_pLogicalDevice && m_VkObject != VK_NULL_HANDLE) + { + m_pLogicalDevice->ReleaseVulkanObject(std::move(*this)); + } + m_VkObject = VK_NULL_HANDLE; + m_pLogicalDevice.reset(); + } + + ~VulkanObjectWrapper() + { + Release(); + } + + private: + friend class VulkanLogicalDevice; + + std::shared_ptr<const VulkanLogicalDevice> m_pLogicalDevice; + VulkanObjectType m_VkObject; + }; + + using CommandPoolWrapper = VulkanObjectWrapper<VkCommandPool>; + using BufferWrapper = VulkanObjectWrapper<VkBuffer>; + using BufferViewWrapper = VulkanObjectWrapper<VkBufferView>; + using ImageWrapper = VulkanObjectWrapper<VkImage>; + using ImageViewWrapper = VulkanObjectWrapper<VkImageView>; + using DeviceMemoryWrapper = VulkanObjectWrapper<VkDeviceMemory>; + using FenceWrapper = VulkanObjectWrapper<VkFence>; +} diff --git a/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanPhysicalDevice.h b/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanPhysicalDevice.h index b64ce488..15f9c8da 100644 --- a/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanPhysicalDevice.h +++ b/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanPhysicalDevice.h @@ -23,6 +23,7 @@ #pragma once +#include <memory> #include <vector> #include "vulkan.h" @@ -31,7 +32,8 @@ namespace VulkanUtilities class VulkanPhysicalDevice { public: - VulkanPhysicalDevice(VkPhysicalDevice vkDevice); + static std::unique_ptr<VulkanPhysicalDevice> Create(VkPhysicalDevice vkDevice); + uint32_t FindQueueFamily(VkQueueFlags QueueFlags)const; VkPhysicalDevice GetVkDeviceHandle()const{return m_VkDevice;} bool IsExtensionSupported(const char *ExtensionName)const; @@ -41,6 +43,8 @@ namespace VulkanUtilities uint32_t GetMemoryTypeIndex(uint32_t typeBits, VkMemoryPropertyFlags properties)const; private: + VulkanPhysicalDevice(VkPhysicalDevice vkDevice); + const VkPhysicalDevice m_VkDevice; VkPhysicalDeviceProperties m_Properties = {}; VkPhysicalDeviceFeatures m_Features = {}; diff --git a/Graphics/GraphicsEngineVulkan/interface/CommandQueueVk.h b/Graphics/GraphicsEngineVulkan/interface/CommandQueueVk.h index c712ca84..9ed10106 100644 --- a/Graphics/GraphicsEngineVulkan/interface/CommandQueueVk.h +++ b/Graphics/GraphicsEngineVulkan/interface/CommandQueueVk.h @@ -41,12 +41,12 @@ class ICommandQueueVk : public Diligent::IObject { public: /// Returns the fence value that will be signaled next time - //virtual UINT64 GetNextFenceValue() = 0; + virtual UINT64 GetNextFenceValue() = 0; - /// Executes a given command list + /// Executes a given command buffer - /// \return Fence value associated with the executed command list - //virtual UINT64 ExecuteCommandList(ID3D12GraphicsCommandList* commandList) = 0; + /// \return Fence value associated with the executed command buffer + virtual Uint64 ExecuteCommandBuffer(VkCommandBuffer cmdBuffer) = 0; /// Returns Vulkan command queue. May return VK_NULL_HANDLE if queue is anavailable virtual VkQueue GetVkQueue() = 0; @@ -55,10 +55,10 @@ public: virtual uint32_t GetQueueFamilyIndex() = 0; /// Returns value of the last completed fence - //virtual Uint64 GetCompletedFenceValue() = 0; + virtual Uint64 GetCompletedFenceValue() = 0; /// Blocks execution until all pending GPU commands are complete - //virtual void IdleGPU() = 0; + virtual void IdleGPU() = 0; }; } diff --git a/Graphics/GraphicsEngineVulkan/interface/RenderDeviceVk.h b/Graphics/GraphicsEngineVulkan/interface/RenderDeviceVk.h index a5a03328..1b93ebfe 100644 --- a/Graphics/GraphicsEngineVulkan/interface/RenderDeviceVk.h +++ b/Graphics/GraphicsEngineVulkan/interface/RenderDeviceVk.h @@ -40,22 +40,19 @@ class IRenderDeviceVk : public IRenderDevice { public: - /// Returns ID3D12Device interface of the internal Direct3D12 device object. - - /// The method does *NOT* call AddRef() on the returned interface, - /// so Release() must not be called. - //virtual ID3D12Device* GetD3D12Device() = 0; + /// Returns logical Vulkan device handle + virtual VkDevice GetVkDevice() = 0; /// Returns the fence value that will be signaled by the GPU command queue next - //virtual Uint64 GetNextFenceValue() = 0; + virtual Uint64 GetNextFenceValue() = 0; /// Checks if the fence value has been signaled by the GPU. True means /// that all associated work has been finished - //virtual Bool IsFenceSignaled(Uint64 FenceValue) = 0; + virtual Bool IsFenceSignaled(Uint64 FenceValue) = 0; /// Should be called at the end of the frame when attached to existing D3D12 device /// Otherwise the method is automatically called before present - //virtual void FinishFrame() = 0; + virtual void FinishFrame() = 0; /// Creates a texture object from native d3d12 resource diff --git a/Graphics/GraphicsEngineVulkan/src/BufferViewVkImpl.cpp b/Graphics/GraphicsEngineVulkan/src/BufferViewVkImpl.cpp index ceb6f830..98b87a14 100644 --- a/Graphics/GraphicsEngineVulkan/src/BufferViewVkImpl.cpp +++ b/Graphics/GraphicsEngineVulkan/src/BufferViewVkImpl.cpp @@ -23,6 +23,7 @@ #include "pch.h" #include "BufferViewVkImpl.h" +#include "RenderDeviceVkImpl.h" namespace Diligent { @@ -31,13 +32,19 @@ BufferViewVkImpl::BufferViewVkImpl( IReferenceCounters *pRefCounters, IRenderDevice *pDevice, const BufferViewDesc& ViewDesc, IBuffer *pBuffer, - VkBufferView vkBuffView, + VulkanUtilities::BufferViewWrapper &&BuffView, bool bIsDefaultView ) : TBufferViewBase( pRefCounters, pDevice, ViewDesc, pBuffer, bIsDefaultView ), - m_VkBuffView(vkBuffView) + m_BuffView(std::move(BuffView)) { } +BufferViewVkImpl::~BufferViewVkImpl() +{ + auto *pDeviceVkImpl = ValidatedCast<RenderDeviceVkImpl>(GetDevice()); + pDeviceVkImpl->SafeReleaseVkObject(std::move(m_BuffView)); +} + IMPLEMENT_QUERY_INTERFACE( BufferViewVkImpl, IID_BufferViewVk, TBufferViewBase ) } diff --git a/Graphics/GraphicsEngineVulkan/src/BufferVkImpl.cpp b/Graphics/GraphicsEngineVulkan/src/BufferVkImpl.cpp index a99afd71..3878c5cf 100644 --- a/Graphics/GraphicsEngineVulkan/src/BufferVkImpl.cpp +++ b/Graphics/GraphicsEngineVulkan/src/BufferVkImpl.cpp @@ -67,7 +67,7 @@ BufferVkImpl :: BufferVkImpl(IReferenceCounters *pRefCounters, } } - auto vkAllocator = pRenderDeviceVk->GetVulkanInstance()->GetVkAllocator(); + const auto& LogicalDevice = pRenderDeviceVk->GetLogicalDevice(); if(m_Desc.Usage == USAGE_DYNAMIC && (m_Desc.BindFlags & (BIND_SHADER_RESOURCE|BIND_UNORDERED_ACCESS)) == 0) { UNSUPPORTED("Dynamic buffers are not yet implemented"); @@ -107,12 +107,9 @@ BufferVkImpl :: BufferVkImpl(IReferenceCounters *pRefCounters, VkBuffCI.pQueueFamilyIndices = nullptr; // list of queue families that will access this buffer // (ignored if sharingMode is not VK_SHARING_MODE_CONCURRENT). - auto vkDevice = pRenderDeviceVk->GetVkDevice(); - auto err = vkCreateBuffer(vkDevice, &VkBuffCI, vkAllocator, &m_VkBuffer); - CHECK_VK_ERROR_AND_THROW(err, "Failed to create Vulkan buffer object"); + m_VulkanBuffer = LogicalDevice.CreateBuffer(VkBuffCI, m_Desc.Name); - VkMemoryRequirements MemReqs = {}; - vkGetBufferMemoryRequirements(vkDevice, m_VkBuffer, &MemReqs); + VkMemoryRequirements MemReqs = LogicalDevice.GetBufferMemoryRequirements(m_VulkanBuffer); VkMemoryAllocateInfo MemAlloc = {}; MemAlloc.pNext = nullptr; @@ -144,32 +141,31 @@ BufferVkImpl :: BufferVkImpl(IReferenceCounters *pRefCounters, LOG_ERROR_AND_THROW("Failed to find suitable device memory type for a buffer"); } - err = vkAllocateMemory(vkDevice, &MemAlloc, vkAllocator, &m_BufferMemory); - CHECK_VK_ERROR_AND_THROW(err, "Failed to allocate device local memory for a Vulkan buffer object"); + { + std::string MemoryName("Device local memory for buffer '"); + MemoryName += m_Desc.Name; + MemoryName += '\''; + m_BufferMemory = LogicalDevice.AllocateDeviceMemory(MemAlloc, MemoryName.c_str()); + } - err = vkBindBufferMemory(vkDevice, m_VkBuffer, m_BufferMemory, 0 /*offset*/); + auto err = LogicalDevice.BindBufferMemory(m_VulkanBuffer, m_BufferMemory, 0 /*offset*/); CHECK_VK_ERROR_AND_THROW(err, "Failed to bind buffer memory"); bool bInitializeBuffer = (BuffData.pData != nullptr && BuffData.DataSize > 0); //if(bInitializeBuffer) // m_UsageState = Vk_RESOURCE_STATE_COPY_DEST; - if( *m_Desc.Name != 0) - VulkanUtilities::SetBufferName(vkDevice, m_VkBuffer, m_Desc.Name); - if( bInitializeBuffer ) { VkBufferCreateInfo VkStaginBuffCI = VkBuffCI; VkStaginBuffCI.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT; - VkBuffer vkStagingBuffer = VK_NULL_HANDLE; - err = vkCreateBuffer(vkDevice, &VkStaginBuffCI, vkAllocator, &vkStagingBuffer); - CHECK_VK_ERROR_AND_THROW(err, "Failed to create staging buffer"); + std::string StagingBufferName = "Staging buffer for '"; + StagingBufferName += m_Desc.Name; + StagingBufferName += '\''; + VulkanUtilities::BufferWrapper StagingBuffer = LogicalDevice.CreateBuffer(VkStaginBuffCI, StagingBufferName.c_str()); - VulkanUtilities::SetBufferName(vkDevice, vkStagingBuffer, "Staging buffer"); - - VkMemoryRequirements StagingBufferMemReqs = {}; - vkGetBufferMemoryRequirements(vkDevice, vkStagingBuffer, &StagingBufferMemReqs); + VkMemoryRequirements StagingBufferMemReqs = LogicalDevice.GetBufferMemoryRequirements(StagingBuffer); VkMemoryAllocateInfo StagingMemAlloc = {}; StagingMemAlloc.pNext = nullptr; @@ -187,32 +183,43 @@ BufferVkImpl :: BufferVkImpl(IReferenceCounters *pRefCounters, "corresponding to a VkMemoryType with a propertyFlags that has both the VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT bit " "and the VK_MEMORY_PROPERTY_HOST_COHERENT_BIT bit set(11.6)"); - VkDeviceMemory vkStagingBufferMemory = VK_NULL_HANDLE; - err = vkAllocateMemory(vkDevice, &StagingMemAlloc, vkAllocator, &vkStagingBufferMemory); - CHECK_VK_ERROR_AND_THROW(err, "Failed to allocate memory for a staging buffer object"); + std::string StagingMemoryName("Staging memory for buffer '"); + StagingMemoryName += m_Desc.Name; + StagingMemoryName += '\''; + VulkanUtilities::DeviceMemoryWrapper StagingBufferMemory = LogicalDevice.AllocateDeviceMemory(StagingMemAlloc, StagingMemoryName.c_str()); { void *StagingData = nullptr; - err = vkMapMemory(vkDevice, vkStagingBufferMemory, + err = LogicalDevice.MapMemory(StagingBufferMemory, 0, // offset StagingMemAlloc.allocationSize, 0, // flags, reserved for future use &StagingData); CHECK_VK_ERROR_AND_THROW(err, "Failed to map staging memory"); memcpy(StagingData, BuffData.pData, BuffData.DataSize); - vkUnmapMemory(vkDevice, vkStagingBufferMemory); + LogicalDevice.UnmapMemory(StagingBufferMemory); } - err = vkBindBufferMemory(vkDevice, vkStagingBuffer, vkStagingBufferMemory, 0 /*offset*/); + err = LogicalDevice.BindBufferMemory(StagingBuffer, StagingBufferMemory, 0 /*offset*/); CHECK_VK_ERROR_AND_THROW(err, "Failed to bind staging bufer memory"); + + auto vkCmdBuff = pRenderDeviceVk->AllocateCommandBuffer("Transient cmd buff to copy staging data to a device buffer"); + #if 0 - auto *pInitContext = pRenderDeviceVk->AllocateCommandContext(); // copy data to the intermediate upload heap and then schedule a copy from the upload heap to the default buffer VERIFY_EXPR(m_UsageState == Vk_RESOURCE_STATE_COPY_DEST); +#endif // We MUST NOT call TransitionResource() from here, because // it will call AddRef() and potentially Release(), while // the object is not constructed yet - pInitContext->CopyResource(m_pVkResource, UploadBuffer); + + // Copy commands MUST be recorded outside of a render pass instance. This is OK here + // as copy will be the only command in the cmd buffer + VkBufferCopy BuffCopy = {}; + BuffCopy.srcOffset = 0; + BuffCopy.dstOffset = 0; + BuffCopy.size = VkBuffCI.size; + vkCmdCopyBuffer(vkCmdBuff, StagingBuffer, m_VulkanBuffer, 1, &BuffCopy); // Command list fence should only be signaled when submitting cmd list // from the immediate context, otherwise the basic requirement will be violated @@ -232,13 +239,14 @@ BufferVkImpl :: BufferVkImpl(IReferenceCounters *pRefCounters, // | N+1, but resource it references | | // | was added to the delete queue | | // | with value N | | - pRenderDeviceVk->CloseAndExecuteCommandContext(pInitContext, false); + pRenderDeviceVk->ExecuteCommandBuffer(vkCmdBuff, false); + pRenderDeviceVk->DisposeCommandBuffer(vkCmdBuff); // Add reference to the object to the release queue to keep it alive // until copy operation is complete. This must be done after // submitting command list for execution! - pRenderDeviceVk->SafeReleaseVkObject(UploadBuffer); -#endif + pRenderDeviceVk->SafeReleaseVkObject(std::move(StagingBuffer)); + pRenderDeviceVk->SafeReleaseVkObject(std::move(StagingBufferMemory)); } //if (m_Desc.BindFlags & BIND_UNIFORM_BUFFER) @@ -316,12 +324,10 @@ BufferVkImpl :: BufferVkImpl(IReferenceCounters *pRefCounters, } BufferVkImpl :: ~BufferVkImpl() { + auto *pDeviceVkImpl = ValidatedCast<RenderDeviceVkImpl>(GetDevice()); // Vk object can only be destroyed when it is no longer used by the GPU - if(m_VkBuffer!=VK_NULL_HANDLE) - { - auto *pDeviceVkImpl = ValidatedCast<RenderDeviceVkImpl>(GetDevice()); - pDeviceVkImpl->SafeReleaseVkBuffer(m_VkBuffer); - } + pDeviceVkImpl->SafeReleaseVkObject(std::move(m_VulkanBuffer)); + pDeviceVkImpl->SafeReleaseVkObject(std::move(m_BufferMemory)); } IMPLEMENT_QUERY_INTERFACE( BufferVkImpl, IID_BufferVk, TBufferBase ) @@ -469,9 +475,9 @@ void BufferVkImpl::CreateViewInternal( const BufferViewDesc &OrigViewDesc, IBuff BufferViewDesc ViewDesc = OrigViewDesc; if( ViewDesc.ViewType == BUFFER_VIEW_UNORDERED_ACCESS || ViewDesc.ViewType == BUFFER_VIEW_SHADER_RESOURCE ) { - auto vkView = CreateView(ViewDesc); + auto View = CreateView(ViewDesc); *ppView = NEW_RC_OBJ(BuffViewAllocator, "BufferViewVkImpl instance", BufferViewVkImpl, bIsDefaultView ? this : nullptr) - (GetDevice(), ViewDesc, this, vkView, bIsDefaultView ); + (GetDevice(), ViewDesc, this, std::move(View), bIsDefaultView ); } if( !bIsDefaultView && *ppView ) @@ -485,9 +491,9 @@ void BufferVkImpl::CreateViewInternal( const BufferViewDesc &OrigViewDesc, IBuff } -VkBufferView BufferVkImpl::CreateView(struct BufferViewDesc &ViewDesc) +VulkanUtilities::BufferViewWrapper BufferVkImpl::CreateView(struct BufferViewDesc &ViewDesc) { - VkBufferView vkBuffView = VK_NULL_HANDLE; + VulkanUtilities::BufferViewWrapper BuffView; CorrectBufferViewDesc(ViewDesc); if( (ViewDesc.ViewType == BUFFER_VIEW_SHADER_RESOURCE || ViewDesc.ViewType == BUFFER_VIEW_UNORDERED_ACCESS) && m_Desc.Mode == BUFFER_MODE_FORMATTED) @@ -496,18 +502,16 @@ VkBufferView BufferVkImpl::CreateView(struct BufferViewDesc &ViewDesc) ViewCI.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO; ViewCI.pNext = nullptr; ViewCI.flags = 0; // reserved for future use - ViewCI.buffer = m_VkBuffer; + ViewCI.buffer = m_VulkanBuffer; ViewCI.format = TypeToVkFormat(m_Desc.Format.ValueType, m_Desc.Format.NumComponents, m_Desc.Format.IsNormalized); ViewCI.offset = ViewDesc.ByteOffset; ViewCI.range = ViewDesc.ByteWidth; // size in bytes of the buffer view auto *pDeviceVkImpl = static_cast<RenderDeviceVkImpl*>(GetDevice()); - auto vkAllocator = pDeviceVkImpl->GetVulkanInstance()->GetVkAllocator(); - auto vkDevice = pDeviceVkImpl->GetVkDevice(); - auto err = vkCreateBufferView(vkDevice, &ViewCI, vkAllocator, &vkBuffView); - CHECK_VK_ERROR_AND_THROW(err, "Failed to create Vulkan buffer view"); + const auto& LogicalDevice = pDeviceVkImpl->GetLogicalDevice(); + BuffView = LogicalDevice.CreateBufferView(ViewCI, ViewDesc.Name); } - return vkBuffView; + return BuffView; } #if 0 diff --git a/Graphics/GraphicsEngineVulkan/src/CommandContext.cpp b/Graphics/GraphicsEngineVulkan/src/CommandContext.cpp index fa1157a1..0b254cfc 100644 --- a/Graphics/GraphicsEngineVulkan/src/CommandContext.cpp +++ b/Graphics/GraphicsEngineVulkan/src/CommandContext.cpp @@ -25,7 +25,6 @@ #include "CommandContext.h" #include "TextureVkImpl.h" #include "BufferVkImpl.h" -#include "CommandListManager.h" namespace Diligent { diff --git a/Graphics/GraphicsEngineVulkan/src/CommandListManager.cpp b/Graphics/GraphicsEngineVulkan/src/CommandListManager.cpp deleted file mode 100644 index b4d67c9a..00000000 --- a/Graphics/GraphicsEngineVulkan/src/CommandListManager.cpp +++ /dev/null @@ -1,109 +0,0 @@ -/* Copyright 2015-2018 Egor Yusov - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF ANY PROPRIETARY RIGHTS. - * - * In no event and under no legal theory, whether in tort (including negligence), - * contract, or otherwise, unless required by applicable law (such as deliberate - * and grossly negligent acts) or agreed to in writing, shall any Contributor be - * liable for any damages, including any direct, indirect, special, incidental, - * or consequential damages of any character arising as a result of this License or - * out of the use or inability to use the software (including but not limited to damages - * for loss of goodwill, work stoppage, computer failure or malfunction, or any and - * all other commercial damages or losses), even if such Contributor has been advised - * of the possibility of such damages. - */ - -#include "pch.h" -#include "CommandListManager.h" -#include "RenderDeviceVkImpl.h" - -namespace Diligent -{ - -CommandListManager::CommandListManager(RenderDeviceVkImpl *pDeviceVk)/* : - m_pDeviceVk(pDeviceVk), - m_DiscardedAllocators(STD_ALLOCATOR_RAW_MEM(DiscardedAllocatorQueueElemType, GetRawAllocator(), "Allocator for deque<DiscardedAllocatorQueueElemType>")) - */ -{ -} - -CommandListManager::~CommandListManager() -{ -} - -#if 0 -void CommandListManager::CreateNewCommandList( IVkGraphicsCommandList** List, IVkCommandAllocator** Allocator ) -{ - RequestAllocator(Allocator); - auto *pVkDevice = m_pDeviceVk->GetVkDevice(); - auto hr = pVkDevice->CreateCommandList(1, Vk_COMMAND_LIST_TYPE_DIRECT, *Allocator, nullptr, __uuidof(*List), reinterpret_cast<void**>(List) ); - VERIFY(SUCCEEDED(hr), "Failed to create command list"); - (*List)->SetName(L"CommandList"); -} - - -void CommandListManager::RequestAllocator(IVkCommandAllocator** ppAllocator) -{ - std::lock_guard<std::mutex> LockGuard(m_AllocatorMutex); - - VERIFY( (*ppAllocator) == nullptr, "Allocator pointer is not null" ); - (*ppAllocator) = nullptr; - - if (!m_DiscardedAllocators.empty()) - { - // Pick the oldest allocator at the front of the deque - // If this allocator is not yet available, there is no point in - // looking at other allocators since they were released even - // later - auto& AllocatorPair = m_DiscardedAllocators.front(); - - // Get the last completed fence value - auto CompletedFenceValue = m_pDeviceVk->GetCompletedFenceValue(); - // Note that CompletedFenceValue only grows. So if after we queried - // the value, the actual value is increased in other thread, this will not - // be an issue as the only consequence is that potentially available - // allocator may not be used. - - // AllocatorPair.first is the fence value that was signaled AFTER the - // command list has been submitted. If CompletedFenceValue is at least - // this value, the allocator can be safely reused - if ( CompletedFenceValue >= AllocatorPair.first ) - { - *ppAllocator = AllocatorPair.second.Detach(); - auto hr = (*ppAllocator)->Reset(); - VERIFY_EXPR(SUCCEEDED(hr)); - m_DiscardedAllocators.pop_front(); - } - } - - // If no allocators were ready to be reused, create a new one - if ((*ppAllocator) == nullptr) - { - auto *pVkDevice = m_pDeviceVk->GetVkDevice(); - auto hr = pVkDevice->CreateCommandAllocator(Vk_COMMAND_LIST_TYPE_DIRECT, __uuidof(*ppAllocator), reinterpret_cast<void**>(ppAllocator)); - VERIFY(SUCCEEDED(hr), "Failed to create command allocator"); - wchar_t AllocatorName[32]; - swprintf(AllocatorName, _countof(AllocatorName), L"Cmd list allocator %ld", Atomics::AtomicIncrement(m_NumAllocators)-1); - (*ppAllocator)->SetName(AllocatorName); - } -} - -void CommandListManager::DiscardAllocator( Uint64 FenceValue, IVkCommandAllocator* pAllocator ) -{ - std::lock_guard<std::mutex> LockGuard(m_AllocatorMutex); - - // FenceValue is the value that was signaled by the command queue after it - // executed the command list created by the allocator - m_DiscardedAllocators.emplace_back( FenceValue, CComPtr<IVkCommandAllocator>(pAllocator) ); -} -#endif - -} diff --git a/Graphics/GraphicsEngineVulkan/src/CommandQueueVkImpl.cpp b/Graphics/GraphicsEngineVulkan/src/CommandQueueVkImpl.cpp index dc6eb140..b25c412c 100644 --- a/Graphics/GraphicsEngineVulkan/src/CommandQueueVkImpl.cpp +++ b/Graphics/GraphicsEngineVulkan/src/CommandQueueVkImpl.cpp @@ -27,17 +27,16 @@ namespace Diligent { -CommandQueueVkImpl::CommandQueueVkImpl(IReferenceCounters *pRefCounters, VkQueue VkNativeCmdQueue, uint32_t QueueFamilyIndex) : - TBase(pRefCounters), - m_VkQueue(VkNativeCmdQueue), - m_QueueFamilyIndex(QueueFamilyIndex) - /*m_VkFence(pVkFence), - m_NextFenceValue(1), - m_WaitForGPUEventHandle( CreateEvent(nullptr, false, false, nullptr) ) - */ +CommandQueueVkImpl::CommandQueueVkImpl(IReferenceCounters *pRefCounters, + std::shared_ptr<VulkanUtilities::VulkanLogicalDevice> LogicalDevice, + uint32_t QueueFamilyIndex) : + TBase(pRefCounters), + m_LogicalDevice(LogicalDevice), + m_VkQueue(LogicalDevice->GetQueue(QueueFamilyIndex, 0)), + m_QueueFamilyIndex(QueueFamilyIndex), + m_NextFenceValue(1), + m_FencePool(LogicalDevice) { - //VERIFY_EXPR(m_WaitForGPUEventHandle != INVALID_HANDLE_VALUE); - //m_VkFence->Signal(0); } CommandQueueVkImpl::~CommandQueueVkImpl() @@ -45,18 +44,43 @@ CommandQueueVkImpl::~CommandQueueVkImpl() // Queues are created along with a logical device during vkCreateDevice. // All queues associated with a logical device are destroyed when vkDestroyDevice // is called on that device. + + while(!m_PendingFences.empty()) + { + m_FencePool.DisposeFence(std::move(m_PendingFences.front().second)); + m_PendingFences.pop_front(); + } } IMPLEMENT_QUERY_INTERFACE( CommandQueueVkImpl, IID_CommandQueueVk, TBase ) -#if 0 -UINT64 CommandQueueVkImpl::ExecuteCommandList(IVkGraphicsCommandList* commandList) + +Uint64 CommandQueueVkImpl::ExecuteCommandBuffer(VkCommandBuffer cmdBuffer) { - IVkCommandList *const ppCmdLists[] = {commandList}; - m_pVkCmdQueue->ExecuteCommandLists(1, ppCmdLists); + std::lock_guard<std::mutex> Lock(m_QueueMutex); + + VkSubmitInfo SubmitInfo = {}; + SubmitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + SubmitInfo.commandBufferCount = 1; + SubmitInfo.pCommandBuffers = &cmdBuffer; + SubmitInfo.waitSemaphoreCount = 0; // the number of semaphores upon which to wait before executing the command buffers + SubmitInfo.pWaitSemaphores = nullptr; // a pointer to an array of semaphores upon which to wait before the command + // buffers begin execution + SubmitInfo.pWaitDstStageMask = nullptr; // a pointer to an array of pipeline stages at which each corresponding + // semaphore wait will occur + SubmitInfo.signalSemaphoreCount = 0; // the number of semaphores to be signaled once the commands specified in + // pCommandBuffers have completed execution + SubmitInfo.pSignalSemaphores = nullptr; // a pointer to an array of semaphores which will be signaled when the + // command buffers for this batch have completed execution + + auto Fence = m_FencePool.GetFence(); + auto err = vkQueueSubmit(m_VkQueue, 1, &SubmitInfo, Fence); + VERIFY(err == VK_SUCCESS, "Failed to submit command buffer to the command queue"); + + // We must atomically place the (value, fence) pair into the deque auto FenceValue = m_NextFenceValue; - // Signal the fence - m_pVkCmdQueue->Signal(m_VkFence, FenceValue); + m_PendingFences.emplace_back(FenceValue, std::move(Fence)); + // Increment the value Atomics::AtomicIncrement(m_NextFenceValue); return FenceValue; @@ -64,24 +88,46 @@ UINT64 CommandQueueVkImpl::ExecuteCommandList(IVkGraphicsCommandList* commandLis void CommandQueueVkImpl::IdleGPU() { - Uint64 LastSignaledFenceValue = m_NextFenceValue; - m_pVkCmdQueue->Signal(m_VkFence, LastSignaledFenceValue); + std::lock_guard<std::mutex> Lock(m_QueueMutex); + + // Update last completed fence value to unlock all waiting events + Uint64 LastCompletedFenceValue = m_NextFenceValue; + // Increment fence before idling the queue Atomics::AtomicIncrement(m_NextFenceValue); - if (GetCompletedFenceValue() < LastSignaledFenceValue) + vkQueueWaitIdle(m_VkQueue); + if(LastCompletedFenceValue > m_LastCompletedFenceValue) + m_LastCompletedFenceValue = LastCompletedFenceValue; + for(auto& val_fence : m_PendingFences) { - m_VkFence->SetEventOnCompletion(LastSignaledFenceValue, m_WaitForGPUEventHandle); - WaitForSingleObject(m_WaitForGPUEventHandle, INFINITE); - VERIFY(GetCompletedFenceValue() == LastSignaledFenceValue, "Unexpected signaled fence value"); + auto status = m_LogicalDevice->GetFenceStatus(val_fence.second); + VERIFY(status == VK_SUCCESS, "All pending fences must now be complete!"); + m_FencePool.DisposeFence(std::move(val_fence.second)); } + m_PendingFences.clear(); } Uint64 CommandQueueVkImpl::GetCompletedFenceValue() { - auto CompletedFenceValue = m_VkFence->GetCompletedValue(); - if(CompletedFenceValue > m_LastCompletedFenceValue) - m_LastCompletedFenceValue = CompletedFenceValue; + std::lock_guard<std::mutex> Lock(m_QueueMutex); + + while(!m_PendingFences.empty()) + { + auto &Value_Fence = m_PendingFences.front(); + auto status = m_LogicalDevice->GetFenceStatus(Value_Fence.second); + if(status == VK_SUCCESS) + { + if(Value_Fence.first > m_LastCompletedFenceValue) + m_LastCompletedFenceValue = Value_Fence.first; + m_FencePool.DisposeFence(std::move(Value_Fence.second)); + m_PendingFences.pop_front(); + } + else + { + break; + } + } + return m_LastCompletedFenceValue; } -#endif } diff --git a/Graphics/GraphicsEngineVulkan/src/DeviceContextVkImpl.cpp b/Graphics/GraphicsEngineVulkan/src/DeviceContextVkImpl.cpp index 95d681b7..8c1580bd 100644 --- a/Graphics/GraphicsEngineVulkan/src/DeviceContextVkImpl.cpp +++ b/Graphics/GraphicsEngineVulkan/src/DeviceContextVkImpl.cpp @@ -550,9 +550,9 @@ namespace Diligent m_CommittedIBFormat = VT_UNDEFINED; m_bCommittedVkVBsUpToDate = false; m_bCommittedVkIBUpToDate = false; +#endif m_pPipelineState.Release(); -#endif } void DeviceContextVkImpl::Flush() diff --git a/Graphics/GraphicsEngineVulkan/src/RenderDeviceFactoryVk.cpp b/Graphics/GraphicsEngineVulkan/src/RenderDeviceFactoryVk.cpp index 36118793..d61c05b8 100644 --- a/Graphics/GraphicsEngineVulkan/src/RenderDeviceFactoryVk.cpp +++ b/Graphics/GraphicsEngineVulkan/src/RenderDeviceFactoryVk.cpp @@ -54,7 +54,7 @@ public: void AttachToVulkanDevice(std::shared_ptr<VulkanUtilities::VulkanInstance>, std::unique_ptr<VulkanUtilities::VulkanPhysicalDevice> PhysicalDevice, - VkDevice vkLogicalDevice, + std::shared_ptr<VulkanUtilities::VulkanLogicalDevice> LogicalDevice, ICommandQueueVk *pCommandQueue, const EngineVkAttribs& EngineAttribs, IRenderDevice **ppDevice, @@ -114,17 +114,16 @@ void EngineFactoryVkImpl::CreateDeviceAndContextsVk( const EngineVkAttribs& Crea *ppDevice = nullptr; memset(ppContexts, 0, sizeof(*ppContexts) * (1 + NumDeferredContexts)); - std::shared_ptr<VulkanUtilities::VulkanInstance> Instance; try { - Instance = std::make_shared<VulkanUtilities::VulkanInstance>( + auto Instance = VulkanUtilities::VulkanInstance::Create( CreationAttribs.EnableValidation, CreationAttribs.GlobalExtensionCount, CreationAttribs.ppGlobalExtensionNames, reinterpret_cast<VkAllocationCallbacks*>(CreationAttribs.pVkAllocator)); auto vkDevice = Instance->SelectPhysicalDevice(); - std::unique_ptr<VulkanUtilities::VulkanPhysicalDevice> PhysicalDevice(new VulkanUtilities::VulkanPhysicalDevice(vkDevice)); + auto PhysicalDevice = VulkanUtilities::VulkanPhysicalDevice::Create(vkDevice); // If an implementation exposes any queue family that supports graphics operations, // at least one queue family of at least one physical device exposed by the implementation @@ -163,30 +162,20 @@ void EngineFactoryVkImpl::CreateDeviceAndContextsVk( const EngineVkAttribs& Crea DeviceCreateInfo.ppEnabledExtensionNames = DeviceExtensions.empty() ? nullptr : DeviceExtensions.data(); DeviceCreateInfo.enabledExtensionCount = static_cast<uint32_t>(DeviceExtensions.size()); - VkDevice VulkanDevice = VK_NULL_HANDLE; - auto res = vkCreateDevice(PhysicalDevice->GetVkDeviceHandle(), &DeviceCreateInfo, Instance->GetVkAllocator(), &VulkanDevice); - CHECK_VK_ERROR_AND_THROW(res, "Failed to create logical device"); - - if (CreationAttribs.EnableValidation) + if (!DebugMarkersSupported && CreationAttribs.EnableValidation) { - if(DebugMarkersSupported) - VulkanUtilities::SetupDebugMarkers(VulkanDevice); - else - LOG_INFO_MESSAGE("Debug marker extensions is not found on the system"); + LOG_INFO_MESSAGE("Debug marker extensions is not found on the system"); } - VkQueue Queue = VK_NULL_HANDLE; - vkGetDeviceQueue(VulkanDevice, - QueueInfo.queueFamilyIndex, // Index of the queue family to which the queue belongs - 0, // Index within this queue family of the queue to retrieve - &Queue); - VERIFY_EXPR(Queue != VK_NULL_HANDLE); - RefCntAutoPtr<CommandQueueVkImpl> pCmdQueueVk; + auto vkAllocator = Instance->GetVkAllocator(); + auto vkPhysicalDevice = PhysicalDevice->GetVkDeviceHandle(); + auto LogicalDevice = VulkanUtilities::VulkanLogicalDevice::Create(vkPhysicalDevice, DeviceCreateInfo, vkAllocator, DebugMarkersSupported && CreationAttribs.EnableValidation); + RefCntAutoPtr<CommandQueueVkImpl> pCmdQueueVk; auto &RawMemAllocator = GetRawAllocator(); - pCmdQueueVk = NEW_RC_OBJ(RawMemAllocator, "CommandQueueVk instance", CommandQueueVkImpl)(Queue, QueueInfo.queueFamilyIndex); + pCmdQueueVk = NEW_RC_OBJ(RawMemAllocator, "CommandQueueVk instance", CommandQueueVkImpl)(LogicalDevice, QueueInfo.queueFamilyIndex); - AttachToVulkanDevice(Instance, std::move(PhysicalDevice), VulkanDevice, pCmdQueueVk, CreationAttribs, ppDevice, ppContexts, NumDeferredContexts); + AttachToVulkanDevice(Instance, std::move(PhysicalDevice), LogicalDevice, pCmdQueueVk, CreationAttribs, ppDevice, ppContexts, NumDeferredContexts); } catch(std::runtime_error& ) { @@ -198,7 +187,7 @@ void EngineFactoryVkImpl::CreateDeviceAndContextsVk( const EngineVkAttribs& Crea /// \param [in] Instance - shared pointer to a VulkanUtilities::VulkanInstance object /// \param [in] PhysicalDevice - pointer to the object representing physical device -/// \param [in] vkLogicalDevice - logical Vulkan device handle +/// \param [in] LogicalDevice - shared pointer to a VulkanUtilities::VulkanLogicalDevice object /// \param [in] pCommandQueue - pointer to the implementation of command queue /// \param [in] EngineAttribs - Engine creation attributes. /// \param [out] ppDevice - Address of the memory location where pointer to @@ -213,7 +202,7 @@ void EngineFactoryVkImpl::CreateDeviceAndContextsVk( const EngineVkAttribs& Crea /// at position 1 void EngineFactoryVkImpl::AttachToVulkanDevice(std::shared_ptr<VulkanUtilities::VulkanInstance> Instance, std::unique_ptr<VulkanUtilities::VulkanPhysicalDevice> PhysicalDevice, - VkDevice vkLogicalDevice, + std::shared_ptr<VulkanUtilities::VulkanLogicalDevice> LogicalDevice, ICommandQueueVk *pCommandQueue, const EngineVkAttribs& EngineAttribs, IRenderDevice **ppDevice, @@ -221,7 +210,7 @@ void EngineFactoryVkImpl::AttachToVulkanDevice(std::shared_ptr<VulkanUtilities:: Uint32 NumDeferredContexts) { VERIFY( pCommandQueue && ppDevice && ppContexts, "Null pointer provided" ); - if(vkLogicalDevice == VK_NULL_HANDLE || !pCommandQueue || !ppDevice || !ppContexts ) + if(!LogicalDevice || !pCommandQueue || !ppDevice || !ppContexts ) return; *ppDevice = nullptr; @@ -230,7 +219,7 @@ void EngineFactoryVkImpl::AttachToVulkanDevice(std::shared_ptr<VulkanUtilities:: try { auto &RawMemAllocator = GetRawAllocator(); - RenderDeviceVkImpl *pRenderDeviceVk( NEW_RC_OBJ(RawMemAllocator, "RenderDeviceVkImpl instance", RenderDeviceVkImpl)(RawMemAllocator, EngineAttribs, pCommandQueue, Instance, std::move(PhysicalDevice), vkLogicalDevice, NumDeferredContexts ) ); + RenderDeviceVkImpl *pRenderDeviceVk( NEW_RC_OBJ(RawMemAllocator, "RenderDeviceVkImpl instance", RenderDeviceVkImpl)(RawMemAllocator, EngineAttribs, pCommandQueue, Instance, std::move(PhysicalDevice), LogicalDevice, NumDeferredContexts ) ); pRenderDeviceVk->QueryInterface(IID_RenderDevice, reinterpret_cast<IObject**>(ppDevice) ); RefCntAutoPtr<DeviceContextVkImpl> pImmediateCtxVk( NEW_RC_OBJ(RawMemAllocator, "DeviceContextVkImpl instance", DeviceContextVkImpl)(pRenderDeviceVk, false, EngineAttribs, 0) ); diff --git a/Graphics/GraphicsEngineVulkan/src/RenderDeviceVkImpl.cpp b/Graphics/GraphicsEngineVulkan/src/RenderDeviceVkImpl.cpp index 53e28f9a..db6fc6e6 100644 --- a/Graphics/GraphicsEngineVulkan/src/RenderDeviceVkImpl.cpp +++ b/Graphics/GraphicsEngineVulkan/src/RenderDeviceVkImpl.cpp @@ -26,7 +26,7 @@ #include "PipelineStateVkImpl.h" #include "ShaderVkImpl.h" #include "TextureVkImpl.h" -//#include "DXGITypeConversions.h" +#include "VulkanTypeConversions.h" #include "SamplerVkImpl.h" #include "BufferVkImpl.h" #include "ShaderResourceBindingVkImpl.h" @@ -42,17 +42,17 @@ RenderDeviceVkImpl :: RenderDeviceVkImpl(IReferenceCounters *pRefCounters, ICommandQueueVk *pCmdQueue, std::shared_ptr<VulkanUtilities::VulkanInstance> Instance, std::unique_ptr<VulkanUtilities::VulkanPhysicalDevice> PhysicalDevice, - VkDevice vkLogicalDevice, + std::shared_ptr<VulkanUtilities::VulkanLogicalDevice> LogicalDevice, Uint32 NumDeferredContexts) : TRenderDeviceBase(pRefCounters, RawMemAllocator, NumDeferredContexts, sizeof(TextureVkImpl), sizeof(TextureViewVkImpl), sizeof(BufferVkImpl), sizeof(BufferViewVkImpl), sizeof(ShaderVkImpl), sizeof(SamplerVkImpl), sizeof(PipelineStateVkImpl), sizeof(ShaderResourceBindingVkImpl)), m_VulkanInstance(Instance), m_PhysicalDevice(std::move(PhysicalDevice)), - m_VkDevice(vkLogicalDevice), + m_LogicalVkDevice(LogicalDevice), m_pCommandQueue(pCmdQueue), - m_EngineAttribs(CreationAttribs) - /*m_FrameNumber(0), + m_EngineAttribs(CreationAttribs), + m_FrameNumber(0), m_NextCmdListNumber(0), - m_CmdListManager(this), + /*m_CmdListManager(this), m_CPUDescriptorHeaps { {RawMemAllocator, this, CreationAttribs.CPUDescriptorHeapAllocationSize[0], Vk_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, Vk_DESCRIPTOR_HEAP_FLAG_NONE}, @@ -71,54 +71,62 @@ RenderDeviceVkImpl :: RenderDeviceVkImpl(IReferenceCounters *pRefCounters, CreationAttribs.DynamicDescriptorAllocationChunkSize[1] // Vk_DESCRIPTOR_HEAP_TYPE_SAMPLER }, m_ContextPool(STD_ALLOCATOR_RAW_MEM(ContextPoolElemType, GetRawAllocator(), "Allocator for vector<unique_ptr<CommandContext>>")), - m_AvailableContexts(STD_ALLOCATOR_RAW_MEM(CommandContext*, GetRawAllocator(), "Allocator for vector<CommandContext*>")), + m_AvailableContexts(STD_ALLOCATOR_RAW_MEM(CommandContext*, GetRawAllocator(), "Allocator for vector<CommandContext*>")),*/ m_VkObjReleaseQueue(STD_ALLOCATOR_RAW_MEM(ReleaseQueueElemType, GetRawAllocator(), "Allocator for queue<ReleaseQueueElemType>")), - m_StaleVkObjects(STD_ALLOCATOR_RAW_MEM(ReleaseQueueElemType, GetRawAllocator(), "Allocator for queue<ReleaseQueueElemType>")), + m_StaleVkObjects(STD_ALLOCATOR_RAW_MEM(ReleaseQueueElemType, GetRawAllocator(), "Allocator for queue<ReleaseQueueElemType>")),/*, m_UploadHeaps(STD_ALLOCATOR_RAW_MEM(UploadHeapPoolElemType, GetRawAllocator(), "Allocator for vector<unique_ptr<DynamicUploadHeap>>")) */ + m_CmdBufferPool(m_LogicalVkDevice, pCmdQueue->GetQueueFamilyIndex(), VK_COMMAND_POOL_CREATE_TRANSIENT_BIT | VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT) { m_DeviceCaps.DevType = DeviceType::Vulkan; m_DeviceCaps.MajorVersion = 1; m_DeviceCaps.MinorVersion = 0; m_DeviceCaps.bSeparableProgramSupported = True; m_DeviceCaps.bMultithreadedResourceCreationSupported = True; + for(int fmt = 1; fmt < m_TextureFormatsInfo.size(); ++fmt) + m_TextureFormatsInfo[fmt].Supported = true; // We will test every format on a specific hardware device } RenderDeviceVkImpl::~RenderDeviceVkImpl() { -#if 0 // Finish current frame. This will release resources taken by previous frames, and // will move all stale resources to the release queues. The resources will not be // release until next call to FinishFrame() - FinishFrame(); + FinishFrame(false); // Wait for the GPU to complete all its operations IdleGPU(true); // Call FinishFrame() again to destroy resources in // release queues FinishFrame(true); - + +#if 0 m_ContextPool.clear(); #endif - if(m_PhysicalDevice) - { - // If m_PhysicalDevice is empty, the device does not own vulkan logical device and must not - // destroy it - vkDestroyDevice(m_VkDevice, m_VulkanInstance->GetVkAllocator()); - } + VERIFY(m_StaleVkObjects.empty(), "Not all stale objects were destroyed"); + VERIFY(m_VkObjReleaseQueue.empty(), "Release queue is not empty"); + + //if(m_PhysicalDevice) + //{ + // // If m_PhysicalDevice is empty, the device does not own vulkan logical device and must not + // // destroy it + // vkDestroyDevice(m_VkDevice, m_VulkanInstance->GetVkAllocator()); + //} } -#if 0 -void RenderDeviceVkImpl::DisposeCommandContext(CommandContext* pCtx) + +void RenderDeviceVkImpl::DisposeCommandBuffer(VkCommandBuffer CmdBuff) { - std::lock_guard<std::mutex> LockGuard(m_ContextAllocationMutex); - m_AvailableContexts.push_back(pCtx); + std::lock_guard<std::mutex> LockGuard(m_CmdPoolMutex); + m_CmdBufferPool.DisposeCommandBuffer(CmdBuff, GetNextFenceValue()); } -void RenderDeviceVkImpl::CloseAndExecuteCommandContext(CommandContext *pCtx, bool DiscardStaleObjects) + +void RenderDeviceVkImpl::ExecuteCommandBuffer(VkCommandBuffer CmdBuff, bool DiscardStaleObjects) { - CComPtr<IVkCommandAllocator> pAllocator; - auto *pCmdList = pCtx->Close(&pAllocator); + VERIFY_EXPR(CmdBuff != VK_NULL_HANDLE); + auto err = vkEndCommandBuffer(CmdBuff); + VERIFY(err == VK_SUCCESS, "Failed to end command buffer"); Uint64 FenceValue = 0; Uint64 CmdListNumber = 0; @@ -126,7 +134,7 @@ void RenderDeviceVkImpl::CloseAndExecuteCommandContext(CommandContext *pCtx, boo std::lock_guard<std::mutex> LockGuard(m_CmdQueueMutex); auto NextFenceValue = m_pCommandQueue->GetNextFenceValue(); // Submit the command list to the queue - FenceValue = m_pCommandQueue->ExecuteCommandList(pCmdList); + FenceValue = m_pCommandQueue->ExecuteCommandBuffer(CmdBuff); VERIFY(FenceValue >= NextFenceValue, "Fence value of the executed command list is less than the next fence value previously queried through GetNextFenceValue()"); FenceValue = std::max(FenceValue, NextFenceValue); CmdListNumber = m_NextCmdListNumber; @@ -167,7 +175,7 @@ void RenderDeviceVkImpl::CloseAndExecuteCommandContext(CommandContext *pCtx, boo // the command list (as is the case with Unity command queue). DiscardStaleVkObjects(CmdListNumber, FenceValue); } - +#if 0 // DiscardAllocator() is thread-safe m_CmdListManager.DiscardAllocator(FenceValue, pAllocator); @@ -177,26 +185,30 @@ void RenderDeviceVkImpl::CloseAndExecuteCommandContext(CommandContext *pCtx, boo std::lock_guard<std::mutex> LockGuard(m_ContextAllocationMutex); m_AvailableContexts.push_back(pCtx); } -} #endif +} + -#if 0 void RenderDeviceVkImpl::IdleGPU(bool ReleaseStaleObjects) { Uint64 FenceValue = 0; Uint64 CmdListNumber = 0; + { // Lock the command queue to avoid other threads interfering with the GPU std::lock_guard<std::mutex> LockGuard(m_CmdQueueMutex); FenceValue = m_pCommandQueue->GetNextFenceValue(); m_pCommandQueue->IdleGPU(); + + m_LogicalVkDevice->WaitIdle(); + // Increment cmd list number while keeping queue locked. // This guarantees that any Vk object released after the lock // is released, will be associated with the incremented cmd list number CmdListNumber = m_NextCmdListNumber; Atomics::AtomicIncrement(m_NextCmdListNumber); } - + if (ReleaseStaleObjects) { // Do not wait until the end of the frame and force deletion. @@ -208,6 +220,7 @@ void RenderDeviceVkImpl::IdleGPU(bool ReleaseStaleObjects) } } + Bool RenderDeviceVkImpl::IsFenceSignaled(Uint64 FenceValue) { return FenceValue <= GetCompletedFenceValue(); @@ -218,8 +231,10 @@ Uint64 RenderDeviceVkImpl::GetCompletedFenceValue() return m_pCommandQueue->GetCompletedFenceValue(); } + void RenderDeviceVkImpl::FinishFrame(bool ReleaseAllResources) { +#if 0 { if (auto pImmediateCtx = m_wpImmediateContext.Lock()) { @@ -238,7 +253,7 @@ void RenderDeviceVkImpl::FinishFrame(bool ReleaseAllResources) } } } - +#endif auto CompletedFenceValue = ReleaseAllResources ? std::numeric_limits<Uint64>::max() : GetCompletedFenceValue(); // We must use NextFenceValue here, NOT current value, because the @@ -258,6 +273,7 @@ void RenderDeviceVkImpl::FinishFrame(bool ReleaseAllResources) Atomics::AtomicIncrement(m_NextCmdListNumber); } +#if 0 { // There is no need to lock as new heaps are only created during initialization // time for every context @@ -298,7 +314,7 @@ void RenderDeviceVkImpl::FinishFrame(bool ReleaseAllResources) { m_GPUDescriptorHeaps[GPUHeap].ReleaseStaleAllocations(CompletedFenceValue); } - +#endif // Discard all remaining objects. This is important to do if there were // no command lists submitted during the frame DiscardStaleVkObjects(CmdListNumber, NextFenceValue); @@ -307,6 +323,7 @@ void RenderDeviceVkImpl::FinishFrame(bool ReleaseAllResources) Atomics::AtomicIncrement(m_FrameNumber); } +#if 0 DynamicUploadHeap* RenderDeviceVkImpl::RequestUploadHeap() { std::lock_guard<std::mutex> LockGuard(m_UploadHeapMutex); @@ -328,11 +345,15 @@ void RenderDeviceVkImpl::ReleaseUploadHeap(DynamicUploadHeap* pUploadHeap) { } +#endif -CommandContext* RenderDeviceVkImpl::AllocateCommandContext(const Char *ID) +VkCommandBuffer RenderDeviceVkImpl::AllocateCommandBuffer(const Char *DebugName) { - std::lock_guard<std::mutex> LockGuard(m_ContextAllocationMutex); + std::lock_guard<std::mutex> LockGuard(m_CmdPoolMutex); + auto CmdBuffer = m_CmdBufferPool.GetCommandBuffer(GetCompletedFenceValue(), DebugName); + return CmdBuffer; +#if 0 CommandContext* ret = nullptr; if (m_AvailableContexts.empty()) { @@ -353,21 +374,44 @@ CommandContext* RenderDeviceVkImpl::AllocateCommandContext(const Char *ID) // EngineProfiling::BeginBlock(ID, NewContext); return ret; -} #endif +} -void RenderDeviceVkImpl::SafeReleaseVkBuffer(VkBuffer vkBuffer) + +template<typename VulkanObjectType> +class RenderDeviceVkImpl::StaleVulkanObject : public StaleVulkanObjectBase +{ +public: + StaleVulkanObject(VulkanUtilities::VulkanObjectWrapper<VulkanObjectType> &&Object) : + m_VkObject(std::move(Object)) + {} + + ~StaleVulkanObject() + { + m_VkObject.Release(); + } + +private: + VulkanUtilities::VulkanObjectWrapper<VulkanObjectType> m_VkObject; +}; + +template<typename VulkanObjectType> +void RenderDeviceVkImpl::SafeReleaseVkObject(VulkanUtilities::VulkanObjectWrapper<VulkanObjectType>&& vkObject) { // When Vk object is released, it is first moved into the // stale objects list. The list is moved into a release queue // when the next command list is executed. std::lock_guard<std::mutex> LockGuard(m_StaleObjectsMutex); -#if 0 - m_StaleVkObjects.emplace_back( m_NextCmdListNumber, CComPtr<IVkObject>(pObj) ); -#endif + m_StaleVkObjects.emplace_back(m_NextCmdListNumber, new StaleVulkanObject<VulkanObjectType>(std::move(vkObject)) ); } -#if 0 +template void RenderDeviceVkImpl::SafeReleaseVkObject<VkBuffer>(VulkanUtilities::BufferWrapper &&Object); +template void RenderDeviceVkImpl::SafeReleaseVkObject<VkBufferView>(VulkanUtilities::BufferViewWrapper &&Object); +template void RenderDeviceVkImpl::SafeReleaseVkObject<VkImage>(VulkanUtilities::ImageWrapper &&Object); +template void RenderDeviceVkImpl::SafeReleaseVkObject<VkImageView>(VulkanUtilities::ImageViewWrapper &&Object); +template void RenderDeviceVkImpl::SafeReleaseVkObject<VkDeviceMemory>(VulkanUtilities::DeviceMemoryWrapper &&Object); + + void RenderDeviceVkImpl::DiscardStaleVkObjects(Uint64 CmdListNumber, Uint64 FenceValue) { // Only discard these stale objects that were released before CmdListNumber @@ -403,122 +447,94 @@ void RenderDeviceVkImpl::ProcessReleaseQueue(Uint64 CompletedFenceValue) } } -bool CreateTestResource(IVkDevice *pDevice, const Vk_RESOURCE_DESC &ResDesc) -{ - // Set the texture pointer address to nullptr to validate input parameters - // without creating the texture - // https://msdn.microsoft.com/en-us/library/windows/desktop/dn899178(v=vs.85).aspx - - Vk_HEAP_PROPERTIES HeapProps; - HeapProps.Type = Vk_HEAP_TYPE_DEFAULT; - HeapProps.CPUPageProperty = Vk_CPU_PAGE_PROPERTY_UNKNOWN; - HeapProps.MemoryPoolPreference = Vk_MEMORY_POOL_UNKNOWN; - HeapProps.CreationNodeMask = 1; - HeapProps.VisibleNodeMask = 1; - - auto hr = pDevice->CreateCommittedResource( &HeapProps, Vk_HEAP_FLAG_NONE, &ResDesc, Vk_RESOURCE_STATE_COMMON, nullptr, __uuidof(IVkResource), nullptr ); - return hr == S_FALSE; // S_FALSE means that input parameters passed validation -} -#endif void RenderDeviceVkImpl::TestTextureFormat( TEXTURE_FORMAT TexFormat ) { -#if 0 auto &TexFormatInfo = m_TextureFormatsInfo[TexFormat]; VERIFY( TexFormatInfo.Supported, "Texture format is not supported" ); - auto DXGIFormat = TexFormatToDXGI_Format(TexFormat); - Vk_RESOURCE_FLAGS DefaultResourceFlags = Vk_RESOURCE_FLAG_NONE; - if( TexFormatInfo.ComponentType == COMPONENT_TYPE_DEPTH || - TexFormatInfo.ComponentType == COMPONENT_TYPE_DEPTH_STENCIL ) - DefaultResourceFlags = Vk_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL; - - const int TestTextureDim = 32; - const int TestTextureDepth = 8; - - Vk_RESOURCE_DESC ResDesc = - { - Vk_RESOURCE_DIMENSION_TEXTURE1D, - 0, // Alignment - TestTextureDim, - 1, // Height - 1, // DepthOrArraySize - 1, // MipLevels - DXGIFormat, - {1, 0}, - Vk_TEXTURE_LAYOUT_UNKNOWN, - DefaultResourceFlags - }; - - // Create test texture 1D - TexFormatInfo.Tex1DFmt = false; - if( TexFormatInfo.ComponentType != COMPONENT_TYPE_COMPRESSED ) - { - TexFormatInfo.Tex1DFmt = CreateTestResource(m_pVkDevice, ResDesc ); - } + auto vkPhysicalDevice = m_PhysicalDevice->GetVkDeviceHandle(); - // Create test texture 2D - TexFormatInfo.Tex2DFmt = false; - TexFormatInfo.TexCubeFmt = false; - TexFormatInfo.ColorRenderable = false; - TexFormatInfo.DepthRenderable = false; - TexFormatInfo.SupportsMS = false; + auto SRVFormat = GetDefaultTextureViewFormat(TexFormat, TEXTURE_VIEW_SHADER_RESOURCE, BIND_SHADER_RESOURCE); + auto RTVFormat = GetDefaultTextureViewFormat(TexFormat, TEXTURE_VIEW_RENDER_TARGET, BIND_RENDER_TARGET); + auto DSVFormat = GetDefaultTextureViewFormat(TexFormat, TEXTURE_VIEW_DEPTH_STENCIL, BIND_DEPTH_STENCIL); + + if(SRVFormat != TEX_FORMAT_UNKNOWN) { - ResDesc.Dimension = Vk_RESOURCE_DIMENSION_TEXTURE2D; - ResDesc.Height = TestTextureDim; - TexFormatInfo.Tex2DFmt = CreateTestResource( m_pVkDevice, ResDesc ); + VkFormat vkSrvFormat = TexFormatToVkFormat(SRVFormat); + VkFormatProperties vkSrvFmtProps = {}; + vkGetPhysicalDeviceFormatProperties(vkPhysicalDevice, vkSrvFormat, &vkSrvFmtProps); - if( TexFormatInfo.Tex2DFmt ) + if(vkSrvFmtProps.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) { + TexFormatInfo.Filterable = true; + { - // Vk_TEXTURE2D_DESC CubeTexDesc = Tex2DDesc; - ResDesc.DepthOrArraySize = 6; - // CubeTexDesc.MiscFlags = Vk_RESOURCE_MISC_TEXTURECUBE; - TexFormatInfo.TexCubeFmt = CreateTestResource( m_pVkDevice, ResDesc ); - ResDesc.DepthOrArraySize = 1; + VkImageFormatProperties ImgFmtProps = {}; + auto err = vkGetPhysicalDeviceImageFormatProperties(vkPhysicalDevice, vkSrvFormat, VK_IMAGE_TYPE_1D, VK_IMAGE_TILING_OPTIMAL, + VK_IMAGE_USAGE_SAMPLED_BIT, 0, &ImgFmtProps); + TexFormatInfo.Tex1DFmt = err == VK_SUCCESS; } - if( TexFormatInfo.ComponentType == COMPONENT_TYPE_DEPTH || - TexFormatInfo.ComponentType == COMPONENT_TYPE_DEPTH_STENCIL ) { - ResDesc.Flags = Vk_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL; - ResDesc.SampleDesc.Count = 1; - TexFormatInfo.DepthRenderable = CreateTestResource( m_pVkDevice, ResDesc ); - - if( TexFormatInfo.DepthRenderable ) - { - ResDesc.SampleDesc.Count = 4; - TexFormatInfo.SupportsMS = CreateTestResource( m_pVkDevice, ResDesc ); - } + VkImageFormatProperties ImgFmtProps = {}; + auto err = vkGetPhysicalDeviceImageFormatProperties(vkPhysicalDevice, vkSrvFormat, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL, + VK_IMAGE_USAGE_SAMPLED_BIT, 0, &ImgFmtProps); + TexFormatInfo.Tex2DFmt = err == VK_SUCCESS; } - else if( TexFormatInfo.ComponentType != COMPONENT_TYPE_COMPRESSED && - TexFormatInfo.Format != DXGI_FORMAT_R9G9B9E5_SHAREDEXP ) + + { + VkImageFormatProperties ImgFmtProps = {}; + auto err = vkGetPhysicalDeviceImageFormatProperties(vkPhysicalDevice, vkSrvFormat, VK_IMAGE_TYPE_3D, VK_IMAGE_TILING_OPTIMAL, + VK_IMAGE_USAGE_SAMPLED_BIT, 0, &ImgFmtProps); + TexFormatInfo.Tex3DFmt = err == VK_SUCCESS; + } + + { + VkImageFormatProperties ImgFmtProps = {}; + auto err = vkGetPhysicalDeviceImageFormatProperties(vkPhysicalDevice, vkSrvFormat, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL, + VK_IMAGE_USAGE_SAMPLED_BIT, VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, &ImgFmtProps); + TexFormatInfo.TexCubeFmt = err == VK_SUCCESS; + } + + } + } + + if (RTVFormat != TEX_FORMAT_UNKNOWN) + { + VkFormat vkRtvFormat = TexFormatToVkFormat(RTVFormat); + VkFormatProperties vkRtvFmtProps = {}; + vkGetPhysicalDeviceFormatProperties(vkPhysicalDevice, vkRtvFormat, &vkRtvFmtProps); + if (vkRtvFmtProps.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) + { + VkImageFormatProperties ImgFmtProps = {}; + auto err = vkGetPhysicalDeviceImageFormatProperties(vkPhysicalDevice, vkRtvFormat, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL, + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, 0, &ImgFmtProps); + TexFormatInfo.ColorRenderable = err == VK_SUCCESS; + if (TexFormatInfo.ColorRenderable) { - ResDesc.Flags = Vk_RESOURCE_FLAG_ALLOW_RENDER_TARGET; - ResDesc.SampleDesc.Count = 1; - TexFormatInfo.ColorRenderable = CreateTestResource( m_pVkDevice, ResDesc ); - if( TexFormatInfo.ColorRenderable ) - { - ResDesc.SampleDesc.Count = 4; - TexFormatInfo.SupportsMS = CreateTestResource( m_pVkDevice, ResDesc ); - } + TexFormatInfo.SupportsMS = ImgFmtProps.sampleCounts > VK_SAMPLE_COUNT_1_BIT; } } } - // Create test texture 3D - TexFormatInfo.Tex3DFmt = false; - // 3D textures do not support depth formats - if( !(TexFormatInfo.ComponentType == COMPONENT_TYPE_DEPTH || - TexFormatInfo.ComponentType == COMPONENT_TYPE_DEPTH_STENCIL) ) + if (DSVFormat != TEX_FORMAT_UNKNOWN) { - ResDesc.SampleDesc.Count = 1; - ResDesc.Dimension = Vk_RESOURCE_DIMENSION_TEXTURE3D; - ResDesc.Flags = DefaultResourceFlags; - ResDesc.DepthOrArraySize = TestTextureDepth; - TexFormatInfo.Tex3DFmt = CreateTestResource( m_pVkDevice, ResDesc ); + VkFormat vkDsvFormat = TexFormatToVkFormat(DSVFormat); + VkFormatProperties vkDsvFmtProps = {}; + vkGetPhysicalDeviceFormatProperties(vkPhysicalDevice, vkDsvFormat, &vkDsvFmtProps); + if (vkDsvFmtProps.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) + { + VkImageFormatProperties ImgFmtProps = {}; + auto err = vkGetPhysicalDeviceImageFormatProperties(vkPhysicalDevice, vkDsvFormat, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL, + VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, 0, &ImgFmtProps); + TexFormatInfo.DepthRenderable = err == VK_SUCCESS; + if (TexFormatInfo.DepthRenderable) + { + TexFormatInfo.SupportsMS = ImgFmtProps.sampleCounts > VK_SAMPLE_COUNT_1_BIT; + } + } } -#endif } diff --git a/Graphics/GraphicsEngineVulkan/src/SwapChainVkImpl.cpp b/Graphics/GraphicsEngineVulkan/src/SwapChainVkImpl.cpp index 30543134..606abc1f 100644 --- a/Graphics/GraphicsEngineVulkan/src/SwapChainVkImpl.cpp +++ b/Graphics/GraphicsEngineVulkan/src/SwapChainVkImpl.cpp @@ -314,12 +314,14 @@ void SwapChainVkImpl::InitBuffersAndViews() BackBufferDesc.Width = m_SwapChainDesc.Width; BackBufferDesc.Height = m_SwapChainDesc.Height; BackBufferDesc.Format = m_SwapChainDesc.ColorBufferFormat; + BackBufferDesc.BindFlags = BIND_RENDER_TARGET; BackBufferDesc.MipLevels = 1; RefCntAutoPtr<TextureVkImpl> pBackBufferTex; ValidatedCast<RenderDeviceVkImpl>(m_pRenderDevice.RawPtr())->CreateTexture(BackBufferDesc, swapchainImages[i], &pBackBufferTex); - UNSUPPORTED("TODO: move all this code to Texture creation"); + //UNSUPPORTED("TODO: move all this code to Texture creation"); + VkImageViewCreateInfo color_image_view = {}; color_image_view.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; color_image_view.pNext = NULL; @@ -396,12 +398,6 @@ IMPLEMENT_QUERY_INTERFACE( SwapChainVkImpl, IID_SwapChainVk, TSwapChainBase ) void SwapChainVkImpl::Present(Uint32 SyncInterval) { -#if 0 - UINT SyncInterval = 0; -#if PLATFORM_UNIVERSAL_WINDOWS - SyncInterval = 1; // Interval 0 is not supported on Windows Phone -#endif - auto pDeviceContext = m_wpDeviceContext.Lock(); if( !pDeviceContext ) { @@ -412,16 +408,18 @@ void SwapChainVkImpl::Present(Uint32 SyncInterval) auto *pImmediateCtx = pDeviceContext.RawPtr(); auto *pImmediateCtxVk = ValidatedCast<DeviceContextVkImpl>( pImmediateCtx ); +#if 0 auto *pCmdCtx = pImmediateCtxVk->RequestCmdContext(); auto *pBackBuffer = ValidatedCast<TextureVkImpl>( GetCurrentBackBufferRTV()->GetTexture() ); pCmdCtx->TransitionResource( pBackBuffer, Vk_RESOURCE_STATE_PRESENT); - +#endif pImmediateCtxVk->Flush(); auto *pDeviceVk = ValidatedCast<RenderDeviceVkImpl>( pImmediateCtxVk->GetDevice() ); - +#if 0 auto hr = m_pSwapChain->Present( SyncInterval, 0 ); VERIFY(SUCCEEDED(hr), "Present failed"); +#endif pDeviceVk->FinishFrame(); @@ -434,7 +432,6 @@ void SwapChainVkImpl::Present(Uint32 SyncInterval) pImmediateCtxVk->CommitRenderTargets(); #endif #endif -#endif } void SwapChainVkImpl::Resize( Uint32 NewWidth, Uint32 NewHeight ) @@ -506,5 +503,4 @@ void SwapChainVkImpl::SetWindowedMode() { } - } diff --git a/Graphics/GraphicsEngineVulkan/src/TextureViewVkImpl.cpp b/Graphics/GraphicsEngineVulkan/src/TextureViewVkImpl.cpp index be36e9dd..48536542 100644 --- a/Graphics/GraphicsEngineVulkan/src/TextureViewVkImpl.cpp +++ b/Graphics/GraphicsEngineVulkan/src/TextureViewVkImpl.cpp @@ -24,6 +24,7 @@ #include "pch.h" #include "TextureViewVkImpl.h" #include "DeviceContextVkImpl.h" +#include "RenderDeviceVkImpl.h" namespace Diligent { @@ -32,13 +33,19 @@ TextureViewVkImpl::TextureViewVkImpl( IReferenceCounters *pRefCounters, IRenderDevice *pDevice, const TextureViewDesc& ViewDesc, ITexture *pTexture, - VkImageView vkImgView, + VulkanUtilities::ImageViewWrapper &&ImgView, bool bIsDefaultView ) : TTextureViewBase( pRefCounters, pDevice, ViewDesc, pTexture, bIsDefaultView ), - m_VkImageView(vkImgView) + m_ImageView(std::move(ImgView)) { } +TextureViewVkImpl::~TextureViewVkImpl() +{ + auto *pDeviceVkImpl = ValidatedCast<RenderDeviceVkImpl>(GetDevice()); + pDeviceVkImpl->SafeReleaseVkObject(std::move(m_ImageView)); +} + IMPLEMENT_QUERY_INTERFACE( TextureViewVkImpl, IID_TextureViewVk, TTextureViewBase ) void TextureViewVkImpl::GenerateMips( IDeviceContext *pContext ) diff --git a/Graphics/GraphicsEngineVulkan/src/TextureVkImpl.cpp b/Graphics/GraphicsEngineVulkan/src/TextureVkImpl.cpp index fabf8323..bb069dd9 100644 --- a/Graphics/GraphicsEngineVulkan/src/TextureVkImpl.cpp +++ b/Graphics/GraphicsEngineVulkan/src/TextureVkImpl.cpp @@ -58,59 +58,92 @@ DXGI_FORMAT GetClearFormat(DXGI_FORMAT Fmt, Vk_RESOURCE_FLAGS Flags) #endif TextureVkImpl :: TextureVkImpl(IReferenceCounters *pRefCounters, - FixedBlockMemoryAllocator &TexViewObjAllocator, - RenderDeviceVkImpl *pRenderDeviceVk, - const TextureDesc& TexDesc, - const TextureData &InitData /*= TextureData()*/) : + FixedBlockMemoryAllocator &TexViewObjAllocator, + RenderDeviceVkImpl *pRenderDeviceVk, + const TextureDesc& TexDesc, + const TextureData &InitData /*= TextureData()*/) : TTextureBase(pRefCounters, TexViewObjAllocator, pRenderDeviceVk, TexDesc), m_IsExternalHandle(false) { if( m_Desc.Usage == USAGE_STATIC && InitData.pSubResources == nullptr ) LOG_ERROR_AND_THROW("Static Texture must be initialized with data at creation time"); -#if 0 - Vk_RESOURCE_DESC Desc = {}; - Desc.Alignment = 0; - if(m_Desc.Type == RESOURCE_DIM_TEX_1D_ARRAY || m_Desc.Type == RESOURCE_DIM_TEX_2D_ARRAY || m_Desc.Type == RESOURCE_DIM_TEX_CUBE || m_Desc.Type == RESOURCE_DIM_TEX_CUBE_ARRAY) - Desc.DepthOrArraySize = (UINT16)m_Desc.ArraySize; - else if(m_Desc.Type == RESOURCE_DIM_TEX_3D ) - Desc.DepthOrArraySize = (UINT16)m_Desc.Depth; - else - Desc.DepthOrArraySize = 1; - - if( m_Desc.Type == RESOURCE_DIM_TEX_1D || m_Desc.Type == RESOURCE_DIM_TEX_1D_ARRAY ) - Desc.Dimension = Vk_RESOURCE_DIMENSION_TEXTURE1D; - else if( m_Desc.Type == RESOURCE_DIM_TEX_2D || m_Desc.Type == RESOURCE_DIM_TEX_2D_ARRAY || m_Desc.Type == RESOURCE_DIM_TEX_CUBE || m_Desc.Type == RESOURCE_DIM_TEX_CUBE_ARRAY) - Desc.Dimension = Vk_RESOURCE_DIMENSION_TEXTURE2D; - else if( m_Desc.Type == RESOURCE_DIM_TEX_3D ) - Desc.Dimension = Vk_RESOURCE_DIMENSION_TEXTURE3D; + + const auto& LogicalDevice = pRenderDeviceVk->GetLogicalDevice(); + const auto& PhysicalDevice = pRenderDeviceVk->GetPhysicalDevice(); + + VkImageCreateInfo ImageCI = {}; + ImageCI.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; + ImageCI.pNext = nullptr; + ImageCI.flags = 0; + if(m_Desc.Type == RESOURCE_DIM_TEX_CUBE || m_Desc.Type == RESOURCE_DIM_TEX_CUBE_ARRAY) + ImageCI.flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT; + const auto &FmtAttribs = GetTextureFormatAttribs(TexDesc.Format); + if(FmtAttribs.IsTypeless) + ImageCI.flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT; // Specifies that the image can be used to create a + // VkImageView with a different format from the image. + + if (m_Desc.Type == RESOURCE_DIM_TEX_1D || m_Desc.Type == RESOURCE_DIM_TEX_1D_ARRAY) + ImageCI.imageType = VK_IMAGE_TYPE_1D; + else if (m_Desc.Type == RESOURCE_DIM_TEX_2D || m_Desc.Type == RESOURCE_DIM_TEX_2D_ARRAY || m_Desc.Type == RESOURCE_DIM_TEX_CUBE || m_Desc.Type == RESOURCE_DIM_TEX_CUBE_ARRAY) + ImageCI.imageType = VK_IMAGE_TYPE_2D; + else if (m_Desc.Type == RESOURCE_DIM_TEX_3D) + ImageCI.imageType = VK_IMAGE_TYPE_3D; else { LOG_ERROR_AND_THROW("Unknown texture type"); } + if (FmtAttribs.IsTypeless) + { + // Use SRV format to create the texture + auto SRVFormat = GetDefaultTextureViewFormat(m_Desc, TEXTURE_VIEW_SHADER_RESOURCE); + ImageCI.format = TexFormatToVkFormat(SRVFormat); + } + else + { + ImageCI.format = TexFormatToVkFormat(m_Desc.Format); + } + + ImageCI.extent.width = m_Desc.Width; + ImageCI.extent.height = (m_Desc.Type == RESOURCE_DIM_TEX_1D || m_Desc.Type == RESOURCE_DIM_TEX_1D_ARRAY) ? 1 : m_Desc.Height; + ImageCI.extent.depth = (m_Desc.Type == RESOURCE_DIM_TEX_3D) ? m_Desc.Depth : 1; + + ImageCI.mipLevels = m_Desc.MipLevels; + if (m_Desc.Type == RESOURCE_DIM_TEX_1D_ARRAY || + m_Desc.Type == RESOURCE_DIM_TEX_2D_ARRAY || + m_Desc.Type == RESOURCE_DIM_TEX_CUBE || + m_Desc.Type == RESOURCE_DIM_TEX_CUBE_ARRAY) + ImageCI.arrayLayers = m_Desc.ArraySize; + else + ImageCI.arrayLayers = 1; + + ImageCI.samples = static_cast<VkSampleCountFlagBits>(1 << (m_Desc.SampleCount-1)); + ImageCI.tiling = VK_IMAGE_TILING_OPTIMAL; + + ImageCI.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; + if (m_Desc.BindFlags & BIND_RENDER_TARGET) + ImageCI.usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; + if (m_Desc.BindFlags & BIND_DEPTH_STENCIL) + ImageCI.usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; + if ((m_Desc.BindFlags & BIND_UNORDERED_ACCESS) || (m_Desc.MiscFlags & MISC_TEXTURE_FLAG_GENERATE_MIPS)) + ImageCI.usage |= VK_IMAGE_USAGE_STORAGE_BIT; + if ((m_Desc.BindFlags & BIND_SHADER_RESOURCE) == 0) + ImageCI.usage |= VK_IMAGE_USAGE_SAMPLED_BIT; + + ImageCI.sharingMode = VK_SHARING_MODE_EXCLUSIVE; + ImageCI.queueFamilyIndexCount = 0; + ImageCI.pQueueFamilyIndices = nullptr; + ImageCI.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; + +#if 0 Desc.Flags = Vk_RESOURCE_FLAG_NONE; - if( m_Desc.BindFlags & BIND_RENDER_TARGET ) - Desc.Flags |= Vk_RESOURCE_FLAG_ALLOW_RENDER_TARGET; - if( m_Desc.BindFlags & BIND_DEPTH_STENCIL ) - Desc.Flags |= Vk_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL; - if( (m_Desc.BindFlags & BIND_UNORDERED_ACCESS) || (m_Desc.MiscFlags & MISC_TEXTURE_FLAG_GENERATE_MIPS) ) - Desc.Flags |= Vk_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS; - if( (m_Desc.BindFlags & BIND_SHADER_RESOURCE) == 0 ) - Desc.Flags |= Vk_RESOURCE_FLAG_DENY_SHADER_RESOURCE; auto Format = TexFormatToDXGI_Format(m_Desc.Format, m_Desc.BindFlags); if (Format == DXGI_FORMAT_R8G8B8A8_UNORM_SRGB && (Desc.Flags & Vk_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS)) Desc.Format = DXGI_FORMAT_R8G8B8A8_TYPELESS; else Desc.Format = Format; - Desc.Height = (UINT)m_Desc.Height; - Desc.Layout = Vk_TEXTURE_LAYOUT_UNKNOWN; - Desc.MipLevels = static_cast<Uint16>(m_Desc.MipLevels); - Desc.SampleDesc.Count = m_Desc.SampleCount; - Desc.SampleDesc.Quality = 0; - Desc.Width = (UINT64)m_Desc.Width; - Vk_HEAP_PROPERTIES HeapProps; HeapProps.Type = Vk_HEAP_TYPE_DEFAULT; @@ -141,19 +174,50 @@ TextureVkImpl :: TextureVkImpl(IReferenceCounters *pRefCounters, } pClearValue = &ClearValue; } +#endif bool bInitializeTexture = (InitData.pSubResources != nullptr && InitData.NumSubresources > 0); - if(bInitializeTexture) - m_UsageState = Vk_RESOURCE_STATE_COPY_DEST; + //if(bInitializeTexture) + // m_UsageState = Vk_RESOURCE_STATE_COPY_DEST; + + m_VulkanImage = LogicalDevice.CreateImage(ImageCI, m_Desc.Name); + + VkMemoryRequirements MemReqs = LogicalDevice.GetImageMemoryRequirements(m_VulkanImage); + + VkMemoryAllocateInfo MemAlloc = {}; + MemAlloc.pNext = nullptr; + MemAlloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; + MemAlloc.allocationSize = MemReqs.size; + + VkMemoryPropertyFlags ImageMemoryFlags = 0; + if (m_Desc.Usage == USAGE_CPU_ACCESSIBLE) + ImageMemoryFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; + else + ImageMemoryFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; + + // memoryTypeBits is a bitmask and contains one bit set for every supported memory type for the resource. + // Bit i is set if and only if the memory type i in the VkPhysicalDeviceMemoryProperties structure for the + // physical device is supported for the resource. + MemAlloc.memoryTypeIndex = PhysicalDevice.GetMemoryTypeIndex(MemReqs.memoryTypeBits, ImageMemoryFlags); + if (ImageMemoryFlags == VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) + { + // There must be at least one memory type with the DEVICE_LOCAL_BIT bit set + VERIFY(MemAlloc.memoryTypeIndex != VulkanUtilities::VulkanPhysicalDevice::InvalidMemoryTypeIndex, + "Vulkan spec requires that memoryTypeBits member always contains " + "at least one bit set corresponding to a VkMemoryType with a propertyFlags that has the " + "VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT bit set (11.6)"); + } + else if (MemAlloc.memoryTypeIndex != VulkanUtilities::VulkanPhysicalDevice::InvalidMemoryTypeIndex) + { + LOG_ERROR_AND_THROW("Failed to find suitable device memory type for an image"); + } - auto hr = pVkDevice->CreateCommittedResource( &HeapProps, Vk_HEAP_FLAG_NONE, - &Desc, m_UsageState, pClearValue, __uuidof(m_pVkResource), reinterpret_cast<void**>(static_cast<IVkResource**>(&m_pVkResource)) ); - if(FAILED(hr)) - LOG_ERROR_AND_THROW("Failed to create Vk texture"); + m_ImageMemory = LogicalDevice.AllocateDeviceMemory(MemAlloc); - if( *m_Desc.Name != 0) - m_pVkResource->SetName(WidenString(m_Desc.Name).c_str()); + auto err = LogicalDevice.BindImageMemory(m_VulkanImage, m_ImageMemory, 0 /*offset*/); + CHECK_VK_ERROR_AND_THROW(err, "Failed to bind image memory"); +#if 0 if(bInitializeTexture) { Uint32 ExpectedNumSubresources = static_cast<Uint32>(Desc.MipLevels * (Desc.Dimension == Vk_RESOURCE_DIMENSION_TEXTURE3D ? 1 : Desc.DepthOrArraySize) ); @@ -277,12 +341,12 @@ static TextureDesc InitTexDescFromVkImage(VkImage vkImg, const TextureDesc& SrcT TextureVkImpl::TextureVkImpl(IReferenceCounters *pRefCounters, - FixedBlockMemoryAllocator &TexViewObjAllocator, - RenderDeviceVkImpl *pDeviceVk, - const TextureDesc& TexDesc, - VkImage VkImageHandle) : + FixedBlockMemoryAllocator &TexViewObjAllocator, + RenderDeviceVkImpl *pDeviceVk, + const TextureDesc& TexDesc, + VkImage VkImageHandle) : TTextureBase(pRefCounters, TexViewObjAllocator, pDeviceVk, InitTexDescFromVkImage(VkImageHandle, TexDesc)), - m_VkImage(VkImageHandle), + m_VulkanImage(nullptr, VkImageHandle), m_IsExternalHandle(true) { } @@ -295,7 +359,7 @@ void TextureVkImpl::CreateViewInternal( const struct TextureViewDesc &ViewDesc, VERIFY( *ppView == nullptr, "Overwriting reference to existing object may cause memory leaks" ); *ppView = nullptr; -#if 0 + try { auto *pDeviceVkImpl = ValidatedCast<RenderDeviceVkImpl>(GetDevice()); @@ -305,38 +369,38 @@ void TextureVkImpl::CreateViewInternal( const struct TextureViewDesc &ViewDesc, auto UpdatedViewDesc = ViewDesc; CorrectTextureViewDesc( UpdatedViewDesc ); - DescriptorHeapAllocation ViewHandleAlloc; + VulkanUtilities::ImageViewWrapper ImgView; switch( ViewDesc.ViewType ) { case TEXTURE_VIEW_SHADER_RESOURCE: { VERIFY( m_Desc.BindFlags & BIND_SHADER_RESOURCE, "BIND_SHADER_RESOURCE flag is not set" ); - ViewHandleAlloc = pDeviceVkImpl->AllocateDescriptor(Vk_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); - CreateSRV( UpdatedViewDesc, ViewHandleAlloc.GetCpuHandle() ); + //ViewHandleAlloc = pDeviceVkImpl->AllocateDescriptor(Vk_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); + //CreateSRV( UpdatedViewDesc, ViewHandleAlloc.GetCpuHandle() ); } break; case TEXTURE_VIEW_RENDER_TARGET: { VERIFY( m_Desc.BindFlags & BIND_RENDER_TARGET, "BIND_RENDER_TARGET flag is not set" ); - ViewHandleAlloc = pDeviceVkImpl->AllocateDescriptor(Vk_DESCRIPTOR_HEAP_TYPE_RTV); - CreateRTV( UpdatedViewDesc, ViewHandleAlloc.GetCpuHandle() ); + //ViewHandleAlloc = pDeviceVkImpl->AllocateDescriptor(Vk_DESCRIPTOR_HEAP_TYPE_RTV); + //CreateRTV( UpdatedViewDesc, ViewHandleAlloc.GetCpuHandle() ); } break; case TEXTURE_VIEW_DEPTH_STENCIL: { VERIFY( m_Desc.BindFlags & BIND_DEPTH_STENCIL, "BIND_DEPTH_STENCIL is not set" ); - ViewHandleAlloc = pDeviceVkImpl->AllocateDescriptor(Vk_DESCRIPTOR_HEAP_TYPE_DSV); - CreateDSV( UpdatedViewDesc, ViewHandleAlloc.GetCpuHandle() ); + //ViewHandleAlloc = pDeviceVkImpl->AllocateDescriptor(Vk_DESCRIPTOR_HEAP_TYPE_DSV); + //CreateDSV( UpdatedViewDesc, ViewHandleAlloc.GetCpuHandle() ); } break; case TEXTURE_VIEW_UNORDERED_ACCESS: { VERIFY( m_Desc.BindFlags & BIND_UNORDERED_ACCESS, "BIND_UNORDERED_ACCESS flag is not set" ); - ViewHandleAlloc = pDeviceVkImpl->AllocateDescriptor(Vk_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); - CreateUAV( UpdatedViewDesc, ViewHandleAlloc.GetCpuHandle() ); + //ViewHandleAlloc = pDeviceVkImpl->AllocateDescriptor(Vk_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); + //CreateUAV( UpdatedViewDesc, ViewHandleAlloc.GetCpuHandle() ); } break; @@ -344,7 +408,7 @@ void TextureVkImpl::CreateViewInternal( const struct TextureViewDesc &ViewDesc, } auto pViewVk = NEW_RC_OBJ(TexViewAllocator, "TextureViewVkImpl instance", TextureViewVkImpl, bIsDefaultView ? this : nullptr) - (GetDevice(), UpdatedViewDesc, this, std::move(ViewHandleAlloc), bIsDefaultView ); + (GetDevice(), UpdatedViewDesc, this, std::move(ImgView), bIsDefaultView ); VERIFY( pViewVk->GetDesc().ViewType == ViewDesc.ViewType, "Incorrect view type" ); if( bIsDefaultView ) @@ -357,20 +421,17 @@ void TextureVkImpl::CreateViewInternal( const struct TextureViewDesc &ViewDesc, const auto *ViewTypeName = GetTexViewTypeLiteralName(ViewDesc.ViewType); LOG_ERROR("Failed to create view \"", ViewDesc.Name ? ViewDesc.Name : "", "\" (", ViewTypeName, ") for texture \"", m_Desc.Name ? m_Desc.Name : "", "\"" ); } -#endif } TextureVkImpl :: ~TextureVkImpl() { if(!m_IsExternalHandle) { - + auto *pDeviceVkImpl = ValidatedCast<RenderDeviceVkImpl>(GetDevice()); + // Vk object can only be destroyed when it is no longer used by the GPU + pDeviceVkImpl->SafeReleaseVkObject(std::move(m_VulkanImage)); + pDeviceVkImpl->SafeReleaseVkObject(std::move(m_ImageMemory)); } -#if 0 - // Vk object can only be destroyed when it is no longer used by the GPU - auto *pDeviceVkImpl = ValidatedCast<RenderDeviceVkImpl>(GetDevice()); - pDeviceVkImpl->SafeReleaseVkObject(m_pVkResource); -#endif } void TextureVkImpl::UpdateData( IDeviceContext *pContext, Uint32 MipLevel, Uint32 Slice, const Box &DstBox, const TextureSubResData &SubresData ) diff --git a/Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanCommandBufferPool.cpp b/Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanCommandBufferPool.cpp new file mode 100644 index 00000000..89214191 --- /dev/null +++ b/Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanCommandBufferPool.cpp @@ -0,0 +1,115 @@ +/* Copyright 2015-2018 Egor Yusov +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF ANY PROPRIETARY RIGHTS. +* +* In no event and under no legal theory, whether in tort (including negligence), +* contract, or otherwise, unless required by applicable law (such as deliberate +* and grossly negligent acts) or agreed to in writing, shall any Contributor be +* liable for any damages, including any direct, indirect, special, incidental, +* or consequential damages of any character arising as a result of this License or +* out of the use or inability to use the software (including but not limited to damages +* for loss of goodwill, work stoppage, computer failure or malfunction, or any and +* all other commercial damages or losses), even if such Contributor has been advised +* of the possibility of such damages. +*/ +#include <sstream> + +#include "VulkanUtilities/VulkanCommandBufferPool.h" +#include "VulkanUtilities/VulkanDebug.h" +#include "Errors.h" +#include "DebugUtilities.h" +#include "VulkanErrors.h" + +namespace VulkanUtilities +{ + VulkanCommandBufferPool::VulkanCommandBufferPool(std::shared_ptr<VulkanUtilities::VulkanLogicalDevice> LogicalDevice, + uint32_t queueFamilyIndex, + VkCommandPoolCreateFlags flags) : + m_LogicalDevice(LogicalDevice) + { + VkCommandPoolCreateInfo CmdPoolCI = {}; + CmdPoolCI.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; + CmdPoolCI.pNext = nullptr; + CmdPoolCI.queueFamilyIndex = queueFamilyIndex; + CmdPoolCI.flags = flags; + m_CmdPool = m_LogicalDevice->CreateCommandPool(CmdPoolCI); + VERIFY_EXPR(m_CmdPool != VK_NULL_HANDLE); + } + + VulkanCommandBufferPool::~VulkanCommandBufferPool() + { + m_CmdPool.Release(); + } + + VkCommandBuffer VulkanCommandBufferPool::GetCommandBuffer(uint64_t LastCompletedFence, const char* DebugName) + { + VkCommandBuffer CmdBuffer = VK_NULL_HANDLE; + + if (!m_DiscardedCmdBuffers.empty()) + { + // Pick the oldest cmd buffer at the front of the deque + // If this buffer is not yet available, there is no point in + // looking at other buffers since they were released even + // later + auto& OldestBuff = m_DiscardedCmdBuffers.front(); + + // Note that LastCompletedFence only grows. So if after we queried + // the value, the actual value is increased in other thread, this will not + // be an issue as the only consequence is that potentially available + // cmd buffer may not be used. + + // OldestBuff.first is the fence value that was signaled AFTER the + // command buffer has been submitted. If LastCompletedFence is at least + // this value, the buffer can be safely reused + if (LastCompletedFence >= OldestBuff.first) + { + CmdBuffer = OldestBuff.second; + auto err = vkResetCommandBuffer(CmdBuffer, + 0 // VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT - specifies that most or all memory resources currently owned by the command buffer should be returned to the parent command pool. + ); + VERIFY(err == VK_SUCCESS, "Failed to reset command buffer"); + m_DiscardedCmdBuffers.pop_front(); + } + } + + // If no allocators were ready to be reused, create a new one + if (CmdBuffer == VK_NULL_HANDLE) + { + VkCommandBufferAllocateInfo BuffAllocInfo = {}; + BuffAllocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + BuffAllocInfo.pNext = nullptr; + BuffAllocInfo.commandPool = m_CmdPool; + BuffAllocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + BuffAllocInfo.commandBufferCount = 1; + + CmdBuffer = m_LogicalDevice->AllocateVkCommandBuffer(BuffAllocInfo); + } + + VkCommandBufferBeginInfo CmdBuffBeginInfo = {}; + CmdBuffBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + CmdBuffBeginInfo.pNext = nullptr; + CmdBuffBeginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; // Each recording of the command buffer will only be + // submitted once, and the command buffer will be reset + // and recorded again between each submission. + CmdBuffBeginInfo.pInheritanceInfo = nullptr; // Ignored for a primary command buffer + auto err = vkBeginCommandBuffer(CmdBuffer, &CmdBuffBeginInfo); + VERIFY(err == VK_SUCCESS, "Failed to begin command buffer"); + + return CmdBuffer; + } + + void VulkanCommandBufferPool::DisposeCommandBuffer(VkCommandBuffer CmdBuffer, uint64_t FenceValue) + { + // FenceValue is the value that was signaled by the command queue after it + // executed the command buffer + m_DiscardedCmdBuffers.emplace_back(FenceValue, CmdBuffer); + } +} diff --git a/Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanDebug.cpp b/Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanDebug.cpp index dabeef91..a66f267a 100644 --- a/Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanDebug.cpp +++ b/Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanDebug.cpp @@ -187,6 +187,11 @@ namespace VulkanUtilities // } //} + void SetCommandPoolName(VkDevice device, VkCommandPool cmdPool, const char * name) + { + SetObjectName(device, (uint64_t)cmdPool, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, name); + } + void SetCommandBufferName(VkDevice device, VkCommandBuffer cmdBuffer, const char * name) { SetObjectName(device, (uint64_t)cmdBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, name); @@ -202,6 +207,11 @@ namespace VulkanUtilities SetObjectName(device, (uint64_t)image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, name); } + void SetImageViewName(VkDevice device, VkImageView imageView, const char * name) + { + SetObjectName(device, (uint64_t)imageView, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT, name); + } + void SetSamplerName(VkDevice device, VkSampler sampler, const char * name) { SetObjectName(device, (uint64_t)sampler, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT, name); @@ -212,6 +222,11 @@ namespace VulkanUtilities SetObjectName(device, (uint64_t)buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, name); } + void SetBufferViewName(VkDevice device, VkBufferView bufferView, const char * name) + { + SetObjectName(device, (uint64_t)bufferView, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT, name); + } + void SetDeviceMemoryName(VkDevice device, VkDeviceMemory memory, const char * name) { SetObjectName(device, (uint64_t)memory, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, name); diff --git a/Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanFencePool.cpp b/Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanFencePool.cpp new file mode 100644 index 00000000..eaf6bd7c --- /dev/null +++ b/Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanFencePool.cpp @@ -0,0 +1,69 @@ +/* Copyright 2015-2018 Egor Yusov +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF ANY PROPRIETARY RIGHTS. +* +* In no event and under no legal theory, whether in tort (including negligence), +* contract, or otherwise, unless required by applicable law (such as deliberate +* and grossly negligent acts) or agreed to in writing, shall any Contributor be +* liable for any damages, including any direct, indirect, special, incidental, +* or consequential damages of any character arising as a result of this License or +* out of the use or inability to use the software (including but not limited to damages +* for loss of goodwill, work stoppage, computer failure or malfunction, or any and +* all other commercial damages or losses), even if such Contributor has been advised +* of the possibility of such damages. +*/ +#include <sstream> + +#include "VulkanUtilities/VulkanFencePool.h" +#include "Errors.h" +#include "DebugUtilities.h" + +namespace VulkanUtilities +{ + VulkanFencePool::VulkanFencePool(std::shared_ptr<const VulkanLogicalDevice> LogicalDevice) : + m_LogicalDevice(LogicalDevice) + {} + + VulkanFencePool::~VulkanFencePool() + { + for(const auto &fence : m_Fences) + { + VERIFY(m_LogicalDevice->GetFenceStatus(fence) == VK_SUCCESS, "Destroying a fence that has not been signaled"); + } + m_Fences.clear(); + } + + VulkanUtilities::FenceWrapper VulkanFencePool::GetFence() + { + VulkanUtilities::FenceWrapper Fence; + if(!m_Fences.empty()) + { + Fence = std::move(m_Fences.back()); + m_LogicalDevice->ResetFence(Fence); + m_Fences.pop_back(); + } + else + { + VkFenceCreateInfo FenceCI = {}; + FenceCI.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; + FenceCI.pNext = nullptr; + FenceCI.flags = 0; // Available flag: VK_FENCE_CREATE_SIGNALED_BIT + Fence = m_LogicalDevice->CreateFence(FenceCI); + } + return Fence; + } + + void VulkanFencePool::DisposeFence(VulkanUtilities::FenceWrapper&& Fence) + { + VERIFY(m_LogicalDevice->GetFenceStatus(Fence) == VK_SUCCESS, "Disposing a fence that has not been signaled"); + m_Fences.emplace_back(std::move(Fence)); + } +} diff --git a/Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanInstance.cpp b/Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanInstance.cpp index 4679b874..43c6d6cc 100644 --- a/Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanInstance.cpp +++ b/Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanInstance.cpp @@ -46,6 +46,15 @@ namespace VulkanUtilities return false; } + std::shared_ptr<VulkanInstance> VulkanInstance::Create(bool EnableValidation, + uint32_t GlobalExtensionCount, + const char* const* ppGlobalExtensionNames, + VkAllocationCallbacks* pVkAllocator) + { + auto Instance = new VulkanInstance(EnableValidation, GlobalExtensionCount, ppGlobalExtensionNames, pVkAllocator); + return std::shared_ptr<VulkanInstance>(Instance); + } + VulkanInstance::VulkanInstance(bool EnableValidation, uint32_t GlobalExtensionCount, const char* const* ppGlobalExtensionNames, diff --git a/Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanLogicalDevice.cpp b/Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanLogicalDevice.cpp new file mode 100644 index 00000000..cc1370d0 --- /dev/null +++ b/Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanLogicalDevice.cpp @@ -0,0 +1,292 @@ +/* Copyright 2015-2018 Egor Yusov +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF ANY PROPRIETARY RIGHTS. +* +* In no event and under no legal theory, whether in tort (including negligence), +* contract, or otherwise, unless required by applicable law (such as deliberate +* and grossly negligent acts) or agreed to in writing, shall any Contributor be +* liable for any damages, including any direct, indirect, special, incidental, +* or consequential damages of any character arising as a result of this License or +* out of the use or inability to use the software (including but not limited to damages +* for loss of goodwill, work stoppage, computer failure or malfunction, or any and +* all other commercial damages or losses), even if such Contributor has been advised +* of the possibility of such damages. +*/ + +#include <limits> +#include "VulkanErrors.h" +#include "VulkanUtilities/VulkanLogicalDevice.h" +#include "VulkanUtilities/VulkanDebug.h" + +namespace VulkanUtilities +{ + std::shared_ptr<VulkanLogicalDevice> VulkanLogicalDevice::Create(VkPhysicalDevice vkPhysicalDevice, + const VkDeviceCreateInfo &DeviceCI, + const VkAllocationCallbacks* vkAllocator, + bool EnableDebugMarkers) + { + auto *LogicalDevice = new VulkanLogicalDevice(vkPhysicalDevice, DeviceCI, vkAllocator, EnableDebugMarkers); + return std::shared_ptr<VulkanLogicalDevice>(LogicalDevice); + } + + VulkanLogicalDevice::~VulkanLogicalDevice() + { + vkDestroyDevice(m_VkDevice, m_VkAllocator); + } + + VulkanLogicalDevice::VulkanLogicalDevice(VkPhysicalDevice vkPhysicalDevice, + const VkDeviceCreateInfo &DeviceCI, + const VkAllocationCallbacks* vkAllocator, + bool EnableDebugMarkers) : + m_VkAllocator(vkAllocator) + { + auto res = vkCreateDevice(vkPhysicalDevice, &DeviceCI, vkAllocator, &m_VkDevice); + CHECK_VK_ERROR_AND_THROW(res, "Failed to create logical device"); + + if (EnableDebugMarkers) + { + VulkanUtilities::SetupDebugMarkers(m_VkDevice); + } + } + + VkQueue VulkanLogicalDevice::GetQueue(uint32_t queueFamilyIndex, uint32_t queueIndex) + { + VkQueue vkQueue = VK_NULL_HANDLE; + vkGetDeviceQueue(m_VkDevice, + queueFamilyIndex, // Index of the queue family to which the queue belongs + 0, // Index within this queue family of the queue to retrieve + &vkQueue); + VERIFY_EXPR(vkQueue != VK_NULL_HANDLE); + return vkQueue; + } + + void VulkanLogicalDevice::WaitIdle()const + { + auto err = vkDeviceWaitIdle(m_VkDevice); + VERIFY_EXPR(err == VK_SUCCESS); + } + + CommandPoolWrapper VulkanLogicalDevice::CreateCommandPool(const VkCommandPoolCreateInfo &CmdPoolCI, + const char *DebugName) const + { + if(DebugName == nullptr) + DebugName = ""; + + VkCommandPool CmdPool = VK_NULL_HANDLE; + auto err = vkCreateCommandPool(m_VkDevice, &CmdPoolCI, m_VkAllocator, &CmdPool); + CHECK_VK_ERROR_AND_THROW(err, "Failed to create Vulkan command pool '", DebugName, '\''); + + if(DebugName != nullptr && *DebugName != 0) + VulkanUtilities::SetCommandPoolName(m_VkDevice, CmdPool, DebugName); + + return CommandPoolWrapper{ GetSharedPtr(), CmdPool}; + } + + BufferWrapper VulkanLogicalDevice::CreateBuffer(const VkBufferCreateInfo &BufferCI, + const char *DebugName)const + { + if (DebugName == nullptr) + DebugName = ""; + + VkBuffer vkBuffer = VK_NULL_HANDLE; + auto err = vkCreateBuffer(m_VkDevice, &BufferCI, m_VkAllocator, &vkBuffer); + CHECK_VK_ERROR_AND_THROW(err, "Failed to create Vulkan buffer '", DebugName, '\''); + + if (DebugName != nullptr && *DebugName != 0) + VulkanUtilities::SetBufferName(m_VkDevice, vkBuffer, DebugName); + + return BufferWrapper{ GetSharedPtr(), vkBuffer }; + } + + BufferViewWrapper VulkanLogicalDevice::CreateBufferView(const VkBufferViewCreateInfo &BuffViewCI, + const char *DebugName)const + { + if (DebugName == nullptr) + DebugName = ""; + + VkBufferView vkBufferView = VK_NULL_HANDLE; + auto err = vkCreateBufferView(m_VkDevice, &BuffViewCI, m_VkAllocator, &vkBufferView); + CHECK_VK_ERROR_AND_THROW(err, "Failed to create Vulkan buffer view '", DebugName, '\''); + + if (DebugName != nullptr && *DebugName != 0) + VulkanUtilities::SetBufferViewName(m_VkDevice, vkBufferView, DebugName); + + return BufferViewWrapper{ GetSharedPtr(), vkBufferView }; + } + + ImageWrapper VulkanLogicalDevice::CreateImage(const VkImageCreateInfo &ImageCI, + const char *DebugName)const + { + if (DebugName == nullptr) + DebugName = ""; + + VkImage vkImage = VK_NULL_HANDLE; + auto err = vkCreateImage(m_VkDevice, &ImageCI, m_VkAllocator, &vkImage); + CHECK_VK_ERROR_AND_THROW(err, "Failed to create Vulkan image '", DebugName, '\''); + + if (DebugName != nullptr && *DebugName != 0) + VulkanUtilities::SetImageName(m_VkDevice, vkImage, DebugName); + + return ImageWrapper{ GetSharedPtr(), vkImage }; + } + + ImageViewWrapper VulkanLogicalDevice::CreateImageView(const VkImageViewCreateInfo &ImageViewCI, + const char *DebugName)const + { + if (DebugName == nullptr) + DebugName = ""; + + VkImageView vkImageView = VK_NULL_HANDLE; + auto err = vkCreateImageView(m_VkDevice, &ImageViewCI, m_VkAllocator, &vkImageView); + CHECK_VK_ERROR_AND_THROW(err, "Failed to create Vulkan image view '", DebugName, '\''); + + if (DebugName != nullptr && *DebugName != 0) + VulkanUtilities::SetImageViewName(m_VkDevice, vkImageView, DebugName); + + return ImageViewWrapper{ GetSharedPtr(), vkImageView }; + } + + FenceWrapper VulkanLogicalDevice::CreateFence(const VkFenceCreateInfo &FenceCI, const char *DebugName)const + { + if (DebugName == nullptr) + DebugName = ""; + + VkFence vkFence = VK_NULL_HANDLE; + auto err = vkCreateFence(m_VkDevice, &FenceCI, m_VkAllocator, &vkFence); + CHECK_VK_ERROR_AND_THROW(err, "Failed to create fence '", DebugName, '\''); + + if (DebugName != nullptr && *DebugName != 0) + VulkanUtilities::SetFenceName(m_VkDevice, vkFence, DebugName); + + return FenceWrapper{ GetSharedPtr(), vkFence }; + } + + DeviceMemoryWrapper VulkanLogicalDevice::AllocateDeviceMemory(const VkMemoryAllocateInfo &AllocInfo, + const char *DebugName)const + { + if (DebugName == nullptr) + DebugName = ""; + + VkDeviceMemory vkDeviceMem = VK_NULL_HANDLE; + + auto err = vkAllocateMemory(m_VkDevice, &AllocInfo, m_VkAllocator, &vkDeviceMem); + CHECK_VK_ERROR_AND_THROW(err, "Failed to allocate device memory '", DebugName, '\''); + + if (DebugName != nullptr && *DebugName != 0) + VulkanUtilities::SetDeviceMemoryName(m_VkDevice, vkDeviceMem, DebugName); + + return DeviceMemoryWrapper{ GetSharedPtr(), vkDeviceMem }; + } + + + VkCommandBuffer VulkanLogicalDevice::AllocateVkCommandBuffer(const VkCommandBufferAllocateInfo &AllocInfo, const char *DebugName)const + { + if (DebugName == nullptr) + DebugName = ""; + + VkCommandBuffer CmdBuff = VK_NULL_HANDLE; + auto err = vkAllocateCommandBuffers(m_VkDevice, &AllocInfo, &CmdBuff); + VERIFY(err == VK_SUCCESS, "Failed to allocate command buffer '", DebugName, '\''); + + if (DebugName != nullptr && *DebugName != 0) + SetCommandBufferName(m_VkDevice, CmdBuff, DebugName); + + return CmdBuff; + } + + void VulkanLogicalDevice::ReleaseVulkanObject(CommandPoolWrapper &&CmdPool)const + { + vkDestroyCommandPool(m_VkDevice, CmdPool.m_VkObject, m_VkAllocator); + CmdPool.m_VkObject = VK_NULL_HANDLE; + } + + void VulkanLogicalDevice::ReleaseVulkanObject(BufferWrapper&& Buffer)const + { + vkDestroyBuffer(m_VkDevice, Buffer.m_VkObject, m_VkAllocator); + Buffer.m_VkObject = VK_NULL_HANDLE; + } + + void VulkanLogicalDevice::ReleaseVulkanObject(BufferViewWrapper&& BufferView)const + { + vkDestroyBufferView(m_VkDevice, BufferView.m_VkObject, m_VkAllocator); + BufferView.m_VkObject = VK_NULL_HANDLE; + } + + void VulkanLogicalDevice::ReleaseVulkanObject(ImageWrapper&& Image)const + { + vkDestroyImage(m_VkDevice, Image.m_VkObject, m_VkAllocator); + Image.m_VkObject = VK_NULL_HANDLE; + } + + void VulkanLogicalDevice::ReleaseVulkanObject(ImageViewWrapper&& ImageView)const + { + vkDestroyImageView(m_VkDevice, ImageView.m_VkObject, m_VkAllocator); + ImageView.m_VkObject = VK_NULL_HANDLE; + } + + void VulkanLogicalDevice::ReleaseVulkanObject(FenceWrapper&& Fence)const + { + vkDestroyFence(m_VkDevice, Fence.m_VkObject, m_VkAllocator); + Fence.m_VkObject = VK_NULL_HANDLE; + } + + void VulkanLogicalDevice::ReleaseVulkanObject(DeviceMemoryWrapper&& Memory)const + { + vkFreeMemory(m_VkDevice, Memory.m_VkObject, m_VkAllocator); + Memory.m_VkObject = VK_NULL_HANDLE; + } + + VkMemoryRequirements VulkanLogicalDevice::GetBufferMemoryRequirements(VkBuffer vkBuffer)const + { + VkMemoryRequirements MemReqs = {}; + vkGetBufferMemoryRequirements(m_VkDevice, vkBuffer, &MemReqs); + return MemReqs; + } + + VkMemoryRequirements VulkanLogicalDevice::GetImageMemoryRequirements(VkImage vkImage)const + { + VkMemoryRequirements MemReqs = {}; + vkGetImageMemoryRequirements(m_VkDevice, vkImage, &MemReqs); + return MemReqs; + } + + VkResult VulkanLogicalDevice::BindBufferMemory(VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)const + { + return vkBindBufferMemory(m_VkDevice, buffer, memory, memoryOffset); + } + + VkResult VulkanLogicalDevice::BindImageMemory(VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)const + { + return vkBindImageMemory(m_VkDevice, image, memory, memoryOffset); + } + + VkResult VulkanLogicalDevice::MapMemory(VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData)const + { + return vkMapMemory(m_VkDevice, memory, offset, size, flags, ppData); + } + + void VulkanLogicalDevice::UnmapMemory(VkDeviceMemory memory)const + { + vkUnmapMemory(m_VkDevice, memory); + } + + VkResult VulkanLogicalDevice::GetFenceStatus(VkFence fence)const + { + return vkGetFenceStatus(m_VkDevice, fence); + } + + VkResult VulkanLogicalDevice::ResetFence(VkFence fence)const + { + auto err = vkResetFences(m_VkDevice, 1, &fence); + VERIFY(err == VK_SUCCESS, "Failed to reset fence"); + return err; + } +} diff --git a/Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanPhysicalDevice.cpp b/Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanPhysicalDevice.cpp index f09dd271..26f5e18a 100644 --- a/Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanPhysicalDevice.cpp +++ b/Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanPhysicalDevice.cpp @@ -27,6 +27,12 @@ namespace VulkanUtilities { + std::unique_ptr<VulkanPhysicalDevice> VulkanPhysicalDevice::Create(VkPhysicalDevice vkDevice) + { + auto *PhysicalDevice = new VulkanPhysicalDevice(vkDevice); + return std::unique_ptr<VulkanPhysicalDevice>(PhysicalDevice); + } + VulkanPhysicalDevice::VulkanPhysicalDevice(VkPhysicalDevice vkDevice) : m_VkDevice(vkDevice) { |