bwidgets/inc/basic_widgets/core/renderer.hpp

#ifndef BWIDGETS_RENDERER_HPP
#define BWIDGETS_RENDERER_HPP

#include <cstdint>
#include <memory>
#include <vector>

#include <SDL2/SDL_render.h>

#include <basic_widgets/core/type/color.hpp>
#include <basic_widgets/core/type/opaque_struct.hpp>
#include <basic_widgets/core/type/sdl_error.hpp>
#include <basic_widgets/core/type/size.hpp>

namespace bwidgets
{
    class Texture;

    class Renderer final : OpaqueStruct<SDL_Renderer>::Wrapper
    {
        friend Texture;

        static inline auto _info(SDL_Renderer* r) -> SDL_RendererInfo
        {
            SDL_RendererInfo info;
            SDLError::success_or_throw(SDL_GetRendererInfo(r, &info), __FILE__,
                                       __FUNCTION__, __LINE__);

            return info;
        }

    public:
        const SDL_RendererInfo info;

        Renderer(SDL_Renderer*);
        Renderer(SDL_Window*, int, uint32_t);
        Renderer(const Renderer&) = delete;
        Renderer(Renderer&&)      = delete;
        ~Renderer() noexcept      = default;

        auto operator=(const Renderer&) = delete;
        auto operator=(Renderer&&) = delete;

        [[nodiscard]] auto blend_mode() -> SDL_BlendMode;
        auto               blend_mode(SDL_BlendMode) -> Renderer*;
        auto               clear() -> Renderer*;
        auto copy(const Texture*, const SDL_Rect*, const SDL_Rect*) -> Renderer*;
        [[nodiscard]] auto draw_color() -> Color;
        auto               draw_color(const Color&) -> Renderer*;
        auto               draw_line(const SDL_Point&, const SDL_Point&) -> Renderer*;
        auto               draw_lines(const std::vector<SDL_Point>&) -> Renderer*;
        auto               draw_point(const SDL_Point&) -> Renderer*;
        auto               draw_points(const std::vector<SDL_Point>&) -> Renderer*;
        auto               draw_rect(const SDL_Rect*) -> Renderer*;
        auto               draw_rects(const std::vector<SDL_Rect>&) -> Renderer*;
        auto               fill_rect(const SDL_Rect*) -> Renderer*;
        auto               fill_rects(const std::vector<SDL_Rect>&) -> Renderer*;
        [[nodiscard]] auto output_size() -> Size;
        void               present() noexcept;
        [[nodiscard]] auto viewport() noexcept -> SDL_Rect;
        auto               viewport(const SDL_Rect*) -> Renderer*;

        inline auto copy(const Texture* t, const SDL_Rect* src, const SDL_Rect& dst)
        {
            const auto d = dst;
            return copy(t, src, &d);
        }
        inline auto copy(const Texture* t, const SDL_Rect& src, const SDL_Rect* dst)
        {
            const auto s = src;
            return copy(t, &s, dst);
        }
        inline auto copy(const Texture* t, const SDL_Rect& src, const SDL_Rect& dst)
        {
            const auto s = src;
            const auto d = dst;
            return copy(t, &s, &d);
        }
        inline auto draw_rect(const SDL_Rect& r)
        {
            const auto rect = r;
            return draw_rect(&rect);
        }
        inline auto fill_rect(const SDL_Rect& r)
        {
            const auto rect = r;
            return fill_rect(&rect);
        }
        inline auto viewport(const SDL_Rect& vp)
        {
            const auto v = vp;
            return viewport(&v);
        }
    };
}

#endif