include/vkcv/Core.hpp

@@ -233,16 +233,26 @@ namespace vkcv
 		[[nodiscard]]
 		vk::Format getImageFormat(const ImageHandle& image);
 
+		/** TODO:
+		 * @param bindings
+		 * @return
+		 */
+		[[nodiscard]]
+		DescriptorSetLayoutHandle createDescriptorSetLayout(const std::unordered_map<uint32_t, DescriptorBinding> &bindingsMap);
+		DescriptorSetLayout getDescriptorSetLayout(const DescriptorSetLayoutHandle handle) const;
+
+		// TODO: existsDescriptorSetLayout function that checks and returns fitting layout upon existence.
+
         /** TODO:
          *   @param setDescriptions
          *   @return
          */
         [[nodiscard]]
-        DescriptorSetHandle createDescriptorSet(const std::vector<DescriptorBinding> &bindings);
+        DescriptorSetHandle createDescriptorSet(const DescriptorSetLayoutHandle &layoutHandle);
 		void writeDescriptorSet(DescriptorSetHandle handle, const DescriptorWrites& writes);
-
 		DescriptorSet getDescriptorSet(const DescriptorSetHandle handle) const;
 
+
 		/**
 		 * @brief start recording command buffers and increment frame index
 		*/

include/vkcv/DescriptorConfig.hpp

 #pragma once
 
+#include <unordered_map>
+
 #include "vkcv/Handles.hpp"
 #include "vkcv/ShaderStage.hpp"
+#include "vkcv/Logger.hpp"
 
 namespace vkcv
 {
-    struct DescriptorSet
-    {
-        vk::DescriptorSet       vulkanHandle;
-        vk::DescriptorSetLayout layout;
-        size_t                  poolIndex;
-    };
-
     /*
     * All the types of descriptors (resources) that can be retrieved by the shaders
     */
@@ -25,7 +21,34 @@ namespace vkcv
         UNIFORM_BUFFER_DYNAMIC,
         STORAGE_BUFFER_DYNAMIC
     };    
-    
+
+    /**
+    * Converts the descriptor types from VulkanCV (vkcv) to native Vulkan (vk).
+    * @param[in] vkcv DescriptorType
+    * @return vk DescriptorType
+    */
+    constexpr vk::DescriptorType getVkDescriptorType(DescriptorType type) noexcept {
+        switch (type)
+        {
+            case DescriptorType::UNIFORM_BUFFER:
+                return vk::DescriptorType::eUniformBuffer;
+            case DescriptorType::UNIFORM_BUFFER_DYNAMIC:
+                return vk::DescriptorType::eUniformBufferDynamic;
+            case DescriptorType::STORAGE_BUFFER:
+                return vk::DescriptorType::eStorageBuffer;
+            case DescriptorType::STORAGE_BUFFER_DYNAMIC:
+                return vk::DescriptorType::eStorageBufferDynamic;
+            case DescriptorType::SAMPLER:
+                return vk::DescriptorType::eSampler;
+            case DescriptorType::IMAGE_SAMPLED:
+                return vk::DescriptorType::eSampledImage;
+            case DescriptorType::IMAGE_STORAGE:
+                return vk::DescriptorType::eStorageImage;
+            default:
+                return vk::DescriptorType::eMutableVALVE;
+        }
+    }
+
     /*
     * One binding for a descriptor set
     * @param[in] a unique binding ID
@@ -42,9 +65,26 @@ namespace vkcv
             ShaderStages shaderStages
         ) noexcept;
         
-        uint32_t bindingID;
-        DescriptorType descriptorType;
-        uint32_t descriptorCount;
-        ShaderStages shaderStages;
+        uint32_t        bindingID;
+        DescriptorType  descriptorType;
+        uint32_t        descriptorCount;
+        ShaderStages    shaderStages;
+
+        bool operator ==(const DescriptorBinding &other) const;
+    };
+    
+    typedef std::unordered_map<uint32_t, DescriptorBinding> DescriptorBindings;
+
+    struct DescriptorSetLayout
+    {
+        vk::DescriptorSetLayout vulkanHandle;
+        DescriptorBindings descriptorBindings;
+    };
+
+    struct DescriptorSet
+    {
+        vk::DescriptorSet           vulkanHandle;
+        DescriptorSetLayoutHandle   setLayoutHandle;
+        size_t                      poolIndex;
     };
 }

include/vkcv/Handles.hpp

@@ -84,6 +84,12 @@ namespace vkcv
 	private:
 		using Handle::Handle;
 	};
+
+	class DescriptorSetLayoutHandle : public Handle {
+	    friend class DescriptorManager;
+	private:
+	    using Handle::Handle;
+	};
 	
 	class SamplerHandle : public Handle {
 		friend class SamplerManager;

include/vkcv/ShaderProgram.hpp

@@ -51,7 +51,13 @@ namespace vkcv {
         const std::vector<VertexAttachment> &getVertexAttachments() const;
 		size_t getPushConstantSize() const;
 
-        const std::vector<std::vector<DescriptorBinding>>& getReflectedDescriptors() const;
+		/**
+		 * Returns the reflected descriptor sets/layouts/bindings in a map of maps.
+		 * First uint32_t serves as descriptor SET id.
+		 * Second uint32_t serves as the descriptor set's BINDING id.
+		 * @return
+		 */
+		const std::unordered_map<uint32_t, std::unordered_map<uint32_t, DescriptorBinding>>& getReflectedDescriptors() const;
 
 	private:
 	    /**
@@ -65,7 +71,7 @@ namespace vkcv {
 
         // contains all vertex input attachments used in the vertex buffer
         std::vector<VertexAttachment> m_VertexAttachments;
-        std::vector<std::vector<DescriptorBinding>> m_DescriptorSets;
+        std::unordered_map<uint32_t, std::unordered_map<uint32_t, DescriptorBinding>> m_DescriptorSets;
 		size_t m_pushConstantSize = 0;
 	};
 }

modules/material/include/vkcv/material/Material.hpp

@@ -23,6 +23,7 @@ namespace vkcv::material {
 		
 		MaterialType m_Type;
 		DescriptorSetHandle m_DescriptorSet;
+		DescriptorSetLayoutHandle m_DescriptorSetLayout;
 		std::vector<Texture> m_Textures;
 		
 	public:
@@ -40,12 +41,15 @@ namespace vkcv::material {
 		
 		[[nodiscard]]
 		const DescriptorSetHandle& getDescriptorSet() const;
+
+		[[nodiscard]]
+		const DescriptorSetLayoutHandle& getDescriptorSetLayout() const;
 		
 		explicit operator bool() const;
 		
 		bool operator!() const;
 		
-		static const std::vector<DescriptorBinding>& getDescriptorBindings(MaterialType type);
+		static const std::unordered_map<uint32_t ,DescriptorBinding>& getDescriptorBindings(MaterialType type);
 		
 		static Material createPBR(Core &core,
 								  const ImageHandle &colorImg,

modules/material/src/vkcv/material/Material.cpp

@@ -14,6 +14,10 @@ namespace vkcv::material {
 	const DescriptorSetHandle & Material::getDescriptorSet() const {
 		return m_DescriptorSet;
 	}
+
+	const DescriptorSetLayoutHandle & Material::getDescriptorSetLayout() const {
+        return m_DescriptorSetLayout;
+	}
 	
 	Material::operator bool() const {
 		return (m_Type != MaterialType::UNKNOWN);
@@ -23,24 +27,25 @@ namespace vkcv::material {
 		return (m_Type == MaterialType::UNKNOWN);
 	}
 	
-	const std::vector<DescriptorBinding>& Material::getDescriptorBindings(MaterialType type)
+	const DescriptorBindings& Material::getDescriptorBindings(MaterialType type)
 	{
-		static std::vector<DescriptorBinding> pbr_bindings;
-		static std::vector<DescriptorBinding> default_bindings;
+		static DescriptorBindings pbr_bindings = {};
+		static DescriptorBindings default_bindings = {};
 		
 		switch (type) {
 			case MaterialType::PBR_MATERIAL:
-				if (pbr_bindings.empty()) {
-					pbr_bindings.emplace_back(0, DescriptorType::IMAGE_SAMPLED, 1, ShaderStage::FRAGMENT);
-					pbr_bindings.emplace_back(1, DescriptorType::SAMPLER, 1, ShaderStage::FRAGMENT);
-					pbr_bindings.emplace_back(2, DescriptorType::IMAGE_SAMPLED, 1, ShaderStage::FRAGMENT);
-					pbr_bindings.emplace_back(3, DescriptorType::SAMPLER, 1, ShaderStage::FRAGMENT);
-					pbr_bindings.emplace_back(4, DescriptorType::IMAGE_SAMPLED, 1, ShaderStage::FRAGMENT);
-					pbr_bindings.emplace_back(5, DescriptorType::SAMPLER, 1, ShaderStage::FRAGMENT);
-					pbr_bindings.emplace_back(6, DescriptorType::IMAGE_SAMPLED, 1, ShaderStage::FRAGMENT);
-					pbr_bindings.emplace_back(7, DescriptorType::SAMPLER, 1, ShaderStage::FRAGMENT);
-					pbr_bindings.emplace_back(8, DescriptorType::IMAGE_SAMPLED, 1, ShaderStage::FRAGMENT);
-					pbr_bindings.emplace_back(9, DescriptorType::SAMPLER, 1, ShaderStage::FRAGMENT);
+				if (pbr_bindings.empty())
+				{
+					pbr_bindings.insert(std::make_pair(0, DescriptorBinding(0, DescriptorType::IMAGE_SAMPLED, 1, ShaderStage::FRAGMENT)));
+					pbr_bindings.insert(std::make_pair(1, DescriptorBinding(1, DescriptorType::SAMPLER, 1, ShaderStage::FRAGMENT)));
+					pbr_bindings.insert(std::make_pair(2, DescriptorBinding(2, DescriptorType::IMAGE_SAMPLED, 1, ShaderStage::FRAGMENT)));
+					pbr_bindings.insert(std::make_pair(3, DescriptorBinding(3, DescriptorType::SAMPLER, 1, ShaderStage::FRAGMENT)));
+					pbr_bindings.insert(std::make_pair(4, DescriptorBinding(4, DescriptorType::IMAGE_SAMPLED, 1, ShaderStage::FRAGMENT)));
+					pbr_bindings.insert(std::make_pair(5, DescriptorBinding(5, DescriptorType::SAMPLER, 1, ShaderStage::FRAGMENT)));
+					pbr_bindings.insert(std::make_pair(6, DescriptorBinding(6, DescriptorType::IMAGE_SAMPLED, 1, ShaderStage::FRAGMENT)));
+					pbr_bindings.insert(std::make_pair(7, DescriptorBinding(7, DescriptorType::SAMPLER, 1, ShaderStage::FRAGMENT)));
+					pbr_bindings.insert(std::make_pair(8, DescriptorBinding(8, DescriptorType::IMAGE_SAMPLED, 1, ShaderStage::FRAGMENT)));
+					pbr_bindings.insert(std::make_pair(9, DescriptorBinding(9, DescriptorType::SAMPLER, 1, ShaderStage::FRAGMENT)));
 				}
 				
 				return pbr_bindings;
@@ -163,7 +168,8 @@ namespace vkcv::material {
 		material.m_Type = MaterialType::PBR_MATERIAL;
 		
 		const auto& bindings = getDescriptorBindings(material.m_Type);
-		material.m_DescriptorSet = core.createDescriptorSet(bindings);;
+		material.m_DescriptorSetLayout = core.createDescriptorSetLayout(bindings);
+		material.m_DescriptorSet = core.createDescriptorSet(material.m_DescriptorSetLayout);;
 		
 		material.m_Textures.reserve(bindings.size());
 		material.m_Textures.push_back({ images[0], samplers[0], std::vector<float>(baseColorFactor, baseColorFactor+4) });

modules/upscaling/include/vkcv/upscaling/FSRUpscaling.hpp

@@ -32,8 +32,11 @@ namespace vkcv::upscaling {
 	private:
 		PipelineHandle m_easuPipeline;
 		PipelineHandle m_rcasPipeline;
-		
+
+		DescriptorSetLayoutHandle m_easuDescriptorSetLayout;
 		DescriptorSetHandle m_easuDescriptorSet;
+
+		DescriptorSetLayoutHandle m_rcasDescriptorSetLayout;
 		DescriptorSetHandle m_rcasDescriptorSet;
 		
 		Buffer<FSRConstants> m_easuConstants;

modules/upscaling/src/vkcv/upscaling/FSRUpscaling.cpp

@@ -65,25 +65,44 @@ namespace vkcv::upscaling {
 		}
 	}
 	
-	static std::vector<DescriptorBinding> getDescriptorBindings() {
-		return std::vector<DescriptorBinding>({
-			DescriptorBinding(
-					0, DescriptorType::UNIFORM_BUFFER_DYNAMIC,
-					1, ShaderStage::COMPUTE
-			),
-			DescriptorBinding(
-					1, DescriptorType::IMAGE_SAMPLED,
-					1, ShaderStage::COMPUTE
-			),
-			DescriptorBinding(
-					2, DescriptorType::IMAGE_STORAGE,
-					1, ShaderStage::COMPUTE
-			),
-			DescriptorBinding(
-					3, DescriptorType::SAMPLER,
-					1, ShaderStage::COMPUTE
-			)
-		});
+	static DescriptorBindings getDescriptorBindings() {
+		DescriptorBindings descriptorBindings = {};
+
+	    auto binding_0 = DescriptorBinding(
+	            0,
+	            DescriptorType::UNIFORM_BUFFER_DYNAMIC,
+	            1,
+	            ShaderStage::COMPUTE
+		);
+
+	    auto binding_1 = DescriptorBinding(
+	            1,
+	            DescriptorType::IMAGE_SAMPLED,
+	            1,
+	            ShaderStage::COMPUTE
+		);
+
+	    auto binding_2 = DescriptorBinding(
+	            2,
+	            DescriptorType::IMAGE_STORAGE,
+	            1,
+	            ShaderStage::COMPUTE
+		);
+
+	    auto binding_3 = DescriptorBinding(
+	            3,
+	            DescriptorType::SAMPLER,
+	            1,
+	            ShaderStage::COMPUTE
+		);
+
+	    descriptorBindings.insert(std::make_pair(0, binding_0));
+	    descriptorBindings.insert(std::make_pair(1, binding_1));
+	    descriptorBindings.insert(std::make_pair(2, binding_2));
+	    descriptorBindings.insert(std::make_pair(3, binding_3));
+
+	    return descriptorBindings;
+
 	}
 	
 	template<typename T>
@@ -155,8 +174,13 @@ namespace vkcv::upscaling {
 	Upscaling(core),
 	m_easuPipeline(),
 	m_rcasPipeline(),
-	m_easuDescriptorSet(m_core.createDescriptorSet(getDescriptorBindings())),
-	m_rcasDescriptorSet(m_core.createDescriptorSet(getDescriptorBindings())),
+
+	m_easuDescriptorSetLayout(m_core.createDescriptorSetLayout(getDescriptorBindings())),
+	m_easuDescriptorSet(m_core.createDescriptorSet(m_easuDescriptorSetLayout)),
+
+	m_rcasDescriptorSetLayout(m_core.createDescriptorSetLayout(getDescriptorBindings())),
+	m_rcasDescriptorSet(m_core.createDescriptorSet(m_rcasDescriptorSetLayout)),
+
 	m_easuConstants(m_core.createBuffer<FSRConstants>(
 			BufferType::UNIFORM,1,
 			BufferMemoryType::HOST_VISIBLE
@@ -207,7 +231,7 @@ namespace vkcv::upscaling {
 			});
 			
 			m_easuPipeline = m_core.createComputePipeline(program, {
-				m_core.getDescriptorSet(m_easuDescriptorSet).layout
+				m_core.getDescriptorSetLayout(m_easuDescriptorSetLayout).vulkanHandle
 			});
 			
 			DescriptorWrites writes;
@@ -228,7 +252,7 @@ namespace vkcv::upscaling {
 			});
 			
 			m_rcasPipeline = m_core.createComputePipeline(program, {
-				m_core.getDescriptorSet(m_rcasDescriptorSet).layout
+			    m_core.getDescriptorSetLayout(m_rcasDescriptorSetLayout).vulkanHandle
 			});
 			
 			DescriptorWrites writes;

projects/first_mesh/src/main.cpp

@@ -105,9 +105,16 @@ int main(int argc, const char** argv) {
 	
 	const vkcv::VertexLayout firstMeshLayout (bindings);
 
-	uint32_t setID = 0;
-	std::vector<vkcv::DescriptorBinding> descriptorBindings = { firstMeshProgram.getReflectedDescriptors()[setID] };
-	vkcv::DescriptorSetHandle descriptorSet = core.createDescriptorSet(descriptorBindings);
+
+	// since we only use one descriptor set (namely, desc set 0), directly address it
+	// recreate copies of the bindings and the handles (to check whether they are properly reused instead of actually recreated)
+	std::unordered_map<uint32_t, vkcv::DescriptorBinding> set0Bindings = firstMeshProgram.getReflectedDescriptors().at(0);
+    auto set0BindingsExplicitCopy = set0Bindings;
+
+	vkcv::DescriptorSetLayoutHandle setLayoutHandle = core.createDescriptorSetLayout(set0Bindings);
+	vkcv::DescriptorSetLayoutHandle setLayoutHandleCopy = core.createDescriptorSetLayout(set0BindingsExplicitCopy);
+
+	vkcv::DescriptorSetHandle descriptorSet = core.createDescriptorSet(setLayoutHandle);
 
 	const vkcv::PipelineConfig firstMeshPipelineConfig {
         firstMeshProgram,
@@ -115,7 +122,7 @@ int main(int argc, const char** argv) {
         UINT32_MAX,
         firstMeshPass,
         {firstMeshLayout},
-		{ core.getDescriptorSet(descriptorSet).layout },
+		{ core.getDescriptorSetLayout(setLayoutHandle).vulkanHandle },
 		true
 	};
 	vkcv::PipelineHandle firstMeshPipeline = core.createGraphicsPipeline(firstMeshPipelineConfig);

projects/first_scene/src/main.cpp

@@ -84,15 +84,15 @@ int main(int argc, const char** argv) {
 	
 	const auto& material0 = scene.getMaterial(0);
 
-	const vkcv::PipelineConfig scenePipelineDefsinition{
+	const vkcv::PipelineConfig scenePipelineDefinition{
 		sceneShaderProgram,
 		UINT32_MAX,
 		UINT32_MAX,
 		scenePass,
 		{sceneLayout},
-		{ core.getDescriptorSet(material0.getDescriptorSet()).layout },
+		{ core.getDescriptorSetLayout(material0.getDescriptorSetLayout()).vulkanHandle },
 		true };
-	vkcv::PipelineHandle scenePipeline = core.createGraphicsPipeline(scenePipelineDefsinition);
+	vkcv::PipelineHandle scenePipeline = core.createGraphicsPipeline(scenePipelineDefinition);
 	
 	if (!scenePipeline) {
 		std::cout << "Error. Could not create graphics pipeline. Exiting." << std::endl;

projects/indirect_dispatch/src/AppSetup.cpp

@@ -122,12 +122,14 @@ bool loadGraphicPass(
 
 	const auto descriptorBindings = shaderProgram.getReflectedDescriptors();
 	const bool hasDescriptor = descriptorBindings.size() > 0;
+	std::vector<vk::DescriptorSetLayout> descriptorSetLayouts = {};
 	if (hasDescriptor)
-		outPassHandles->descriptorSet = core.createDescriptorSet(descriptorBindings[0]);
+	{
+	    outPassHandles->descriptorSetLayout = core.createDescriptorSetLayout(descriptorBindings.at(0));
+	    outPassHandles->descriptorSet = core.createDescriptorSet(outPassHandles->descriptorSetLayout);
+	    descriptorSetLayouts.push_back(core.getDescriptorSetLayout(outPassHandles->descriptorSetLayout).vulkanHandle);
+	}
 
-	std::vector<vk::DescriptorSetLayout> descriptorLayouts;
-	if (hasDescriptor)
-		descriptorLayouts.push_back(core.getDescriptorSet(outPassHandles->descriptorSet).layout);
 
 	vkcv::PipelineConfig pipelineConfig{
 		shaderProgram,
@@ -135,7 +137,7 @@ bool loadGraphicPass(
 		UINT32_MAX,
 		outPassHandles->renderPass,
 		{ vertexLayout },
-		descriptorLayouts,
+		descriptorSetLayouts,
 		true };
 	pipelineConfig.m_depthTest  = depthTest;
 	outPassHandles->pipeline    = core.createGraphicsPipeline(pipelineConfig);
@@ -254,11 +256,11 @@ bool loadComputePass(vkcv::Core& core, const std::filesystem::path& path, Comput
 		return false;
 	}
 
-	outComputePass->descriptorSet = core.createDescriptorSet(shaderProgram.getReflectedDescriptors()[0]);
-
+	outComputePass->descriptorSetLayout = core.createDescriptorSetLayout(shaderProgram.getReflectedDescriptors().at(0));
+	outComputePass->descriptorSet = core.createDescriptorSet(outComputePass->descriptorSetLayout);
 	outComputePass->pipeline = core.createComputePipeline(
 		shaderProgram,
-		{ core.getDescriptorSet(outComputePass->descriptorSet).layout });
+		{ core.getDescriptorSetLayout(outComputePass->descriptorSetLayout).vulkanHandle });
 
 	if (!outComputePass->pipeline) {
 		vkcv_log(vkcv::LogLevel::ERROR, "Compute shader pipeline creation failed");

projects/indirect_dispatch/src/AppSetup.hpp

@@ -8,14 +8,16 @@ struct AppRenderTargets {
 };
 
 struct GraphicPassHandles {
-	vkcv::PipelineHandle        pipeline;
-	vkcv::PassHandle            renderPass;
-	vkcv::DescriptorSetHandle   descriptorSet;
+	vkcv::PipelineHandle                pipeline;
+	vkcv::PassHandle                    renderPass;
+	vkcv::DescriptorSetLayoutHandle     descriptorSetLayout;
+	vkcv::DescriptorSetHandle           descriptorSet;
 };
 
 struct ComputePassHandles {
-	vkcv::PipelineHandle        pipeline;
-	vkcv::DescriptorSetHandle   descriptorSet;
+	vkcv::PipelineHandle                pipeline;
+	vkcv::DescriptorSetLayoutHandle     descriptorSetLayout;
+	vkcv::DescriptorSetHandle           descriptorSet;
 };
 
 struct MeshResources {

projects/mesh_shader/src/main.cpp

@@ -205,7 +205,8 @@ int main(int argc, const char** argv) {
     }
     const vkcv::VertexLayout bunnyLayout (bindings);
 
-	vkcv::DescriptorSetHandle vertexShaderDescriptorSet = core.createDescriptorSet(bunnyShaderProgram.getReflectedDescriptors()[0]);
+    vkcv::DescriptorSetLayoutHandle vertexShaderDescriptorSetLayout = core.createDescriptorSetLayout(bunnyShaderProgram.getReflectedDescriptors().at(0));
+    vkcv::DescriptorSetHandle vertexShaderDescriptorSet = core.createDescriptorSet(vertexShaderDescriptorSetLayout);
 
 	const vkcv::PipelineConfig bunnyPipelineDefinition {
 			bunnyShaderProgram,
@@ -213,7 +214,7 @@ int main(int argc, const char** argv) {
 			(uint32_t)windowHeight,
 			renderPass,
 			{ bunnyLayout },
-			{ core.getDescriptorSet(vertexShaderDescriptorSet).layout },
+			{ core.getDescriptorSetLayout(vertexShaderDescriptorSetLayout).vulkanHandle },
 			false
 	};
 
@@ -253,8 +254,8 @@ int main(int argc, const char** argv) {
 		meshShaderProgram.addShader(shaderStage, path);
 	});
 
-	uint32_t setID = 0;
-	vkcv::DescriptorSetHandle meshShaderDescriptorSet = core.createDescriptorSet( meshShaderProgram.getReflectedDescriptors()[setID]);
+	vkcv::DescriptorSetLayoutHandle meshShaderDescriptorSetLayout = core.createDescriptorSetLayout(meshShaderProgram.getReflectedDescriptors().at(0));
+	vkcv::DescriptorSetHandle meshShaderDescriptorSet = core.createDescriptorSet(meshShaderDescriptorSetLayout);
 	const vkcv::VertexLayout meshShaderLayout(bindings);
 
 	const vkcv::PipelineConfig meshShaderPipelineDefinition{
@@ -263,7 +264,7 @@ int main(int argc, const char** argv) {
 		(uint32_t)windowHeight,
 		renderPass,
 		{meshShaderLayout},
-		{core.getDescriptorSet(meshShaderDescriptorSet).layout},
+		{core.getDescriptorSetLayout(meshShaderDescriptorSetLayout).vulkanHandle},
 		false
 	};
 

projects/particle_simulation/src/BloomAndFlares.cpp

@@ -30,11 +30,14 @@ BloomAndFlares::BloomAndFlares(
                      });
     for(uint32_t mipLevel = 0; mipLevel < m_Blur.getMipCount(); mipLevel++)
     {
+        m_DownsampleDescSetLayouts.push_back(
+                p_Core->createDescriptorSetLayout(dsProg.getReflectedDescriptors().at(0)));
+
 		m_DownsampleDescSets.push_back(
-                p_Core->createDescriptorSet(dsProg.getReflectedDescriptors()[0]));
+		        p_Core->createDescriptorSet(m_DownsampleDescSetLayouts.back()));
     }
     m_DownsamplePipe = p_Core->createComputePipeline(
-            dsProg, { p_Core->getDescriptorSet(m_DownsampleDescSets[0]).layout });
+            dsProg, { p_Core->getDescriptorSetLayout(m_DownsampleDescSetLayouts[0]).vulkanHandle });
 
     // UPSAMPLE
     vkcv::ShaderProgram usProg;
@@ -46,11 +49,13 @@ BloomAndFlares::BloomAndFlares(
                      });
     for(uint32_t mipLevel = 0; mipLevel < m_Blur.getMipCount(); mipLevel++)
     {
+        m_UpsampleDescSetLayouts.push_back(
+                p_Core->createDescriptorSetLayout(usProg.getReflectedDescriptors().at(0)));
         m_UpsampleDescSets.push_back(
-                p_Core->createDescriptorSet(usProg.getReflectedDescriptors()[0]));
+                p_Core->createDescriptorSet(m_UpsampleDescSetLayouts.back()));
     }
     m_UpsamplePipe = p_Core->createComputePipeline(
-            usProg, { p_Core->getDescriptorSet(m_UpsampleDescSets[0]).layout });
+            usProg, { p_Core->getDescriptorSetLayout(m_UpsampleDescSetLayouts[0]).vulkanHandle });
 
     // LENS FEATURES
     vkcv::ShaderProgram lensProg;
@@ -60,9 +65,10 @@ BloomAndFlares::BloomAndFlares(
                      {
                          lensProg.addShader(shaderStage, path);
                      });
-    m_LensFlareDescSet = p_Core->createDescriptorSet(lensProg.getReflectedDescriptors()[0]);
+    m_LensFlareDescSetLayout = p_Core->createDescriptorSetLayout(lensProg.getReflectedDescriptors().at(0));
+    m_LensFlareDescSet = p_Core->createDescriptorSet(m_LensFlareDescSetLayout);
     m_LensFlarePipe = p_Core->createComputePipeline(
-            lensProg, { p_Core->getDescriptorSet(m_LensFlareDescSet).layout });
+            lensProg, { p_Core->getDescriptorSetLayout(m_LensFlareDescSetLayout).vulkanHandle });
 
     // COMPOSITE
     vkcv::ShaderProgram compProg;
@@ -72,9 +78,10 @@ BloomAndFlares::BloomAndFlares(
                      {
                          compProg.addShader(shaderStage, path);
                      });
-    m_CompositeDescSet = p_Core->createDescriptorSet(compProg.getReflectedDescriptors()[0]);
+    m_CompositeDescSetLayout = p_Core->createDescriptorSetLayout(compProg.getReflectedDescriptors().at(0));
+    m_CompositeDescSet = p_Core->createDescriptorSet(m_CompositeDescSetLayout);
     m_CompositePipe = p_Core->createComputePipeline(
-            compProg, { p_Core->getDescriptorSet(m_CompositeDescSet).layout });
+            compProg, { p_Core->getDescriptorSetLayout(m_CompositeDescSetLayout).vulkanHandle });
 }
 
 void BloomAndFlares::execDownsamplePipe(const vkcv::CommandStreamHandle &cmdStream,

projects/particle_simulation/src/BloomAndFlares.hpp

@@ -25,17 +25,21 @@ private:
     vkcv::Image m_LensFeatures;
 
 
-    vkcv::PipelineHandle                     m_DownsamplePipe;
-    std::vector<vkcv::DescriptorSetHandle>   m_DownsampleDescSets; // per mip desc set
+    vkcv::PipelineHandle                            m_DownsamplePipe;
+    std::vector<vkcv::DescriptorSetLayoutHandle>    m_DownsampleDescSetLayouts;
+    std::vector<vkcv::DescriptorSetHandle>          m_DownsampleDescSets; // per mip desc set
 
-    vkcv::PipelineHandle                     m_UpsamplePipe;
-    std::vector<vkcv::DescriptorSetHandle>   m_UpsampleDescSets;   // per mip desc set
+    vkcv::PipelineHandle                            m_UpsamplePipe;
+    std::vector<vkcv::DescriptorSetLayoutHandle>    m_UpsampleDescSetLayouts;
+    std::vector<vkcv::DescriptorSetHandle>          m_UpsampleDescSets;   // per mip desc set
 
-    vkcv::PipelineHandle                     m_LensFlarePipe;
-    vkcv::DescriptorSetHandle                m_LensFlareDescSet;
+    vkcv::PipelineHandle                            m_LensFlarePipe;
+    vkcv::DescriptorSetLayoutHandle                 m_LensFlareDescSetLayout;
+    vkcv::DescriptorSetHandle                       m_LensFlareDescSet;
 
-    vkcv::PipelineHandle                     m_CompositePipe;
-    vkcv::DescriptorSetHandle                m_CompositeDescSet;
+    vkcv::PipelineHandle                            m_CompositePipe;
+    vkcv::DescriptorSetLayoutHandle                 m_CompositeDescSetLayout;
+    vkcv::DescriptorSetHandle                       m_CompositeDescSet;
 
     void execDownsamplePipe(const vkcv::CommandStreamHandle &cmdStream, const vkcv::ImageHandle &colorAttachment);
     void execUpsamplePipe(const vkcv::CommandStreamHandle &cmdStream);

projects/particle_simulation/src/main.cpp

@@ -82,7 +82,8 @@ int main(int argc, const char **argv) {
         computeShaderProgram.addShader(shaderStage, path);
     });
 
-    vkcv::DescriptorSetHandle computeDescriptorSet = core.createDescriptorSet(computeShaderProgram.getReflectedDescriptors()[0]);
+    vkcv::DescriptorSetLayoutHandle computeDescriptorSetLayout = core.createDescriptorSetLayout(computeShaderProgram.getReflectedDescriptors().at(0));
+    vkcv::DescriptorSetHandle computeDescriptorSet = core.createDescriptorSet(computeDescriptorSetLayout);
 
     const std::vector<vkcv::VertexAttachment> computeVertexAttachments = computeShaderProgram.getVertexAttachments();
 
@@ -100,8 +101,9 @@ int main(int argc, const char **argv) {
         particleShaderProgram.addShader(shaderStage, path);
     });
 
-    vkcv::DescriptorSetHandle descriptorSet = core.createDescriptorSet(
-            particleShaderProgram.getReflectedDescriptors()[0]);
+    vkcv::DescriptorSetLayoutHandle descriptorSetLayout = core.createDescriptorSetLayout(
+            particleShaderProgram.getReflectedDescriptors().at(0));
+    vkcv::DescriptorSetHandle descriptorSet = core.createDescriptorSet(descriptorSetLayout);
 
     vkcv::Buffer<glm::vec3> vertexBuffer = core.createBuffer<glm::vec3>(
             vkcv::BufferType::VERTEX,
@@ -125,7 +127,7 @@ int main(int argc, const char **argv) {
             UINT32_MAX,
             particlePass,
             {particleLayout},
-            {core.getDescriptorSet(descriptorSet).layout},
+            {core.getDescriptorSetLayout(descriptorSetLayout).vulkanHandle},
             true};
     particlePipelineDefinition.m_blendMode = vkcv::BlendMode::Additive;
 
@@ -137,7 +139,7 @@ int main(int argc, const char **argv) {
 
     vkcv::PipelineHandle particlePipeline = core.createGraphicsPipeline(particlePipelineDefinition);
 
-    vkcv::PipelineHandle computePipeline = core.createComputePipeline(computeShaderProgram, {core.getDescriptorSet(computeDescriptorSet).layout} );
+    vkcv::PipelineHandle computePipeline = core.createComputePipeline(computeShaderProgram, {core.getDescriptorSetLayout(computeDescriptorSetLayout).vulkanHandle} );
 
     vkcv::Buffer<glm::vec4> color = core.createBuffer<glm::vec4>(
             vkcv::BufferType::UNIFORM,
@@ -227,10 +229,11 @@ int main(int argc, const char **argv) {
         tonemappingShader.addShader(shaderStage, path);
     });
 
-    vkcv::DescriptorSetHandle tonemappingDescriptor = core.createDescriptorSet(tonemappingShader.getReflectedDescriptors()[0]);
+    vkcv::DescriptorSetLayoutHandle tonemappingDescriptorLayout = core.createDescriptorSetLayout(tonemappingShader.getReflectedDescriptors().at(0));
+    vkcv::DescriptorSetHandle tonemappingDescriptor = core.createDescriptorSet(tonemappingDescriptorLayout);
     vkcv::PipelineHandle tonemappingPipe = core.createComputePipeline(
         tonemappingShader, 
-        { core.getDescriptorSet(tonemappingDescriptor).layout });
+        { core.getDescriptorSetLayout(tonemappingDescriptorLayout).vulkanHandle });
 
     std::uniform_real_distribution<float> rdm = std::uniform_real_distribution<float>(0.95f, 1.05f);
     std::default_random_engine rdmEngine;

projects/voxelization/src/BloomAndFlares.cpp

@@ -44,11 +44,13 @@ BloomAndFlares::BloomAndFlares(
                      });
     for(uint32_t mipLevel = 0; mipLevel < m_Blur.getMipCount(); mipLevel++)
     {
-		m_DownsampleDescSets.push_back(
-                p_Core->createDescriptorSet(dsProg.getReflectedDescriptors()[0]));
+        m_DownsampleDescSetLayouts.push_back(
+                p_Core->createDescriptorSetLayout(dsProg.getReflectedDescriptors().at(0))
+                );
+        m_DownsampleDescSets.push_back(p_Core->createDescriptorSet(m_DownsampleDescSetLayouts.back()));
     }
     m_DownsamplePipe = p_Core->createComputePipeline(
-            dsProg, { p_Core->getDescriptorSet(m_DownsampleDescSets[0]).layout });
+            dsProg, { p_Core->getDescriptorSetLayout(m_DownsampleDescSetLayouts[0]).vulkanHandle });
 
     // UPSAMPLE
     vkcv::ShaderProgram usProg;
@@ -60,16 +62,20 @@ BloomAndFlares::BloomAndFlares(
                      });
     for(uint32_t mipLevel = 0; mipLevel < m_Blur.getMipCount(); mipLevel++)
     {
+        m_UpsampleDescSetLayouts.push_back(
+                p_Core->createDescriptorSetLayout(usProg.getReflectedDescriptors().at(0)));
         m_UpsampleDescSets.push_back(
-                p_Core->createDescriptorSet(usProg.getReflectedDescriptors()[0]));
+                p_Core->createDescriptorSet(m_UpsampleDescSetLayouts.back()));
     }
     for (uint32_t mipLevel = 0; mipLevel < m_LensFeatures.getMipCount(); mipLevel++) {
+        m_UpsampleLensFlareDescSetLayouts.push_back(
+                p_Core->createDescriptorSetLayout(usProg.getReflectedDescriptors().at(0)));
         m_UpsampleLensFlareDescSets.push_back(
-            p_Core->createDescriptorSet(usProg.getReflectedDescriptors()[0]));
+                p_Core->createDescriptorSet(m_UpsampleLensFlareDescSetLayouts.back()));
     }
 
     m_UpsamplePipe = p_Core->createComputePipeline(
-            usProg, { p_Core->getDescriptorSet(m_UpsampleDescSets[0]).layout });
+            usProg, { p_Core->getDescriptorSetLayout(m_UpsampleDescSetLayouts[0]).vulkanHandle });
 
     // LENS FEATURES
     vkcv::ShaderProgram lensProg;
@@ -79,9 +85,10 @@ BloomAndFlares::BloomAndFlares(
                      {
                          lensProg.addShader(shaderStage, path);
                      });
-    m_LensFlareDescSet = p_Core->createDescriptorSet(lensProg.getReflectedDescriptors()[0]);
+    m_LensFlareDescSetLayout = p_Core->createDescriptorSetLayout(lensProg.getReflectedDescriptors().at(0));
+    m_LensFlareDescSet = p_Core->createDescriptorSet(m_LensFlareDescSetLayout);
     m_LensFlarePipe = p_Core->createComputePipeline(
-            lensProg, { p_Core->getDescriptorSet(m_LensFlareDescSet).layout });
+            lensProg, { p_Core->getDescriptorSetLayout(m_LensFlareDescSetLayout).vulkanHandle });
 
     // COMPOSITE
     vkcv::ShaderProgram compProg;
@@ -91,9 +98,11 @@ BloomAndFlares::BloomAndFlares(
                      {
                          compProg.addShader(shaderStage, path);
                      });
-    m_CompositeDescSet = p_Core->createDescriptorSet(compProg.getReflectedDescriptors()[0]);
+
+    m_CompositeDescSetLayout = p_Core->createDescriptorSetLayout(compProg.getReflectedDescriptors().at(0));
+    m_CompositeDescSet = p_Core->createDescriptorSet(m_CompositeDescSetLayout);
     m_CompositePipe = p_Core->createComputePipeline(
-            compProg, { p_Core->getDescriptorSet(m_CompositeDescSet).layout });
+            compProg, { p_Core->getDescriptorSetLayout(m_CompositeDescSetLayout).vulkanHandle });
 
     // radial LUT
     const auto texture = vkcv::asset::loadTexture("resources/RadialLUT.png");

projects/voxelization/src/BloomAndFlares.hpp

@@ -29,18 +29,24 @@ private:
     vkcv::Image m_radialLut;
     vkcv::Image m_lensDirt;
 
-    vkcv::PipelineHandle                     m_DownsamplePipe;
-    std::vector<vkcv::DescriptorSetHandle>   m_DownsampleDescSets; // per mip desc set
-    std::vector<vkcv::DescriptorSetHandle>   m_UpsampleLensFlareDescSets; // per mip desc set
+    vkcv::PipelineHandle                            m_DownsamplePipe;
+    std::vector<vkcv::DescriptorSetLayoutHandle>    m_DownsampleDescSetLayouts;
+    std::vector<vkcv::DescriptorSetHandle>          m_DownsampleDescSets; // per mip desc set
 
-    vkcv::PipelineHandle                     m_UpsamplePipe;
-    std::vector<vkcv::DescriptorSetHandle>   m_UpsampleDescSets;   // per mip desc set
+    std::vector<vkcv::DescriptorSetLayoutHandle>    m_UpsampleLensFlareDescSetLayouts;
+    std::vector<vkcv::DescriptorSetHandle>          m_UpsampleLensFlareDescSets; // per mip desc set
 
-    vkcv::PipelineHandle                     m_LensFlarePipe;
-    vkcv::DescriptorSetHandle                m_LensFlareDescSet;
+    vkcv::PipelineHandle                            m_UpsamplePipe;
+    std::vector<vkcv::DescriptorSetLayoutHandle>    m_UpsampleDescSetLayouts;
+    std::vector<vkcv::DescriptorSetHandle>          m_UpsampleDescSets;   // per mip desc set
 
-    vkcv::PipelineHandle                     m_CompositePipe;
-    vkcv::DescriptorSetHandle                m_CompositeDescSet;
+    vkcv::PipelineHandle                            m_LensFlarePipe;
+    vkcv::DescriptorSetLayoutHandle                 m_LensFlareDescSetLayout;
+    vkcv::DescriptorSetHandle                       m_LensFlareDescSet;
+
+    vkcv::PipelineHandle                            m_CompositePipe;
+    vkcv::DescriptorSetLayoutHandle                 m_CompositeDescSetLayout;
+    vkcv::DescriptorSetHandle                       m_CompositeDescSet;
 
     void execDownsamplePipe(const vkcv::CommandStreamHandle &cmdStream, const vkcv::ImageHandle &colorAttachment);
     void execUpsamplePipe(const vkcv::CommandStreamHandle &cmdStream);

projects/voxelization/src/ShadowMapping.cpp

@@ -189,8 +189,9 @@ ShadowMapping::ShadowMapping(vkcv::Core* corePtr, const vkcv::VertexLayout& vert
 
 	// depth to moments
 	vkcv::ShaderProgram depthToMomentsShader    = loadDepthToMomentsShader();
-	m_depthToMomentsDescriptorSet               = corePtr->createDescriptorSet(depthToMomentsShader.getReflectedDescriptors()[0]);
-	m_depthToMomentsPipe                        = corePtr->createComputePipeline(depthToMomentsShader, { corePtr->getDescriptorSet(m_depthToMomentsDescriptorSet).layout });
+	m_depthToMomentsDescriptorSetLayout         = corePtr->createDescriptorSetLayout(depthToMomentsShader.getReflectedDescriptors().at(0));
+	m_depthToMomentsDescriptorSet               = corePtr->createDescriptorSet(m_depthToMomentsDescriptorSetLayout);
+	m_depthToMomentsPipe                        = corePtr->createComputePipeline(depthToMomentsShader, { corePtr->getDescriptorSetLayout(m_depthToMomentsDescriptorSetLayout).vulkanHandle });
 
 	vkcv::DescriptorWrites depthToMomentDescriptorWrites;
 	depthToMomentDescriptorWrites.sampledImageWrites    = { vkcv::SampledImageDescriptorWrite(0, m_shadowMapDepth.getHandle()) };
@@ -199,9 +200,10 @@ ShadowMapping::ShadowMapping(vkcv::Core* corePtr, const vkcv::VertexLayout& vert
 	corePtr->writeDescriptorSet(m_depthToMomentsDescriptorSet, depthToMomentDescriptorWrites);
 
 	// shadow blur X
-	vkcv::ShaderProgram shadowBlurXShader    = loadShadowBlurXShader();
-	m_shadowBlurXDescriptorSet              = corePtr->createDescriptorSet(shadowBlurXShader.getReflectedDescriptors()[0]);
-	m_shadowBlurXPipe                       = corePtr->createComputePipeline(shadowBlurXShader, { corePtr->getDescriptorSet(m_shadowBlurXDescriptorSet).layout });
+	vkcv::ShaderProgram shadowBlurXShader   = loadShadowBlurXShader();
+	m_shadowBlurXDescriptorSetLayout        = corePtr->createDescriptorSetLayout(shadowBlurXShader.getReflectedDescriptors().at(0));
+	m_shadowBlurXDescriptorSet              = corePtr->createDescriptorSet(m_shadowBlurXDescriptorSetLayout);
+	m_shadowBlurXPipe                       = corePtr->createComputePipeline(shadowBlurXShader, { corePtr->getDescriptorSetLayout(m_shadowBlurXDescriptorSetLayout).vulkanHandle });
 
 	vkcv::DescriptorWrites shadowBlurXDescriptorWrites;
 	shadowBlurXDescriptorWrites.sampledImageWrites   = { vkcv::SampledImageDescriptorWrite(0, m_shadowMap.getHandle()) };
@@ -210,9 +212,10 @@ ShadowMapping::ShadowMapping(vkcv::Core* corePtr, const vkcv::VertexLayout& vert
 	corePtr->writeDescriptorSet(m_shadowBlurXDescriptorSet, shadowBlurXDescriptorWrites);
 
 	// shadow blur Y
-	vkcv::ShaderProgram shadowBlurYShader = loadShadowBlurYShader();
-	m_shadowBlurYDescriptorSet = corePtr->createDescriptorSet(shadowBlurYShader.getReflectedDescriptors()[0]);
-	m_shadowBlurYPipe = corePtr->createComputePipeline(shadowBlurYShader, { corePtr->getDescriptorSet(m_shadowBlurYDescriptorSet).layout });
+	vkcv::ShaderProgram shadowBlurYShader   = loadShadowBlurYShader();
+	m_shadowBlurYDescriptorSetLayout        = corePtr->createDescriptorSetLayout(shadowBlurYShader.getReflectedDescriptors().at(0));
+	m_shadowBlurYDescriptorSet              = corePtr->createDescriptorSet(m_shadowBlurYDescriptorSetLayout);
+	m_shadowBlurYPipe                       = corePtr->createComputePipeline(shadowBlurYShader, { corePtr->getDescriptorSetLayout(m_shadowBlurYDescriptorSetLayout).vulkanHandle });
 
 	vkcv::DescriptorWrites shadowBlurYDescriptorWrites;
 	shadowBlurYDescriptorWrites.sampledImageWrites  = { vkcv::SampledImageDescriptorWrite(0, m_shadowMapIntermediate.getHandle()) };

projects/voxelization/src/ShadowMapping.hpp

@@ -36,21 +36,24 @@ public:
 private:
 	vkcv::Core* m_corePtr;
 
-	vkcv::Image                 m_shadowMap;
-	vkcv::Image                 m_shadowMapIntermediate;
-	vkcv::Image                 m_shadowMapDepth;
-	vkcv::SamplerHandle         m_shadowSampler;
-	vkcv::Buffer<LightInfo>     m_lightInfoBuffer;
-
-	vkcv::PassHandle            m_shadowMapPass;
-	vkcv::PipelineHandle        m_shadowMapPipe;
-
-	vkcv::PipelineHandle        m_depthToMomentsPipe;
-	vkcv::DescriptorSetHandle   m_depthToMomentsDescriptorSet;
-
-	vkcv::PipelineHandle        m_shadowBlurXPipe;
-	vkcv::DescriptorSetHandle   m_shadowBlurXDescriptorSet;
-
-	vkcv::PipelineHandle        m_shadowBlurYPipe;
-	vkcv::DescriptorSetHandle   m_shadowBlurYDescriptorSet;
+	vkcv::Image                         m_shadowMap;
+	vkcv::Image                         m_shadowMapIntermediate;
+	vkcv::Image                         m_shadowMapDepth;
+	vkcv::SamplerHandle                 m_shadowSampler;
+	vkcv::Buffer<LightInfo>             m_lightInfoBuffer;
+
+	vkcv::PassHandle                    m_shadowMapPass;
+	vkcv::PipelineHandle                m_shadowMapPipe;
+
+	vkcv::PipelineHandle                m_depthToMomentsPipe;
+	vkcv::DescriptorSetLayoutHandle     m_depthToMomentsDescriptorSetLayout;
+	vkcv::DescriptorSetHandle           m_depthToMomentsDescriptorSet;
+
+	vkcv::PipelineHandle                m_shadowBlurXPipe;
+	vkcv::DescriptorSetLayoutHandle     m_shadowBlurXDescriptorSetLayout;
+	vkcv::DescriptorSetHandle           m_shadowBlurXDescriptorSet;
+
+	vkcv::PipelineHandle                m_shadowBlurYPipe;
+	vkcv::DescriptorSetLayoutHandle     m_shadowBlurYDescriptorSetLayout;
+	vkcv::DescriptorSetHandle           m_shadowBlurYDescriptorSet;
 };
\ No newline at end of file