VulkanImage.h

#pragma once
 
#include "spark/base/Macros.h"
#include "spark/render/Format.h"
#include "spark/render/Image.h"
#include "spark/render/Resource.h"
#include "spark/render/StateResource.h"
#include "spark/render/vk/Export.h"
#include "spark/render/vk/Helpers.h"
 
#include "spark/math/Vector3.h"
 
#include <memory>
#include <string>
 
SPARK_FWD_DECLARE_VK_HANDLE(VkImage)
SPARK_FWD_DECLARE_VK_HANDLE(VkImageView)
SPARK_FWD_DECLARE_VK_HANDLE(VmaAllocator)
SPARK_FWD_DECLARE_VK_HANDLE(VmaAllocation)
using VkImageAspectFlags = uint32_t;
struct VkImageCreateInfo;
struct VmaAllocationCreateInfo;
struct VmaAllocationInfo;
 
namespace spark::render::vk
{
    class VulkanDevice;
 
    class SPARK_RENDER_VK_EXPORT IVulkanImage : public IImage, public virtual IResource<VkImage>
    {
    public:
        ~IVulkanImage() noexcept override = default;
 
        [[nodiscard]] virtual VkImageAspectFlags aspectMask() const noexcept = 0;
 
        [[nodiscard]] virtual VkImageAspectFlags aspectMask(unsigned int plane = 0) const = 0;
 
        [[nodiscard]] virtual const VkImageView& imageView(unsigned int plane = 0) const = 0;
    };
 
    SPARK_WARNING_PUSH
    SPARK_DISABLE_MSVC_WARNING(4250) // 'VulkanImage': inherits 'StateResource::name' via dominance
 
    class SPARK_RENDER_VK_EXPORT VulkanImage final : public IVulkanImage, public Resource<VkImage>, public StateResource
    {
    public:
        explicit VulkanImage(const VulkanDevice& device,
                             VkImage image,
                             const math::Vector3<unsigned>& extent,
                             Format format,
                             ImageDimensions dimensions,
                             unsigned levels,
                             unsigned layers,
                             MultiSamplingLevel samples,
                             bool writable,
                             ImageLayout initial_layout,
                             VmaAllocator allocator = nullptr,
                             VmaAllocation allocation = nullptr,
                             const std::string& name = "");
        ~VulkanImage() override;
 
        VulkanImage(const VulkanImage& other) = delete;
        VulkanImage(VulkanImage&& other) noexcept = delete;
        VulkanImage& operator=(const VulkanImage& other) = delete;
        VulkanImage& operator=(VulkanImage&& other) noexcept = delete;
 
        static std::unique_ptr<VulkanImage> Allocate(const VulkanDevice& device,
                                                     const math::Vector3<unsigned>& extent,
                                                     Format format,
                                                     ImageDimensions dimensions,
                                                     unsigned levels,
                                                     unsigned layers,
                                                     MultiSamplingLevel samples,
                                                     bool writable,
                                                     ImageLayout initial_layout,
                                                     VmaAllocator& allocator,
                                                     const VkImageCreateInfo& create_info,
                                                     const VmaAllocationCreateInfo& allocation_info,
                                                     VmaAllocationInfo* allocation_result = nullptr);
 
        static std::unique_ptr<VulkanImage> Allocate(const std::string& name,
                                                     const VulkanDevice& device,
                                                     const math::Vector3<unsigned>& extent,
                                                     Format format,
                                                     ImageDimensions dimensions,
                                                     unsigned levels,
                                                     unsigned layers,
                                                     MultiSamplingLevel samples,
                                                     bool writable,
                                                     ImageLayout initial_layout,
                                                     VmaAllocator& allocator,
                                                     const VkImageCreateInfo& create_info,
                                                     const VmaAllocationCreateInfo& allocation_info,
                                                     VmaAllocationInfo* allocation_result = nullptr);
 
        [[nodiscard]] VkImageAspectFlags aspectMask() const noexcept override;
 
        [[nodiscard]] VkImageAspectFlags aspectMask(unsigned plane) const override;
 
        [[nodiscard]] const VkImageView& imageView(unsigned plane = 0) const override;
 
        [[nodiscard]] unsigned elements() const noexcept override;
 
        [[nodiscard]] std::size_t size() const noexcept override;
 
        [[nodiscard]] std::size_t elementSize() const noexcept override;
 
        [[nodiscard]] std::size_t elementAlignment() const override;
 
        [[nodiscard]] std::size_t alignedElementSize() const noexcept override;
 
        [[nodiscard]] bool writable() const noexcept override;
 
        [[nodiscard]] std::size_t size(unsigned level) const override;
 
        [[nodiscard]] math::Vector3<unsigned> extent(unsigned level) const noexcept override;
 
        [[nodiscard]] Format format() const noexcept override;
 
        [[nodiscard]] ImageDimensions dimensions() const noexcept override;
 
        [[nodiscard]] unsigned levels() const noexcept override;
 
        [[nodiscard]] unsigned layers() const noexcept override;
 
        [[nodiscard]] unsigned planes() const noexcept override;
 
        [[nodiscard]] MultiSamplingLevel samples() const noexcept override;
 
        [[nodiscard]] ImageLayout layout(unsigned sub_resource) const override;
 
    private:
        struct Impl;
        std::unique_ptr<Impl> m_impl;
    };
 
    SPARK_WARNING_POP
}