RT pipeline

interfaces/Crafter.Graphics-DescriptorLayoutVulkan.cppm

@@ -0,0 +1,128 @@
+/*
+Crafter®.Graphics
+Copyright (C) 2026 Catcrafts®
+catcrafts.net
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License version 3.0 as published by the Free Software Foundation;
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+*/
+
+module;
+#ifdef CRAFTER_GRAPHICS_VULKAN
+#include <vulkan/vulkan.h>
+#endif
+export module Crafter.Graphics:DescriptorLayoutVulkan;
+#ifdef CRAFTER_GRAPHICS_VULKAN
+import std;
+import :VulkanDevice;
+import :Types;
+
+export namespace Crafter {
+    struct DescriptorEntry {
+        VkDescriptorType type;
+        bool occured = true;
+    };
+
+    template <typename... Shaders>
+    class DescriptorLayoutVulkan {
+        public:
+        inline static VkDescriptorSetLayout descriptorSetLayout[sizeof...(Shaders)];
+
+        template <typename Shader>
+        consteval static void GetOccuringDescriptors(std::array<DescriptorEntry, 20>& types) {
+            for (const DescriptorBinding& binding : Shader::descriptors) {
+                for (DescriptorEntry& type : types) {
+                    if (type.type == binding.type) {
+                        type.occured = true;
+                    }
+                }
+            }
+        }
+
+        consteval static std::uint32_t GetUniqueDiscriptorCount() {
+            std::array<DescriptorEntry, 20> types = {{{VK_DESCRIPTOR_TYPE_SAMPLER, 0},{VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 0},{VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 0},{VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 0},{VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 0},{VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 0},{VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0},{VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 0},{VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 0},{VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, 0},{VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 0},{VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK, 0},{VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, 0},{VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV, 0},{VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, 0},{VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, 0},{VK_DESCRIPTOR_TYPE_MUTABLE_EXT, 0},{VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV, 0},{VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, 0},{VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, 0}}};
+    
+            (GetOccuringDescriptors<Shaders>(types), ... );
+    
+            std::uint32_t size = 0;
+            for(DescriptorEntry& type : types) {
+                if(type.occured) {
+                    size++;
+                }
+            }
+    
+            return size;
+        }
+        constexpr static std::uint32_t uniqueDescriptorCount = GetUniqueDiscriptorCount();
+    
+        consteval static std::array<VkDescriptorPoolSize, uniqueDescriptorCount> GetPoolSizes() {
+            std::array<VkDescriptorPoolSize, uniqueDescriptorCount> types = {};
+            for(std::uint32_t i = 0; i < uniqueDescriptorCount; i++){
+                types[i].descriptorCount = 12345;
+            }
+
+            ([&] {
+                    for (const DescriptorBinding& binding : Shaders::descriptors) {
+                        bool found = false;
+                        for(VkDescriptorPoolSize& type : types) {
+                            if(type.type == binding.type && type.descriptorCount != 12345) {
+                                type.descriptorCount += 1;
+                                found = true;
+                            }
+                        }
+                        if(!found) {
+                            for(std::uint32_t i = 0; i < uniqueDescriptorCount; i++){
+                                if(types[i].descriptorCount == 12345) {
+                                    types[i].type = binding.type;
+                                    types[i].descriptorCount = 1;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }(), 
+            ...);
+    
+            return types;
+        }
+
+        template <typename Shader>
+		consteval static std::array<VkDescriptorSetLayoutBinding, Shader::descriptorCount> GetDescriptorSet() {
+			std::array<VkDescriptorSetLayoutBinding, Shader::descriptorCount> set;
+
+			for(std::uint32_t i = 0; i < Shader::descriptors.size(); i++) {
+				set[i] = {Shader::descriptors[i].slot, Shader::descriptors[i].type, 1, Shader::_stage, nullptr};
+			}
+
+			return set;
+		}
+
+        public:
+        static void Init() {
+            std::uint32_t shaderIndex = 0;
+
+            ([&] {
+                    constexpr std::array<VkDescriptorSetLayoutBinding, Shaders::descriptorCount> setLayoutBindingsMesh = GetDescriptorSet<Shaders>();
+                    VkDescriptorSetLayoutCreateInfo descriptorLayoutInfoMesh = {
+                        .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
+                        .bindingCount = Shaders::descriptorCount,
+                        .pBindings = setLayoutBindingsMesh.data()
+                    };
+                    VulkanDevice::CheckVkResult(vkCreateDescriptorSetLayout(VulkanDevice::device, &descriptorLayoutInfoMesh, nullptr, &descriptorSetLayout[shaderIndex++]));
+                }(), 
+            ...);
+        }
+    };
+}
+
+#endif