Crafter.Graphics/interfaces/Crafter.Graphics-DescriptorSetVulkan.cppm

/*
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:DescriptorSetVulkan;
#ifdef CRAFTER_GRAPHICS_VULKAN
import std;
import :VulkanDevice;
import :Types;
import Crafter.Event;

export namespace Crafter {
    struct DescriptorEntry {
        VkDescriptorType type;
        bool occured = true;
    };


    template <std::uint32_t PoolCount, typename... Shaders>
    class DescriptorPool {
        public:
        inline static Event<void> onDescriptorRefresh;
        inline static std::uint32_t setIndex = 0;
        inline static std::uint32_t setsCount = 0;
        inline static std::vector<VkDescriptorSet> sets;
        inline static VkDescriptorPool descriptorPool[PoolCount] = { VK_NULL_HANDLE };

        private:
        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 BuildPool(std::uint32_t poolIndex) {
            if(descriptorPool[poolIndex] != VK_NULL_HANDLE) {
                vkDestroyDescriptorPool(VulkanDevice::device, descriptorPool[poolIndex], nullptr);
            }
    
            std::array<VkDescriptorPoolSize, uniqueDescriptorCount> poolSizes = GetPoolSizes();
            for(VkDescriptorPoolSize& size : poolSizes) {
                size.descriptorCount *= setsCount;
            }

            VkDescriptorPoolCreateInfo descriptorPoolInfo {
                .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
                .maxSets = static_cast<std::uint32_t>(setsCount),
                .poolSizeCount = uniqueDescriptorCount,
                .pPoolSizes = poolSizes.data()
            };

            VulkanDevice::CheckVkResult(vkCreateDescriptorPool(VulkanDevice::device, &descriptorPoolInfo, nullptr, &descriptorPool[poolIndex]));

            VkDescriptorSetLayout descriptorSetLayout[sizeof...(Shaders)];

            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++]));
                }(), 
            ...);

            VkDescriptorSetAllocateInfo allocInfo {
                .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
                .descriptorPool = descriptorPool[poolIndex],
                .descriptorSetCount = setsCount,
                .pSetLayouts = descriptorSetLayout,
            };

            sets.resize(setsCount);
            VulkanDevice::CheckVkResult(vkAllocateDescriptorSets(VulkanDevice::device, &allocInfo, sets.data()));

            setIndex = 0;

            onDescriptorRefresh.Invoke();
        }
    };
}

#endif