Rasterizer.h

#pragma once
 
#include "spark/render/DepthStencilState.h"
#include "spark/render/Export.h"
 
#include <format>
#include <memory>
 
namespace spark::render
{
    enum class PolygonMode
    {
        Solid = 0x00000001,
 
        WireFrame = 0x00000002,
 
        Point = 0x00000004
    };
 
    enum class CullMode
    {
        FrontFaces = 0x00000001,
 
        BackFaces = 0x00000002,
 
        Both = 0x00000004,
 
        Disabled = 0x0000000F
    };
 
    enum class CullOrder
    {
        ClockWise = 0x00000001,
 
        CounterClockWise = 0x00000002
    };
 
    class SPARK_RENDER_EXPORT IRasterizer
    {
    public:
        virtual ~IRasterizer() noexcept = default;
 
        [[nodiscard]] virtual PolygonMode polygonMode() const noexcept = 0;
 
        [[nodiscard]] virtual CullMode cullMode() const noexcept = 0;
 
        [[nodiscard]] virtual CullOrder cullOrder() const noexcept = 0;
 
        [[nodiscard]] virtual float lineWidth() const noexcept = 0;
 
        [[nodiscard]] virtual const DepthStencilState& depthStencilState() const noexcept = 0;
    };
 
    class SPARK_RENDER_EXPORT Rasterizer : public IRasterizer
    {
    public:
        explicit Rasterizer(PolygonMode polygon_mode, CullMode cull_mode, CullOrder cull_order, float line_width, const DepthStencilState& depth_stencil_state) noexcept;
        ~Rasterizer() noexcept override;
 
        Rasterizer(const Rasterizer& other);
        Rasterizer(Rasterizer&& other) noexcept;
        Rasterizer& operator=(const Rasterizer& other);
        Rasterizer& operator=(Rasterizer&& other) noexcept;
 
        [[nodiscard]] PolygonMode polygonMode() const noexcept override;
 
        [[nodiscard]] CullMode cullMode() const noexcept override;
 
        [[nodiscard]] CullOrder cullOrder() const noexcept override;
 
        [[nodiscard]] float lineWidth() const noexcept override;
 
        [[nodiscard]] const DepthStencilState& depthStencilState() const noexcept override;
 
    protected:
        [[nodiscard]] float& lineWidth() noexcept;
 
    private:
        struct Impl;
        std::unique_ptr<Impl> m_impl;
    };
}
 
template <>
struct std::formatter<spark::render::PolygonMode> : std::formatter<std::string_view>
{
    static constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
 
    static constexpr auto format(const spark::render::PolygonMode polygon_mode, auto& ctx)
    {
        switch (polygon_mode)
        {
        case spark::render::PolygonMode::Solid:
            return std::format_to(ctx.out(), "Solid");
        case spark::render::PolygonMode::WireFrame:
            return std::format_to(ctx.out(), "WireFrame");
        case spark::render::PolygonMode::Point:
            return std::format_to(ctx.out(), "Point");
        }
 
        return std::format_to(ctx.out(), "Unknown");
    }
};
 
template <>
struct std::formatter<spark::render::CullMode> : std::formatter<std::string_view>
{
    static constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
 
    static constexpr auto format(const spark::render::CullMode cull_mode, auto& ctx)
    {
        switch (cull_mode)
        {
        case spark::render::CullMode::FrontFaces:
            return std::format_to(ctx.out(), "FrontFaces");
        case spark::render::CullMode::BackFaces:
            return std::format_to(ctx.out(), "BackFaces");
        case spark::render::CullMode::Both:
            return std::format_to(ctx.out(), "Both");
        case spark::render::CullMode::Disabled:
            return std::format_to(ctx.out(), "Disabled");
        }
 
        return std::format_to(ctx.out(), "Unknown");
    }
};
 
template <>
struct std::formatter<spark::render::CullOrder> : std::formatter<std::string_view>
{
    static constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
 
    static constexpr auto format(const spark::render::CullOrder cull_order, auto& ctx)
    {
        switch (cull_order)
        {
        case spark::render::CullOrder::ClockWise:
            return std::format_to(ctx.out(), "ClockWise");
        case spark::render::CullOrder::CounterClockWise:
            return std::format_to(ctx.out(), "CounterClockWise");
        }
 
        return std::format_to(ctx.out(), "Unknown");
    }
};