DescriptorSetLayoutGenerator.h

#pragma once
 
// Standard.
#include <variant>
#include <vector>
#include <unordered_map>
#include <array>
#include <unordered_set>
 
// Custom.
#include "misc/Error.h"
#include "render/general/resources/frame/FrameResourceManager.h"
#include "shader/VulkanAlignmentConstants.hpp"
#include "misc/StdHashes.hpp"
 
// External.
#include "vulkan/vulkan.h"
 
namespace ne {
    class GlslShader;
    class VulkanRenderer;
 
    enum class GlslResourceType {
        UNIFORM_BUFFER,
        STORAGE_BUFFER,
        COMBINED_SAMPLER,
        STORAGE_IMAGE,
        // ... add new resource types here ...
    };
 
    class DescriptorSetLayoutGenerator {
    public:
        struct Collected {
            struct DescriptorSetLayoutBindingInfo {
                GlslResourceType resourceType;
 
                std::string sResourceName;
            };
 
            std::unordered_map<uint32_t, DescriptorSetLayoutBindingInfo> bindingInfo;
 
            std::unordered_map<std::string, size_t> pushConstantUintFieldOffsets;
        };
 
        struct Generated {
            VkDescriptorSetLayout pDescriptorSetLayout = nullptr;
 
            VkDescriptorPool pDescriptorPool = nullptr;
 
            std::array<VkDescriptorSet, FrameResourceManager::getFrameResourceCount()> vDescriptorSets;
 
            std::unordered_map<std::string, uint32_t, StdStringHash, std::equal_to<>> resourceBindings;
 
            std::unordered_map<std::string, size_t> pushConstantUintFieldOffsets;
        };
 
        DescriptorSetLayoutGenerator() = delete;
        DescriptorSetLayoutGenerator(const DescriptorSetLayoutGenerator&) = delete;
        DescriptorSetLayoutGenerator& operator=(const DescriptorSetLayoutGenerator&) = delete;
 
        static std::variant<Collected, Error>
        collectInfoFromBytecode(void* pSpirvBytecode, size_t iSizeInBytes);
 
        static std::variant<Generated, Error>
        generateGraphics(VulkanRenderer* pRenderer, GlslShader* pVertexShader, GlslShader* pFragmentShader);
 
        static std::variant<Generated, Error>
        generateCompute(VulkanRenderer* pRenderer, GlslShader* pComputeShader);
 
    private:
        static std::variant<std::pair<VkDescriptorSetLayoutBinding, VkDescriptorBindingFlags>, Error>
        generateLayoutBinding(
            uint32_t iBindingIndex,
            const Collected::DescriptorSetLayoutBindingInfo& bindingInfo,
            bool bIsComputeShader);
    };
} // namespace ne