RenderTarget.h

#pragma once
 
#include "spark/render/Export.h"
#include "spark/render/Format.h"
 
#include "spark/base/Macros.h"
#include "spark/math/Vector4.h"
 
#include <memory>
#include <string>
 
namespace spark::render
{
    enum class RenderTargetType
    {
        Color = 0x00000001,
 
        DepthStencil = 0x00000002,
 
        Present = 0x00000004
    };
 
    enum class BlendFactor
    {
        Zero                     = 0,
        One                      = 1,
        SourceColor              = 2,
        OneMinusSourceColor      = 3,
        DestinationColor         = 4,
        OneMinusDestinationColor = 5,
        SourceAlpha              = 6,
        OneMinusSourceAlpha      = 7,
        DestinationAlpha         = 8,
        OneMinusDestinationAlpha = 9,
        ConstantColor            = 10,
        OneMinusConstantColor    = 11,
        ConstantAlpha            = 12,
        OneMinusConstantAlpha    = 13,
        SourceAlphaSaturate      = 14,
        Source1Color             = 15,
        OneMinusSource1Color     = 16,
        Source1Alpha             = 17,
        OneMinusSource1Alpha     = 18
    };
 
    enum class WriteMask
    {
        R = 0x01,
 
        G = 0x02,
 
        B = 0x04,
 
        A = 0x08
    };
 
    SPARK_DEFINE_ENUM_FLAGS(WriteMask)
 
    
    enum class BlendOperation
    {
        Add             = 0x01,
        Subtract        = 0x02,
        ReverseSubtract = 0x03,
        Minimum         = 0x04,
        Maximum         = 0x05
    };
 
    class SPARK_RENDER_EXPORT IRenderTarget
    {
    public:
        virtual ~IRenderTarget() noexcept = default;
 
        struct BlendState
        {
        public:
            bool enable = false;
 
            BlendFactor sourceColor {BlendFactor::One};
 
            BlendFactor destinationColor {BlendFactor::Zero};
 
            BlendFactor sourceAlpha {BlendFactor::One};
 
            BlendFactor destinationAlpha {BlendFactor::Zero};
 
            BlendOperation colorOperation {BlendOperation::Add};
 
            BlendOperation alphaOperation {BlendOperation::Add};
 
            WriteMask writeMask {WriteMask::R | WriteMask::G | WriteMask::B | WriteMask::A};
        };
 
        [[nodiscard]] virtual std::string name() const noexcept = 0;
 
        [[nodiscard]] virtual unsigned int location() const noexcept = 0;
 
        [[nodiscard]] virtual RenderTargetType type() const noexcept = 0;
 
        [[nodiscard]] virtual Format format() const noexcept = 0;
 
        virtual bool clearBuffer() const noexcept = 0;
 
        virtual bool clearStencil() const noexcept = 0;
 
        [[nodiscard]] virtual math::Vector4<float> clearValues() const noexcept = 0;
 
        [[nodiscard]] virtual bool isVolatile() const noexcept = 0;
 
        [[nodiscard]] virtual BlendState blendState() const noexcept = 0;
    };
 
    class SPARK_RENDER_EXPORT RenderTarget final : public IRenderTarget
    {
    public:
        explicit RenderTarget() noexcept;
 
        explicit RenderTarget(unsigned int location,
                              RenderTargetType type,
                              Format format,
                              bool clear_buffer,
                              const math::Vector4<float>& clear_values = {0.f, 0.f, 0.f, 0.f},
                              bool clear_stencil = true,
                              bool is_volatile = false,
                              const BlendState& blend_state = {});
 
        explicit RenderTarget(const std::string& name,
                              unsigned int location,
                              RenderTargetType type,
                              Format format,
                              bool clear_buffer,
                              const math::Vector4<float>& clear_values = {0.f, 0.f, 0.f, 0.f},
                              bool clear_stencil = true,
                              bool is_volatile = false,
                              const BlendState& blend_state = {});
        ~RenderTarget() noexcept override;
 
        RenderTarget(const RenderTarget& other);
        RenderTarget(RenderTarget&& other) noexcept;
        RenderTarget& operator=(const RenderTarget& other);
        RenderTarget& operator=(RenderTarget&& other) noexcept;
 
        [[nodiscard]] std::string name() const noexcept override;
 
        [[nodiscard]] unsigned location() const noexcept override;
 
        [[nodiscard]] RenderTargetType type() const noexcept override;
 
        [[nodiscard]] Format format() const noexcept override;
 
        bool clearBuffer() const noexcept override;
 
        bool clearStencil() const noexcept override;
 
        [[nodiscard]] math::Vector4<float> clearValues() const noexcept override;
 
        [[nodiscard]] bool isVolatile() const noexcept override;
 
        [[nodiscard]] BlendState blendState() const noexcept override;
 
    private:
        struct Impl;
        std::unique_ptr<Impl> m_impl;
    };
}