Merge branch 'master' of github.com:Kbz-8/42_vox

Application/Chunk.cpp

@@ -290,6 +290,7 @@ void Chunk::GenerateMesh()
 
 							int occ_count = (occ1 ? 1 : 0) + (occ2 ? 1 : 0) + (occ3 ? 1 : 0);
 							float ao = 1.0f - (occ_count * 0.2f);
+
 							vertex_color = Scop::Vec4f(Scop::Vec3f(base_color) * ao, 1.0f);
 						}
 						else

ScopEngine/Runtime/Includes/Graphics/Actor.h

@@ -14,6 +14,13 @@ namespace Scop
 	{
 		friend Scene;
 
+		public:
+			struct CustomPipeline
+			{
+				std::shared_ptr<Shader> shader;
+				CPUBuffer data;
+			};
+
 		public:
 			Actor();
 			Actor(Model model);

ScopEngine/Runtime/Includes/Graphics/Material.h

@@ -36,8 +36,8 @@ namespace Scop
 			~Material() { m_data_buffer.Destroy(); }
 
 		private:
-			[[nodiscard]] inline bool IsSetInit() const noexcept { return m_set.IsInit(); }
+			[[nodiscard]] inline bool IsSetInit() const noexcept { return p_set && p_set->IsInit(); }
-			[[nodiscard]] inline VkDescriptorSet GetSet(std::size_t frame_index) const noexcept { return m_set.GetSet(frame_index); }
+			[[nodiscard]] inline VkDescriptorSet GetSet(std::size_t frame_index) const noexcept { return p_set->GetSet(frame_index); }
 
 			inline void SetupEventListener()
 			{
@@ -49,18 +49,18 @@ namespace Scop
 				EventBus::RegisterListener({ functor, "__ScopMaterial" + std::to_string(reinterpret_cast<std::uintptr_t>(this)) });
 			}
 
-			inline void UpdateDescriptorSet(const DescriptorSet& set)
+			inline void UpdateDescriptorSet(std::shared_ptr<DescriptorSet> set)
 			{
-				m_set = set.Duplicate();
+				p_set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool().RequestDescriptorSet(set->GetShaderLayout(), set->GetShaderType());
 			}
 
 			inline void Bind(std::size_t frame_index, VkCommandBuffer cmd)
 			{
 				if(m_have_been_updated_this_frame)
 					return;
-				m_set.SetImage(frame_index, 0, *m_textures.albedo);
+				p_set->SetImage(frame_index, 0, *m_textures.albedo);
-				m_set.SetUniformBuffer(frame_index, 1, m_data_buffer.Get(frame_index));
+				p_set->SetUniformBuffer(frame_index, 1, m_data_buffer.Get(frame_index));
-				m_set.Update(frame_index, cmd);
+				p_set->Update(frame_index, cmd);
 
 				static CPUBuffer buffer(sizeof(MaterialData));
 				std::memcpy(buffer.GetData(), &m_data, buffer.GetSize());
@@ -73,7 +73,7 @@ namespace Scop
 			UniformBuffer m_data_buffer;
 			MaterialTextures m_textures;
 			MaterialData m_data;
-			DescriptorSet m_set;
+			std::shared_ptr<DescriptorSet> p_set;
 			bool m_have_been_updated_this_frame = false;
 	};
 }

ScopEngine/Runtime/Includes/Graphics/Model.h

@@ -30,7 +30,7 @@ namespace Scop
 			[[nodiscard]] inline Vec3f GetCenter() const noexcept { return m_center; }
 			[[nodiscard]] inline std::shared_ptr<Mesh> GetMesh() const { return p_mesh; }
 
-			void Draw(VkCommandBuffer cmd, const DescriptorSet& matrices_set, const class GraphicPipeline& pipeline, DescriptorSet& set, std::size_t& drawcalls, std::size_t& polygondrawn, std::size_t frame_index) const;
+			void Draw(VkCommandBuffer cmd, std::shared_ptr<DescriptorSet> matrices_set, const class GraphicPipeline& pipeline, std::shared_ptr<DescriptorSet> set, std::size_t& drawcalls, std::size_t& polygondrawn, std::size_t frame_index) const;
 
 			~Model() = default;
 

ScopEngine/Runtime/Includes/Graphics/Sprite.h

@@ -37,22 +37,22 @@ namespace Scop
 			~Sprite();
 
 		private:
-			[[nodiscard]] inline bool IsSetInit() const noexcept { return m_set.IsInit(); }
+			[[nodiscard]] inline bool IsSetInit() const noexcept { return p_set && p_set->IsInit(); }
-			[[nodiscard]] inline VkDescriptorSet GetSet(std::size_t frame_index) const noexcept { return m_set.GetSet(frame_index); }
+			[[nodiscard]] inline VkDescriptorSet GetSet(std::size_t frame_index) const noexcept { return p_set->GetSet(frame_index); }
 
-			inline void UpdateDescriptorSet(const DescriptorSet& set)
+			inline void UpdateDescriptorSet(std::shared_ptr<DescriptorSet> set)
 			{
-				m_set = set.Duplicate();
+				p_set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool().RequestDescriptorSet(set->GetShaderLayout(), set->GetShaderType());
 			}
 
 			inline void Bind(std::size_t frame_index, VkCommandBuffer cmd)
 			{
-				m_set.SetImage(frame_index, 0, *p_texture);
+				p_set->SetImage(frame_index, 0, *p_texture);
-				m_set.Update(frame_index, cmd);
+				p_set->Update(frame_index, cmd);
 			}
 
 		private:
-			DescriptorSet m_set;
+			std::shared_ptr<DescriptorSet> p_set;
 			std::shared_ptr<Texture> p_texture;
 			std::shared_ptr<class SpriteScript> p_script;
 			std::shared_ptr<Mesh> p_mesh;

ScopEngine/Runtime/Includes/Graphics/Text.h

@@ -29,20 +29,20 @@ namespace Scop
 			virtual ~Text() = default;
 
 		private:
-			[[nodiscard]] inline bool IsSetInit() const noexcept { return m_set.IsInit(); }
+			[[nodiscard]] inline bool IsSetInit() const noexcept { return p_set && p_set->IsInit(); }
-			[[nodiscard]] inline VkDescriptorSet GetSet(std::size_t frame_index) const noexcept { return m_set.GetSet(frame_index); }
+			[[nodiscard]] inline VkDescriptorSet GetSet(std::size_t frame_index) const noexcept { return p_set->GetSet(frame_index); }
-			inline void UpdateDescriptorSet(const DescriptorSet& set)
+			inline void UpdateDescriptorSet(std::shared_ptr<DescriptorSet> set)
 			{
-				m_set = set.Duplicate();
+				p_set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool().RequestDescriptorSet(set->GetShaderLayout(), set->GetShaderType());
 			}
 			inline void Bind(std::size_t frame_index, VkCommandBuffer cmd)
 			{
-				m_set.SetImage(frame_index, 0, const_cast<Texture&>(p_font->GetTexture()));
+				p_set->SetImage(frame_index, 0, const_cast<Texture&>(p_font->GetTexture()));
-				m_set.Update(frame_index, cmd);
+				p_set->Update(frame_index, cmd);
 			}
 
 		private:
-			DescriptorSet m_set;
+			std::shared_ptr<DescriptorSet> p_set;
 			std::shared_ptr<Mesh> p_mesh;
 			std::shared_ptr<Font> p_font;
 			std::string m_text;

ScopEngine/Runtime/Includes/Renderer/Descriptor.h

@@ -5,8 +5,8 @@
 #include <cstdint>
 
 #include <kvf.h>
-#include <Renderer/RenderCore.h>
 #include <Utils/NonOwningPtr.h>
+#include <Renderer/RenderCore.h>
 #include <Renderer/Pipelines/Shader.h>
 
 namespace Scop
@@ -17,34 +17,76 @@ namespace Scop
 		NonOwningPtr<class GPUBuffer> uniform_buffer_ptr;
 		NonOwningPtr<class Image> image_ptr;
 		VkDescriptorType type;
-		ShaderType shader_type;
 		std::uint32_t binding;
 	};
 
-	class DescriptorSet
+	class DescriptorPool
 	{
 		public:
-			DescriptorSet() { m_set.fill(VK_NULL_HANDLE); }
+			DescriptorPool() = default;
-			DescriptorSet(const ShaderSetLayout& layout, VkDescriptorSetLayout vklayout, ShaderType shader_type);
 
+			void Init() noexcept;
+			void Destroy() noexcept;
+
+			std::shared_ptr<class DescriptorSet> RequestDescriptorSet(const ShaderSetLayout& layout, ShaderType shader_type);
+			void ReturnDescriptorSet(std::shared_ptr<class DescriptorSet> set);
+
+			[[nodiscard]] inline VkDescriptorPool Get() const noexcept { return m_pool; }
+			[[nodiscard]] inline std::size_t GetNumberOfSetsAllocated() const noexcept { return m_allocation_count; }
+
+			~DescriptorPool() = default;
+
+		private:
+			std::vector<std::shared_ptr<class DescriptorSet>> m_free_sets;
+			std::vector<std::shared_ptr<class DescriptorSet>> m_used_sets;
+			VkDescriptorPool m_pool;
+			std::size_t m_allocation_count = 0;
+	};
+
+	class DescriptorPoolManager
+	{
+		public:
+			DescriptorPoolManager() = default;
+
+			DescriptorPool& GetAvailablePool();
+			void Destroy();
+
+			~DescriptorPoolManager() = default;
+
+		private:
+			std::vector<DescriptorPool> m_pools;
+	};
+
+	class DescriptorSet : public std::enable_shared_from_this<DescriptorSet>
+	{
+		friend DescriptorPool;
+
+		public:
 			void SetImage(std::size_t i, std::uint32_t binding, class Image& image);
 			void SetStorageBuffer(std::size_t i, std::uint32_t binding, class GPUBuffer& buffer);
 			void SetUniformBuffer(std::size_t i, std::uint32_t binding, class GPUBuffer& buffer);
 			void Update(std::size_t i, VkCommandBuffer cmd = VK_NULL_HANDLE) noexcept;
 
-			[[nodiscard]] inline VkDescriptorSet GetSet(std::size_t i) const noexcept { return m_set[i]; }
+			void ReturnDescriptorSetToPool();
-			[[nodiscard]] inline DescriptorSet Duplicate() const { return DescriptorSet{ m_set_layout, m_descriptors }; }
+
-			[[nodiscard]] inline bool IsInit() const noexcept { return m_set[0] != VK_NULL_HANDLE; }
+			[[nodiscard]] inline VkDescriptorSet GetSet(std::size_t i) const noexcept { return m_sets[i]; }
+			[[nodiscard]] inline bool IsInit() const noexcept { return m_sets[0] != VK_NULL_HANDLE; }
+			[[nodiscard]] inline VkDescriptorSetLayout GetVulkanLayout() const noexcept { return m_set_layout; }
+			[[nodiscard]] inline const ShaderSetLayout& GetShaderLayout() const { return m_shader_layout; }
+			[[nodiscard]] inline ShaderType GetShaderType() const noexcept { return m_shader_type; }
 
 			~DescriptorSet() = default;
 
 		private:
-			DescriptorSet(VkDescriptorSetLayout layout, const std::vector<Descriptor>& descriptors);
+			DescriptorSet(DescriptorPool& pool, VkDescriptorSetLayout vulkan_layout, const ShaderSetLayout& layout, std::array<VkDescriptorSet, MAX_FRAMES_IN_FLIGHT> vulkan_sets, ShaderType shader_type);
 
 		private:
+			ShaderSetLayout m_shader_layout;
 			std::vector<Descriptor> m_descriptors;
-			std::array<VkDescriptorSet, MAX_FRAMES_IN_FLIGHT> m_set;
+			std::array<VkDescriptorSet, MAX_FRAMES_IN_FLIGHT> m_sets;
 			VkDescriptorSetLayout m_set_layout;
+			ShaderType m_shader_type;
+			DescriptorPool& m_pool;
 	};
 }
 

ScopEngine/Runtime/Includes/Renderer/Pipelines/Shader.h

@@ -14,6 +14,8 @@ namespace Scop
 		std::vector<std::pair<int, VkDescriptorType> > binds;
 
 		ShaderSetLayout(std::vector<std::pair<int, VkDescriptorType> > b) : binds(std::move(b)) {}
+
+		inline bool operator==(const ShaderSetLayout& rhs) const { return binds == rhs.binds; }
 	};
 
 	struct ShaderPushConstantLayout

ScopEngine/Runtime/Includes/Renderer/RenderCore.h

@@ -35,6 +35,7 @@ namespace Scop
 			[[nodiscard]] inline VkPhysicalDevice GetPhysicalDevice() const noexcept { return m_physical_device; }
 			[[nodiscard]] inline DeviceAllocator& GetAllocator() noexcept { return m_allocator; }
 			[[nodiscard]] inline bool StackSubmits() const noexcept { return m_stack_submits; }
+			[[nodiscard]] inline class DescriptorPoolManager& GetDescriptorPoolManager() noexcept { return *p_descriptor_pool_manager; }
 
 			[[nodiscard]] inline std::shared_ptr<class Shader> GetDefaultVertexShader() const { return m_internal_shaders[DEFAULT_VERTEX_SHADER_ID]; }
 			[[nodiscard]] inline std::shared_ptr<class Shader> GetBasicFragmentShader() const { return m_internal_shaders[BASIC_FRAGMENT_SHADER_ID]; }
@@ -71,6 +72,7 @@ namespace Scop
 			VkInstance m_instance = VK_NULL_HANDLE;
 			VkDevice m_device = VK_NULL_HANDLE;
 			VkPhysicalDevice m_physical_device = VK_NULL_HANDLE;
+			std::unique_ptr<class DescriptorPoolManager> p_descriptor_pool_manager;
 			bool m_stack_submits = false;
 	};
 }

ScopEngine/Runtime/Sources/Graphics/Model.cpp

@@ -25,7 +25,7 @@ namespace Scop
 		m_materials.back() = s_default_material;
 	}
 
-	void Model::Draw(VkCommandBuffer cmd, const DescriptorSet& matrices_set, const GraphicPipeline& pipeline, DescriptorSet& set, std::size_t& drawcalls, std::size_t& polygondrawn, std::size_t frame_index) const
+	void Model::Draw(VkCommandBuffer cmd, std::shared_ptr<DescriptorSet> matrices_set, const GraphicPipeline& pipeline, std::shared_ptr<DescriptorSet> set, std::size_t& drawcalls, std::size_t& polygondrawn, std::size_t frame_index) const
 	{
 		if(!p_mesh)
 			return;
@@ -39,7 +39,7 @@ namespace Scop
 			if(!material->IsSetInit())
 				material->UpdateDescriptorSet(set);
 			material->Bind(frame_index, cmd);
-			std::array<VkDescriptorSet, 2> sets = { matrices_set.GetSet(frame_index), material->GetSet(frame_index) };
+			std::array<VkDescriptorSet, 2> sets = { matrices_set->GetSet(frame_index), material->GetSet(frame_index) };
 			RenderCore::Get().vkCmdBindDescriptorSets(cmd, pipeline.GetPipelineBindPoint(), pipeline.GetPipelineLayout(), 0, sets.size(), sets.data(), 0, nullptr);
 			p_mesh->Draw(cmd, drawcalls, polygondrawn, i);
 		}

ScopEngine/Runtime/Sources/Graphics/Scene.cpp

@@ -165,7 +165,7 @@ namespace Scop
 
 		if(m_descriptor.post_process_shader)
 		{
-			m_post_process.set = std::make_shared<DescriptorSet>(m_descriptor.post_process_shader->GetShaderLayout().set_layouts[0].second, m_descriptor.post_process_shader->GetPipelineLayout().set_layouts[0], ShaderType::Fragment);
+			m_post_process.set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool().RequestDescriptorSet(m_descriptor.post_process_shader->GetShaderLayout().set_layouts[0].second, ShaderType::Fragment);
 			m_post_process.data_buffer = std::make_shared<UniformBuffer>();
 			m_post_process.data_buffer->Init(m_descriptor.post_process_data_size, m_name + "_post_process_data_buffer");
 		}
@@ -178,13 +178,13 @@ namespace Scop
 		m_forward.matrices_buffer = std::make_shared<UniformBuffer>();
 		m_forward.matrices_buffer->Init(sizeof(ViewerData), m_name + "_matrice_buffer");
 
-		m_forward.matrices_set = std::make_shared<DescriptorSet>(vertex_shader->GetShaderLayout().set_layouts[0].second, vertex_shader->GetPipelineLayout().set_layouts[0], ShaderType::Vertex);
+		m_forward.matrices_set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool().RequestDescriptorSet(vertex_shader->GetShaderLayout().set_layouts[0].second, ShaderType::Vertex);
 		for(std::size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
 		{
 			m_forward.matrices_set->SetUniformBuffer(i, 0, m_forward.matrices_buffer->Get(i));
 			m_forward.matrices_set->Update(i);
 		}
-		m_forward.albedo_set = std::make_shared<DescriptorSet>(m_descriptor.fragment_shader->GetShaderLayout().set_layouts[0].second, m_descriptor.fragment_shader->GetPipelineLayout().set_layouts[0], ShaderType::Fragment);
+		m_forward.albedo_set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool().RequestDescriptorSet(m_descriptor.fragment_shader->GetShaderLayout().set_layouts[0].second, ShaderType::Fragment);
 
 		for(auto& child : m_scene_children)
 			child.Init(renderer);

ScopEngine/Runtime/Sources/Renderer/Descriptor.cpp

@@ -5,11 +5,14 @@
 #include <Renderer/Image.h>
 #include <Renderer/Enums.h>
 #include <Renderer/Buffer.h>
+#include <Renderer/RenderCore.h>
 #include <Renderer/Descriptor.h>
 #include <Renderer/RenderCore.h>
 
 namespace Scop
 {
+	constexpr std::size_t MAX_SETS_PER_POOL = MAX_FRAMES_IN_FLIGHT * 1024;
+
 	void TransitionImageToCorrectLayout(Image& image, VkCommandBuffer cmd)
 	{
 		if(!image.IsInit())
@@ -22,30 +25,144 @@ namespace Scop
 			Error("Vulkan: cannot transition descriptor image layout, unkown image type");
 	}
 
-	DescriptorSet::DescriptorSet(const ShaderSetLayout& layout, VkDescriptorSetLayout vklayout, ShaderType shader_type)
+	void DescriptorPool::Init() noexcept
-	: m_set_layout(vklayout)
+	{
+		VkDescriptorPoolSize pool_sizes[] = {
+			{ VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, MAX_SETS_PER_POOL },
+			{ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, MAX_SETS_PER_POOL },
+			{ VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, MAX_SETS_PER_POOL }
+		};
+
+		VkDescriptorPoolCreateInfo pool_info{};
+		pool_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
+		pool_info.poolSizeCount = sizeof(pool_sizes) / sizeof(pool_sizes[0]);
+		pool_info.pPoolSizes = pool_sizes;
+		pool_info.maxSets = MAX_SETS_PER_POOL;
+		pool_info.flags = 0;
+		kvfCheckVk(RenderCore::Get().vkCreateDescriptorPool(RenderCore::Get().GetDevice(), &pool_info, nullptr, &m_pool));
+		m_allocation_count = 0;
+	}
+
+	void DescriptorPool::Destroy() noexcept
+	{
+		if(m_pool == VK_NULL_HANDLE)
+			return;
+		for(auto& set : m_free_sets)
+			kvfDestroyDescriptorSetLayout(RenderCore::Get().GetDevice(), set->m_set_layout);
+		for(auto& set : m_used_sets)
+			kvfDestroyDescriptorSetLayout(RenderCore::Get().GetDevice(), set->m_set_layout);
+		RenderCore::Get().vkDestroyDescriptorPool(RenderCore::Get().GetDevice(), m_pool, nullptr);
+		m_pool = VK_NULL_HANDLE;
+		m_allocation_count = 0;
+		m_free_sets.clear();
+		m_used_sets.clear();
+	}
+
+	std::shared_ptr<DescriptorSet> DescriptorPool::RequestDescriptorSet(const ShaderSetLayout& layout, ShaderType shader_type)
+	{
+		auto it = std::find_if(m_free_sets.begin(), m_free_sets.end(), [&](std::shared_ptr<DescriptorSet> set)
+		{
+			return shader_type == set->GetShaderType() && layout == set->GetShaderLayout();
+		});
+		if(it != m_free_sets.end())
+		{
+			std::shared_ptr<DescriptorSet> set = *it;
+			m_free_sets.erase(it);
+			m_used_sets.push_back(set);
+			return set;
+		}
+
+		std::array<VkDescriptorSet, MAX_FRAMES_IN_FLIGHT> vulkan_sets;
+
+		VkShaderStageFlagBits vulkan_shader_stage;
+		switch(shader_type)
+		{
+			case ShaderType::Vertex: vulkan_shader_stage = VK_SHADER_STAGE_VERTEX_BIT; break;
+			case ShaderType::Fragment: vulkan_shader_stage = VK_SHADER_STAGE_FRAGMENT_BIT; break;
+
+			default: FatalError("wtf"); vulkan_shader_stage = VK_SHADER_STAGE_VERTEX_BIT; /* Just to shut up warnings */ break;
+		}
+
+		std::vector<VkDescriptorSetLayoutBinding> bindings(layout.binds.size());
+		for(std::size_t i = 0; i < layout.binds.size(); i++)
+		{
+			bindings[i].binding = layout.binds[i].first;
+			bindings[i].descriptorCount = 1;
+			bindings[i].descriptorType = layout.binds[i].second;
+			bindings[i].pImmutableSamplers = nullptr;
+			bindings[i].stageFlags = vulkan_shader_stage;
+		}
+		VkDescriptorSetLayout vulkan_layout = kvfCreateDescriptorSetLayout(RenderCore::Get().GetDevice(), bindings.data(), bindings.size());
+
+		for(int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
+		{
+			VkDescriptorSetAllocateInfo alloc_info = {};
+			alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
+			alloc_info.descriptorPool = m_pool;
+			alloc_info.descriptorSetCount = 1;
+			alloc_info.pSetLayouts = &vulkan_layout;
+			VkDescriptorSet vulkan_set;
+			kvfCheckVk(RenderCore::Get().vkAllocateDescriptorSets(RenderCore::Get().GetDevice(), &alloc_info, &vulkan_set));
+			m_allocation_count++;
+			vulkan_sets[i] = vulkan_set;
+		}
+
+		std::shared_ptr<DescriptorSet> set(new DescriptorSet(*this, vulkan_layout, layout, std::move(vulkan_sets), shader_type));
+		m_used_sets.push_back(set);
+		return set;
+	}
+
+	void DescriptorPool::ReturnDescriptorSet(std::shared_ptr<DescriptorSet> set)
+	{
+		//std::size_t i = 0;
+		auto it = std::find_if(m_used_sets.begin(), m_used_sets.end(), [&](const std::shared_ptr<DescriptorSet>& rhs_set)
+		{
+			//i++;
+			//std::cout << m_used_sets.size() << " " << i << std::endl;
+			return set == rhs_set;
+		});
+		if(it == m_used_sets.end())
+			return;
+		m_used_sets.erase(it);
+		m_free_sets.push_back(set);
+	}
+
+	DescriptorPool& DescriptorPoolManager::GetAvailablePool()
+	{
+		for(auto& pool : m_pools)
+		{
+			if(pool.GetNumberOfSetsAllocated() < MAX_SETS_PER_POOL)
+				return pool;
+		}
+		m_pools.emplace_back().Init();
+		return m_pools.back();
+	}
+
+	void DescriptorPoolManager::Destroy()
+	{
+		for(auto& pool : m_pools)
+			pool.Destroy();
+		m_pools.clear();
+	}
+
+	DescriptorSet::DescriptorSet(DescriptorPool& pool, VkDescriptorSetLayout vulkan_layout, const ShaderSetLayout& layout, std::array<VkDescriptorSet, MAX_FRAMES_IN_FLIGHT> vulkan_sets, ShaderType shader_type) :
+		m_shader_layout(layout),
+		m_sets(std::move(vulkan_sets)),
+		m_set_layout(vulkan_layout),
+		m_shader_type(shader_type),
+		m_pool(pool)
 	{
 		for(auto& [binding, type] : layout.binds)
 		{
 			m_descriptors.emplace_back();
 			m_descriptors.back().type = type;
-			m_descriptors.back().shader_type = shader_type;
 			m_descriptors.back().binding = binding;
 		}
-		for(std::size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
-			m_set[i] = kvfAllocateDescriptorSet(RenderCore::Get().GetDevice(), vklayout);
-	}
-
-	DescriptorSet::DescriptorSet(VkDescriptorSetLayout layout, const std::vector<Descriptor>& descriptors)
-	: m_set_layout(layout), m_descriptors(descriptors)
-	{
-		for(std::size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
-			m_set[i] = kvfAllocateDescriptorSet(RenderCore::Get().GetDevice(), layout);
 	}
 
 	void DescriptorSet::SetImage(std::size_t i, std::uint32_t binding, class Image& image)
 	{
-		Verify(m_set[i] != VK_NULL_HANDLE, "invalid descriptor");
+		Verify(m_sets[i] != VK_NULL_HANDLE, "invalid descriptor");
 		auto it = std::find_if(m_descriptors.begin(), m_descriptors.end(), [=](Descriptor descriptor)
 		{
 			return binding == descriptor.binding;
@@ -65,7 +182,7 @@ namespace Scop
 
 	void DescriptorSet::SetStorageBuffer(std::size_t i, std::uint32_t binding, class GPUBuffer& buffer)
 	{
-		Verify(m_set[i] != VK_NULL_HANDLE, "invalid descriptor");
+		Verify(m_sets[i] != VK_NULL_HANDLE, "invalid descriptor");
 		auto it = std::find_if(m_descriptors.begin(), m_descriptors.end(), [=](Descriptor descriptor)
 		{
 			return binding == descriptor.binding;
@@ -85,7 +202,7 @@ namespace Scop
 
 	void DescriptorSet::SetUniformBuffer(std::size_t i, std::uint32_t binding, class GPUBuffer& buffer)
 	{
-		Verify(m_set[i] != VK_NULL_HANDLE, "invalid descriptor");
+		Verify(m_sets[i] != VK_NULL_HANDLE, "invalid descriptor");
 		auto it = std::find_if(m_descriptors.begin(), m_descriptors.end(), [=](Descriptor descriptor)
 		{
 			return binding == descriptor.binding;
@@ -105,7 +222,7 @@ namespace Scop
 
 	void DescriptorSet::Update(std::size_t i, VkCommandBuffer cmd) noexcept
 	{
-		Verify(m_set[i] != VK_NULL_HANDLE, "invalid descriptor");
+		Verify(m_sets[i] != VK_NULL_HANDLE, "invalid descriptor");
 
 		std::size_t image_count = 0;
 		std::size_t buffer_count = 0;
@@ -137,7 +254,7 @@ namespace Scop
 				info.imageLayout = descriptor.image_ptr->GetLayout();
 				info.imageView = descriptor.image_ptr->GetImageView();
 				image_infos[image_index] = std::move(info);
-				writes[write_index] = kvfWriteImageToDescriptorSet(RenderCore::Get().GetDevice(), m_set[i], &image_infos[image_index], descriptor.binding);
+				writes[write_index] = kvfWriteImageToDescriptorSet(RenderCore::Get().GetDevice(), m_sets[i], &image_infos[image_index], descriptor.binding);
 				image_index++;
 			}
 			else if(descriptor.uniform_buffer_ptr)
@@ -147,7 +264,7 @@ namespace Scop
 				info.offset = descriptor.uniform_buffer_ptr->GetOffset();
 				info.range = VK_WHOLE_SIZE;
 				buffer_infos[buffer_index] = std::move(info);
-				writes[write_index] = kvfWriteUniformBufferToDescriptorSet(RenderCore::Get().GetDevice(), m_set[i], &buffer_infos[buffer_index], descriptor.binding);
+				writes[write_index] = kvfWriteUniformBufferToDescriptorSet(RenderCore::Get().GetDevice(), m_sets[i], &buffer_infos[buffer_index], descriptor.binding);
 				buffer_index++;
 			}
 			else if(descriptor.storage_buffer_ptr)
@@ -157,11 +274,16 @@ namespace Scop
 				info.offset = descriptor.storage_buffer_ptr->GetOffset();
 				info.range = VK_WHOLE_SIZE;
 				buffer_infos[buffer_index] = std::move(info);
-				writes[write_index] = kvfWriteStorageBufferToDescriptorSet(RenderCore::Get().GetDevice(), m_set[i], &buffer_infos[buffer_index], descriptor.binding);
+				writes[write_index] = kvfWriteStorageBufferToDescriptorSet(RenderCore::Get().GetDevice(), m_sets[i], &buffer_infos[buffer_index], descriptor.binding);
 				buffer_index++;
 			}
 			write_index++;
 		}
 		RenderCore::Get().vkUpdateDescriptorSets(RenderCore::Get().GetDevice(), writes.size(), writes.data(), 0, nullptr);
 	}
+
+	void DescriptorSet::ReturnDescriptorSetToPool()
+	{
+		m_pool.ReturnDescriptorSet(shared_from_this());
+	}
 }

ScopEngine/Runtime/Sources/Renderer/RenderCore.cpp

@@ -6,6 +6,7 @@
 
 #include <Core/Engine.h>
 #include <Platform/Window.h>
+#include <Renderer/Descriptor.h>
 #include <Renderer/RenderCore.h>
 #include <Renderer/Pipelines/Shader.h>
 #include <Renderer/Vulkan/VulkanLoader.h>
@@ -120,6 +121,8 @@ namespace Scop
 
 		m_allocator.AttachToDevice(m_device, m_physical_device);
 
+		p_descriptor_pool_manager = std::make_unique<DescriptorPoolManager>();
+
 		ShaderLayout vertex_shader_layout(
 			{
 				{ 0,
@@ -258,6 +261,8 @@ namespace Scop
 		if(s_instance == nullptr)
 			return;
 		WaitDeviceIdle();
+		p_descriptor_pool_manager->Destroy();
+		p_descriptor_pool_manager.reset();
 		m_allocator.DetachFromDevice();
 		for(auto shader: m_internal_shaders)
 			shader->Destroy();

ScopEngine/Runtime/Sources/Renderer/RenderPasses/2DPass.cpp

@@ -49,8 +49,8 @@ namespace Scop
 		};
 		EventBus::RegisterListener({ functor, "__ScopRender2DPass" });
 
-		p_viewer_data_set = std::make_shared<DescriptorSet>(p_vertex_shader->GetShaderLayout().set_layouts[0].second, p_vertex_shader->GetPipelineLayout().set_layouts[0], ShaderType::Vertex);
+		p_viewer_data_set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool().RequestDescriptorSet(p_vertex_shader->GetShaderLayout().set_layouts[0].second,ShaderType::Vertex);
-		p_texture_set = std::make_shared<DescriptorSet>(p_fragment_shader->GetShaderLayout().set_layouts[0].second, p_fragment_shader->GetPipelineLayout().set_layouts[0], ShaderType::Fragment);
+		p_texture_set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool().RequestDescriptorSet(p_fragment_shader->GetShaderLayout().set_layouts[0].second, ShaderType::Fragment);
 
 		p_viewer_data_buffer = std::make_shared<UniformBuffer>();
 		p_viewer_data_buffer->Init(sizeof(ViewerData2D));
@@ -91,7 +91,7 @@ namespace Scop
 			sprite_data.position = Vec2f{ static_cast<float>(sprite.GetPosition().x), static_cast<float>(sprite.GetPosition().y) };
 			sprite_data.color = sprite.GetColor();
 			if(!sprite.IsSetInit())
-				const_cast<Sprite&>(sprite).UpdateDescriptorSet(*p_texture_set);
+				const_cast<Sprite&>(sprite).UpdateDescriptorSet(p_texture_set);
 			const_cast<Sprite&>(sprite).Bind(frame_index, cmd);
 			std::array<VkDescriptorSet, 2> sets = { p_viewer_data_set->GetSet(frame_index), sprite.GetSet(frame_index) };
 			RenderCore::Get().vkCmdBindDescriptorSets(cmd, m_pipeline.GetPipelineBindPoint(), m_pipeline.GetPipelineLayout(), 0, sets.size(), sets.data(), 0, nullptr);
@@ -104,7 +104,7 @@ namespace Scop
 			sprite_data.position = Vec2f{ static_cast<float>(text.GetPosition().x), static_cast<float>(text.GetPosition().y) };
 			sprite_data.color = text.GetColor();
 			if(!text.IsSetInit())
-				const_cast<Text&>(text).UpdateDescriptorSet(*p_texture_set);
+				const_cast<Text&>(text).UpdateDescriptorSet(p_texture_set);
 			const_cast<Text&>(text).Bind(frame_index, cmd);
 			std::array<VkDescriptorSet, 2> sets = { p_viewer_data_set->GetSet(frame_index), text.GetSet(frame_index) };
 			RenderCore::Get().vkCmdBindDescriptorSets(cmd, m_pipeline.GetPipelineBindPoint(), m_pipeline.GetPipelineLayout(), 0, sets.size(), sets.data(), 0, nullptr);

ScopEngine/Runtime/Sources/Renderer/RenderPasses/FinalPass.cpp

@@ -31,7 +31,7 @@ namespace Scop
 		};
 		EventBus::RegisterListener({ functor, "__ScopFinalPass" });
 
-		p_set = std::make_shared<DescriptorSet>(p_fragment_shader->GetShaderLayout().set_layouts[0].second, p_fragment_shader->GetPipelineLayout().set_layouts[0], ShaderType::Fragment);
+		p_set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool().RequestDescriptorSet(p_fragment_shader->GetShaderLayout().set_layouts[0].second, ShaderType::Fragment);
 	}
 
 	void FinalPass::Pass(Scene& scene, Renderer& renderer, Texture& render_target)

ScopEngine/Runtime/Sources/Renderer/RenderPasses/ForwardPass.cpp

@@ -65,7 +65,7 @@ namespace Scop
 			{
 				auto model_data = setup_model(actor);
 				RenderCore::Get().vkCmdPushConstants(cmd, pipeline.GetPipelineLayout(), VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(ModelData), &model_data);
-				actor.GetModel().Draw(cmd, *data.matrices_set, pipeline, *data.albedo_set, renderer.GetDrawCallsCounterRef(), renderer.GetPolygonDrawnCounterRef(), renderer.GetCurrentFrameIndex());
+				actor.GetModel().Draw(cmd, data.matrices_set, pipeline, data.albedo_set, renderer.GetDrawCallsCounterRef(), renderer.GetPolygonDrawnCounterRef(), renderer.GetCurrentFrameIndex());
 			}
 			else
 			{
@@ -79,7 +79,7 @@ namespace Scop
 				continue;
 			auto model_data = setup_model(it->second);
 			RenderCore::Get().vkCmdPushConstants(cmd, pipeline.GetPipelineLayout(), VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(ModelData), &model_data);
-			it->second.GetModel().Draw(cmd, *data.matrices_set, pipeline, *data.albedo_set, renderer.GetDrawCallsCounterRef(), renderer.GetPolygonDrawnCounterRef(), renderer.GetCurrentFrameIndex());
+			it->second.GetModel().Draw(cmd, data.matrices_set, pipeline, data.albedo_set, renderer.GetDrawCallsCounterRef(), renderer.GetPolygonDrawnCounterRef(), renderer.GetCurrentFrameIndex());
 		}
 		pipeline.EndPipeline(cmd);
 	}

ScopEngine/Runtime/Sources/Renderer/RenderPasses/Passes.cpp

@@ -24,7 +24,7 @@ namespace Scop
 		if(!m_main_render_texture.IsInit())
 		{
 			auto extent = kvfGetSwapchainImagesSize(renderer.GetSwapchain().Get());
-			m_main_render_texture.Init({}, extent.width, extent.height, VK_FORMAT_R8G8B8A8_UNORM, false, "scop_main_render_texture", true);
+			m_main_render_texture.Init({}, extent.width, extent.height, VK_FORMAT_R8G8B8A8_UNORM, false, "scop_main_render_texture", false);
 		}
 
 		scene.GetDepth().Clear(renderer.GetActiveCommandBuffer(), {});

ScopEngine/Runtime/Sources/Renderer/RenderPasses/PostProcessPass.cpp

@@ -32,7 +32,7 @@ namespace Scop
 		if(!m_render_texture.IsInit())
 		{
 			auto extent = kvfGetSwapchainImagesSize(renderer.GetSwapchain().Get());
-			m_render_texture.Init({}, extent.width, extent.height, VK_FORMAT_R8G8B8A8_UNORM, false, "scop_post_process_render_texture", true);
+			m_render_texture.Init({}, extent.width, extent.height, VK_FORMAT_R8G8B8A8_UNORM, false, "scop_post_process_render_texture", false);
 		}
 
 		if(m_pipeline.GetPipeline() == VK_NULL_HANDLE)

ScopEngine/Runtime/Sources/Renderer/RenderPasses/SkyboxPass.cpp

@@ -40,7 +40,7 @@ namespace Scop
 		EventBus::RegisterListener({ functor, "__ScopSkyboxPass" });
 
 		m_cube = CreateCube();
-		p_set = std::make_shared<DescriptorSet>(p_fragment_shader->GetShaderLayout().set_layouts[0].second, p_fragment_shader->GetPipelineLayout().set_layouts[0], ShaderType::Fragment);
+		p_set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool().RequestDescriptorSet(p_fragment_shader->GetShaderLayout().set_layouts[0].second, ShaderType::Fragment);
 	}
 
 	void SkyboxPass::Pass(Scene& scene, Renderer& renderer, class Texture& render_target)

ScopEngine/ThirdParty/KVF/kvf.h

@@ -374,12 +374,12 @@ void kvfCheckVk(VkResult result);
 #ifdef KVF_DESCRIPTOR_POOL_CAPACITY
 	#undef KVF_DESCRIPTOR_POOL_CAPACITY
 #endif
-#define KVF_DESCRIPTOR_POOL_CAPACITY 512
+#define KVF_DESCRIPTOR_POOL_CAPACITY 1024
 
 #ifdef KVF_COMMAND_POOL_CAPACITY
 	#undef KVF_COMMAND_POOL_CAPACITY
 #endif
-#define KVF_COMMAND_POOL_CAPACITY 512
+#define KVF_COMMAND_POOL_CAPACITY 1024
 
 typedef struct
 {