Descriptor.hpp

#pragma once
 
#include <volk.h>
 
#include <cstdint>
#include <memory>
#include <optional>
 
namespace PixelBullet
{
    class OffsetSize
    {
    public:
        OffsetSize(uint32_t offset, uint32_t size)
            : m_Offset(offset)
            , m_Size(size)
        {
        }
 
        uint32_t GetOffset() const
        {
            return m_Offset;
        }
        uint32_t GetSize() const
        {
            return m_Size;
        }
 
        bool operator==(const OffsetSize& rhs) const
        {
            return m_Offset == rhs.m_Offset && m_Size == rhs.m_Size;
        }
 
        bool operator!=(const OffsetSize& rhs) const
        {
            return !operator==(rhs);
        }
 
    private:
        uint32_t m_Offset;
        uint32_t m_Size;
    };
 
    class WriteDescriptorSet
    {
    public:
        WriteDescriptorSet(const VkWriteDescriptorSet& writeDescriptorSet, const VkDescriptorImageInfo& imageInfo)
            : m_WriteDescriptorSet(writeDescriptorSet)
            , m_ImageInfo(std::make_unique<VkDescriptorImageInfo>(imageInfo))
        {
            this->m_WriteDescriptorSet.descriptorCount = 1;
            this->m_WriteDescriptorSet.pImageInfo = m_ImageInfo ? m_ImageInfo.get() : nullptr;
        }
 
        WriteDescriptorSet(const VkWriteDescriptorSet& writeDescriptorSet, const VkDescriptorBufferInfo& bufferInfo)
            : m_WriteDescriptorSet(writeDescriptorSet)
            , m_BufferInfo(std::make_unique<VkDescriptorBufferInfo>(bufferInfo))
        {
            this->m_WriteDescriptorSet.descriptorCount = 1;
            this->m_WriteDescriptorSet.pBufferInfo = m_BufferInfo ? m_BufferInfo.get() : nullptr;
        }
 
        const VkWriteDescriptorSet& GetWriteDescriptorSet() const
        {
            return m_WriteDescriptorSet;
        }
 
    private:
        VkWriteDescriptorSet m_WriteDescriptorSet;
        std::unique_ptr<VkDescriptorImageInfo> m_ImageInfo;
        std::unique_ptr<VkDescriptorBufferInfo> m_BufferInfo;
    };
 
    class Descriptor
    {
    public:
        Descriptor() = default;
        virtual ~Descriptor() = default;
 
        virtual WriteDescriptorSet GetWriteDescriptor(uint32_t binding, VkDescriptorType descriptorType,
                                                      const std::optional<OffsetSize>& offsetSize) const = 0;
    };
} // namespace PixelBullet