Image.h

#pragma once
 
#include "spark/render/DeviceMemory.h"
#include "spark/render/Export.h"
#include "spark/render/StateResource.h"
#include "spark/render/Format.h"
 
#include "spark/math/Vector3.h"
 
namespace spark::render
{
    enum class ImageDimensions
    {
        DIM_1 = 0x01,
 
        DIM_2 = 0x02,
 
        DIM_3 = 0x03,
 
        CUBE = 0x04
    };
 
    enum class ImageLayout
    {
        Common = 0x00000001,
 
        ShaderResource = 0x00000002,
 
        ReadWrite = 0x00000003,
 
        CopySource = 0x00000010,
 
        CopyDestination = 0x00000011,
 
        RenderTarget = 0x00000020,
 
        DepthRead = 0x00000021,
 
        DepthWrite = 0x00000022,
 
        Present = 0x00000023,
 
        ResolveSource = 0x00000024,
 
        ResolveDestination = 0x00000025,
 
        Undefined = 0x7FFFFFFF
    };
 
    enum class MultiSamplingLevel
    {
        X1  = 0x00000001,
        X2  = 0x00000002,
        X4  = 0x00000004,
        X8  = 0x00000008,
        X16 = 0x00000010,
        X32 = 0x00000020,
        X64 = 0x00000040
    };
 
    class SPARK_RENDER_EXPORT IImage : public virtual IStateResource, public virtual IDeviceMemory
    {
    public:
        ~IImage() noexcept override = default;
 
        // Needed to make clang happy, else it complains about a hidden overloaded virtual function (but it is not hidden)
        using IDeviceMemory::size;
 
        [[nodiscard]] virtual std::size_t size(unsigned int level) const = 0;
 
        [[nodiscard]] virtual math::Vector3<unsigned> extent(unsigned level = 0) const noexcept = 0;
 
        [[nodiscard]] virtual Format format() const noexcept = 0;
 
        [[nodiscard]] virtual ImageDimensions dimensions() const noexcept = 0;
 
        [[nodiscard]] virtual unsigned int levels() const noexcept = 0;
 
        [[nodiscard]] virtual unsigned int layers() const noexcept = 0;
 
        [[nodiscard]] virtual unsigned int planes() const noexcept = 0;
 
        [[nodiscard]] virtual MultiSamplingLevel samples() const noexcept = 0;
 
        [[nodiscard]] virtual ImageLayout layout(unsigned int sub_resource = 0) const = 0;
 
        [[nodiscard]] virtual unsigned int subResourceId(unsigned& level, unsigned& layer, unsigned& plane) const noexcept
        {
            return level + layer * levels() + plane * levels() * layers();
        }
 
        [[nodiscard]] std::tuple<unsigned, unsigned, unsigned> resolveSubresource(const unsigned subresource) const noexcept
        {
            const unsigned level = levels();
            const unsigned resources_per_plane = level * layers();
            return std::make_tuple<unsigned, unsigned, unsigned>(subresource / resources_per_plane, subresource % resources_per_plane / level, subresource % level);
        }
    };
}
 
template <>
struct std::formatter<spark::render::MultiSamplingLevel> : std::formatter<std::string_view>
{
    static constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
 
    static constexpr auto format(const spark::render::MultiSamplingLevel level, auto& ctx)
    {
        switch (level) // NOLINT(clang-diagnostic-switch-enum): X1 is handled after the switch statement.
        {
        case spark::render::MultiSamplingLevel::X2:
            return std::format_to(ctx.out(), "X2");
        case spark::render::MultiSamplingLevel::X4:
            return std::format_to(ctx.out(), "X4");
        case spark::render::MultiSamplingLevel::X8:
            return std::format_to(ctx.out(), "X8");
        case spark::render::MultiSamplingLevel::X16:
            return std::format_to(ctx.out(), "X16");
        case spark::render::MultiSamplingLevel::X32:
            return std::format_to(ctx.out(), "X32");
        case spark::render::MultiSamplingLevel::X64:
            return std::format_to(ctx.out(), "X64");
        default:
            break;
        }
        return std::format_to(ctx.out(), "X1");
    }
};