Buffer.h

#pragma once
 
#include "spark/render/DeviceMemory.h"
#include "spark/render/Export.h"
#include "spark/render/Mappable.h"
#include "spark/render/StateResource.h"
 
#include <format>
 
namespace spark::render
{
    enum class BufferFormat
    {
        // ReSharper disable CppInconsistentNaming
        None    = 0x00000000,
        X16F    = 0x10000101,
        X16I    = 0x10000201,
        X16U    = 0x10000401,
        XY16F   = 0x10000102,
        XY16I   = 0x10000202,
        XY16U   = 0x10000402,
        XYZ16F  = 0x10000103,
        XYZ16I  = 0x10000203,
        XYZ16U  = 0x10000403,
        XYZW16F = 0x10000104,
        XYZW16I = 0x10000204,
        XYZW16U = 0x10000404,
        X32F    = 0x20000101,
        X32I    = 0x20000201,
        X32U    = 0x20000401,
        XY32F   = 0x20000102,
        XY32I   = 0x20000202,
        XY32U   = 0x20000402,
        XYZ32F  = 0x20000103,
        XYZ32I  = 0x20000203,
        XYZ32U  = 0x20000403,
        XYZW32F = 0x20000104,
        XYZW32I = 0x20000204,
        XYZW32U = 0x20000404
        // ReSharper restore CppInconsistentNaming
    };
 
    enum class BufferType
    {
        Vertex = 0x00000001,
 
        Index = 0x00000002,
 
        Uniform = 0x00000003,
 
        Storage = 0x00000004,
 
        Texel = 0x00000005,
 
        Other = 0x7FFFFFFF
    };
 
    enum class BufferUsage
    {
        Staging = 0x00000001,
 
        Resource = 0x00000002,
 
        Dynamic = 0x00000010,
 
        Readback = 0x00000100
    };
 
    enum class AttributeSemantic
    {
        Binormal = 0x00000001,
 
        BlendIndices = 0x00000002,
 
        BlendWeight = 0x00000003,
 
        Color = 0x00000004,
 
        Normal = 0x00000005,
 
        Position = 0x00000006,
 
        TransformedPosition = 0x00000007,
 
        PointSize = 0x00000008,
 
        Tangent = 0x00000009,
 
        TextureCoordinate = 0x0000000A,
 
        Unknown = 0x7FFFFFFF
    };
 
    class SPARK_RENDER_EXPORT IBuffer : public IDeviceMemory, public IMappable, public virtual IStateResource
    {
    public:
        ~IBuffer() noexcept override = default;
 
        [[nodiscard]] virtual BufferType type() const = 0;
    };
 
    class SPARK_RENDER_EXPORT IBufferLayout
    {
    public:
        virtual ~IBufferLayout() noexcept = default;
 
        [[nodiscard]] virtual std::size_t elementSize() const noexcept = 0;
 
        [[nodiscard]] virtual unsigned int binding() const noexcept = 0;
 
        [[nodiscard]] virtual BufferType type() const noexcept = 0;
    };
 
    class SPARK_RENDER_EXPORT BufferAttribute final
    {
    public:
        BufferAttribute() noexcept;
 
        BufferAttribute(unsigned int location, unsigned int offset, BufferFormat format, AttributeSemantic semantic, unsigned int semantic_index) noexcept;
        ~BufferAttribute() noexcept;
 
        BufferAttribute(const BufferAttribute& other) = delete;
        BufferAttribute(BufferAttribute&& other) noexcept;
        BufferAttribute& operator=(const BufferAttribute& other) = delete;
        BufferAttribute& operator=(BufferAttribute&& other) noexcept;
 
        [[nodiscard]] unsigned int location() const noexcept;
 
        [[nodiscard]] BufferFormat format() const noexcept;
 
        [[nodiscard]] unsigned int offset() const noexcept;
 
        [[nodiscard]] AttributeSemantic semantic() const noexcept;
 
        [[nodiscard]] unsigned int semanticIndex() const noexcept;
 
    private:
        struct Impl;
        std::unique_ptr<Impl> m_impl;
    };
}
 
template <>
struct std::formatter<spark::render::BufferFormat> : std::formatter<std::string_view>
{
    static constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
 
    static constexpr auto format(const spark::render::BufferFormat format, auto& ctx)
    {
        switch (format)
        {
        case spark::render::BufferFormat::None:
            return std::format_to(ctx.out(), "None");
        case spark::render::BufferFormat::X16F:
            return std::format_to(ctx.out(), "X16F");
        case spark::render::BufferFormat::X16I:
            return std::format_to(ctx.out(), "X16I");
        case spark::render::BufferFormat::X16U:
            return std::format_to(ctx.out(), "X16U");
        case spark::render::BufferFormat::XY16F:
            return std::format_to(ctx.out(), "XY16F");
        case spark::render::BufferFormat::XY16I:
            return std::format_to(ctx.out(), "XY16I");
        case spark::render::BufferFormat::XY16U:
            return std::format_to(ctx.out(), "XY16U");
        case spark::render::BufferFormat::XYZ16F:
            return std::format_to(ctx.out(), "XYZ16F");
        case spark::render::BufferFormat::XYZ16I:
            return std::format_to(ctx.out(), "XYZ16I");
        case spark::render::BufferFormat::XYZ16U:
            return std::format_to(ctx.out(), "XYZ16U");
        case spark::render::BufferFormat::XYZW16F:
            return std::format_to(ctx.out(), "XYZW16F");
        case spark::render::BufferFormat::XYZW16I:
            return std::format_to(ctx.out(), "XYZW16I");
        case spark::render::BufferFormat::XYZW16U:
            return std::format_to(ctx.out(), "XYZW16U");
        case spark::render::BufferFormat::X32F:
            return std::format_to(ctx.out(), "X32F");
        case spark::render::BufferFormat::X32I:
            return std::format_to(ctx.out(), "X32I");
        case spark::render::BufferFormat::X32U:
            return std::format_to(ctx.out(), "X32U");
        case spark::render::BufferFormat::XY32F:
            return std::format_to(ctx.out(), "XY32F");
        case spark::render::BufferFormat::XY32I:
            return std::format_to(ctx.out(), "XY32I");
        case spark::render::BufferFormat::XY32U:
            return std::format_to(ctx.out(), "XY32U");
        case spark::render::BufferFormat::XYZ32F:
            return std::format_to(ctx.out(), "XYZ32F");
        case spark::render::BufferFormat::XYZ32I:
            return std::format_to(ctx.out(), "XYZ32I");
        case spark::render::BufferFormat::XYZ32U:
            return std::format_to(ctx.out(), "XYZ32U");
        case spark::render::BufferFormat::XYZW32F:
            return std::format_to(ctx.out(), "XYZW32F");
        case spark::render::BufferFormat::XYZW32I:
            return std::format_to(ctx.out(), "XYZW32I");
        case spark::render::BufferFormat::XYZW32U:
            return std::format_to(ctx.out(), "XYZW32U");
        }
        return std::format_to(ctx.out(), "Unknown");
    }
};
 
template <>
struct std::formatter<spark::render::BufferType> : std::formatter<std::string_view>
{
    static constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
 
    static constexpr auto format(const spark::render::BufferType type, auto& ctx)
    {
        switch (type)
        {
        case spark::render::BufferType::Vertex:
            return std::format_to(ctx.out(), "Vertex");
        case spark::render::BufferType::Index:
            return std::format_to(ctx.out(), "Index");
        case spark::render::BufferType::Uniform:
            return std::format_to(ctx.out(), "Uniform");
        case spark::render::BufferType::Storage:
            return std::format_to(ctx.out(), "Storage");
        case spark::render::BufferType::Texel:
            return std::format_to(ctx.out(), "Texel");
        case spark::render::BufferType::Other:
            return std::format_to(ctx.out(), "Other");
        }
        return std::format_to(ctx.out(), "Unknown");
    }
};