VulkanDescriptorSets.h

Go to the documentation of this file.

 
#pragma once
 
#include "KarmaTypes.h"
#include <vulkan/vulkan.h>
 
namespace Karma
{
    class FVulkanDevice;
    
    class FVulkanDescriptorSetsLayoutInfo
    {
    public:
        FVulkanDescriptorSetsLayoutInfo()
        {
        }
 
        void SetLayoutTypes(const KarmaVector<VkDescriptorType>& NeededDescriptorTypes)
        {
            for (const VkDescriptorType& type : NeededDescriptorTypes)
            {
                m_LayoutTypes.Add(type, 1);
            }
        }
        
        inline uint32_t GetTypesUsed(VkDescriptorType Type) const
        {
            if (m_LayoutTypes.Contains(Type))
            {
                return m_LayoutTypes[Type];
            }
            else
            {
                return 0;
            }
        }
        
        struct FSetLayout
        {
            KarmaVector<VkDescriptorSetLayoutBinding> m_LayoutBindings;
            uint32_t m_Hash = 0;

            uint32_t m_NumberOfDescriptorSets = 0;
            
            inline void GenerateHash()
            {
                // Simple hash generation based on bindings
                m_Hash = 0;
                for (const auto& binding : m_LayoutBindings)
                {
                    m_Hash ^= std::hash<uint32_t>()(binding.binding) ^
                    std::hash<uint32_t>()(binding.descriptorType) ^
                    std::hash<uint32_t>()(binding.descriptorCount) ^
                    std::hash<uint32_t>()(binding.stageFlags);
                }
            }
            
            friend uint32_t GetTypeHash(const FSetLayout& Layout)
            {
                return Layout.m_Hash;
            }
            
        };
        
        inline const KarmaVector<FSetLayout>& GetLayouts() const
        {
            return m_SetLayouts;
        }
        
        inline const KarmaMap<VkDescriptorType, uint32_t>& GetLayoutTypes() const
        {
            return m_LayoutTypes;
        }
        
    /*protected:*/
        void AddDescriptor(int32_t DescriptorSetIndex, const VkDescriptorSetLayoutBinding& Descriptor);
        void AddDescriptorSet(FSetLayout SetLayout);
 
    protected:
        KarmaMap<VkDescriptorType, uint32_t> m_LayoutTypes;
        KarmaVector<FSetLayout> m_SetLayouts;
        
        uint32_t m_Hash = 0;
        VkPipelineBindPoint m_BindPoint = VK_PIPELINE_BIND_POINT_MAX_ENUM;
    };
 
    class FVulkanDescriptorSetsLayout : public FVulkanDescriptorSetsLayoutInfo
    {
    public:
        FVulkanDescriptorSetsLayout(FVulkanDevice* InDevice);
        ~FVulkanDescriptorSetsLayout();
 
        void Compile();
 
        inline const KarmaVector<VkDescriptorSetLayout>& GetHandles() const
        {
            return m_LayoutHandles;
        }
 
        inline const KarmaVector<uint32_t>& GetHandleIds() const
        {
            return m_LayoutHandleIds;
        }
 
        inline const VkDescriptorSetAllocateInfo& GetAllocateInfo() const
        {
            return m_DescriptorSetsAllocateInfo;
        }
 
        inline uint32_t GetHash() const
        {
            return m_Hash;
        }
 
    private:
        FVulkanDevice* m_Device;
        KarmaVector<VkDescriptorSetLayout> m_LayoutHandles;
        KarmaVector<uint32_t> m_LayoutHandleIds;
        VkDescriptorSetAllocateInfo m_DescriptorSetsAllocateInfo;
    };
 
    struct FVulkanDescriptorSets
    {
        FVulkanDescriptorSets(FVulkanDevice* InDevice, const FVulkanDescriptorSetsLayout& InLayout);

        void UpdateUniformBufferDescriptorSet(class VulkanUniformBuffer* Uniform, uint32_t SetLayoutIndex, uint32_t DescriptorSetIndex, uint32_t FrameIndex);

        void UpdateTextureDescriptorSet(class VulkanTexture* Texture, uint32_t SetLayoutIndex, uint32_t DescriptorSetIndex);
 
        FVulkanDevice* m_Device;
        KarmaVector<KarmaVector<VkDescriptorSet>> m_DescriptorSets;
    };
 
    class FVulkanDescriptorPool
    {
    public:
        FVulkanDescriptorPool(FVulkanDevice* InDevice, const FVulkanDescriptorSetsLayout& InLayout/*, uint32_t MaxSetsAllocations*/);
        ~FVulkanDescriptorPool();

        inline VkDescriptorPool GetHandle() const
        {
            return m_DescriptorPool;
        }
 
        
        void AllocateDescriptorSets(const FVulkanDescriptorSetsLayout& InLayout, FVulkanDescriptorSets& InDSets);
 
    private:
        FVulkanDevice* m_Device;
        uint32_t m_MaxDescriptorSets;
        const FVulkanDescriptorSetsLayout& m_Layout;
        VkDescriptorPool m_DescriptorPool;
    };
 
    class FVulkanDescriptorPoolsManager
    {
    private:
        FVulkanDevice* m_Device = nullptr;
 
    };
}