Image.hpp

#pragma once
 
#include "PixelBullet/Graphics/Commands/CommandBuffer.hpp"
#include "PixelBullet/Graphics/Descriptors/Descriptor.hpp"
 
#include <glm/vec2.hpp>
 
#include <vector>
 
namespace PixelBullet
{
    class Bitmap;
 
    class Image : public Descriptor
    {
    public:
        Image(VkFilter filter, VkSamplerAddressMode addressMode, VkSampleCountFlagBits samples, VkImageLayout layout,
              VkImageUsageFlags usage, VkFormat format, uint32_t mipLevels, uint32_t arrayLayers,
              const VkExtent3D& extent);
 
        ~Image();
 
        WriteDescriptorSet GetWriteDescriptor(uint32_t binding, VkDescriptorType descriptorType,
                                              const std::optional<OffsetSize>& offsetSize) const override;
        static VkDescriptorSetLayoutBinding GetDescriptorSetLayout(uint32_t binding, VkDescriptorType descriptorType,
                                                                   VkShaderStageFlags stage, uint32_t count);
 
        std::unique_ptr<Bitmap> GetBitmap(uint32_t mipLevel = 0, uint32_t arrayLayer = 0) const;
 
        const VkExtent3D& GetExtent() const
        {
            return m_Extent;
        }
        glm::uvec2 GetSize() const
        {
            return { m_Extent.width, m_Extent.height };
        }
        VkFormat GetFormat() const
        {
            return m_Format;
        }
        VkSampleCountFlagBits GetSamples() const
        {
            return m_Samples;
        }
        VkImageUsageFlags GetUsage() const
        {
            return m_Usage;
        }
        uint32_t GetMipLevels() const
        {
            return m_MIPLevels;
        }
        uint32_t GetArrayLevels() const
        {
            return m_ArrayLayers;
        }
        VkFilter GetFilter() const
        {
            return m_Filter;
        }
        VkSamplerAddressMode GetAddressMode() const
        {
            return m_AddressMode;
        }
        VkImageLayout GetLayout() const
        {
            return m_Layout;
        }
        const VkImage& GetImage()
        {
            return m_Image;
        }
        const VkDeviceMemory& GetMemory()
        {
            return m_Memory;
        }
        const VkSampler& GetSampler() const
        {
            return m_Sampler;
        }
        const VkImageView& GetView() const
        {
            return m_View;
        }
 
        static uint32_t GetMipLevels(const VkExtent3D& extent);
 
        static VkFormat FindSupportedFormat(const std::vector<VkFormat>& candidates, VkImageTiling tiling,
                                            VkFormatFeatureFlags features);
 
        static bool HasDepth(VkFormat format);
 
        static bool HasStencil(VkFormat format);
 
        static void CreateImage(VkImage& image, VkDeviceMemory& memory, const VkExtent3D& extent, VkFormat format,
                                VkSampleCountFlagBits samples, VkImageTiling tiling, VkImageUsageFlags usage,
                                VkMemoryPropertyFlags properties, uint32_t mipLevels, uint32_t arrayLayers,
                                VkImageType type);
        static void CreateImageSampler(VkSampler& sampler, VkFilter filter, VkSamplerAddressMode addressMode,
                                       bool anisotropic, uint32_t mipLevels);
        static void CreateImageView(const VkImage& image, VkImageView& imageView, VkImageViewType type, VkFormat format,
                                    VkImageAspectFlags imageAspect, uint32_t mipLevels, uint32_t baseMipLevel,
                                    uint32_t layerCount, uint32_t baseArrayLayer);
        static void CreateMipmaps(const VkImage& image, const VkExtent3D& extent, VkFormat format,
                                  VkImageLayout dstImageLayout, uint32_t mipLevels, uint32_t baseArrayLayer,
                                  uint32_t layerCount);
        static void TransitionImageLayout(const VkImage& image, VkFormat format, VkImageLayout srcImageLayout,
                                          VkImageLayout dstImageLayout, VkImageAspectFlags imageAspect,
                                          uint32_t mipLevels, uint32_t baseMipLevel, uint32_t layerCount,
                                          uint32_t baseArrayLayer);
        static void InsertImageMemoryBarrier(const CommandBuffer& commandBuffer, const VkImage& image,
                                             VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask,
                                             VkImageLayout oldImageLayout, VkImageLayout newImageLayout,
                                             VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask,
                                             VkImageAspectFlags imageAspect, uint32_t mipLevels, uint32_t baseMipLevel,
                                             uint32_t layerCount, uint32_t baseArrayLayer);
        static void CopyBufferToImage(const VkBuffer& buffer, const VkImage& image, const VkExtent3D& extent,
                                      uint32_t layerCount, uint32_t baseArrayLayer);
        static bool CopyImage(const VkImage& srcImage, VkImage& dstImage, VkDeviceMemory& dstImageMemory,
                              VkFormat srcFormat, const VkExtent3D& extent, VkImageLayout srcImageLayout,
                              uint32_t mipLevel, uint32_t arrayLayer);
 
    protected:
        VkExtent3D m_Extent;
        VkSampleCountFlagBits m_Samples;
        VkImageUsageFlags m_Usage;
        VkFormat m_Format = VK_FORMAT_UNDEFINED;
        uint32_t m_MIPLevels = 0;
        uint32_t m_ArrayLayers;
 
        VkFilter m_Filter;
        VkSamplerAddressMode m_AddressMode;
 
        VkImageLayout m_Layout;
 
        VkImage m_Image = VK_NULL_HANDLE;
        VkDeviceMemory m_Memory = VK_NULL_HANDLE;
        VkSampler m_Sampler = VK_NULL_HANDLE;
        VkImageView m_View = VK_NULL_HANDLE;
    };
} // namespace PixelBullet