Renderer: Add release queue to fix deletion while use

include/Nazara/OpenGLRenderer/OpenGLRenderWindow.hpp

@@ -44,7 +44,7 @@ namespace Nz
 		private:
 			std::size_t m_currentFrame;
 			std::shared_ptr<OpenGLDevice> m_device;
-			std::vector<OpenGLRenderImage> m_renderImage;
+			std::vector<std::unique_ptr<OpenGLRenderImage>> m_renderImage;
 			std::unique_ptr<GL::Context> m_context;
 			OpenGLRenderPass m_renderPass;
 			OpenGLWindowFramebuffer m_framebuffer;

include/Nazara/Renderer/RenderFrame.hpp

@@ -10,13 +10,13 @@
 #include <Nazara/Prerequisites.hpp>
 #include <Nazara/Renderer/Config.hpp>
 #include <Nazara/Renderer/Enums.hpp>
+#include <Nazara/Renderer/RenderImage.hpp>
 #include <functional>
 
 namespace Nz
 {
 	class CommandBuffer;
 	class CommandBufferBuilder;
-	class RenderImage;
 	class UploadPool;
 
 	class NAZARA_RENDERER_API RenderFrame
@@ -34,10 +34,13 @@ namespace Nz
 
 			inline bool IsFramebufferInvalidated() const;
 
-			void SubmitCommandBuffer(CommandBuffer* commandBuffer, QueueTypeFlags queueTypeFlags) ;
+			template<typename T> void PushForRelease(T&& value);
+			template<typename F> void PushReleaseCallback(F&& releaseCallback);
 
 			void Present();
 
+			void SubmitCommandBuffer(CommandBuffer* commandBuffer, QueueTypeFlags queueTypeFlags) ;
+
 			inline explicit operator bool();
 
 			RenderFrame& operator=(const RenderFrame&) = delete;

include/Nazara/Renderer/RenderFrame.inl

@@ -23,6 +23,21 @@ namespace Nz
 		return m_framebufferInvalidation;
 	}
 
+	template<typename T>
+	void RenderFrame::PushForRelease(T&& value)
+	{
+		return PushReleaseCallback([v = std::forward<T>(value)] {});
+	}
+
+	template<typename F>
+	void RenderFrame::PushReleaseCallback(F&& releaseCallback)
+	{
+		if (!m_image)
+			throw std::runtime_error("frame is either invalid or has already been presented");
+
+		m_image->PushReleaseCallback(std::forward<F>(releaseCallback));
+	}
+
 	inline RenderFrame::operator bool()
 	{
 		return m_image != nullptr;

include/Nazara/Renderer/RenderImage.hpp

@@ -21,12 +21,19 @@ namespace Nz
 	class NAZARA_RENDERER_API RenderImage
 	{
 		public:
+			class Releasable;
+			template<typename T> class ReleasableLambda;
+
 			virtual ~RenderImage();
 
 			virtual void Execute(const std::function<void(CommandBufferBuilder& builder)>& callback, QueueTypeFlags queueTypeFlags) = 0;
 
+			inline void FlushReleaseQueue();
+
 			virtual UploadPool& GetUploadPool() = 0;
 
+			template<typename F> void PushReleaseCallback(F&& callback);
+
 			virtual void SubmitCommandBuffer(CommandBuffer* commandBuffer, QueueTypeFlags queueTypeFlags) = 0;
 
 			virtual void Present() = 0;
@@ -34,7 +41,41 @@ namespace Nz
 		protected:
 			RenderImage() = default;
 			RenderImage(const RenderImage&) = delete;
-			RenderImage(RenderImage&&) = default;
+			RenderImage(RenderImage&&) = delete;
+
+		private:
+			static constexpr std::size_t BlockSize = 4 * 1024;
+
+			using Block = std::vector<UInt8>;
+
+			std::vector<Releasable*> m_releaseQueue;
+			std::vector<Block> m_releaseMemoryPool;
+	};
+
+	class NAZARA_RENDERER_API RenderImage::Releasable
+	{
+		public:
+			virtual ~Releasable();
+
+			virtual void Release() = 0;
+	};
+
+	template<typename T>
+	class RenderImage::ReleasableLambda : public Releasable
+	{
+		public:
+			template<typename U> ReleasableLambda(U&& lambda);
+			ReleasableLambda(const ReleasableLambda&) = delete;
+			ReleasableLambda(ReleasableLambda&&) = delete;
+			~ReleasableLambda() = default;
+
+			void Release() override;
+
+			ReleasableLambda& operator=(const ReleasableLambda&) = delete;
+			ReleasableLambda& operator=(ReleasableLambda&&) = delete;
+
+		private:
+			T m_lambda;
 	};
 }
 

include/Nazara/Renderer/RenderImage.inl

@@ -3,10 +3,91 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Renderer/RenderImage.hpp>
+#include <Nazara/Core/Algorithm.hpp>
+#include <Nazara/Core/MemoryHelper.hpp>
 #include <Nazara/Renderer/Debug.hpp>
 
 namespace Nz
 {
+	inline void RenderImage::FlushReleaseQueue()
+	{
+		for (Releasable* releasable : m_releaseQueue)
+		{
+			releasable->Release();
+			PlacementDestroy(releasable);
+		}
+		m_releaseQueue.clear();
+
+		for (auto& memoryblock : m_releaseMemoryPool)
+			memoryblock.clear();
+	}
+
+	template<typename F>
+	void RenderImage::PushReleaseCallback(F&& callback)
+	{
+		using Functor = ReleasableLambda<std::remove_cv_t<std::remove_reference_t<F>>>;
+
+		constexpr std::size_t functorSize = sizeof(Functor);
+		constexpr std::size_t functorAlignment = alignof(Functor);
+
+		// Try to minimize lost space
+		struct
+		{
+			Block* block = nullptr;
+			UInt64 alignedOffset = 0;
+			UInt64 lostSpace = 0;
+		} bestBlock;
+
+		for (Block& block : m_releaseMemoryPool)
+		{
+			std::size_t freeOffset = block.size();
+
+			UInt64 alignedOffset = Align(freeOffset, functorAlignment);
+			if (alignedOffset + functorSize > block.capacity())
+				continue; //< Not enough space
+
+			UInt64 lostSpace = alignedOffset - freeOffset;
+
+			if (!bestBlock.block || lostSpace < bestBlock.lostSpace)
+			{
+				bestBlock.block = &block;
+				bestBlock.alignedOffset = alignedOffset;
+				bestBlock.lostSpace = lostSpace;
+			}
+		}
+
+		// No block found, allocate a new one
+		if (!bestBlock.block)
+		{
+			Block newBlock;
+			newBlock.reserve(BlockSize);
+
+			bestBlock.block = &m_releaseMemoryPool.emplace_back(std::move(newBlock));
+			bestBlock.alignedOffset = 0;
+			bestBlock.lostSpace = 0;
+		}
+
+		Block& targetBlock = *bestBlock.block;
+		targetBlock.resize(bestBlock.alignedOffset + functorSize);
+
+		Functor* releasable = reinterpret_cast<Functor*>(&targetBlock[bestBlock.alignedOffset]);
+		PlacementNew(releasable, std::forward<F>(callback));
+
+		m_releaseQueue.push_back(releasable);
+	}
+
+	template<typename T>
+	template<typename U>
+	RenderImage::ReleasableLambda<T>::ReleasableLambda(U&& lambda) :
+	m_lambda(std::forward<U>(lambda))
+	{
+	}
+
+	template<typename T>
+	void RenderImage::ReleasableLambda<T>::Release()
+	{
+		m_lambda();
+	}
 }
 
 #include <Nazara/Renderer/DebugOff.hpp>

include/Nazara/VulkanRenderer/VkRenderWindow.hpp

@@ -74,7 +74,7 @@ namespace Nz
 			std::shared_ptr<VulkanDevice> m_device;
 			std::size_t m_currentFrame;
 			std::vector<Vk::Fence*> m_inflightFences;
-			std::vector<VulkanRenderImage> m_concurrentImageData;
+			std::vector<std::unique_ptr<VulkanRenderImage>> m_concurrentImageData;
 			Vk::DeviceMemory m_depthBufferMemory;
 			Vk::Image m_depthBuffer;
 			Vk::ImageView m_depthBufferView;

include/Nazara/VulkanRenderer/VulkanRenderImage.hpp

@@ -36,13 +36,13 @@ namespace Nz
 			inline Vk::Semaphore& GetRenderFinishedSemaphore();
 			VulkanUploadPool& GetUploadPool() override;
 
-			void SubmitCommandBuffer(CommandBuffer* commandBuffer, QueueTypeFlags queueTypeFlags) override;
-			void SubmitCommandBuffer(VkCommandBuffer commandBuffer, QueueTypeFlags queueTypeFlags);
-
 			void Present() override;
 
 			inline void Reset(UInt32 imageIndex);
 
+			void SubmitCommandBuffer(CommandBuffer* commandBuffer, QueueTypeFlags queueTypeFlags) override;
+			void SubmitCommandBuffer(VkCommandBuffer commandBuffer, QueueTypeFlags queueTypeFlags);
+
 			VulkanRenderImage& operator=(const VulkanRenderImage&) = delete;
 			VulkanRenderImage& operator=(VulkanRenderImage&&) = delete;
 

include/Nazara/VulkanRenderer/VulkanRenderImage.inl

@@ -7,7 +7,7 @@
 
 namespace Nz
 {
-	inline Vk::Fence& Nz::VulkanRenderImage::GetInFlightFence()
+	inline Vk::Fence& VulkanRenderImage::GetInFlightFence()
 	{
 		return m_inFlightFence;
 	}
@@ -29,6 +29,8 @@ namespace Nz
 
 	inline void VulkanRenderImage::Reset(UInt32 imageIndex)
 	{
+		FlushReleaseQueue();
+
 		m_graphicalCommandsBuffers.clear();
 		m_currentCommandBuffer = 0;
 		m_imageIndex = imageIndex;

src/Nazara/Graphics/BakedFrameGraph.cpp

@@ -45,7 +45,7 @@ namespace Nz
 			if (!regenerateCommandBuffer)
 				continue;
 
-			passData.commandBuffer.reset(); //< Release command buffer resources before reallocating it
+			renderFrame.PushForRelease(std::move(passData.commandBuffer));
 			passData.commandBuffer = m_commandPool->BuildCommandBuffer([&](CommandBufferBuilder& builder)
 			{
 				for (auto& textureTransition : passData.transitions)

src/Nazara/OpenGLRenderer/OpenGLRenderImage.cpp

@@ -35,6 +35,7 @@ namespace Nz
 	{
 		m_owner.Present();
 		m_uploadPool.Reset();
+		FlushReleaseQueue();
 	}
 
 	void OpenGLRenderImage::SubmitCommandBuffer(CommandBuffer* commandBuffer, QueueTypeFlags /*queueTypeFlags*/)

src/Nazara/OpenGLRenderer/OpenGLRenderWindow.cpp

@@ -33,7 +33,7 @@ namespace Nz
 			m_size = size;
 		}
 
-		return RenderFrame(&m_renderImage[m_currentFrame], invalidateFramebuffer);
+		return RenderFrame(m_renderImage[m_currentFrame].get(), invalidateFramebuffer);
 	}
 
 	bool OpenGLRenderWindow::Create(RendererImpl* renderer, RenderSurface* surface, const RenderWindowParameters& parameters)
@@ -55,7 +55,7 @@ namespace Nz
 
 		m_renderImage.reserve(RenderImageCount);
 		for (std::size_t i = 0; i < RenderImageCount; ++i)
-			m_renderImage.emplace_back(*this);
+			m_renderImage.emplace_back(std::make_unique<OpenGLRenderImage>(*this));
 
 		return true;
 	}

src/Nazara/Renderer/RenderImage.cpp

@@ -7,5 +7,10 @@
 
 namespace Nz
 {
-	RenderImage::~RenderImage() = default;
+	RenderImage::~RenderImage()
+	{
+		FlushReleaseQueue();
+	}
+
+	RenderImage::Releasable::~Releasable() = default;
 }

src/Nazara/VulkanRenderer/VkRenderWindow.cpp

@@ -57,7 +57,7 @@ namespace Nz
 			invalidateFramebuffer = true;
 		}
 
-		VulkanRenderImage& currentFrame = m_concurrentImageData[m_currentFrame];
+		VulkanRenderImage& currentFrame = *m_concurrentImageData[m_currentFrame];
 		Vk::Fence& inFlightFence = currentFrame.GetInFlightFence();
 
 		// Wait until previous rendering to this image has been done
@@ -564,7 +564,7 @@ namespace Nz
 			m_concurrentImageData.reserve(imageCount);
 
 			for (std::size_t i = 0; i < imageCount; ++i)
-				m_concurrentImageData.emplace_back(*this);
+				m_concurrentImageData.emplace_back(std::make_unique<VulkanRenderImage>(*this));
 		}
 
 		return true;