Descriptors.hpp

Go to the documentation of this file.

///
/// @file Descriptors.hpp
/// @brief This file contains the Descriptors class
/// @namespace ven
///
 
#pragma once
 
#include <memory>
#include <unordered_map>
 
#include "VEngine/Device.hpp"
 
namespace ven {
 
///
    /// @class DescriptorSetLayout
    /// @brief Class for descriptor set layout
    /// @namespace ven
    ///
    class DescriptorSetLayout {
 
        public:
 
            class Builder {
 
                public:
 
                    explicit Builder(Device &device) : m_device{device} {}
 
                    Builder &addBinding(uint32_t binding, VkDescriptorType descriptorType, VkShaderStageFlags stageFlags, uint32_t count = 1);
                    std::unique_ptr<DescriptorSetLayout> build() const { return std::make_unique<DescriptorSetLayout>(m_device, m_bindings); }
 
                private:
                    Device &m_device;
                    std::unordered_map<uint32_t, VkDescriptorSetLayoutBinding> m_bindings;
            };
 
            DescriptorSetLayout(Device &device, const std::unordered_map<uint32_t, VkDescriptorSetLayoutBinding>& bindings);
            ~DescriptorSetLayout() { vkDestroyDescriptorSetLayout(m_device.device(), m_descriptorSetLayout, nullptr); }
            DescriptorSetLayout(const DescriptorSetLayout &) = delete;
            DescriptorSetLayout &operator=(const DescriptorSetLayout &) = delete;
 
            VkDescriptorSetLayout getDescriptorSetLayout() const { return m_descriptorSetLayout; }
 
        private:
 
            Device &m_device;
            VkDescriptorSetLayout m_descriptorSetLayout;
            std::unordered_map<uint32_t, VkDescriptorSetLayoutBinding> m_bindings;
 
            friend class DescriptorWriter;
 
    }; // class DescriptorSetLayout
 
    ///
    /// @class DescriptorPool
    /// @brief Class for descriptor pool
    /// @namespace ven
    ///
    class DescriptorPool {
 
        public:
 
            class Builder {
 
                public:
 
                    explicit Builder(Device &device) : m_device{device} {}
 
                    Builder &addPoolSize(VkDescriptorType descriptorType, uint32_t count);
                    Builder &setPoolFlags(VkDescriptorPoolCreateFlags flags);
                    Builder &setMaxSets(uint32_t count);
                    [[nodiscard]] std::unique_ptr<DescriptorPool> build() const { return std::make_unique<DescriptorPool>(m_device, m_maxSets, m_poolFlags, m_poolSizes); }
 
                private:
 
                    Device &m_device;
                    std::vector<VkDescriptorPoolSize> m_poolSizes;
                    uint32_t m_maxSets = 1000;
                    VkDescriptorPoolCreateFlags m_poolFlags = 0;
            };
 
            DescriptorPool(Device &device, uint32_t maxSets, VkDescriptorPoolCreateFlags poolFlags, const std::vector<VkDescriptorPoolSize> &poolSizes);
            ~DescriptorPool() { vkDestroyDescriptorPool(m_device.device(), m_descriptorPool, nullptr); }
            DescriptorPool(const DescriptorPool &) = delete;
            DescriptorPool &operator=(const DescriptorPool &) = delete;
 
            bool allocateDescriptor(VkDescriptorSetLayout descriptorSetLayout, VkDescriptorSet &descriptor) const;
 
            void freeDescriptors(const std::vector<VkDescriptorSet> &descriptors) const { vkFreeDescriptorSets(m_device.device(), m_descriptorPool, static_cast<uint32_t>(descriptors.size()), descriptors.data()); }
 
            void resetPool() const { vkResetDescriptorPool(m_device.device(), m_descriptorPool, 0); }
 
        private:
 
            Device &m_device;
            VkDescriptorPool m_descriptorPool;
 
            friend class DescriptorWriter;
 
    }; // class DescriptorPool
 
    ///
    /// @class DescriptorWriter
    /// @brief Class for descriptor writer
    /// @namespace ven
    ///
    class DescriptorWriter {
 
        public:
 
            DescriptorWriter(DescriptorSetLayout &setLayout, DescriptorPool &pool) :  m_setLayout{setLayout}, m_pool{pool} {}
 
            DescriptorWriter &writeBuffer(uint32_t binding, const VkDescriptorBufferInfo *bufferInfo);
            DescriptorWriter &writeImage(uint32_t binding, const VkDescriptorImageInfo *imageInfo);
 
            bool build(VkDescriptorSet &set);
            void overwrite(const VkDescriptorSet &set);
 
        private:
 
            DescriptorSetLayout &m_setLayout;
            DescriptorPool &m_pool;
            std::vector<VkWriteDescriptorSet> m_writes;
 
    }; // class DescriptorWriter
 
} // namespace ven