DescriptorBuilder.hpp

Go to the documentation of this file.

#pragma once
#include <vulkan/vulkan.h>
 
#include <memory>
#include <unordered_map>
#include <vector>
 
// Chunk size for descriptor pool allocations
constexpr VkDeviceSize POOL_CHUNK_SIZE = 256;
 
// Standard pool sizes for descriptor types
const std::vector<VkDescriptorPoolSize> STANDARD_POOL_SIZES({{VK_DESCRIPTOR_TYPE_SAMPLER, 1000},
                                                             {VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1000},
                                                             {VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1000},
                                                             {VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1000},
                                                             {VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 1000},
                                                             {VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 1000},
                                                             {VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1000},
                                                             {VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1000},
                                                             {VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1000},
                                                             {VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, 1000},
                                                             {VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 1000}});
 
class PoolManager
{
public:
    PoolManager(VkDevice device);
    ~PoolManager();
 
    void resetPools();
 
    bool allocateDescriptorSet(VkDescriptorSetLayout layout, VkDescriptorSet& descSet);
 
    VkDescriptorPool createPool(VkDevice device, VkDescriptorPoolCreateFlags flags, uint32_t maxSets,
                                const std::vector<VkDescriptorPoolSize>& poolSizes);
 
    VkDevice getDevice() const
    {
        return logDeviceM;
    }
 
private:
    VkDescriptorPool grabPool();
 
    VkDevice logDeviceM;
    VkDescriptorPool currentPoolM;
    std::vector<VkDescriptorPool> freePoolsM;
    std::vector<VkDescriptorPool> usedPoolsM;
};
 
class DescriptorSetLayoutCache
{
public:
    DescriptorSetLayoutCache(VkDevice device);
    ~DescriptorSetLayoutCache();
 
    VkDescriptorSetLayout createDescriptorSetLayout(VkDescriptorSetLayoutCreateInfo& layoutInfo);
 
    VkDescriptorSetLayout createDescriptorSetLayout(const VkDescriptorSetLayoutBinding* bindings,
                                                    uint32_t bindingCount);
 
    struct DescriptorSetLayoutInfo
    {
        std::vector<VkDescriptorSetLayoutBinding> bindings;
        bool operator==(const DescriptorSetLayoutInfo& other) const;
        size_t hash() const;
    };
 
private:
    struct DescriptorLayoutHasher
    {
        size_t operator()(const DescriptorSetLayoutInfo& info) const
        {
            return info.hash();
        }
    };
 
    VkDevice logDeviceM;
    std::unordered_map<DescriptorSetLayoutInfo, VkDescriptorSetLayout, DescriptorLayoutHasher> layoutCacheM;
};
 
class DescriptorBuilder
{
public:
    DescriptorBuilder(PoolManager& poolManager, DescriptorSetLayoutCache& cache);
    ~DescriptorBuilder();
 
    DescriptorBuilder& bindBuffer(VkDescriptorBufferInfo& bufferInfo, VkDescriptorType type,
                                  VkShaderStageFlags stageFlags);
 
    DescriptorBuilder& bindBuffers(const VkDescriptorBufferInfo* bufferInfos, VkDescriptorType type, VkShaderStageFlags stageFlags, uint32_t count);
 
    DescriptorBuilder& bindImage(VkDescriptorImageInfo& imageInfo, VkDescriptorType type,
                                 VkShaderStageFlags stageFlags);
 
    DescriptorBuilder& bindImages(const VkDescriptorImageInfo* imageInfos, VkDescriptorType type,
                                  VkShaderStageFlags stageFlags, uint32_t count);
 
    bool build(VkDescriptorSet& set, VkDescriptorSetLayout& layout);
 
    bool build(VkDescriptorSet& set);
 
    void setDescriptorSetLayout(const VkDescriptorSetLayoutBinding* bindings, uint32_t bindingCount,
                                VkDescriptorSetLayout& layout);
 
    const PoolManager& getPoolManager() const;
 
private:
    uint32_t currentBindingM;
    std::vector<VkWriteDescriptorSet> writeSetsM;
    std::vector<VkDescriptorSetLayoutBinding> layoutBindingsM;
 
    std::unique_ptr<PoolManager> pPoolManagerM;
    std::unique_ptr<DescriptorSetLayoutCache> pLayoutCacheM;
};