fixing better vk command buffers management

.gdb_history

@@ -0,0 +1 @@
+q

example/main.c

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/04 17:55:21 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/04 12:44:58 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/01/07 01:24:29 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -114,8 +114,8 @@ int main(int argc, char* argv[])
 			"that text will disappear");
 	mlx_loop_hook(mlx.mlx, update, &mlx);
 	mlx_loop(mlx.mlx);
-	mlx_destroy_image(mlx.mlx, mlx.img);
 	mlx_destroy_image(mlx.mlx, mlx.logo);
+	mlx_destroy_image(mlx.mlx, mlx.img);
 	mlx_destroy_window(mlx.mlx, mlx.win);
 	mlx_destroy_display(mlx.mlx);
 	return (0);

src/core/UUID.cpp

@@ -0,0 +1,25 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   UUID.cpp                                           :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/01/06 11:26:37 by maldavid          #+#    #+#             */
+/*   Updated: 2024/01/06 11:28:15 by maldavid         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include <core/UUID.h>
+#include <random>
+#include <unordered_map>
+
+namespace mlx
+{
+	static std::random_device random_device;
+	static std::mt19937_64 engine(random_device());
+	static std::uniform_int_distribution<uint64_t> uniform_distribution;
+
+	UUID::UUID() : _uuid(uniform_distribution(engine)) {}
+	UUID::UUID(uint64_t uuid) : _uuid(uuid) {}
+}

src/core/UUID.h

@@ -0,0 +1,48 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   UUID.h                                             :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/01/06 11:13:23 by maldavid          #+#    #+#             */
+/*   Updated: 2024/01/06 11:29:34 by maldavid         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef __MLX_UUID__
+#define __MLX_UUID__
+
+#include <cstdint>
+
+namespace mlx
+{
+	class UUID
+	{
+		public:
+			UUID();
+			UUID(uint64_t uuid);
+
+			inline operator uint64_t() const { return _uuid; }
+
+		private:
+			uint64_t _uuid;
+	};
+}
+
+namespace std
+{
+	template <typename T> struct hash;
+
+	template<>
+	struct hash<mlx::UUID>
+	{
+		std::size_t operator()(const mlx::UUID& uuid) const
+		{
+			return static_cast<uint64_t>(uuid);
+		}
+	};
+
+}
+
+#endif

src/core/application.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/04 22:10:52 by maldavid          #+#    #+#             */
-/*   Updated: 2023/12/27 21:30:10 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/01/07 01:31:44 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -38,12 +38,19 @@ namespace mlx::core
 		{
 			_in->update();
 
+			Render_Core::get().getSingleTimeCmdManager().updateSingleTimesCmdBuffersSubmitState();
+
 			if(_loop_hook)
 				_loop_hook(_param);
 
 			for(auto& gs : _graphics)
 				gs->render();
 		}
+		for(auto& gs : _graphics)
+		{
+			for(int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
+				gs->getRenderer().getCmdBuffer(i).waitForExecution();
+		}
 	}
 
 	void* Application::newTexture(int w, int h)
@@ -64,9 +71,16 @@ namespace mlx::core
 
 	void Application::destroyTexture(void* ptr)
 	{
-		vkDeviceWaitIdle(Render_Core::get().getDevice().get()); // TODO : synchronize with another method than stopping all the GPU process
+		if(ptr == nullptr)
+		{
+			core::error::report(e_kind::error, "wrong texture (NULL)");
+			return;
+		}
 		Texture* texture = static_cast<Texture*>(ptr);
-		texture->destroy();
+		if(!texture->isInit())
+			core::error::report(e_kind::error, "trying to destroy a texture that has already been destroyed");
+		else
+			texture->destroy();
 	}
 
 	Application::~Application()

src/core/graphics.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/04/02 14:49:49 by maldavid          #+#    #+#             */
-/*   Updated: 2023/12/24 08:56:14 by kbz_8            ###   ########.fr       */
+/*   Updated: 2024/01/07 01:27:09 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -47,6 +47,8 @@ namespace mlx
 			inline void texturePut(Texture* texture, int x, int y);
 			inline void loadFont(const std::filesystem::path& filepath, float scale);
 
+			inline Renderer& getRenderer() { return *_renderer; }
+
 			~GraphicsSupport();
 
 		private:

src/renderer/buffers/vk_buffer.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/08 18:55:57 by maldavid          #+#    #+#             */
-/*   Updated: 2023/12/17 17:35:03 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/01/07 01:18:35 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -22,15 +22,6 @@ namespace mlx
 {
 	void Buffer::create(Buffer::kind type, VkDeviceSize size, VkBufferUsageFlags usage, const char* name, const void* data)
 	{
-		CmdResource::setDestroyer([this]()
-		{
-			if(_is_mapped)
-				unmapMem();
-			if(_buffer != VK_NULL_HANDLE)
-				Render_Core::get().getAllocator().destroyBuffer(_allocation, _buffer);
-			_buffer = VK_NULL_HANDLE;
-		});
-
 		_usage = usage;
 		if(type == Buffer::kind::constant || type == Buffer::kind::dynamic_device_local)
 		{
@@ -61,6 +52,15 @@ namespace mlx
 
 	void Buffer::destroy() noexcept
 	{
+		// not creating destroyer in `create` as some image may be copied (and so `this` will be invalid)
+		CmdResource::setDestroyer([this]()
+		{
+			if(_is_mapped)
+				unmapMem();
+			if(_buffer != VK_NULL_HANDLE)
+				Render_Core::get().getAllocator().destroyBuffer(_allocation, _buffer);
+			_buffer = VK_NULL_HANDLE;
+		});
 		CmdResource::requireDestroy();
 	}
 
@@ -101,13 +101,10 @@ namespace mlx
 			return false;
 		}
 
-		// TODO, use global cmd buffer pool to manage resources
 		CmdBuffer& cmd = Render_Core::get().getSingleTimeCmdBuffer();
 		cmd.beginRecord();
 
-		VkBufferCopy copyRegion{};
+		cmd.copyBuffer(*this, const_cast<Buffer&>(buffer));
-		copyRegion.size = _size;
-		vkCmdCopyBuffer(cmd.get(), buffer._buffer, _buffer, 1, &copyRegion);
 
 		cmd.endRecord();
 		cmd.submitIdle();
@@ -129,7 +126,7 @@ namespace mlx
 			newBuffer.createBuffer(newBuffer._usage, alloc_info, _size, nullptr);
 		#endif
 
-		if(newBuffer.copyFromBuffer(*this)) // if the copy succeded we swap the buffers, else the new one is deleted
+		if(newBuffer.copyFromBuffer(*this)) // if the copy succeded we swap the buffers, otherwise the new one is deleted
 			this->swap(newBuffer);
 		newBuffer.destroy();
 	}
@@ -155,6 +152,12 @@ namespace mlx
 		VkBufferUsageFlags temp_u = _usage;
 		_usage = buffer._usage;
 		buffer._usage = temp_u;
+
+		#ifdef DEBUG
+			std::string temp_n = _name;
+			_name = buffer._name;
+			buffer._name = temp_n;
+		#endif
 	}
 
 	void Buffer::flush(VkDeviceSize size, VkDeviceSize offset)

src/renderer/command/single_time_cmd_manager.cpp

@@ -6,23 +6,20 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/12/15 19:57:49 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/05 20:29:01 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/01/07 01:30:49 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include <algorithm>
 #include <renderer/command/single_time_cmd_manager.h>
-#include <renderer/command/vk_cmd_buffer.h>
 #include <renderer/core/render_core.h>
 
 namespace mlx
 {
-	SingleTimeCmdManager::SingleTimeCmdManager() : _buffers(MIN_POOL_SIZE) {}
-
 	void SingleTimeCmdManager::init() noexcept
 	{
 		_pool.init();
-		for(int i = 0; i < MIN_POOL_SIZE; i++)
+		for(int i = 0; i < BASE_POOL_SIZE; i++)
 		{
 			_buffers.emplace_back();
 			_buffers.back().init(CmdBuffer::kind::single_time, &_pool);
@@ -43,6 +40,19 @@ namespace mlx
 		return _buffers.back();
 	}
 
+	void SingleTimeCmdManager::updateSingleTimesCmdBuffersSubmitState() noexcept
+	{
+		for(CmdBuffer& cmd : _buffers)
+			cmd.updateSubmitState();
+	}
+
+	void SingleTimeCmdManager::waitForAllExecutions() noexcept
+	{
+		for(CmdBuffer& cmd : _buffers)
+			cmd.waitForExecution();
+	}
+
+
 	void SingleTimeCmdManager::destroy() noexcept
 	{
 		std::for_each(_buffers.begin(), _buffers.end(), [](CmdBuffer& buf)
@@ -51,6 +61,4 @@ namespace mlx
 		});
 		_pool.destroy();
 	}
-
-	SingleTimeCmdManager::~SingleTimeCmdManager() {}
 }

src/renderer/command/single_time_cmd_manager.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/12/15 18:25:57 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/05 20:28:41 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/01/07 01:30:19 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -14,7 +14,7 @@
 #define __MLX_SINGLE_TIME_CMD_MANAGER__
 
 #include <vector>
-
+#include <renderer/command/vk_cmd_buffer.h>
 #include <renderer/command/vk_cmd_pool.h>
 
 namespace mlx
@@ -23,20 +23,23 @@ namespace mlx
 
 	class SingleTimeCmdManager
 	{
+		friend class Render_Core;
+
 		public:
-			SingleTimeCmdManager();
+			SingleTimeCmdManager() = default;
 
 			void init() noexcept;
 			void destroy() noexcept;
 
+			void updateSingleTimesCmdBuffersSubmitState() noexcept;
+			void waitForAllExecutions() noexcept;
+
 			inline CmdPool& getCmdPool() noexcept { return _pool; }
 			CmdBuffer& getCmdBuffer() noexcept;
 
-			~SingleTimeCmdManager();
+			~SingleTimeCmdManager() = default;
 
-			inline static constexpr const uint8_t MIN_POOL_SIZE = 8;
+			inline static constexpr const uint8_t BASE_POOL_SIZE = 16;
-
-		private:
 
 		private:
 			std::vector<CmdBuffer> _buffers;

src/renderer/command/vk_cmd_buffer.cpp

@@ -6,11 +6,12 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/06 18:26:06 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/05 23:06:04 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/01/07 01:07:07 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "vk_cmd_buffer.h"
+#include <renderer/core/cmd_resource.h>
 #include <renderer/core/render_core.h>
 #include <renderer/command/cmd_manager.h>
 #include <renderer/core/vk_semaphore.h>
@@ -19,6 +20,21 @@
 
 namespace mlx
 {
+	bool vector_push_back_if_not_found(std::vector<CmdResource*>& vector, CmdResource* res)
+	{
+		auto it = std::find_if(vector.begin(), vector.end(), [=](const CmdResource* vres)
+		{
+			return vres->getUUID() == res->getUUID();
+		});
+
+		if(it == vector.end())
+		{
+			vector.push_back(res);
+			return true;
+		}
+		return false;
+	}
+
 	void CmdBuffer::init(kind type, CmdManager* manager)
 	{
 		init(type, &manager->getCmdPool());
@@ -62,7 +78,7 @@ namespace mlx
 		_state = state::recording;
 	}
 
-	void CmdBuffer::bindVertexBuffer(Buffer& buffer) const noexcept
+	void CmdBuffer::bindVertexBuffer(Buffer& buffer) noexcept
 	{
 		if(!isRecording())
 		{
@@ -71,10 +87,12 @@ namespace mlx
 		}
 		VkDeviceSize offset[] = { buffer.getOffset() };
 		vkCmdBindVertexBuffers(_cmd_buffer, 0, 1, &buffer.get(), offset);
+
 		buffer.recordedInCmdBuffer();
+		vector_push_back_if_not_found(_cmd_resources, &buffer);
 	}
 
-	void CmdBuffer::bindIndexBuffer(Buffer& buffer) const noexcept
+	void CmdBuffer::bindIndexBuffer(Buffer& buffer) noexcept
 	{
 		if(!isRecording())
 		{
@@ -82,30 +100,43 @@ namespace mlx
 			return;
 		}
 		vkCmdBindIndexBuffer(_cmd_buffer, buffer.get(), buffer.getOffset(), VK_INDEX_TYPE_UINT16);
+
 		buffer.recordedInCmdBuffer();
+		vector_push_back_if_not_found(_cmd_resources, &buffer);
 	}
 
-	void CmdBuffer::copyBuffer(Buffer& dst, Buffer& src) const noexcept
+	void CmdBuffer::copyBuffer(Buffer& dst, Buffer& src) noexcept
 	{
 		if(!isRecording())
 		{
 			core::error::report(e_kind::warning, "Vulkan : trying to do a buffer to buffer copy in a non recording command buffer");
 			return;
 		}
+
+		preTransferBarrier();
+
 		VkBufferCopy copyRegion{};
 		copyRegion.size = src.getSize();
 		vkCmdCopyBuffer(_cmd_buffer, src.get(), dst.get(), 1, &copyRegion);
+
+		postTransferBarrier();
+
 		dst.recordedInCmdBuffer();
 		src.recordedInCmdBuffer();
+		vector_push_back_if_not_found(_cmd_resources, &dst);
+		vector_push_back_if_not_found(_cmd_resources, &src);
 	}
 
-	void CmdBuffer::copyBufferToImage(Buffer& buffer, Image& image) const noexcept
+	void CmdBuffer::copyBufferToImage(Buffer& buffer, Image& image) noexcept
 	{
 		if(!isRecording())
 		{
 			core::error::report(e_kind::warning, "Vulkan : trying to do a buffer to image copy in a non recording command buffer");
 			return;
 		}
+		
+		preTransferBarrier();
+
 		VkBufferImageCopy region{};
 		region.bufferOffset = 0;
 		region.bufferRowLength = 0;
@@ -119,17 +150,24 @@ namespace mlx
 
 		vkCmdCopyBufferToImage(_cmd_buffer, buffer.get(), image.get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
 
+		postTransferBarrier();
+
 		image.recordedInCmdBuffer();
 		buffer.recordedInCmdBuffer();
+		vector_push_back_if_not_found(_cmd_resources, &image);
+		vector_push_back_if_not_found(_cmd_resources, &buffer);
 	}
 
-	void CmdBuffer::copyImagetoBuffer(Image& image, Buffer& buffer) const noexcept
+	void CmdBuffer::copyImagetoBuffer(Image& image, Buffer& buffer) noexcept
 	{
 		if(!isRecording())
 		{
 			core::error::report(e_kind::warning, "Vulkan : trying to do an image to buffer copy in a non recording command buffer");
 			return;
 		}
+
+		preTransferBarrier();
+
 		VkBufferImageCopy region{};
 		region.bufferOffset = 0;
 		region.bufferRowLength = 0;
@@ -143,11 +181,15 @@ namespace mlx
 
 		vkCmdCopyImageToBuffer(_cmd_buffer, image.get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, buffer.get(), 1, &region);
 
+		postTransferBarrier();
+
 		image.recordedInCmdBuffer();
 		buffer.recordedInCmdBuffer();
+		vector_push_back_if_not_found(_cmd_resources, &buffer);
+		vector_push_back_if_not_found(_cmd_resources, &image);
 	}
 
-	void CmdBuffer::transitionImageLayout(Image& image, VkImageLayout new_layout) const noexcept
+	void CmdBuffer::transitionImageLayout(Image& image, VkImageLayout new_layout) noexcept
 	{
 		if(!isRecording())
 		{
@@ -176,7 +218,7 @@ namespace mlx
 		if(barrier.oldLayout == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR)
 			sourceStage = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
 		else if(barrier.srcAccessMask != 0)
-			sourceStage = accessFlagsToPipelineStage(barrier.srcAccessMask, VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+			sourceStage = RCore::accessFlagsToPipelineStage(barrier.srcAccessMask, VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
 		else
 			sourceStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
 
@@ -184,12 +226,14 @@ namespace mlx
 		if(barrier.newLayout == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR)
 			destinationStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
 		else if(barrier.dstAccessMask != 0)
-			destinationStage = accessFlagsToPipelineStage(barrier.dstAccessMask, VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+			destinationStage = RCore::accessFlagsToPipelineStage(barrier.dstAccessMask, VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
 		else
 			destinationStage = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
 
 		vkCmdPipelineBarrier(_cmd_buffer, sourceStage, destinationStage, 0, 0, nullptr, 0, nullptr, 1, &barrier);
+
 		image.recordedInCmdBuffer();
+		vector_push_back_if_not_found(_cmd_resources, &image);
 	}
 
 	void CmdBuffer::endRecord()
@@ -204,28 +248,28 @@ namespace mlx
 		_state = state::idle;
 	}
 
-	void CmdBuffer::submitIdle() noexcept
+	void CmdBuffer::submitIdle(bool shouldWaitForExecution) noexcept
 	{
-		auto device = Render_Core::get().getDevice().get();
+		if(_type != kind::single_time)
+		{
+			core::error::report(e_kind::error, "Vulkan : try to perform an idle submit on a command buffer that is not single-time, this is not allowed");
+			return;
+		}
 
-		VkSubmitInfo submitInfo = {};
+		_fence.reset();
+
+		VkSubmitInfo submitInfo{};
 		submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
 		submitInfo.commandBufferCount = 1;
 		submitInfo.pCommandBuffers = &_cmd_buffer;
 
-		VkFenceCreateInfo fenceCreateInfo = {};
+		VkResult res = vkQueueSubmit(Render_Core::get().getQueue().getGraphic(), 1, &submitInfo, _fence.get());
-		fenceCreateInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
-
-		VkFence fence;
-		vkCreateFence(device, &fenceCreateInfo, nullptr, &fence);
-		vkResetFences(device, 1, &fence);
-		VkResult res = vkQueueSubmit(Render_Core::get().getQueue().getGraphic(), 1, &submitInfo, fence);
 		if(res != VK_SUCCESS)
 			core::error::report(e_kind::fatal_error, "Vulkan error : failed to submit a single time command buffer, %s", RCore::verbaliseResultVk(res));
 		_state = state::submitted;
-		vkWaitForFences(device, 1, &fence, VK_TRUE, UINT64_MAX);
+
-		vkDestroyFence(device, fence, nullptr);
+		if(shouldWaitForExecution)
-		_state = state::ready;
+			waitForExecution();
 	}
 
 	void CmdBuffer::submit(Semaphore* semaphores) noexcept
@@ -245,6 +289,8 @@ namespace mlx
 		}
 		VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };
 
+		_fence.reset();
+
 		VkSubmitInfo submitInfo{};
 		submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
 		submitInfo.waitSemaphoreCount = (semaphores == nullptr ? 0 : waitSemaphores.size());
@@ -261,10 +307,46 @@ namespace mlx
 		_state = state::submitted;
 	}
 
+	void CmdBuffer::updateSubmitState() noexcept
+	{
+		if(!_fence.isReady())
+			return;
+
+		for(CmdResource* res : _cmd_resources)
+			res->removedFromCmdBuffer();
+		_cmd_resources.clear();
+		_state = state::ready;
+	}
+
+	void CmdBuffer::preTransferBarrier() noexcept
+	{
+		VkMemoryBarrier memoryBarrier{};
+		memoryBarrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
+		memoryBarrier.pNext = nullptr;
+		memoryBarrier.srcAccessMask = 0U;
+		memoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
+
+		vkCmdPipelineBarrier(_cmd_buffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1, &memoryBarrier, 0, nullptr, 0, nullptr);
+	}
+
+	void CmdBuffer::postTransferBarrier() noexcept
+	{
+		VkMemoryBarrier memoryBarrier{};
+		memoryBarrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
+		memoryBarrier.pNext = nullptr;
+		memoryBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+		memoryBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_UNIFORM_READ_BIT;
+
+		vkCmdPipelineBarrier(_cmd_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, 0, 1, &memoryBarrier, 0, nullptr, 0, nullptr);
+	}
+
 	void CmdBuffer::destroy() noexcept
 	{
 		_fence.destroy();
 		_cmd_buffer = VK_NULL_HANDLE;
 		_state = state::uninit;
+		#ifdef DEBUG
+			core::error::report(e_kind::message, "Vulkan : destroyed command buffer");
+		#endif
 	}
 }

src/renderer/command/vk_cmd_buffer.h

@@ -6,18 +6,17 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/06 18:25:42 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/05 23:10:01 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/01/07 01:25:50 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #ifndef __MLX_VK_CMD_BUFFER__
 #define __MLX_VK_CMD_BUFFER__
 
-#include <renderer/core/cmd_resource.h>
 #include <mlx_profile.h>
 #include <volk.h>
 #include <renderer/core/vk_fence.h>
-#include <unordered_set>
+#include <vector>
 
 namespace mlx
 {
@@ -49,17 +48,18 @@ namespace mlx
 
 			void beginRecord(VkCommandBufferUsageFlags usage = 0);
 			void submit(class Semaphore* semaphores) noexcept;
-			void submitIdle() noexcept;
+			void submitIdle(bool shouldWaitForExecution = true) noexcept; // TODO : handle `shouldWaitForExecution` as false by default (needs to modify CmdResources lifetimes to do so)
-			inline void waitForExecution() noexcept { _fence.waitAndReset(); _state = state::ready; }
+			void updateSubmitState() noexcept;
+			inline void waitForExecution() noexcept { _fence.wait(); updateSubmitState(); _state = state::ready; }
 			inline void reset() noexcept { vkResetCommandBuffer(_cmd_buffer, 0); }
 			void endRecord();
 
-			void bindVertexBuffer(Buffer& buffer) const noexcept;
+			void bindVertexBuffer(Buffer& buffer) noexcept;
-			void bindIndexBuffer(Buffer& buffer) const noexcept;
+			void bindIndexBuffer(Buffer& buffer) noexcept;
-			void copyBuffer(Buffer& dst, Buffer& src) const noexcept;
+			void copyBuffer(Buffer& dst, Buffer& src) noexcept;
-			void copyBufferToImage(Buffer& buffer, Image& image) const noexcept;
+			void copyBufferToImage(Buffer& buffer, Image& image) noexcept;
-			void copyImagetoBuffer(Image& image, Buffer& buffer) const noexcept;
+			void copyImagetoBuffer(Image& image, Buffer& buffer) noexcept;
-			void transitionImageLayout(Image& image, VkImageLayout new_layout) const noexcept;
+			void transitionImageLayout(Image& image, VkImageLayout new_layout) noexcept;
 
 			inline bool isInit() const noexcept { return _state != state::uninit; }
 			inline bool isReadyToBeUsed() const noexcept { return _state == state::ready; }
@@ -72,7 +72,11 @@ namespace mlx
 			inline Fence& getFence() noexcept { return _fence; }
 
 		private:
-			std::unordered_set<CmdResource> _resources;
+			void preTransferBarrier() noexcept;
+			void postTransferBarrier() noexcept;
+
+		private:
+			std::vector<class CmdResource*> _cmd_resources;
 			Fence _fence;
 			VkCommandBuffer _cmd_buffer = VK_NULL_HANDLE;
 			class CmdPool* _pool = nullptr;

src/renderer/core/cmd_resource.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/12/16 20:44:29 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/05 23:12:45 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/01/07 01:19:10 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -14,6 +14,7 @@
 #define __MLX_COMMAND_RESOURCE__
 
 #include <function.h>
+#include <core/UUID.h>
 
 namespace mlx
 {
@@ -28,18 +29,18 @@ namespace mlx
 			};
 
 		public:
-			CmdResource() = default;
+			CmdResource() : _uuid() {}
 			inline void recordedInCmdBuffer() noexcept { _state = state::in_cmd_buffer; }
 			inline void removedFromCmdBuffer() noexcept
 			{
 				_state = state::out_cmd_buffer;
-				if(_destroy_required && _destroy_required)
+				if(_destroy_required && _destroyer)
 				{
 					_destroyer();
 					_destroy_required = false;
 				}
 			}
-			inline void setDestroyer(func::function<void(void)>&& functor) { _destroyer = functor; }
+			inline void setDestroyer(func::function<void(void)> functor) { _destroyer = functor; }
 			inline void requireDestroy() noexcept
 			{
 				if(_state == state::out_cmd_buffer && _destroyer)
@@ -47,30 +48,15 @@ namespace mlx
 				else
 					_destroy_required = true;
 			}
-			inline uint64_t getUUID() const noexcept { return _uuid; }
+			inline UUID getUUID() const noexcept { return _uuid; }
 			virtual ~CmdResource() = default;
 
 		private:
-			void realDestroy();
+			UUID _uuid;
-
-		private:
-			uint64_t _uuid = 0;
 			state _state = state::out_cmd_buffer;
 			func::function<void(void)> _destroyer;
 			bool _destroy_required = false;
 	};
 }
 
-namespace std
-{
-	template <>
-	struct hash<mlx::CmdResource>
-	{
-		std::size_t operator()(const mlx::CmdResource& res) const noexcept
-		{
-			return res.getUUID();
-		}
-	};
-}
-
 #endif

src/renderer/core/memory.cpp

@@ -6,7 +6,7 @@
 /*   By: kbz_8 <kbz_8.dev@akel-engine.com>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/10/20 22:02:37 by kbz_8             #+#    #+#             */
-/*   Updated: 2024/01/03 13:09:40 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/01/07 00:09:18 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -91,7 +91,10 @@ namespace mlx
 		if(res != VK_SUCCESS)
 			core::error::report(e_kind::fatal_error, "Graphics allocator : failed to allocate a buffer, %s", RCore::verbaliseResultVk(res));
 		if(name != nullptr)
+		{
+			Render_Core::get().getLayers().setDebugUtilsObjectNameEXT(VK_OBJECT_TYPE_BUFFER, (uint64_t)buffer, name);
 			vmaSetAllocationName(_allocator, allocation, name);
+		}
 		#ifdef DEBUG
 			core::error::report(e_kind::message, "Graphics Allocator : created new buffer");
 		#endif
@@ -116,7 +119,10 @@ namespace mlx
 		if(res != VK_SUCCESS)
 			core::error::report(e_kind::fatal_error, "Graphics allocator : failed to allocate an image, %s", RCore::verbaliseResultVk(res));
 		if(name != nullptr)
+		{
+			Render_Core::get().getLayers().setDebugUtilsObjectNameEXT(VK_OBJECT_TYPE_IMAGE, (uint64_t)image, name);
 			vmaSetAllocationName(_allocator, allocation, name);
+		}
 		#ifdef DEBUG
 			core::error::report(e_kind::message, "Graphics Allocator : created new image");
 		#endif

src/renderer/core/render_core.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/12/17 23:33:34 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/03 15:22:38 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/01/07 01:29:31 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -14,6 +14,7 @@
 
 #include <mlx_profile.h>
 #include <renderer/core/render_core.h>
+#include <renderer/command/vk_cmd_buffer.h>
 #include <mutex>
 
 #ifdef DEBUG
@@ -75,6 +76,43 @@ namespace mlx
 			}
 			return nullptr;
 		}
+
+		VkPipelineStageFlags accessFlagsToPipelineStage(VkAccessFlags accessFlags, VkPipelineStageFlags stageFlags)
+		{
+			VkPipelineStageFlags stages = 0;
+
+			while(accessFlags != 0)
+			{
+				VkAccessFlagBits AccessFlag = static_cast<VkAccessFlagBits>(accessFlags & (~(accessFlags - 1)));
+				if(AccessFlag == 0 || (AccessFlag & (AccessFlag - 1)) != 0)
+					core::error::report(e_kind::fatal_error, "Vulkan : an error has been caught during access flag to pipeline stage operation");
+				accessFlags &= ~AccessFlag;
+
+				switch(AccessFlag)
+				{
+					case VK_ACCESS_INDIRECT_COMMAND_READ_BIT: stages |= VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT; break;
+					case VK_ACCESS_INDEX_READ_BIT: stages |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT; break;
+					case VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT: stages |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT; break;
+					case VK_ACCESS_UNIFORM_READ_BIT: stages |= stageFlags | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT; break;
+					case VK_ACCESS_INPUT_ATTACHMENT_READ_BIT: stages |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; break;
+					case VK_ACCESS_SHADER_READ_BIT: stages |= stageFlags | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT; break;
+					case VK_ACCESS_SHADER_WRITE_BIT: stages |= stageFlags | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT; break;
+					case VK_ACCESS_COLOR_ATTACHMENT_READ_BIT: stages |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; break;
+					case VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT: stages |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; break;
+					case VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT: stages |= VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT; break;
+					case VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: stages |= VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT; break;
+					case VK_ACCESS_TRANSFER_READ_BIT: stages |= VK_PIPELINE_STAGE_TRANSFER_BIT; break;
+					case VK_ACCESS_TRANSFER_WRITE_BIT: stages |= VK_PIPELINE_STAGE_TRANSFER_BIT; break;
+					case VK_ACCESS_HOST_READ_BIT: stages |= VK_PIPELINE_STAGE_HOST_BIT; break;
+					case VK_ACCESS_HOST_WRITE_BIT: stages |= VK_PIPELINE_STAGE_HOST_BIT; break;
+					case VK_ACCESS_MEMORY_READ_BIT: break;
+					case VK_ACCESS_MEMORY_WRITE_BIT: break;
+
+					default: core::error::report(e_kind::error, "Vulkan : unknown access flag"); break;
+				}
+			}
+			return stages;
+		}
 	}
 
 	void Render_Core::init()

src/renderer/core/render_core.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/08 19:16:32 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/03 15:26:08 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/01/07 01:31:37 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -33,6 +33,7 @@ namespace mlx
 	{
 		std::optional<uint32_t> findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties, bool error = true);
 		const char* verbaliseResultVk(VkResult result);
+		VkPipelineStageFlags accessFlagsToPipelineStage(VkAccessFlags accessFlags, VkPipelineStageFlags stageFlags);
 	}
 
 	#ifdef DEBUG
@@ -59,6 +60,7 @@ namespace mlx
 			inline GPUallocator& getAllocator() noexcept { return _allocator; }
 			inline ValidationLayers& getLayers() noexcept { return _layers; }
 			inline CmdBuffer& getSingleTimeCmdBuffer() noexcept { return _cmd_manager.getCmdBuffer(); }
+			inline SingleTimeCmdManager& getSingleTimeCmdManager() noexcept { return _cmd_manager; }
 
 			~Render_Core() = default;
 

src/renderer/core/vk_fence.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/04/02 17:53:06 by maldavid          #+#    #+#             */
-/*   Updated: 2023/12/16 18:47:36 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/01/06 16:57:26 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -49,5 +49,8 @@ namespace mlx
 		if(_fence != VK_NULL_HANDLE)
 			vkDestroyFence(Render_Core::get().getDevice().get(), _fence, nullptr);
 		_fence = VK_NULL_HANDLE;
+		#ifdef DEBUG
+			core::error::report(e_kind::message, "Vulkan : destroyed fence");
+		#endif
 	}
 }

src/renderer/core/vk_validation_layers.cpp

@@ -6,12 +6,12 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/12/19 14:05:25 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/03 13:11:27 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/01/07 00:33:40 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
-#include "vk_validation_layers.h"
 #include "render_core.h"
+#include "vulkan/vulkan_core.h"
 
 #include <core/errors.h>
 #include <iostream>
@@ -25,6 +25,16 @@ namespace mlx
 		if constexpr(!enableValidationLayers)
 			return;
 
+		uint32_t extensionCount;
+		vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr);
+		std::vector<VkExtensionProperties> extensions(extensionCount);
+		vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, extensions.data());
+		if(!std::any_of(extensions.begin(), extensions.end(), [=](VkExtensionProperties ext) { return std::strcmp(ext.extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME) == 0; }))
+		{
+			core::error::report(e_kind::warning , "Vulkan : %s not present, debug utils are disabled", VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
+			return;
+		}
+
 		VkDebugUtilsMessengerCreateInfoEXT createInfo{};
 		populateDebugMessengerCreateInfo(createInfo);
 		VkResult res = createDebugUtilsMessengerEXT(&createInfo, nullptr);
@@ -34,6 +44,14 @@ namespace mlx
 		else
 			core::error::report(e_kind::message, "Vulkan : enabled validation layers");
 		#endif
+
+		real_vkSetDebugUtilsObjectNameEXT = (PFN_vkSetDebugUtilsObjectNameEXT)vkGetInstanceProcAddr(Render_Core::get().getInstance().get(), "vkSetDebugUtilsObjectNameEXT");
+		if(!real_vkSetDebugUtilsObjectNameEXT)
+			core::error::report(e_kind::warning, "Vulkan : failed to set up debug object names, %s", RCore::verbaliseResultVk(VK_ERROR_EXTENSION_NOT_PRESENT));
+		#ifdef DEBUG
+		else
+			core::error::report(e_kind::message, "Vulkan : enabled debug object names");
+		#endif
 	}
 
 	bool ValidationLayers::checkValidationLayerSupport()
@@ -55,6 +73,19 @@ namespace mlx
 		});
 	}
 
+	VkResult ValidationLayers::setDebugUtilsObjectNameEXT(VkObjectType object_type, uint64_t object_handle, const char* object_name)
+	{
+		if(!real_vkSetDebugUtilsObjectNameEXT)
+			return VK_ERROR_EXTENSION_NOT_PRESENT;
+
+		VkDebugUtilsObjectNameInfoEXT name_info{};
+		name_info.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
+		name_info.objectType = object_type;
+		name_info.objectHandle = object_handle;
+		name_info.pObjectName = object_name;
+		return real_vkSetDebugUtilsObjectNameEXT(Render_Core::get().getDevice().get(), &name_info);
+	}
+
 	void ValidationLayers::populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo)
 	{
 		createInfo = {};
@@ -64,7 +95,6 @@ namespace mlx
 		createInfo.pfnUserCallback = ValidationLayers::debugCallback;
 	}
 
-
 	void ValidationLayers::destroy()
 	{
 		if constexpr(enableValidationLayers)
@@ -80,16 +110,9 @@ namespace mlx
 	VKAPI_ATTR VkBool32 VKAPI_CALL ValidationLayers::debugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, [[maybe_unused]] VkDebugUtilsMessageTypeFlagsEXT messageType, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, [[maybe_unused]] void* pUserData)
 	{
 		if(messageSeverity == VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT)
-		{
+			core::error::report(e_kind::error, pCallbackData->pMessage);
-			std::cout << '\n';
-			core::error::report(e_kind::error, std::string("Vulkan layer error: ") + pCallbackData->pMessage);
-		}
 		else if(messageSeverity == VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT)
-		{
+			core::error::report(e_kind::warning, pCallbackData->pMessage);
-			std::cout << '\n';
-			core::error::report(e_kind::warning, std::string("Vulkan layer warning: ") + pCallbackData->pMessage);
-		}
-
 		return VK_FALSE;
 	}
 

src/renderer/core/vk_validation_layers.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <marvin@42.fr>                    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/12/19 14:04:25 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/03 15:26:49 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/01/07 00:21:42 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -22,10 +22,15 @@ namespace mlx
 	{
 		public:
 			ValidationLayers() = default;
+			
 			void init();
+			void destroy();
+			
 			bool checkValidationLayerSupport();
 			void populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo);
-			void destroy();
+			
+			VkResult setDebugUtilsObjectNameEXT(VkObjectType object_type, uint64_t object_handle, const char* object_name);
+
 			~ValidationLayers() = default;
 
 		private:
@@ -35,6 +40,7 @@ namespace mlx
 
 		private:
 			VkDebugUtilsMessengerEXT _debugMessenger;
+			PFN_vkSetDebugUtilsObjectNameEXT real_vkSetDebugUtilsObjectNameEXT = nullptr;
 	};
 }
 

src/renderer/images/vk_image.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/01/25 11:59:07 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/05 23:08:47 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/01/07 01:17:54 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -99,55 +99,8 @@ namespace mlx
 		return accessMask;
 	}
 
-	VkPipelineStageFlags accessFlagsToPipelineStage(VkAccessFlags accessFlags, VkPipelineStageFlags stageFlags)
-	{
-		VkPipelineStageFlags stages = 0;
-
-		while(accessFlags != 0)
-		{
-			VkAccessFlagBits AccessFlag = static_cast<VkAccessFlagBits>(accessFlags & (~(accessFlags - 1)));
-			if(AccessFlag == 0 || (AccessFlag & (AccessFlag - 1)) != 0)
-				core::error::report(e_kind::fatal_error, "Vulkan : an error has been caught during access flag to pipeline stage operation");
-			accessFlags &= ~AccessFlag;
-
-			switch(AccessFlag)
-			{
-				case VK_ACCESS_INDIRECT_COMMAND_READ_BIT: stages |= VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT; break;
-				case VK_ACCESS_INDEX_READ_BIT: stages |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT; break;
-				case VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT: stages |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT; break;
-				case VK_ACCESS_UNIFORM_READ_BIT: stages |= stageFlags | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT; break;
-				case VK_ACCESS_INPUT_ATTACHMENT_READ_BIT: stages |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; break;
-				case VK_ACCESS_SHADER_READ_BIT: stages |= stageFlags | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT; break;
-				case VK_ACCESS_SHADER_WRITE_BIT: stages |= stageFlags | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT; break;
-				case VK_ACCESS_COLOR_ATTACHMENT_READ_BIT: stages |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; break;
-				case VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT: stages |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; break;
-				case VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT: stages |= VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT; break;
-				case VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: stages |= VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT; break;
-				case VK_ACCESS_TRANSFER_READ_BIT: stages |= VK_PIPELINE_STAGE_TRANSFER_BIT; break;
-				case VK_ACCESS_TRANSFER_WRITE_BIT: stages |= VK_PIPELINE_STAGE_TRANSFER_BIT; break;
-				case VK_ACCESS_HOST_READ_BIT: stages |= VK_PIPELINE_STAGE_HOST_BIT; break;
-				case VK_ACCESS_HOST_WRITE_BIT: stages |= VK_PIPELINE_STAGE_HOST_BIT; break;
-				case VK_ACCESS_MEMORY_READ_BIT: break;
-				case VK_ACCESS_MEMORY_WRITE_BIT: break;
-
-				default: core::error::report(e_kind::error, "Vulkan : unknown access flag"); break;
-			}
-		}
-		return stages;
-	}
-
 	void Image::create(uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, const char* name, bool dedicated_memory)
 	{
-		CmdResource::setDestroyer([this]()
-		{
-			this->destroySampler();
-			this->destroyImageView();
-
-			if(_image != VK_NULL_HANDLE)
-				Render_Core::get().getAllocator().destroyImage(_allocation, _image);
-			_image = VK_NULL_HANDLE;
-		});
-
 		_width = width;
 		_height = height;
 		_format = format;
@@ -177,6 +130,9 @@ namespace mlx
 		}
 
 		_allocation = Render_Core::get().getAllocator().createImage(&imageInfo, &alloc_info, _image, name);
+		#ifdef DEBUG
+			_name = name;
+		#endif
 	}
 
 	void Image::createImageView(VkImageViewType type, VkImageAspectFlags aspectFlags) noexcept
@@ -195,6 +151,10 @@ namespace mlx
 		VkResult res = vkCreateImageView(Render_Core::get().getDevice().get(), &viewInfo, nullptr, &_image_view);
 		if(res != VK_SUCCESS)
 			core::error::report(e_kind::fatal_error, "Vulkan : failed to create an image view, %s", RCore::verbaliseResultVk(res));
+		#ifdef DEBUG
+		else
+			Render_Core::get().getLayers().setDebugUtilsObjectNameEXT(VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t)_image_view, _name.c_str());
+		#endif
 	}
 
 	void Image::createSampler() noexcept
@@ -214,7 +174,11 @@ namespace mlx
 
 		VkResult res = vkCreateSampler(Render_Core::get().getDevice().get(), &info, nullptr, &_sampler);
 		if(res != VK_SUCCESS)
-			core::error::report(e_kind::fatal_error, "Vulkan : failed to create an image, %s", RCore::verbaliseResultVk(res));
+			core::error::report(e_kind::fatal_error, "Vulkan : failed to create an image sampler, %s", RCore::verbaliseResultVk(res));
+		#ifdef DEBUG
+		else
+			Render_Core::get().getLayers().setDebugUtilsObjectNameEXT(VK_OBJECT_TYPE_SAMPLER, (uint64_t)_sampler, _name.c_str());
+		#endif
 	}
 
 	void Image::copyFromBuffer(Buffer& buffer)
@@ -287,6 +251,16 @@ namespace mlx
 
 	void Image::destroy() noexcept
 	{
+		// not creating destroyer in `create` as some image may be copied (and so `this` will be invalid)
+		CmdResource::setDestroyer([this]()
+		{
+			destroySampler();
+			destroyImageView();
+
+			if(_image != VK_NULL_HANDLE)
+				Render_Core::get().getAllocator().destroyImage(_allocation, _image);
+			_image = VK_NULL_HANDLE;
+		});
 		CmdResource::requireDestroy();
 	}
 

src/renderer/images/vk_image.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/01/25 11:54:21 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/05 22:36:58 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/01/07 01:20:31 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -22,6 +22,10 @@
 #include <renderer/command/vk_cmd_buffer.h>
 #include <renderer/command/vk_cmd_pool.h>
 
+#ifdef DEBUG
+	#include <string>
+#endif
+
 namespace mlx
 {
 	uint32_t formatSize(VkFormat format);
@@ -29,7 +33,6 @@ namespace mlx
 	bool isDepthFormat(VkFormat format);
 	VkFormat bitsToFormat(uint32_t bits);
 	VkPipelineStageFlags layoutToAccessMask(VkImageLayout layout, bool isDestination);
-	VkPipelineStageFlags accessFlagsToPipelineStage(VkAccessFlags accessFlags, VkPipelineStageFlags stageFlags);
 
 	class Image : public CmdResource
 	{
@@ -76,6 +79,9 @@ namespace mlx
 			VkImage _image = VK_NULL_HANDLE;
 			VkImageView _image_view = VK_NULL_HANDLE;
 			VkSampler _sampler = VK_NULL_HANDLE;
+			#ifdef DEBUG
+				std::string _name;
+			#endif
 			VkFormat _format;
 			VkImageTiling _tiling;
 			VkImageLayout _layout = VK_IMAGE_LAYOUT_UNDEFINED;

src/renderer/renderer.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/12/18 17:25:16 by maldavid          #+#    #+#             */
-/*   Updated: 2023/12/24 16:04:04 by kbz_8            ###   ########.fr       */
+/*   Updated: 2024/01/07 01:00:18 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -150,7 +150,7 @@ namespace mlx
 		}
 		else
 		{
-			_cmd.getCmdBuffer(_current_frame_index).submitIdle();
+			_cmd.getCmdBuffer(_current_frame_index).submitIdle(true);
 			_current_frame_index = 0;
 		}
 	}