From 0dce525d8ea2ee85b090b849befff84067453ffe Mon Sep 17 00:00:00 2001
From: Artur Wasmut <awasmut@uni-koblenz.de>
Date: Tue, 24 Aug 2021 12:40:48 +0200
Subject: [PATCH] Revert "[#76] WIP: use vk::ShaderStageFlagBits to allow
 descriptors to use multiple shader stages."

This reverts commit 7fae0111cc6944508aad31cbec9fb76a24e50d75.
---
 config/Sources.cmake                          |   2 +
 include/vkcv/Core.hpp                         |   9 +-
 include/vkcv/DescriptorConfig.hpp             |  17 +-
 include/vkcv/ShaderProgram.hpp                |  25 +-
 include/vkcv/ShaderStage.hpp                  |  38 +++
 .../include/vkcv/material/PBRMaterial.hpp     |   2 +-
 .../src/vkcv/material/PBRMaterial.cpp         |  26 +-
 .../include/vkcv/shader/Compiler.hpp          |   4 +-
 .../include/vkcv/shader/GLSLCompiler.hpp      |   5 +-
 .../src/vkcv/shader/GLSLCompiler.cpp          |  16 +-
 projects/bloom/src/BloomAndFlares.cpp         |  24 +-
 projects/bloom/src/main.cpp                   |  26 +-
 projects/first_mesh/src/main.cpp              |   8 +-
 projects/first_scene/src/main.cpp             |   8 +-
 projects/first_triangle/src/main.cpp          |  12 +-
 .../src/BloomAndFlares.cpp                    |  24 +-
 projects/particle_simulation/src/main.cpp     |  14 +-
 projects/voxelization/src/BloomAndFlares.cpp  |  26 +-
 projects/voxelization/src/ShadowMapping.cpp   |  26 +-
 projects/voxelization/src/Voxelization.cpp    |  52 ++--
 projects/voxelization/src/main.cpp            |  54 ++---
 src/vkcv/Core.cpp                             |   2 +-
 src/vkcv/DescriptorConfig.cpp                 |   2 +-
 src/vkcv/DescriptorManager.cpp                |  14 +-
 src/vkcv/DescriptorManager.hpp                |   4 +-
 src/vkcv/PipelineManager.cpp                  |  16 +-
 src/vkcv/PipelineManager.hpp                  |   2 +-
 src/vkcv/ShaderProgram.cpp                    | 223 +++++-------------
 28 files changed, 303 insertions(+), 378 deletions(-)
 create mode 100644 include/vkcv/ShaderStage.hpp

diff --git a/config/Sources.cmake b/config/Sources.cmake
index a8b7eb7a..54bb3485 100644
--- a/config/Sources.cmake
+++ b/config/Sources.cmake
@@ -35,6 +35,8 @@ set(vkcv_sources
 		${vkcv_include}/vkcv/Swapchain.hpp
 		${vkcv_source}/vkcv/Swapchain.cpp
 		
+		${vkcv_include}/vkcv/ShaderStage.hpp
+		
 		${vkcv_include}/vkcv/ShaderProgram.hpp
 		${vkcv_source}/vkcv/ShaderProgram.cpp
 
diff --git a/include/vkcv/Core.hpp b/include/vkcv/Core.hpp
index d865b061..cbbe1e90 100644
--- a/include/vkcv/Core.hpp
+++ b/include/vkcv/Core.hpp
@@ -227,13 +227,12 @@ namespace vkcv
         [[nodiscard]]
         const uint32_t getImageHeight(ImageHandle imageHandle);
 
-        /**
-         * Creates a descriptor set from the given bindings
-         * @param bindings an unordered map of descriptor bindings
-         * @return descriptor set handle
+        /** TODO:
+         *   @param setDescriptions
+         *   @return
          */
         [[nodiscard]]
-        DescriptorSetHandle createDescriptorSet(const std::unordered_map<uint32_t, DescriptorBinding> &bindings);
+        DescriptorSetHandle createDescriptorSet(const std::vector<DescriptorBinding> &bindings);
 		void writeDescriptorSet(DescriptorSetHandle handle, const DescriptorWrites& writes);
 
 		DescriptorSet getDescriptorSet(const DescriptorSetHandle handle) const;
diff --git a/include/vkcv/DescriptorConfig.hpp b/include/vkcv/DescriptorConfig.hpp
index f34c6707..78e111f4 100644
--- a/include/vkcv/DescriptorConfig.hpp
+++ b/include/vkcv/DescriptorConfig.hpp
@@ -3,6 +3,7 @@
 #include <vulkan/vulkan.hpp>
 
 #include "vkcv/Handles.hpp"
+#include "vkcv/ShaderStage.hpp"
 
 namespace vkcv
 {
@@ -34,15 +35,15 @@ namespace vkcv
     struct DescriptorBinding
     {
         DescriptorBinding(
-            uint32_t             bindingID,
-            DescriptorType       descriptorType,
-            uint32_t             descriptorCount,
-            vk::ShaderStageFlags shaderStages
+            uint32_t bindingID,
+            DescriptorType descriptorType,
+            uint32_t descriptorCount,
+            ShaderStages shaderStages
         ) noexcept;
         
-        uint32_t                bindingID;
-        DescriptorType          descriptorType;
-        uint32_t                descriptorCount;
-        vk::ShaderStageFlags    shaderStages;
+        uint32_t bindingID;
+        DescriptorType descriptorType;
+        uint32_t descriptorCount;
+        ShaderStages shaderStages;
     };
 }
diff --git a/include/vkcv/ShaderProgram.hpp b/include/vkcv/ShaderProgram.hpp
index e4d995b3..c7d67b19 100644
--- a/include/vkcv/ShaderProgram.hpp
+++ b/include/vkcv/ShaderProgram.hpp
@@ -14,13 +14,14 @@
 #include <spirv_cross.hpp>
 #include "VertexLayout.hpp"
 #include "DescriptorConfig.hpp"
+#include "ShaderStage.hpp"
 
 namespace vkcv {
 
     struct Shader
     {
         std::vector<char> shaderCode;
-        vk::ShaderStageFlags shaderStage;
+        ShaderStage shaderStage;
     };
 
 	class ShaderProgram
@@ -36,21 +37,21 @@ namespace vkcv {
         * @param[in] flag that signals the respective shaderStage (e.g. VK_SHADER_STAGE_VERTEX_BIT)
         * @param[in] relative path to the shader code (e.g. "../../../../../shaders/vert.spv")
         */
-        bool addShader(vk::ShaderStageFlagBits shaderStage, const std::filesystem::path &shaderPath);
+        bool addShader(ShaderStage shaderStage, const std::filesystem::path &shaderPath);
 
         /**
         * Returns the shader program's shader of the specified shader.
         * Needed for the transfer to the pipeline.
         * @return Shader object consisting of buffer with shader code and shader stage enum
         */
-        const Shader &getShader(vk::ShaderStageFlagBits shaderStage) const;
+        const Shader &getShader(ShaderStage shaderStage) const;
 
-        bool existsShader(vk::ShaderStageFlagBits shaderStage) const;
+        bool existsShader(ShaderStage shaderStage) const;
 
         const std::vector<VertexAttachment> &getVertexAttachments() const;
 		size_t getPushConstantSize() const;
 
-        const std::unordered_map<uint32_t, std::unordered_map<uint32_t, DescriptorBinding>>& getReflectedDescriptors() const;
+        const std::vector<std::vector<DescriptorBinding>>& getReflectedDescriptors() const;
 
 	private:
 	    /**
@@ -58,21 +59,13 @@ namespace vkcv {
 	     * Fills vertex input attachments and descriptor sets (if present).
 	     * @param shaderStage the stage to reflect data from
 	     */
-        void reflectShader(vk::ShaderStageFlagBits shaderStage);
+        void reflectShader(ShaderStage shaderStage);
 
-        std::unordered_map<vk::ShaderStageFlagBits, Shader> m_Shaders;
+        std::unordered_map<ShaderStage, Shader> m_Shaders;
 
         // contains all vertex input attachments used in the vertex buffer
         std::vector<VertexAttachment> m_VertexAttachments;
-
-        /**
-         * Map of map structure
-         * First Key: Set ID, return an unordered map to the corresponding set's bindings
-         * Second Key: Binding ID, returns the actual descriptor binding description
-         * Value: descriptor binding description
-         */
-        std::unordered_map<uint32_t, std::unordered_map<uint32_t, DescriptorBinding>> m_DescriptorSets;
-
+        std::vector<std::vector<DescriptorBinding>> m_DescriptorSets;
 		size_t m_pushConstantSize = 0;
 	};
 }
diff --git a/include/vkcv/ShaderStage.hpp b/include/vkcv/ShaderStage.hpp
new file mode 100644
index 00000000..d671b87b
--- /dev/null
+++ b/include/vkcv/ShaderStage.hpp
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <vulkan/vulkan.hpp>
+
+namespace vkcv {
+	
+	enum class ShaderStage : VkShaderStageFlags {
+		VERTEX = static_cast<VkShaderStageFlags>(vk::ShaderStageFlagBits::eVertex),
+		TESS_CONTROL = static_cast<VkShaderStageFlags>(vk::ShaderStageFlagBits::eTessellationControl),
+		TESS_EVAL = static_cast<VkShaderStageFlags>(vk::ShaderStageFlagBits::eTessellationEvaluation),
+		GEOMETRY = static_cast<VkShaderStageFlags>(vk::ShaderStageFlagBits::eGeometry),
+		FRAGMENT = static_cast<VkShaderStageFlags>(vk::ShaderStageFlagBits::eFragment),
+		COMPUTE = static_cast<VkShaderStageFlags>(vk::ShaderStageFlagBits::eCompute)
+	};
+	
+	using ShaderStages = vk::Flags<ShaderStage>;
+	
+	constexpr vk::ShaderStageFlags getShaderStageFlags(ShaderStages shaderStages) noexcept {
+		return vk::ShaderStageFlags(static_cast<VkShaderStageFlags>(shaderStages));
+	}
+	
+	constexpr ShaderStages operator|(ShaderStage stage0, ShaderStage stage1) noexcept {
+		return ShaderStages(stage0) | stage1;
+	}
+	
+	constexpr ShaderStages operator&(ShaderStage stage0, ShaderStage stage1) noexcept {
+		return ShaderStages(stage0) & stage1;
+	}
+	
+	constexpr ShaderStages operator^(ShaderStage stage0, ShaderStage stage1) noexcept {
+		return ShaderStages(stage0) ^ stage1;
+	}
+	
+	constexpr ShaderStages operator~(ShaderStage stage) noexcept {
+		return ~(ShaderStages(stage));
+	}
+	
+}
diff --git a/modules/material/include/vkcv/material/PBRMaterial.hpp b/modules/material/include/vkcv/material/PBRMaterial.hpp
index 48d456d6..09a5214b 100644
--- a/modules/material/include/vkcv/material/PBRMaterial.hpp
+++ b/modules/material/include/vkcv/material/PBRMaterial.hpp
@@ -78,7 +78,7 @@ namespace vkcv::material
         * 8 - emissive texture
         * 9 - emissive sampler
         */
-        static std::unordered_map<uint32_t, DescriptorBinding> getDescriptorBindings() noexcept;
+        static std::vector<DescriptorBinding> getDescriptorBindings() noexcept;
 
         static PBRMaterial create(
             vkcv::Core* core,
diff --git a/modules/material/src/vkcv/material/PBRMaterial.cpp b/modules/material/src/vkcv/material/PBRMaterial.cpp
index 9d86f4f1..d27e755c 100644
--- a/modules/material/src/vkcv/material/PBRMaterial.cpp
+++ b/modules/material/src/vkcv/material/PBRMaterial.cpp
@@ -41,21 +41,21 @@ namespace vkcv::material
     {
     }
 
-    std::unordered_map<uint32_t, DescriptorBinding> PBRMaterial::getDescriptorBindings() noexcept
+    std::vector<DescriptorBinding> PBRMaterial::getDescriptorBindings() noexcept
     {
-		static std::unordered_map<uint32_t, DescriptorBinding> bindings;
-
+		static std::vector<DescriptorBinding> bindings;
+		
 		if (bindings.empty()) {
-			bindings.insert(std::make_pair(0, DescriptorBinding(0, DescriptorType::IMAGE_SAMPLED, 1, vk::ShaderStageFlagBits::eFragment)));
-			bindings.insert(std::make_pair(1, DescriptorBinding(1, DescriptorType::SAMPLER, 1, vk::ShaderStageFlagBits::eFragment)));
-            bindings.insert(std::make_pair(2, DescriptorBinding(2, DescriptorType::IMAGE_SAMPLED, 1, vk::ShaderStageFlagBits::eFragment)));
-            bindings.insert(std::make_pair(3, DescriptorBinding(3, DescriptorType::SAMPLER, 1, vk::ShaderStageFlagBits::eFragment)));
-            bindings.insert(std::make_pair(4, DescriptorBinding(4, DescriptorType::IMAGE_SAMPLED, 1, vk::ShaderStageFlagBits::eFragment)));
-            bindings.insert(std::make_pair(5, DescriptorBinding(5, DescriptorType::SAMPLER, 1, vk::ShaderStageFlagBits::eFragment)));
-            bindings.insert(std::make_pair(6, DescriptorBinding(6, DescriptorType::IMAGE_SAMPLED, 1, vk::ShaderStageFlagBits::eFragment)));
-            bindings.insert(std::make_pair(7, DescriptorBinding(7, DescriptorType::SAMPLER, 1, vk::ShaderStageFlagBits::eFragment)));
-            bindings.insert(std::make_pair(8, DescriptorBinding(8, DescriptorType::IMAGE_SAMPLED, 1, vk::ShaderStageFlagBits::eFragment)));
-            bindings.insert(std::make_pair(9, DescriptorBinding(9, DescriptorType::SAMPLER, 1, vk::ShaderStageFlagBits::eFragment)));
+			bindings.emplace_back(0, DescriptorType::IMAGE_SAMPLED, 1, ShaderStage::FRAGMENT);
+			bindings.emplace_back(1, DescriptorType::SAMPLER, 1, ShaderStage::FRAGMENT);
+			bindings.emplace_back(2, DescriptorType::IMAGE_SAMPLED, 1, ShaderStage::FRAGMENT);
+			bindings.emplace_back(3, DescriptorType::SAMPLER, 1, ShaderStage::FRAGMENT);
+			bindings.emplace_back(4, DescriptorType::IMAGE_SAMPLED, 1, ShaderStage::FRAGMENT);
+			bindings.emplace_back(5, DescriptorType::SAMPLER, 1, ShaderStage::FRAGMENT);
+			bindings.emplace_back(6, DescriptorType::IMAGE_SAMPLED, 1, ShaderStage::FRAGMENT);
+			bindings.emplace_back(7, DescriptorType::SAMPLER, 1, ShaderStage::FRAGMENT);
+			bindings.emplace_back(8, DescriptorType::IMAGE_SAMPLED, 1, ShaderStage::FRAGMENT);
+			bindings.emplace_back(9, DescriptorType::SAMPLER, 1, ShaderStage::FRAGMENT);
 		}
     	
         return bindings;
diff --git a/modules/shader_compiler/include/vkcv/shader/Compiler.hpp b/modules/shader_compiler/include/vkcv/shader/Compiler.hpp
index 118023fc..d7b7af71 100644
--- a/modules/shader_compiler/include/vkcv/shader/Compiler.hpp
+++ b/modules/shader_compiler/include/vkcv/shader/Compiler.hpp
@@ -4,12 +4,12 @@
 
 namespace vkcv::shader {
 	
-	typedef typename event_function<vk::ShaderStageFlagBits, const std::filesystem::path&>::type ShaderCompiledFunction;
+	typedef typename event_function<ShaderStage, const std::filesystem::path&>::type ShaderCompiledFunction;
 	
 	class Compiler {
 	private:
 	public:
-		virtual void compile(vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& shaderPath,
+		virtual void compile(ShaderStage shaderStage, const std::filesystem::path& shaderPath,
 							 const ShaderCompiledFunction& compiled, bool update = false) = 0;
 		
 	};
diff --git a/modules/shader_compiler/include/vkcv/shader/GLSLCompiler.hpp b/modules/shader_compiler/include/vkcv/shader/GLSLCompiler.hpp
index bd31a80a..7105d93a 100644
--- a/modules/shader_compiler/include/vkcv/shader/GLSLCompiler.hpp
+++ b/modules/shader_compiler/include/vkcv/shader/GLSLCompiler.hpp
@@ -1,7 +1,8 @@
 #pragma once
 
 #include <filesystem>
-#include <vulkan/vulkan.hpp>
+
+#include <vkcv/ShaderStage.hpp>
 #include "Compiler.hpp"
 
 namespace vkcv::shader {
@@ -19,7 +20,7 @@ namespace vkcv::shader {
 		GLSLCompiler& operator=(const GLSLCompiler& other);
 		GLSLCompiler& operator=(GLSLCompiler&& other) = default;
 		
-		void compile(vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& shaderPath,
+		void compile(ShaderStage shaderStage, const std::filesystem::path& shaderPath,
 					 const ShaderCompiledFunction& compiled, bool update = false);
 		
 	};
diff --git a/modules/shader_compiler/src/vkcv/shader/GLSLCompiler.cpp b/modules/shader_compiler/src/vkcv/shader/GLSLCompiler.cpp
index 8d5246b5..ec358188 100644
--- a/modules/shader_compiler/src/vkcv/shader/GLSLCompiler.cpp
+++ b/modules/shader_compiler/src/vkcv/shader/GLSLCompiler.cpp
@@ -36,19 +36,19 @@ namespace vkcv::shader {
 		return *this;
 	}
 	
-	constexpr EShLanguage findShaderLanguage(vk::ShaderStageFlagBits shaderStage) {
+	constexpr EShLanguage findShaderLanguage(ShaderStage shaderStage) {
 		switch (shaderStage) {
-			case vk::ShaderStageFlagBits::eVertex:
+			case ShaderStage::VERTEX:
 				return EShLangVertex;
-			case vk::ShaderStageFlagBits::eTessellationControl:
+			case ShaderStage::TESS_CONTROL:
 				return EShLangTessControl;
-			case vk::ShaderStageFlagBits::eTessellationEvaluation:
+			case ShaderStage::TESS_EVAL:
 				return EShLangTessEvaluation;
-			case vk::ShaderStageFlagBits::eGeometry:
+			case ShaderStage::GEOMETRY:
 				return EShLangGeometry;
-			case vk::ShaderStageFlagBits::eFragment:
+			case ShaderStage::FRAGMENT:
 				return EShLangFragment;
-			case vk::ShaderStageFlagBits::eCompute:
+			case ShaderStage::COMPUTE:
 				return EShLangCompute;
 			default:
 				return EShLangCount;
@@ -197,7 +197,7 @@ namespace vkcv::shader {
 		return true;
 	}
 	
-	void GLSLCompiler::compile(vk::ShaderStageFlagBits shaderStage, const std::filesystem::path &shaderPath,
+	void GLSLCompiler::compile(ShaderStage shaderStage, const std::filesystem::path &shaderPath,
 							   const ShaderCompiledFunction& compiled, bool update) {
 		const EShLanguage language = findShaderLanguage(shaderStage);
 		
diff --git a/projects/bloom/src/BloomAndFlares.cpp b/projects/bloom/src/BloomAndFlares.cpp
index c6e27f3e..6f26db9d 100644
--- a/projects/bloom/src/BloomAndFlares.cpp
+++ b/projects/bloom/src/BloomAndFlares.cpp
@@ -22,57 +22,57 @@ BloomAndFlares::BloomAndFlares(
 
     // DOWNSAMPLE
     vkcv::ShaderProgram dsProg;
-    compiler.compile(vk::ShaderStageFlagBits::eCompute,
+    compiler.compile(vkcv::ShaderStage::COMPUTE,
                      "resources/shaders/downsample.comp",
-                     [&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path)
+                     [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path)
                      {
                          dsProg.addShader(shaderStage, path);
                      });
     for(uint32_t mipLevel = 0; mipLevel < m_Blur.getMipCount(); mipLevel++)
     {
 		m_DownsampleDescSets.push_back(
-                p_Core->createDescriptorSet(dsProg.getReflectedDescriptors().at(0)));
+                p_Core->createDescriptorSet(dsProg.getReflectedDescriptors()[0]));
     }
     m_DownsamplePipe = p_Core->createComputePipeline(
             dsProg, { p_Core->getDescriptorSet(m_DownsampleDescSets[0]).layout });
 
     // UPSAMPLE
     vkcv::ShaderProgram usProg;
-    compiler.compile(vk::ShaderStageFlagBits::eCompute,
+    compiler.compile(vkcv::ShaderStage::COMPUTE,
                      "resources/shaders/upsample.comp",
-                     [&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path)
+                     [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path)
                      {
                          usProg.addShader(shaderStage, path);
                      });
     for(uint32_t mipLevel = 0; mipLevel < m_Blur.getMipCount(); mipLevel++)
     {
         m_UpsampleDescSets.push_back(
-                p_Core->createDescriptorSet(usProg.getReflectedDescriptors().at(0)));
+                p_Core->createDescriptorSet(usProg.getReflectedDescriptors()[0]));
     }
     m_UpsamplePipe = p_Core->createComputePipeline(
             usProg, { p_Core->getDescriptorSet(m_UpsampleDescSets[0]).layout });
 
     // LENS FEATURES
     vkcv::ShaderProgram lensProg;
-    compiler.compile(vk::ShaderStageFlagBits::eCompute,
+    compiler.compile(vkcv::ShaderStage::COMPUTE,
                      "resources/shaders/lensFlares.comp",
-                     [&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path)
+                     [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path)
                      {
                          lensProg.addShader(shaderStage, path);
                      });
-    m_LensFlareDescSet = p_Core->createDescriptorSet(lensProg.getReflectedDescriptors().at(0));
+    m_LensFlareDescSet = p_Core->createDescriptorSet(lensProg.getReflectedDescriptors()[0]);
     m_LensFlarePipe = p_Core->createComputePipeline(
             lensProg, { p_Core->getDescriptorSet(m_LensFlareDescSet).layout });
 
     // COMPOSITE
     vkcv::ShaderProgram compProg;
-    compiler.compile(vk::ShaderStageFlagBits::eCompute,
+    compiler.compile(vkcv::ShaderStage::COMPUTE,
                      "resources/shaders/composite.comp",
-                     [&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path)
+                     [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path)
                      {
                          compProg.addShader(shaderStage, path);
                      });
-    m_CompositeDescSet = p_Core->createDescriptorSet(compProg.getReflectedDescriptors().at(0));
+    m_CompositeDescSet = p_Core->createDescriptorSet(compProg.getReflectedDescriptors()[0]);
     m_CompositePipe = p_Core->createComputePipeline(
             compProg, { p_Core->getDescriptorSet(m_CompositeDescSet).layout });
 }
diff --git a/projects/bloom/src/main.cpp b/projects/bloom/src/main.cpp
index 96085db7..7a17a51f 100644
--- a/projects/bloom/src/main.cpp
+++ b/projects/bloom/src/main.cpp
@@ -121,12 +121,12 @@ int main(int argc, const char** argv) {
 	vkcv::shader::GLSLCompiler compiler;
 
 	vkcv::ShaderProgram forwardProgram;
-	compiler.compile(vk::ShaderStageFlagBits::eVertex, std::filesystem::path("resources/shaders/shader.vert"),
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::VERTEX, std::filesystem::path("resources/shaders/shader.vert"), 
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		forwardProgram.addShader(shaderStage, path);
 	});
-	compiler.compile(vk::ShaderStageFlagBits::eFragment, std::filesystem::path("resources/shaders/shader.frag"),
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::FRAGMENT, std::filesystem::path("resources/shaders/shader.frag"),
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		forwardProgram.addShader(shaderStage, path);
 	});
 
@@ -159,7 +159,7 @@ int main(int argc, const char** argv) {
 	vkcv::Buffer lightBuffer = core.createBuffer<LightInfo>(vkcv::BufferType::UNIFORM, sizeof(glm::vec3));
 
 	vkcv::DescriptorSetHandle forwardShadingDescriptorSet = 
-		core.createDescriptorSet(forwardProgram.getReflectedDescriptors().at(0));
+		core.createDescriptorSet({ forwardProgram.getReflectedDescriptors()[0] });
 
 	vkcv::DescriptorWrites forwardDescriptorWrites;
 	forwardDescriptorWrites.uniformBufferWrites = { vkcv::UniformBufferDescriptorWrite(0, lightBuffer.getHandle()) };
@@ -178,7 +178,7 @@ int main(int argc, const char** argv) {
 	std::vector<vkcv::DescriptorSetHandle> perMeshDescriptorSets;
 	std::vector<vkcv::Image> sceneImages;
 	for (const auto& vertexGroup : scene.vertexGroups) {
-		perMeshDescriptorSets.push_back(core.createDescriptorSet(forwardProgram.getReflectedDescriptors().at(1)));
+		perMeshDescriptorSets.push_back(core.createDescriptorSet(forwardProgram.getReflectedDescriptors()[1]));
 
 		const auto& material = scene.materials[vertexGroup.materialIndex];
 
@@ -227,12 +227,12 @@ int main(int argc, const char** argv) {
 	const vkcv::ImageHandle swapchainInput = vkcv::ImageHandle::createSwapchainImageHandle();
 
 	vkcv::ShaderProgram shadowShader;
-	compiler.compile(vk::ShaderStageFlagBits::eVertex, "resources/shaders/shadow.vert",
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::VERTEX, "resources/shaders/shadow.vert",
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		shadowShader.addShader(shaderStage, path);
 	});
-	compiler.compile(vk::ShaderStageFlagBits::eFragment, "resources/shaders/shadow.frag",
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::FRAGMENT, "resources/shaders/shadow.frag",
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		shadowShader.addShader(shaderStage, path);
 	});
 
@@ -257,11 +257,11 @@ int main(int argc, const char** argv) {
 
 	// gamma correction compute shader
 	vkcv::ShaderProgram gammaCorrectionProgram;
-	compiler.compile(vk::ShaderStageFlagBits::eCompute, "resources/shaders/gammaCorrection.comp",
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::COMPUTE, "resources/shaders/gammaCorrection.comp",
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		gammaCorrectionProgram.addShader(shaderStage, path);
 	});
-	vkcv::DescriptorSetHandle gammaCorrectionDescriptorSet = core.createDescriptorSet(gammaCorrectionProgram.getReflectedDescriptors().at(0));
+	vkcv::DescriptorSetHandle gammaCorrectionDescriptorSet = core.createDescriptorSet(gammaCorrectionProgram.getReflectedDescriptors()[0]);
 	vkcv::PipelineHandle gammaCorrectionPipeline = core.createComputePipeline(gammaCorrectionProgram,
 		{ core.getDescriptorSet(gammaCorrectionDescriptorSet).layout });
 
diff --git a/projects/first_mesh/src/main.cpp b/projects/first_mesh/src/main.cpp
index c941e94e..e7546fc3 100644
--- a/projects/first_mesh/src/main.cpp
+++ b/projects/first_mesh/src/main.cpp
@@ -79,8 +79,8 @@ int main(int argc, const char** argv) {
 	}
 
 	vkcv::ShaderProgram firstMeshProgram{};
-    firstMeshProgram.addShader(vk::ShaderStageFlagBits::eVertex, std::filesystem::path("resources/shaders/vert.spv"));
-    firstMeshProgram.addShader(vk::ShaderStageFlagBits::eFragment, std::filesystem::path("resources/shaders/frag.spv"));
+    firstMeshProgram.addShader(vkcv::ShaderStage::VERTEX, std::filesystem::path("resources/shaders/vert.spv"));
+    firstMeshProgram.addShader(vkcv::ShaderStage::FRAGMENT, std::filesystem::path("resources/shaders/frag.spv"));
 	
 	auto& attributes = mesh.vertexGroups[0].vertexBuffer.attributes;
 
@@ -98,8 +98,8 @@ int main(int argc, const char** argv) {
 	const vkcv::VertexLayout firstMeshLayout (bindings);
 
 	uint32_t setID = 0;
-
-	vkcv::DescriptorSetHandle descriptorSet = core.createDescriptorSet(firstMeshProgram.getReflectedDescriptors().at(setID));
+	std::vector<vkcv::DescriptorBinding> descriptorBindings = { firstMeshProgram.getReflectedDescriptors()[setID] };
+	vkcv::DescriptorSetHandle descriptorSet = core.createDescriptorSet(descriptorBindings);
 
 	const vkcv::PipelineConfig firstMeshPipelineConfig {
         firstMeshProgram,
diff --git a/projects/first_scene/src/main.cpp b/projects/first_scene/src/main.cpp
index 842018f6..52181873 100644
--- a/projects/first_scene/src/main.cpp
+++ b/projects/first_scene/src/main.cpp
@@ -128,8 +128,8 @@ int main(int argc, const char** argv) {
 	}
 
 	vkcv::ShaderProgram sceneShaderProgram{};
-	sceneShaderProgram.addShader(vk::ShaderStageFlagBits::eVertex, std::filesystem::path("resources/shaders/vert.spv"));
-	sceneShaderProgram.addShader(vk::ShaderStageFlagBits::eFragment, std::filesystem::path("resources/shaders/frag.spv"));
+	sceneShaderProgram.addShader(vkcv::ShaderStage::VERTEX, std::filesystem::path("resources/shaders/vert.spv"));
+	sceneShaderProgram.addShader(vkcv::ShaderStage::FRAGMENT, std::filesystem::path("resources/shaders/frag.spv"));
 
 	const std::vector<vkcv::VertexAttachment> vertexAttachments = sceneShaderProgram.getVertexAttachments();
 	std::vector<vkcv::VertexBinding> bindings;
@@ -141,6 +141,8 @@ int main(int argc, const char** argv) {
 
 	uint32_t setID = 0;
 
+	std::vector<vkcv::DescriptorBinding> descriptorBindings = { sceneShaderProgram.getReflectedDescriptors()[setID] };
+
 	vkcv::SamplerHandle sampler = core.createSampler(
 		vkcv::SamplerFilterType::LINEAR,
 		vkcv::SamplerFilterType::LINEAR,
@@ -151,7 +153,7 @@ int main(int argc, const char** argv) {
 	std::vector<vkcv::Image> sceneImages;
 	std::vector<vkcv::DescriptorSetHandle> descriptorSets;
 	for (const auto& vertexGroup : scene.vertexGroups) {
-		descriptorSets.push_back(core.createDescriptorSet(sceneShaderProgram.getReflectedDescriptors().at(setID)));
+		descriptorSets.push_back(core.createDescriptorSet(descriptorBindings));
 
 		const auto& material = scene.materials[vertexGroup.materialIndex];
 
diff --git a/projects/first_triangle/src/main.cpp b/projects/first_triangle/src/main.cpp
index da352171..5bdd55a2 100644
--- a/projects/first_triangle/src/main.cpp
+++ b/projects/first_triangle/src/main.cpp
@@ -96,13 +96,13 @@ int main(int argc, const char** argv) {
 	vkcv::ShaderProgram triangleShaderProgram{};
 	vkcv::shader::GLSLCompiler compiler;
 	
-	compiler.compile(vk::ShaderStageFlagBits::eVertex, std::filesystem::path("shaders/shader.vert"),
-					 [&triangleShaderProgram](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::VERTEX, std::filesystem::path("shaders/shader.vert"),
+					 [&triangleShaderProgram](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		 triangleShaderProgram.addShader(shaderStage, path);
 	});
 	
-	compiler.compile(vk::ShaderStageFlagBits::eFragment, std::filesystem::path("shaders/shader.frag"),
-					 [&triangleShaderProgram](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::FRAGMENT, std::filesystem::path("shaders/shader.frag"),
+					 [&triangleShaderProgram](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		triangleShaderProgram.addShader(shaderStage, path);
 	});
 
@@ -126,10 +126,10 @@ int main(int argc, const char** argv) {
 
 	// Compute Pipeline
 	vkcv::ShaderProgram computeShaderProgram{};
-	computeShaderProgram.addShader(vk::ShaderStageFlagBits::eCompute, std::filesystem::path("shaders/comp.spv"));
+	computeShaderProgram.addShader(vkcv::ShaderStage::COMPUTE, std::filesystem::path("shaders/comp.spv"));
 
 	// take care, assuming shader has exactly one descriptor set
-	vkcv::DescriptorSetHandle computeDescriptorSet = core.createDescriptorSet(computeShaderProgram.getReflectedDescriptors().at(0));
+	vkcv::DescriptorSetHandle computeDescriptorSet = core.createDescriptorSet(computeShaderProgram.getReflectedDescriptors()[0]);
 
 	vkcv::PipelineHandle computePipeline = core.createComputePipeline(
 		computeShaderProgram, 
diff --git a/projects/particle_simulation/src/BloomAndFlares.cpp b/projects/particle_simulation/src/BloomAndFlares.cpp
index 8140583e..23ace2bc 100644
--- a/projects/particle_simulation/src/BloomAndFlares.cpp
+++ b/projects/particle_simulation/src/BloomAndFlares.cpp
@@ -22,57 +22,57 @@ BloomAndFlares::BloomAndFlares(
 
     // DOWNSAMPLE
     vkcv::ShaderProgram dsProg;
-    compiler.compile(vk::ShaderStageFlagBits::eCompute,
+    compiler.compile(vkcv::ShaderStage::COMPUTE,
                      "shaders/bloom/downsample.comp",
-                     [&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path)
+                     [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path)
                      {
                          dsProg.addShader(shaderStage, path);
                      });
     for(uint32_t mipLevel = 0; mipLevel < m_Blur.getMipCount(); mipLevel++)
     {
 		m_DownsampleDescSets.push_back(
-                p_Core->createDescriptorSet(dsProg.getReflectedDescriptors().at(0)));
+                p_Core->createDescriptorSet(dsProg.getReflectedDescriptors()[0]));
     }
     m_DownsamplePipe = p_Core->createComputePipeline(
             dsProg, { p_Core->getDescriptorSet(m_DownsampleDescSets[0]).layout });
 
     // UPSAMPLE
     vkcv::ShaderProgram usProg;
-    compiler.compile(vk::ShaderStageFlagBits::eCompute,
+    compiler.compile(vkcv::ShaderStage::COMPUTE,
                      "shaders/bloom/upsample.comp",
-                     [&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path)
+                     [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path)
                      {
                          usProg.addShader(shaderStage, path);
                      });
     for(uint32_t mipLevel = 0; mipLevel < m_Blur.getMipCount(); mipLevel++)
     {
         m_UpsampleDescSets.push_back(
-                p_Core->createDescriptorSet(usProg.getReflectedDescriptors().at(0)));
+                p_Core->createDescriptorSet(usProg.getReflectedDescriptors()[0]));
     }
     m_UpsamplePipe = p_Core->createComputePipeline(
             usProg, { p_Core->getDescriptorSet(m_UpsampleDescSets[0]).layout });
 
     // LENS FEATURES
     vkcv::ShaderProgram lensProg;
-    compiler.compile(vk::ShaderStageFlagBits::eCompute,
+    compiler.compile(vkcv::ShaderStage::COMPUTE,
                      "shaders/bloom/lensFlares.comp",
-                     [&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path)
+                     [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path)
                      {
                          lensProg.addShader(shaderStage, path);
                      });
-    m_LensFlareDescSet = p_Core->createDescriptorSet(lensProg.getReflectedDescriptors().at(0));
+    m_LensFlareDescSet = p_Core->createDescriptorSet(lensProg.getReflectedDescriptors()[0]);
     m_LensFlarePipe = p_Core->createComputePipeline(
             lensProg, { p_Core->getDescriptorSet(m_LensFlareDescSet).layout });
 
     // COMPOSITE
     vkcv::ShaderProgram compProg;
-    compiler.compile(vk::ShaderStageFlagBits::eCompute,
+    compiler.compile(vkcv::ShaderStage::COMPUTE,
                      "shaders/bloom/composite.comp",
-                     [&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path)
+                     [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path)
                      {
                          compProg.addShader(shaderStage, path);
                      });
-    m_CompositeDescSet = p_Core->createDescriptorSet(compProg.getReflectedDescriptors().at(0));
+    m_CompositeDescSet = p_Core->createDescriptorSet(compProg.getReflectedDescriptors()[0]);
     m_CompositePipe = p_Core->createComputePipeline(
             compProg, { p_Core->getDescriptorSet(m_CompositeDescSet).layout });
 }
diff --git a/projects/particle_simulation/src/main.cpp b/projects/particle_simulation/src/main.cpp
index 91672cdc..a22044f0 100644
--- a/projects/particle_simulation/src/main.cpp
+++ b/projects/particle_simulation/src/main.cpp
@@ -63,11 +63,11 @@ int main(int argc, const char **argv) {
 
     vkcv::shader::GLSLCompiler compiler;
     vkcv::ShaderProgram computeShaderProgram{};
-    compiler.compile(vk::ShaderStageFlagBits::eCompute, useSpace ? "shaders/shader_space.comp" : "shaders/shader_water.comp", [&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+    compiler.compile(vkcv::ShaderStage::COMPUTE, useSpace ? "shaders/shader_space.comp" : "shaders/shader_water.comp", [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
         computeShaderProgram.addShader(shaderStage, path);
     });
 
-    vkcv::DescriptorSetHandle computeDescriptorSet = core.createDescriptorSet(computeShaderProgram.getReflectedDescriptors().at(0));
+    vkcv::DescriptorSetHandle computeDescriptorSet = core.createDescriptorSet(computeShaderProgram.getReflectedDescriptors()[0]);
 
     const std::vector<vkcv::VertexAttachment> computeVertexAttachments = computeShaderProgram.getVertexAttachments();
 
@@ -78,15 +78,15 @@ int main(int argc, const char **argv) {
     const vkcv::VertexLayout computeLayout(computeBindings);
 
     vkcv::ShaderProgram particleShaderProgram{};
-    compiler.compile(vk::ShaderStageFlagBits::eVertex, "shaders/shader.vert", [&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+    compiler.compile(vkcv::ShaderStage::VERTEX, "shaders/shader.vert", [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
         particleShaderProgram.addShader(shaderStage, path);
     });
-    compiler.compile(vk::ShaderStageFlagBits::eFragment, useSpace ? "shaders/shader_space.frag" : "shaders/shader_water.frag", [&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+    compiler.compile(vkcv::ShaderStage::FRAGMENT, useSpace ? "shaders/shader_space.frag" : "shaders/shader_water.frag", [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
         particleShaderProgram.addShader(shaderStage, path);
     });
 
     vkcv::DescriptorSetHandle descriptorSet = core.createDescriptorSet(
-            particleShaderProgram.getReflectedDescriptors().at(0));
+            particleShaderProgram.getReflectedDescriptors()[0]);
 
     vkcv::Buffer<glm::vec3> vertexBuffer = core.createBuffer<glm::vec3>(
             vkcv::BufferType::VERTEX,
@@ -230,11 +230,11 @@ int main(int argc, const char **argv) {
     });
 
     vkcv::ShaderProgram tonemappingShader;
-    compiler.compile(vk::ShaderStageFlagBits::eCompute, "shaders/tonemapping.comp", [&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+    compiler.compile(vkcv::ShaderStage::COMPUTE, "shaders/tonemapping.comp", [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
         tonemappingShader.addShader(shaderStage, path);
     });
 
-    vkcv::DescriptorSetHandle tonemappingDescriptor = core.createDescriptorSet(tonemappingShader.getReflectedDescriptors().at(0));
+    vkcv::DescriptorSetHandle tonemappingDescriptor = core.createDescriptorSet(tonemappingShader.getReflectedDescriptors()[0]);
     vkcv::PipelineHandle tonemappingPipe = core.createComputePipeline(
         tonemappingShader, 
         { core.getDescriptorSet(tonemappingDescriptor).layout });
diff --git a/projects/voxelization/src/BloomAndFlares.cpp b/projects/voxelization/src/BloomAndFlares.cpp
index c953ef51..fac57735 100644
--- a/projects/voxelization/src/BloomAndFlares.cpp
+++ b/projects/voxelization/src/BloomAndFlares.cpp
@@ -36,36 +36,36 @@ BloomAndFlares::BloomAndFlares(
 
     // DOWNSAMPLE
     vkcv::ShaderProgram dsProg;
-    compiler.compile(vk::ShaderStageFlagBits::eCompute,
+    compiler.compile(vkcv::ShaderStage::COMPUTE,
                      "resources/shaders/bloomDownsample.comp",
-                     [&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path)
+                     [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path)
                      {
                          dsProg.addShader(shaderStage, path);
                      });
     for(uint32_t mipLevel = 0; mipLevel < m_Blur.getMipCount(); mipLevel++)
     {
 		m_DownsampleDescSets.push_back(
-                p_Core->createDescriptorSet(dsProg.getReflectedDescriptors().at(0)));
+                p_Core->createDescriptorSet(dsProg.getReflectedDescriptors()[0]));
     }
     m_DownsamplePipe = p_Core->createComputePipeline(
             dsProg, { p_Core->getDescriptorSet(m_DownsampleDescSets[0]).layout });
 
     // UPSAMPLE
     vkcv::ShaderProgram usProg;
-    compiler.compile(vk::ShaderStageFlagBits::eCompute,
+    compiler.compile(vkcv::ShaderStage::COMPUTE,
                      "resources/shaders/bloomUpsample.comp",
-                     [&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path)
+                     [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path)
                      {
                          usProg.addShader(shaderStage, path);
                      });
     for(uint32_t mipLevel = 0; mipLevel < m_Blur.getMipCount(); mipLevel++)
     {
         m_UpsampleDescSets.push_back(
-                p_Core->createDescriptorSet(usProg.getReflectedDescriptors().at(0)));
+                p_Core->createDescriptorSet(usProg.getReflectedDescriptors()[0]));
     }
     for (uint32_t mipLevel = 0; mipLevel < m_LensFeatures.getMipCount(); mipLevel++) {
         m_UpsampleLensFlareDescSets.push_back(
-            p_Core->createDescriptorSet(usProg.getReflectedDescriptors().at(0)));
+            p_Core->createDescriptorSet(usProg.getReflectedDescriptors()[0]));
     }
 
     m_UpsamplePipe = p_Core->createComputePipeline(
@@ -73,25 +73,25 @@ BloomAndFlares::BloomAndFlares(
 
     // LENS FEATURES
     vkcv::ShaderProgram lensProg;
-    compiler.compile(vk::ShaderStageFlagBits::eCompute,
+    compiler.compile(vkcv::ShaderStage::COMPUTE,
                      "resources/shaders/lensFlares.comp",
-                     [&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path)
+                     [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path)
                      {
                          lensProg.addShader(shaderStage, path);
                      });
-    m_LensFlareDescSet = p_Core->createDescriptorSet(lensProg.getReflectedDescriptors().at(0));
+    m_LensFlareDescSet = p_Core->createDescriptorSet(lensProg.getReflectedDescriptors()[0]);
     m_LensFlarePipe = p_Core->createComputePipeline(
             lensProg, { p_Core->getDescriptorSet(m_LensFlareDescSet).layout });
 
     // COMPOSITE
     vkcv::ShaderProgram compProg;
-    compiler.compile(vk::ShaderStageFlagBits::eCompute,
+    compiler.compile(vkcv::ShaderStage::COMPUTE,
                      "resources/shaders/bloomFlaresComposite.comp",
-                     [&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path)
+                     [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path)
                      {
                          compProg.addShader(shaderStage, path);
                      });
-    m_CompositeDescSet = p_Core->createDescriptorSet(compProg.getReflectedDescriptors().at(0));
+    m_CompositeDescSet = p_Core->createDescriptorSet(compProg.getReflectedDescriptors()[0]);
     m_CompositePipe = p_Core->createComputePipeline(
             compProg, { p_Core->getDescriptorSet(m_CompositeDescSet).layout });
 
diff --git a/projects/voxelization/src/ShadowMapping.cpp b/projects/voxelization/src/ShadowMapping.cpp
index ec5b7380..a330394b 100644
--- a/projects/voxelization/src/ShadowMapping.cpp
+++ b/projects/voxelization/src/ShadowMapping.cpp
@@ -9,12 +9,12 @@ const vkcv::Multisampling   msaa                    = vkcv::Multisampling::MSAA8
 vkcv::ShaderProgram loadShadowShader() {
 	vkcv::ShaderProgram shader;
 	vkcv::shader::GLSLCompiler compiler;
-	compiler.compile(vk::ShaderStageFlagBits::eVertex, "resources/shaders/shadow.vert",
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::VERTEX, "resources/shaders/shadow.vert",
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		shader.addShader(shaderStage, path);
 	});
-	compiler.compile(vk::ShaderStageFlagBits::eFragment, "resources/shaders/shadow.frag",
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::FRAGMENT, "resources/shaders/shadow.frag",
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		shader.addShader(shaderStage, path);
 	});
 	return shader;
@@ -23,8 +23,8 @@ vkcv::ShaderProgram loadShadowShader() {
 vkcv::ShaderProgram loadDepthToMomentsShader() {
 	vkcv::ShaderProgram shader;
 	vkcv::shader::GLSLCompiler compiler;
-	compiler.compile(vk::ShaderStageFlagBits::eCompute, "resources/shaders/depthToMoments.comp",
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::COMPUTE, "resources/shaders/depthToMoments.comp",
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		shader.addShader(shaderStage, path);
 	});
 	return shader;
@@ -33,8 +33,8 @@ vkcv::ShaderProgram loadDepthToMomentsShader() {
 vkcv::ShaderProgram loadShadowBlurXShader() {
 	vkcv::ShaderProgram shader;
 	vkcv::shader::GLSLCompiler compiler;
-	compiler.compile(vk::ShaderStageFlagBits::eCompute, "resources/shaders/shadowBlurX.comp",
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::COMPUTE, "resources/shaders/shadowBlurX.comp",
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		shader.addShader(shaderStage, path);
 	});
 	return shader;
@@ -43,8 +43,8 @@ vkcv::ShaderProgram loadShadowBlurXShader() {
 vkcv::ShaderProgram loadShadowBlurYShader() {
 	vkcv::ShaderProgram shader;
 	vkcv::shader::GLSLCompiler compiler;
-	compiler.compile(vk::ShaderStageFlagBits::eCompute, "resources/shaders/shadowBlurY.comp",
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::COMPUTE, "resources/shaders/shadowBlurY.comp",
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		shader.addShader(shaderStage, path);
 	});
 	return shader;
@@ -189,7 +189,7 @@ ShadowMapping::ShadowMapping(vkcv::Core* corePtr, const vkcv::VertexLayout& vert
 
 	// depth to moments
 	vkcv::ShaderProgram depthToMomentsShader    = loadDepthToMomentsShader();
-	m_depthToMomentsDescriptorSet               = corePtr->createDescriptorSet(depthToMomentsShader.getReflectedDescriptors().at(0));
+	m_depthToMomentsDescriptorSet               = corePtr->createDescriptorSet(depthToMomentsShader.getReflectedDescriptors()[0]);
 	m_depthToMomentsPipe                        = corePtr->createComputePipeline(depthToMomentsShader, { corePtr->getDescriptorSet(m_depthToMomentsDescriptorSet).layout });
 
 	vkcv::DescriptorWrites depthToMomentDescriptorWrites;
@@ -200,7 +200,7 @@ ShadowMapping::ShadowMapping(vkcv::Core* corePtr, const vkcv::VertexLayout& vert
 
 	// shadow blur X
 	vkcv::ShaderProgram shadowBlurXShader    = loadShadowBlurXShader();
-	m_shadowBlurXDescriptorSet              = corePtr->createDescriptorSet(shadowBlurXShader.getReflectedDescriptors().at(0));
+	m_shadowBlurXDescriptorSet              = corePtr->createDescriptorSet(shadowBlurXShader.getReflectedDescriptors()[0]);
 	m_shadowBlurXPipe                       = corePtr->createComputePipeline(shadowBlurXShader, { corePtr->getDescriptorSet(m_shadowBlurXDescriptorSet).layout });
 
 	vkcv::DescriptorWrites shadowBlurXDescriptorWrites;
@@ -211,7 +211,7 @@ ShadowMapping::ShadowMapping(vkcv::Core* corePtr, const vkcv::VertexLayout& vert
 
 	// shadow blur Y
 	vkcv::ShaderProgram shadowBlurYShader = loadShadowBlurYShader();
-	m_shadowBlurYDescriptorSet = corePtr->createDescriptorSet(shadowBlurYShader.getReflectedDescriptors().at(0));
+	m_shadowBlurYDescriptorSet = corePtr->createDescriptorSet(shadowBlurYShader.getReflectedDescriptors()[0]);
 	m_shadowBlurYPipe = corePtr->createComputePipeline(shadowBlurYShader, { corePtr->getDescriptorSet(m_shadowBlurYDescriptorSet).layout });
 
 	vkcv::DescriptorWrites shadowBlurYDescriptorWrites;
diff --git a/projects/voxelization/src/Voxelization.cpp b/projects/voxelization/src/Voxelization.cpp
index 9ef4e874..c117b4b9 100644
--- a/projects/voxelization/src/Voxelization.cpp
+++ b/projects/voxelization/src/Voxelization.cpp
@@ -6,16 +6,16 @@
 vkcv::ShaderProgram loadVoxelizationShader() {
 	vkcv::shader::GLSLCompiler compiler;
 	vkcv::ShaderProgram shader;
-	compiler.compile(vk::ShaderStageFlagBits::eVertex, "resources/shaders/voxelization.vert",
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::VERTEX, "resources/shaders/voxelization.vert",
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		shader.addShader(shaderStage, path);
 	});
-	compiler.compile(vk::ShaderStageFlagBits::eGeometry, "resources/shaders/voxelization.geom",
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::GEOMETRY, "resources/shaders/voxelization.geom",
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		shader.addShader(shaderStage, path);
 	});
-	compiler.compile(vk::ShaderStageFlagBits::eFragment, "resources/shaders/voxelization.frag",
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::FRAGMENT, "resources/shaders/voxelization.frag",
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		shader.addShader(shaderStage, path);
 	});
 	return shader;
@@ -24,16 +24,16 @@ vkcv::ShaderProgram loadVoxelizationShader() {
 vkcv::ShaderProgram loadVoxelVisualisationShader() {
 	vkcv::shader::GLSLCompiler compiler;
 	vkcv::ShaderProgram shader;
-	compiler.compile(vk::ShaderStageFlagBits::eVertex, "resources/shaders/voxelVisualisation.vert",
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::VERTEX, "resources/shaders/voxelVisualisation.vert",
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		shader.addShader(shaderStage, path);
 	});
-	compiler.compile(vk::ShaderStageFlagBits::eGeometry, "resources/shaders/voxelVisualisation.geom",
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::GEOMETRY, "resources/shaders/voxelVisualisation.geom",
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		shader.addShader(shaderStage, path);
 	});
-	compiler.compile(vk::ShaderStageFlagBits::eFragment, "resources/shaders/voxelVisualisation.frag",
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::FRAGMENT, "resources/shaders/voxelVisualisation.frag",
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		shader.addShader(shaderStage, path);
 	});
 	return shader;
@@ -42,8 +42,8 @@ vkcv::ShaderProgram loadVoxelVisualisationShader() {
 vkcv::ShaderProgram loadVoxelResetShader() {
 	vkcv::shader::GLSLCompiler compiler;
 	vkcv::ShaderProgram shader;
-	compiler.compile(vk::ShaderStageFlagBits::eCompute, "resources/shaders/voxelReset.comp",
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::COMPUTE, "resources/shaders/voxelReset.comp",
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		shader.addShader(shaderStage, path);
 	});
 	return shader;
@@ -52,8 +52,8 @@ vkcv::ShaderProgram loadVoxelResetShader() {
 vkcv::ShaderProgram loadVoxelBufferToImageShader() {
 	vkcv::shader::GLSLCompiler compiler;
 	vkcv::ShaderProgram shader;
-	compiler.compile(vk::ShaderStageFlagBits::eCompute, "resources/shaders/voxelBufferToImage.comp",
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::COMPUTE, "resources/shaders/voxelBufferToImage.comp",
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		shader.addShader(shaderStage, path);
 	});
 	return shader;
@@ -62,8 +62,8 @@ vkcv::ShaderProgram loadVoxelBufferToImageShader() {
 vkcv::ShaderProgram loadSecondaryBounceShader() {
 	vkcv::shader::GLSLCompiler compiler;
 	vkcv::ShaderProgram shader;
-	compiler.compile(vk::ShaderStageFlagBits::eCompute, "resources/shaders/voxelSecondaryBounce.comp",
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::COMPUTE, "resources/shaders/voxelSecondaryBounce.comp",
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		shader.addShader(shaderStage, path);
 	});
 	return shader;
@@ -98,10 +98,12 @@ Voxelization::Voxelization(
 		voxelizationDummyFormat) });
 	m_voxelizationPass = m_corePtr->createPass(voxelizationPassConfig);
 
-	m_voxelizationDescriptorSet = m_corePtr->createDescriptorSet(voxelizationShader.getReflectedDescriptors().at(0));
+	std::vector<vkcv::DescriptorBinding> voxelizationDescriptorBindings = 
+	{ voxelizationShader.getReflectedDescriptors()[0] };
+	m_voxelizationDescriptorSet = m_corePtr->createDescriptorSet(voxelizationDescriptorBindings);
 
 	vkcv::DescriptorSetHandle dummyPerMeshDescriptorSet =
-		m_corePtr->createDescriptorSet({ voxelizationShader.getReflectedDescriptors().at(1) });
+		m_corePtr->createDescriptorSet({ voxelizationShader.getReflectedDescriptors()[1] });
 
 	const vkcv::PipelineConfig voxelizationPipeConfig{
 		voxelizationShader,
@@ -129,7 +131,9 @@ Voxelization::Voxelization(
 
 	vkcv::ShaderProgram voxelVisualisationShader = loadVoxelVisualisationShader();
 
-	m_visualisationDescriptorSet = m_corePtr->createDescriptorSet(voxelVisualisationShader.getReflectedDescriptors().at(0));
+	const std::vector<vkcv::DescriptorBinding> voxelVisualisationDescriptorBindings = 
+		{ voxelVisualisationShader.getReflectedDescriptors()[0] };
+	m_visualisationDescriptorSet = m_corePtr->createDescriptorSet(voxelVisualisationDescriptorBindings);
 
 	const vkcv::AttachmentDescription voxelVisualisationColorAttachments(
 		vkcv::AttachmentOperation::STORE,
@@ -170,7 +174,7 @@ Voxelization::Voxelization(
 
 	vkcv::ShaderProgram resetVoxelShader = loadVoxelResetShader();
 
-	m_voxelResetDescriptorSet = m_corePtr->createDescriptorSet(resetVoxelShader.getReflectedDescriptors().at(0));
+	m_voxelResetDescriptorSet = m_corePtr->createDescriptorSet(resetVoxelShader.getReflectedDescriptors()[0]);
 	m_voxelResetPipe = m_corePtr->createComputePipeline(
 		resetVoxelShader,
 		{ m_corePtr->getDescriptorSet(m_voxelResetDescriptorSet).layout });
@@ -182,7 +186,7 @@ Voxelization::Voxelization(
 	// buffer to image
 	vkcv::ShaderProgram bufferToImageShader = loadVoxelBufferToImageShader();
 
-	m_bufferToImageDescriptorSet = m_corePtr->createDescriptorSet(bufferToImageShader.getReflectedDescriptors().at(0));
+	m_bufferToImageDescriptorSet = m_corePtr->createDescriptorSet(bufferToImageShader.getReflectedDescriptors()[0]);
 	m_bufferToImagePipe = m_corePtr->createComputePipeline(
 		bufferToImageShader,
 		{ m_corePtr->getDescriptorSet(m_bufferToImageDescriptorSet).layout });
@@ -195,7 +199,7 @@ Voxelization::Voxelization(
 	// secondary bounce
 	vkcv::ShaderProgram secondaryBounceShader = loadSecondaryBounceShader();
 
-	m_secondaryBounceDescriptorSet = m_corePtr->createDescriptorSet(secondaryBounceShader.getReflectedDescriptors().at(0));
+	m_secondaryBounceDescriptorSet = m_corePtr->createDescriptorSet(secondaryBounceShader.getReflectedDescriptors()[0]);
 	m_secondaryBouncePipe = m_corePtr->createComputePipeline(
 		secondaryBounceShader,
 		{ m_corePtr->getDescriptorSet(m_secondaryBounceDescriptorSet).layout });
diff --git a/projects/voxelization/src/main.cpp b/projects/voxelization/src/main.cpp
index a3248c38..edc50c55 100644
--- a/projects/voxelization/src/main.cpp
+++ b/projects/voxelization/src/main.cpp
@@ -171,12 +171,12 @@ int main(int argc, const char** argv) {
 	vkcv::shader::GLSLCompiler compiler;
 
 	vkcv::ShaderProgram forwardProgram;
-	compiler.compile(vk::ShaderStageFlagBits::eVertex, std::filesystem::path("resources/shaders/shader.vert"),
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::VERTEX, std::filesystem::path("resources/shaders/shader.vert"), 
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		forwardProgram.addShader(shaderStage, path);
 	});
-	compiler.compile(vk::ShaderStageFlagBits::eFragment, std::filesystem::path("resources/shaders/shader.frag"),
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::FRAGMENT, std::filesystem::path("resources/shaders/shader.frag"),
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		forwardProgram.addShader(shaderStage, path);
 	});
 
@@ -189,16 +189,16 @@ int main(int argc, const char** argv) {
 	const vkcv::VertexLayout vertexLayout (vertexBindings);
 
 	vkcv::DescriptorSetHandle forwardShadingDescriptorSet = 
-		core.createDescriptorSet(forwardProgram.getReflectedDescriptors().at(0));
+		core.createDescriptorSet({ forwardProgram.getReflectedDescriptors()[0] });
 
 	// depth prepass config
 	vkcv::ShaderProgram depthPrepassShader;
-	compiler.compile(vk::ShaderStageFlagBits::eVertex, std::filesystem::path("resources/shaders/depthPrepass.vert"),
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::VERTEX, std::filesystem::path("resources/shaders/depthPrepass.vert"),
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		depthPrepassShader.addShader(shaderStage, path);
 	});
-	compiler.compile(vk::ShaderStageFlagBits::eFragment, std::filesystem::path("resources/shaders/depthPrepass.frag"),
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::FRAGMENT, std::filesystem::path("resources/shaders/depthPrepass.frag"),
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		depthPrepassShader.addShader(shaderStage, path);
 	});
 
@@ -247,7 +247,7 @@ int main(int argc, const char** argv) {
 			specularIndex = 0;
 		}
 
-		materialDescriptorSets.push_back(core.createDescriptorSet(forwardProgram.getReflectedDescriptors().at(1)));
+		materialDescriptorSets.push_back(core.createDescriptorSet(forwardProgram.getReflectedDescriptors()[1]));
 
 		vkcv::asset::Texture& albedoTexture     = scene.textures[albedoIndex];
 		vkcv::asset::Texture& normalTexture     = scene.textures[normalIndex];
@@ -292,7 +292,7 @@ int main(int argc, const char** argv) {
 	}
 
 	// prepass pipeline
-	vkcv::DescriptorSetHandle prepassDescriptorSet = core.createDescriptorSet({});
+	vkcv::DescriptorSetHandle prepassDescriptorSet = core.createDescriptorSet(std::vector<vkcv::DescriptorBinding>());
 
 	vkcv::PipelineConfig prepassPipelineConfig{
 		depthPrepassShader,
@@ -358,12 +358,12 @@ int main(int argc, const char** argv) {
 	vkcv::PassHandle skyPass = core.createPass(skyPassConfig);
 
 	vkcv::ShaderProgram skyShader;
-	compiler.compile(vk::ShaderStageFlagBits::eVertex, std::filesystem::path("resources/shaders/sky.vert"),
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::VERTEX, std::filesystem::path("resources/shaders/sky.vert"),
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		skyShader.addShader(shaderStage, path);
 	});
-	compiler.compile(vk::ShaderStageFlagBits::eFragment, std::filesystem::path("resources/shaders/sky.frag"),
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::FRAGMENT, std::filesystem::path("resources/shaders/sky.frag"),
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		skyShader.addShader(shaderStage, path);
 	});
 
@@ -412,24 +412,24 @@ int main(int argc, const char** argv) {
 
 	// tonemapping compute shader
 	vkcv::ShaderProgram tonemappingProgram;
-	compiler.compile(vk::ShaderStageFlagBits::eCompute, "resources/shaders/tonemapping.comp",
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::COMPUTE, "resources/shaders/tonemapping.comp", 
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		tonemappingProgram.addShader(shaderStage, path);
 	});
 	vkcv::DescriptorSetHandle tonemappingDescriptorSet = core.createDescriptorSet(
-		tonemappingProgram.getReflectedDescriptors().at(0));
+		tonemappingProgram.getReflectedDescriptors()[0]);
 	vkcv::PipelineHandle tonemappingPipeline = core.createComputePipeline(
 		tonemappingProgram,
 		{ core.getDescriptorSet(tonemappingDescriptorSet).layout });
 
 	// resolve compute shader
 	vkcv::ShaderProgram resolveProgram;
-	compiler.compile(vk::ShaderStageFlagBits::eCompute, "resources/shaders/msaa4XResolve.comp",
-		[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+	compiler.compile(vkcv::ShaderStage::COMPUTE, "resources/shaders/msaa4XResolve.comp",
+		[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 		resolveProgram.addShader(shaderStage, path);
 	});
 	vkcv::DescriptorSetHandle resolveDescriptorSet = core.createDescriptorSet(
-		resolveProgram.getReflectedDescriptors().at(0));
+		resolveProgram.getReflectedDescriptors()[0]);
 	vkcv::PipelineHandle resolvePipeline = core.createComputePipeline(
 		resolveProgram,
 		{ core.getDescriptorSet(resolveDescriptorSet).layout });
@@ -753,12 +753,12 @@ int main(int argc, const char** argv) {
 			if (ImGui::Button("Reload forward pass")) {
 
 				vkcv::ShaderProgram newForwardProgram;
-				compiler.compile(vk::ShaderStageFlagBits::eVertex, std::filesystem::path("resources/shaders/shader.vert"),
-					[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+				compiler.compile(vkcv::ShaderStage::VERTEX, std::filesystem::path("resources/shaders/shader.vert"),
+					[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 					newForwardProgram.addShader(shaderStage, path);
 				});
-				compiler.compile(vk::ShaderStageFlagBits::eFragment, std::filesystem::path("resources/shaders/shader.frag"),
-					[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+				compiler.compile(vkcv::ShaderStage::FRAGMENT, std::filesystem::path("resources/shaders/shader.frag"),
+					[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 					newForwardProgram.addShader(shaderStage, path);
 				});
 				forwardPipelineConfig.m_ShaderProgram = newForwardProgram;
@@ -771,8 +771,8 @@ int main(int argc, const char** argv) {
 			if (ImGui::Button("Reload tonemapping")) {
 
 				vkcv::ShaderProgram newProgram;
-				compiler.compile(vk::ShaderStageFlagBits::eCompute, std::filesystem::path("resources/shaders/tonemapping.comp"),
-					[&](vk::ShaderStageFlagBits shaderStage, const std::filesystem::path& path) {
+				compiler.compile(vkcv::ShaderStage::COMPUTE, std::filesystem::path("resources/shaders/tonemapping.comp"),
+					[&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
 					newProgram.addShader(shaderStage, path);
 				});
 				vkcv::PipelineHandle newPipeline = core.createComputePipeline(
diff --git a/src/vkcv/Core.cpp b/src/vkcv/Core.cpp
index 39692a01..352a1cf6 100644
--- a/src/vkcv/Core.cpp
+++ b/src/vkcv/Core.cpp
@@ -532,7 +532,7 @@ namespace vkcv
 		return m_ImageManager->getImageHeight(imageHandle);
 	}
 
-    DescriptorSetHandle Core::createDescriptorSet(const std::unordered_map<uint32_t, DescriptorBinding>& bindings)
+    DescriptorSetHandle Core::createDescriptorSet(const std::vector<DescriptorBinding>& bindings)
     {
         return m_DescriptorManager->createDescriptorSet(bindings);
     }
diff --git a/src/vkcv/DescriptorConfig.cpp b/src/vkcv/DescriptorConfig.cpp
index 1fc075ce..a9a127fe 100644
--- a/src/vkcv/DescriptorConfig.cpp
+++ b/src/vkcv/DescriptorConfig.cpp
@@ -5,7 +5,7 @@ namespace vkcv {
 		uint32_t bindingID,
 		DescriptorType descriptorType,
 		uint32_t descriptorCount,
-		vk::ShaderStageFlags shaderStages) noexcept
+		ShaderStages shaderStages) noexcept
 		:
 		bindingID(bindingID),
 		descriptorType(descriptorType),
diff --git a/src/vkcv/DescriptorManager.cpp b/src/vkcv/DescriptorManager.cpp
index 5197adc7..d28dd9d1 100644
--- a/src/vkcv/DescriptorManager.cpp
+++ b/src/vkcv/DescriptorManager.cpp
@@ -35,17 +35,17 @@ namespace vkcv
 		}
     }
 
-    DescriptorSetHandle DescriptorManager::createDescriptorSet(const std::unordered_map<uint32_t, DescriptorBinding>& bindings)
+    DescriptorSetHandle DescriptorManager::createDescriptorSet(const std::vector<DescriptorBinding>& bindings)
     {
         std::vector<vk::DescriptorSetLayoutBinding> setBindings = {};
 
-        //create the set's bindings
-		for (auto bindingIter = bindings.begin(); bindingIter != bindings.end(); bindingIter++) {
+        //create each set's binding
+        for (uint32_t i = 0; i < bindings.size(); i++) {
             vk::DescriptorSetLayoutBinding descriptorSetLayoutBinding(
-				bindingIter->second.bindingID,
-                convertDescriptorTypeFlag(bindingIter->second.descriptorType),
-				bindingIter->second.descriptorCount,
-				bindingIter->second.shaderStages);
+                bindings[i].bindingID,
+                convertDescriptorTypeFlag(bindings[i].descriptorType),
+                bindings[i].descriptorCount,
+				getShaderStageFlags(bindings[i].shaderStages));
             setBindings.push_back(descriptorSetLayoutBinding);
         }
 
diff --git a/src/vkcv/DescriptorManager.hpp b/src/vkcv/DescriptorManager.hpp
index 90ad43b3..df58daa5 100644
--- a/src/vkcv/DescriptorManager.hpp
+++ b/src/vkcv/DescriptorManager.hpp
@@ -1,5 +1,5 @@
 /**
- * @authors Artur Wasmut, Susanne Dötsch, Simeon Hermann
+ * @authors Artur Wasmut, Susanne D�tsch, Simeon Hermann
  * @file src/vkcv/DescriptorManager.cpp
  * @brief Creation and handling of descriptor sets and the respective descriptor pools
  */
@@ -21,7 +21,7 @@ namespace vkcv
 	    explicit DescriptorManager(vk::Device device) noexcept;
 	    ~DescriptorManager() noexcept;
 
-        DescriptorSetHandle createDescriptorSet(const std::unordered_map<uint32_t, DescriptorBinding> &descriptorBindings);
+        DescriptorSetHandle createDescriptorSet(const std::vector<DescriptorBinding> &descriptorBindings);
 
 		void writeDescriptorSet(
 			const DescriptorSetHandle	&handle,
diff --git a/src/vkcv/PipelineManager.cpp b/src/vkcv/PipelineManager.cpp
index 0e35c2db..8b1f0b68 100644
--- a/src/vkcv/PipelineManager.cpp
+++ b/src/vkcv/PipelineManager.cpp
@@ -67,8 +67,8 @@ namespace vkcv
     {
 		const vk::RenderPass &pass = passManager.getVkPass(config.m_PassHandle);
     	
-        const bool existsVertexShader = config.m_ShaderProgram.existsShader(vk::ShaderStageFlagBits::eVertex);
-        const bool existsFragmentShader = config.m_ShaderProgram.existsShader(vk::ShaderStageFlagBits::eFragment);
+        const bool existsVertexShader = config.m_ShaderProgram.existsShader(ShaderStage::VERTEX);
+        const bool existsFragmentShader = config.m_ShaderProgram.existsShader(ShaderStage::FRAGMENT);
         if (!(existsVertexShader && existsFragmentShader))
         {
 			vkcv_log(LogLevel::ERROR, "Requires vertex and fragment shader code");
@@ -76,7 +76,7 @@ namespace vkcv
         }
 
         // vertex shader stage
-        std::vector<char> vertexCode = config.m_ShaderProgram.getShader(vk::ShaderStageFlagBits::eVertex).shaderCode;
+        std::vector<char> vertexCode = config.m_ShaderProgram.getShader(ShaderStage::VERTEX).shaderCode;
         vk::ShaderModuleCreateInfo vertexModuleInfo({}, vertexCode.size(), reinterpret_cast<uint32_t*>(vertexCode.data()));
         vk::ShaderModule vertexModule{};
         if (m_Device.createShaderModule(&vertexModuleInfo, nullptr, &vertexModule) != vk::Result::eSuccess)
@@ -91,7 +91,7 @@ namespace vkcv
         );
 
         // fragment shader stage
-        std::vector<char> fragCode = config.m_ShaderProgram.getShader(vk::ShaderStageFlagBits::eFragment).shaderCode;
+        std::vector<char> fragCode = config.m_ShaderProgram.getShader(ShaderStage::FRAGMENT).shaderCode;
         vk::ShaderModuleCreateInfo fragmentModuleInfo({}, fragCode.size(), reinterpret_cast<uint32_t*>(fragCode.data()));
         vk::ShaderModule fragmentModule{};
         if (m_Device.createShaderModule(&fragmentModuleInfo, nullptr, &fragmentModule) != vk::Result::eSuccess)
@@ -285,8 +285,8 @@ namespace vkcv
 
 		const char *geometryShaderName = "main";	// outside of if to make sure it stays in scope
 		vk::ShaderModule geometryModule;
-		if (config.m_ShaderProgram.existsShader(vk::ShaderStageFlagBits::eGeometry)) {
-			const vkcv::Shader geometryShader = config.m_ShaderProgram.getShader(vk::ShaderStageFlagBits::eGeometry);
+		if (config.m_ShaderProgram.existsShader(ShaderStage::GEOMETRY)) {
+			const vkcv::Shader geometryShader = config.m_ShaderProgram.getShader(ShaderStage::GEOMETRY);
 			const auto& geometryCode = geometryShader.shaderCode;
 			const vk::ShaderModuleCreateInfo geometryModuleInfo({}, geometryCode.size(), reinterpret_cast<const uint32_t*>(geometryCode.data()));
 			if (m_Device.createShaderModule(&geometryModuleInfo, nullptr, &geometryModule) != vk::Result::eSuccess) {
@@ -402,7 +402,7 @@ namespace vkcv
 
         // Temporally handing over the Shader Program instead of a pipeline config
         vk::ShaderModule computeModule{};
-        if (createShaderModule(computeModule, shaderProgram, vk::ShaderStageFlagBits::eCompute) != vk::Result::eSuccess)
+        if (createShaderModule(computeModule, shaderProgram, ShaderStage::COMPUTE) != vk::Result::eSuccess)
             return PipelineHandle();
 
         vk::PipelineShaderStageCreateInfo pipelineComputeShaderStageInfo(
@@ -451,7 +451,7 @@ namespace vkcv
     // There is an issue for refactoring the Pipeline Manager.
     // While including Compute Pipeline Creation, some private helper functions where introduced:
 
-    vk::Result PipelineManager::createShaderModule(vk::ShaderModule &module, const ShaderProgram &shaderProgram, const vk::ShaderStageFlagBits stage)
+    vk::Result PipelineManager::createShaderModule(vk::ShaderModule &module, const ShaderProgram &shaderProgram, const ShaderStage stage)
     {
         std::vector<char> code = shaderProgram.getShader(stage).shaderCode;
         vk::ShaderModuleCreateInfo moduleInfo({}, code.size(), reinterpret_cast<uint32_t*>(code.data()));
diff --git a/src/vkcv/PipelineManager.hpp b/src/vkcv/PipelineManager.hpp
index b48e06f0..b153eb46 100644
--- a/src/vkcv/PipelineManager.hpp
+++ b/src/vkcv/PipelineManager.hpp
@@ -22,7 +22,7 @@ namespace vkcv
         
         void destroyPipelineById(uint64_t id);
 
-        vk::Result createShaderModule(vk::ShaderModule &module, const ShaderProgram &shaderProgram, vk::ShaderStageFlagBits stage);
+        vk::Result createShaderModule(vk::ShaderModule &module, const ShaderProgram &shaderProgram, ShaderStage stage);
 
     public:
         PipelineManager() = delete; // no default ctor
diff --git a/src/vkcv/ShaderProgram.cpp b/src/vkcv/ShaderProgram.cpp
index 5225b567..134ba7af 100644
--- a/src/vkcv/ShaderProgram.cpp
+++ b/src/vkcv/ShaderProgram.cpp
@@ -76,7 +76,7 @@ namespace vkcv {
     m_DescriptorSets{}
 	{}
 
-	bool ShaderProgram::addShader(vk::ShaderStageFlagBits shaderStage, const std::filesystem::path &shaderPath)
+	bool ShaderProgram::addShader(ShaderStage shaderStage, const std::filesystem::path &shaderPath)
 	{
 	    if(m_Shaders.find(shaderStage) != m_Shaders.end()) {
 			vkcv_log(LogLevel::WARNING, "Overwriting existing shader stage");
@@ -94,12 +94,12 @@ namespace vkcv {
         }
 	}
 
-    const Shader &ShaderProgram::getShader(vk::ShaderStageFlagBits shaderStage) const
+    const Shader &ShaderProgram::getShader(ShaderStage shaderStage) const
     {
 	    return m_Shaders.at(shaderStage);
 	}
 
-    bool ShaderProgram::existsShader(vk::ShaderStageFlagBits shaderStage) const
+    bool ShaderProgram::existsShader(ShaderStage shaderStage) const
     {
 	    if(m_Shaders.find(shaderStage) == m_Shaders.end())
 	        return false;
@@ -107,7 +107,7 @@ namespace vkcv {
 	        return true;
     }
 
-    void ShaderProgram::reflectShader(vk::ShaderStageFlagBits shaderStage)
+    void ShaderProgram::reflectShader(ShaderStage shaderStage)
     {
         auto shaderCodeChar = m_Shaders.at(shaderStage).shaderCode;
         std::vector<uint32_t> shaderCode;
@@ -119,7 +119,7 @@ namespace vkcv {
         spirv_cross::ShaderResources resources = comp.get_shader_resources();
 
         //reflect vertex input
-		if (shaderStage == vk::ShaderStageFlagBits::eVertex)
+		if (shaderStage == ShaderStage::VERTEX)
 		{
 			// spirv-cross API (hopefully) returns the stage_inputs in order
 			for (uint32_t i = 0; i < resources.stage_inputs.size(); i++)
@@ -140,195 +140,80 @@ namespace vkcv {
 		}
 
 		//reflect descriptor sets (uniform buffer, storage buffer, sampler, sampled image, storage image)
-        // std::vector<std::pair<uint32_t, DescriptorBinding>> bindings;
+        std::vector<std::pair<uint32_t, DescriptorBinding>> bindings;
         int32_t maxSetID = -1;
         for (uint32_t i = 0; i < resources.uniform_buffers.size(); i++) {
             auto& u = resources.uniform_buffers[i];
             const spirv_cross::SPIRType& base_type = comp.get_type(u.base_type_id);
-
-            const uint32_t setID = comp.get_decoration(u.id, spv::DecorationDescriptorSet);
-            const uint32_t bindingID = comp.get_decoration(u.id, spv::DecorationBinding);
-
-            const DescriptorBinding binding(bindingID, DescriptorType::UNIFORM_BUFFER, base_type.vecsize, shaderStage);
-
-            auto setIter = m_DescriptorSets.find(setID);
-            if (setIter == m_DescriptorSets.end())
-            {
-                // create a map for this set ID
-                std::unordered_map<uint32_t, DescriptorBinding> setBindings;
-                // insert the binding to this set ID's bindings
-                setBindings.insert(std::make_pair(bindingID, binding));
-                // insert this set ID's map to the descriptor sets
-                m_DescriptorSets.insert(std::make_pair(setID, setBindings));
-            }
-            else
-            {
-                // search for an existing binding for this set
-                auto bindingIter = setIter->second.find(bindingID);
-                if (bindingIter == setIter->second.end())
-                {
-                    // if binding did not exist, insert it
-                    setIter->second.insert(std::make_pair(bindingID, binding));
-                }
-                else
-                {
-                    if(bindingIter->second.descriptorType != DescriptorType::UNIFORM_BUFFER)
-                        vkcv_log(LogLevel::WARNING, "Descriptor type mismatch in shader reflection!");
-                    // if binding exists, append additional shader stage to it
-                    bindingIter->second.shaderStages | shaderStage;
-                }
-            }
+            std::pair descriptor(comp.get_decoration(u.id, spv::DecorationDescriptorSet),
+                DescriptorBinding(comp.get_decoration(u.id, spv::DecorationBinding), DescriptorType::UNIFORM_BUFFER, base_type.vecsize, shaderStage));
+            bindings.push_back(descriptor);
+            if ((int32_t)comp.get_decoration(u.id, spv::DecorationDescriptorSet) > maxSetID) 
+                maxSetID = comp.get_decoration(u.id, spv::DecorationDescriptorSet);
         }
 
         for (uint32_t i = 0; i < resources.storage_buffers.size(); i++) {
             auto& u = resources.storage_buffers[i];
             const spirv_cross::SPIRType& base_type = comp.get_type(u.base_type_id);
-
-            const uint32_t setID = comp.get_decoration(u.id, spv::DecorationDescriptorSet);
-            const uint32_t bindingID = comp.get_decoration(u.id, spv::DecorationBinding);
-
-            const DescriptorBinding binding(bindingID, DescriptorType::STORAGE_BUFFER, base_type.vecsize, shaderStage);
-
-            auto setIter = m_DescriptorSets.find(setID);
-            if (setIter == m_DescriptorSets.end())
-            {
-                // create a map for this set ID
-                std::unordered_map<uint32_t, DescriptorBinding> setBindings;
-                // insert the binding to this set ID's bindings
-                setBindings.insert(std::make_pair(bindingID, binding));
-                // insert this set ID's map to the descriptor sets
-                m_DescriptorSets.insert(std::make_pair(setID, setBindings));
-            }
-            else
-            {
-                // search for an existing binding for this set
-                auto bindingIter = setIter->second.find(bindingID);
-                if (bindingIter == setIter->second.end())
-                {
-                    // if binding did not exist, insert it
-                    setIter->second.insert(std::make_pair(bindingID, binding));
-                }
-                else
-                {
-                    if (bindingIter->second.descriptorType != DescriptorType::STORAGE_BUFFER)
-                        vkcv_log(LogLevel::WARNING, "Descriptor type mismatch in shader reflection!");
-                    // if binding exists, append additional shader stage to it
-                    bindingIter->second.shaderStages | shaderStage;
-                }
-            }
+            std::pair descriptor(comp.get_decoration(u.id, spv::DecorationDescriptorSet),
+                DescriptorBinding(comp.get_decoration(u.id, spv::DecorationBinding), DescriptorType::STORAGE_BUFFER, base_type.vecsize, shaderStage));
+            bindings.push_back(descriptor);
+            if ((int32_t)comp.get_decoration(u.id, spv::DecorationDescriptorSet) > maxSetID) 
+                maxSetID = comp.get_decoration(u.id, spv::DecorationDescriptorSet);
         }
 
         for (uint32_t i = 0; i < resources.separate_samplers.size(); i++) {
             auto& u = resources.separate_samplers[i];
             const spirv_cross::SPIRType& base_type = comp.get_type(u.base_type_id);
-
-            const uint32_t setID = comp.get_decoration(u.id, spv::DecorationDescriptorSet);
-            const uint32_t bindingID = comp.get_decoration(u.id, spv::DecorationBinding);
-
-            const DescriptorBinding binding(bindingID, DescriptorType::SAMPLER, base_type.vecsize, shaderStage);
-
-            auto setIter = m_DescriptorSets.find(setID);
-            if (setIter == m_DescriptorSets.end())
-            {
-                // create a map for this set ID
-                std::unordered_map<uint32_t, DescriptorBinding> setBindings;
-                // insert the binding to this set ID's bindings
-                setBindings.insert(std::make_pair(bindingID, binding));
-                // insert this set ID's map to the descriptor sets
-                m_DescriptorSets.insert(std::make_pair(setID, setBindings));
-            }
-            else
-            {
-                // search for an existing binding for this set
-                auto bindingIter = setIter->second.find(bindingID);
-                if (bindingIter == setIter->second.end())
-                {
-                    // if binding did not exist, insert it
-                    setIter->second.insert(std::make_pair(bindingID, binding));
-                }
-                else
-                {
-                    if (bindingIter->second.descriptorType != DescriptorType::SAMPLER)
-                        vkcv_log(LogLevel::WARNING, "Descriptor type mismatch in shader reflection!");
-                    // if binding exists, append additional shader stage to it
-                    bindingIter->second.shaderStages | shaderStage;
-                }
-            }
+            std::pair descriptor(comp.get_decoration(u.id, spv::DecorationDescriptorSet),
+                DescriptorBinding(comp.get_decoration(u.id, spv::DecorationBinding), DescriptorType::SAMPLER, base_type.vecsize, shaderStage));
+            bindings.push_back(descriptor);
+            if ((int32_t)comp.get_decoration(u.id, spv::DecorationDescriptorSet) > maxSetID) 
+                maxSetID = comp.get_decoration(u.id, spv::DecorationDescriptorSet);
         }
 
         for (uint32_t i = 0; i < resources.separate_images.size(); i++) {
             auto& u = resources.separate_images[i];
             const spirv_cross::SPIRType& base_type = comp.get_type(u.base_type_id);
+            std::pair descriptor(comp.get_decoration(u.id, spv::DecorationDescriptorSet),
+                DescriptorBinding(comp.get_decoration(u.id, spv::DecorationBinding), DescriptorType::IMAGE_SAMPLED, base_type.vecsize, shaderStage));
+            bindings.push_back(descriptor);
+            if ((int32_t)comp.get_decoration(u.id, spv::DecorationDescriptorSet) > maxSetID)
+                maxSetID = comp.get_decoration(u.id, spv::DecorationDescriptorSet);
 
-            const uint32_t setID = comp.get_decoration(u.id, spv::DecorationDescriptorSet);
-            const uint32_t bindingID = comp.get_decoration(u.id, spv::DecorationBinding);
-
-            const DescriptorBinding binding(bindingID, DescriptorType::IMAGE_SAMPLED, base_type.vecsize, shaderStage);
-
-            auto setIter = m_DescriptorSets.find(setID);
-            if (setIter == m_DescriptorSets.end())
-            {
-                // create a map for this set ID
-                std::unordered_map<uint32_t, DescriptorBinding> setBindings;
-                // insert the binding to this set ID's bindings
-                setBindings.insert(std::make_pair(bindingID, binding));
-                // insert this set ID's map to the descriptor sets
-                m_DescriptorSets.insert(std::make_pair(setID, setBindings));
-            }
-            else
-            {
-                // search for an existing binding for this set
-                auto bindingIter = setIter->second.find(bindingID);
-                if (bindingIter == setIter->second.end())
-                {
-                    // if binding did not exist, insert it
-                    setIter->second.insert(std::make_pair(bindingID, binding));
-                }
-                else
-                {
-                    if (bindingIter->second.descriptorType != DescriptorType::IMAGE_SAMPLED)
-                        vkcv_log(LogLevel::WARNING, "Descriptor type mismatch in shader reflection!");
-                    // if binding exists, append additional shader stage to it
-                    bindingIter->second.shaderStages | shaderStage;
-                }
-            }
         }
 
         for (uint32_t i = 0; i < resources.storage_images.size(); i++) {
             auto& u = resources.storage_images[i];
             const spirv_cross::SPIRType& base_type = comp.get_type(u.base_type_id);
-
-            const uint32_t setID = comp.get_decoration(u.id, spv::DecorationDescriptorSet);
-            const uint32_t bindingID = comp.get_decoration(u.id, spv::DecorationBinding);
-
-            const DescriptorBinding binding(bindingID, DescriptorType::IMAGE_STORAGE, base_type.vecsize, shaderStage);
-
-            auto setIter = m_DescriptorSets.find(setID);
-            if (setIter == m_DescriptorSets.end())
-            {
-                // create a map for this set ID
-                std::unordered_map<uint32_t, DescriptorBinding> setBindings;
-                // insert the binding to this set ID's bindings
-                setBindings.insert(std::make_pair(bindingID, binding));
-                // insert this set ID's map to the descriptor sets
-                m_DescriptorSets.insert(std::make_pair(setID, setBindings));
-            }
-            else
-            {
-                // search for an existing binding for this set
-                auto bindingIter = setIter->second.find(bindingID);
-                if (bindingIter == setIter->second.end())
-                {
-                    // if binding did not exist, insert it
-                    setIter->second.insert(std::make_pair(bindingID, binding));
-                }
-                else
-                {
-                    if (bindingIter->second.descriptorType != DescriptorType::IMAGE_STORAGE)
-                        vkcv_log(LogLevel::WARNING, "Descriptor type mismatch in shader reflection!");
-                    // if binding exists, append additional shader stage to it
-                    bindingIter->second.shaderStages | shaderStage;
+            std::pair descriptor(comp.get_decoration(u.id, spv::DecorationDescriptorSet),
+                DescriptorBinding(comp.get_decoration(u.id, spv::DecorationBinding), DescriptorType::IMAGE_STORAGE, base_type.vecsize, shaderStage));
+            bindings.push_back(descriptor);
+            if ((int32_t)comp.get_decoration(u.id, spv::DecorationDescriptorSet) > maxSetID)
+                maxSetID = comp.get_decoration(u.id, spv::DecorationDescriptorSet);
+        }
+        if (maxSetID != -1) {
+            if((int32_t)m_DescriptorSets.size() <= maxSetID) m_DescriptorSets.resize(maxSetID + 1);
+            for (const auto &binding : bindings) {
+                //checking if descriptor has already been reflected in another shader stage
+                bool bindingFound = false;
+                uint32_t pos = 0;
+                for (const auto& descriptor : m_DescriptorSets[binding.first]) {
+                    if (binding.second.bindingID == descriptor.bindingID) {
+                        if (binding.second.descriptorType == descriptor.descriptorType && binding.second.descriptorCount == descriptor.descriptorCount) {
+                            //updating descriptor binding with another shader stage
+                            ShaderStages updatedShaders = descriptor.shaderStages | shaderStage;
+                            DescriptorBinding newBinding = DescriptorBinding(binding.second.bindingID, binding.second.descriptorType, binding.second.descriptorCount, updatedShaders);
+                            m_DescriptorSets[binding.first][pos] = newBinding;
+                            bindingFound = true;
+                            break;
+                        }
+                        else vkcv_log(LogLevel::ERROR, "Included shaders contain resources with same identifier but different type or count");
+                    }
+                    pos++;
                 }
+                //append new descriptor if it has not been reflected yet
+                if(!bindingFound) m_DescriptorSets[binding.first].push_back(binding.second);
             }
         }
 
@@ -346,7 +231,7 @@ namespace vkcv {
         return m_VertexAttachments;
 	}
 
-    const std::unordered_map<uint32_t, std::unordered_map<uint32_t, DescriptorBinding>>& ShaderProgram::getReflectedDescriptors() const {
+    const std::vector<std::vector<DescriptorBinding>>& ShaderProgram::getReflectedDescriptors() const {
         return m_DescriptorSets;
     }
 
-- 
GitLab