Renderer.h

Go to the documentation of this file.

#pragma once

#include <memory>
#include <stack>
#include <SDL.h>
#include "Color.h"
#include "ScreenMetrics.h"
#include "Utilities.h"
#include "Types.h"

namespace rose::sdl {

    class Texture;

    class GradientTexture;

    struct RenderFlip {
        SDL_RendererFlip mFlip;

        constexpr RenderFlip() noexcept : mFlip(SDL_FLIP_NONE) {}

        constexpr explicit RenderFlip(SDL_RendererFlip flip) noexcept : mFlip(flip) {}
    };

    class WindowDestroy {
    public:
        void operator()(SDL_Window *sdlWindow) {
            SDL_DestroyWindow(sdlWindow);
        }
    };

    using Window = std::unique_ptr<SDL_Window, WindowDestroy>;   

    class Renderer {
    protected:
        friend class RenderTargetGuard;

        class RendererDestroy {
        public:
            void operator()(SDL_Renderer *sdlRenderer) {
                SDL_DestroyRenderer(sdlRenderer);
            }
        };

        using RendererPtr = std::unique_ptr<SDL_Renderer, RendererDestroy>; 
        RendererPtr mRenderer{};    

        std::stack<SDL_Texture *> mTargetTextureStack{};     

        [[nodiscard]] int popRenderTarget() {
            if (mTargetTextureStack.empty())
                return SDL_SetRenderTarget(mRenderer.get(), nullptr);
            else {
                mTargetTextureStack.pop();
                if (mTargetTextureStack.empty())
                    return SDL_SetRenderTarget(mRenderer.get(), nullptr);
                else
                    return SDL_SetRenderTarget(mRenderer.get(), mTargetTextureStack.top());
            }
        }

        [[nodiscard]] int pushRenderTarget(sdl::Texture &texture);

        [[nodiscard]] int pushRenderTarget() {
            mTargetTextureStack.push(nullptr);
            return SDL_SetRenderTarget(mRenderer.get(), nullptr);
        }

    public:
        Renderer() = default;

        Renderer(const Renderer &renderer) = delete; 

        Renderer(Window &window, int index, Uint32 flags);

        Renderer(Renderer &&renderer) noexcept = default;

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

        Renderer &operator=(Renderer &&renderer) = default;

        explicit operator bool() const noexcept { return mRenderer.operator bool(); }

        [[nodiscard]] auto get() const { return mRenderer.get(); }

        void setDrawBlendMode(SDL_BlendMode blendMode) {
            SDL_SetRenderDrawBlendMode(mRenderer.get(), blendMode);
        }

        Texture createTexture(Size size);

        void copyFullTexture(sdl::Texture &source, sdl::Texture &destination);

        int renderClear() { return SDL_RenderClear(mRenderer.get()); }

        void renderPresent() { SDL_RenderPresent(mRenderer.get()); }

        int renderCopy(const Texture &texture);

        int renderCopy(const Texture &texture, Rectangle dst);

        int renderCopy(const Texture &texture, Rectangle src, Rectangle dst);

        int renderCopy(GradientTexture &texture, Rectangle dst);

        int renderCopyEx(Texture &texture, Rectangle src, Rectangle dst, double angle, RenderFlip renderFlip,
                         std::optional<Position> point = std::nullopt) const;

        int fillRect(Rectangle rectangle, color::RGBA color);

        int drawLine(int x0, int y0, int x1, int y1);

        int drawPoint(const Position& position, const color::RGBA &rgba);

        template<class C>
        int drawLines(C pointsContainer) {
            auto *points = new SDL_Point[pointsContainer.size()];
            auto first = pointsContainer.begin();
            auto last = pointsContainer.end();
            for (size_t idx = 0; idx < pointsContainer.size() && first != last; ++idx) {
                points[idx].x = first->x();
                points[idx].y = first->y();
                ++first;
            }
            auto status = SDL_RenderDrawLines(get(), points, pointsContainer.size());
            delete [] points;
            return status;
        }
    };

    class RenderTargetGuardException : public RoseRuntimeError {
    public:
        explicit RenderTargetGuardException(const std::string &what_arg) : RoseRuntimeError(what_arg) {}
    };

    class RenderTargetGuard {
    protected:
        Renderer &mRenderer;    
        bool popped{false};     
        int status{0};          

    public:
        RenderTargetGuard() = delete;   
        RenderTargetGuard(const RenderTargetGuard &) = delete;   

        ~RenderTargetGuard() noexcept(false) {
            if (!popped) {
                status = mRenderer.popRenderTarget();
            }
        }

        explicit operator bool() const noexcept { return status == 0; }

        RenderTargetGuard(Renderer &renderer, Texture &texture) : mRenderer(renderer) {
            status = mRenderer.pushRenderTarget(texture);
        }

        void clear() {
            status = mRenderer.popRenderTarget();
            popped = true;
        }

        int setRenderTarget(Texture &texture);
    };

    class DrawColorGuardException : public RoseRuntimeError {
    public:
        explicit DrawColorGuardException(const std::string &what_arg) : RoseRuntimeError(what_arg) {}
    };

    class DrawColorGuard {
    protected:
        Renderer &mRenderer;    
        SDL_Color mOldColor{};  
        int mStatus;             

    public:
        DrawColorGuard() = delete;  
        DrawColorGuard(const DrawColorGuard &) = delete; 
        DrawColorGuard(DrawColorGuard &&) = default;

        DrawColorGuard &operator=(const DrawColorGuard &) = delete;

        ~DrawColorGuard() noexcept(false) {
            if (SDL_SetRenderDrawColor(mRenderer.get(), mOldColor.r, mOldColor.g, mOldColor.b, mOldColor.a)) {
                throw DrawColorGuardException(util::StringCompositor("Call to SDL_XxxRenderDrawColor failed:",
                                                                     SDL_GetError()));
            }
        }

        DrawColorGuard(Renderer &renderer, SDL_Color color);

        DrawColorGuard(Renderer &renderer, color::RGBA color);

        explicit operator bool() const noexcept { return mStatus == 0; }

        int setDrawColor(SDL_Color color);

        int setDrawColor(color::RGBA color) {
            return setDrawColor(color.toSdlColor());
        }
    };

    class ClipRectangleGuard {
    protected:
        Renderer &mRenderer;    
        SDL_Rect mOldClip{};    

    public:
        ClipRectangleGuard() = delete;  
        ClipRectangleGuard(const ClipRectangleGuard &) = delete;     

        ~ClipRectangleGuard() {
            SDL_RenderSetClipRect(mRenderer.get(), &mOldClip);
        }

        explicit ClipRectangleGuard(Renderer &renderer) : mRenderer(renderer) {
            SDL_RenderGetClipRect(mRenderer.get(), &mOldClip);
        }

        ClipRectangleGuard(Renderer &renderer, const SDL_Rect &clip) : mRenderer(renderer) {
            SDL_RenderGetClipRect(mRenderer.get(), &mOldClip);
            SDL_RenderSetClipRect(mRenderer.get(), &clip);
        }

        ClipRectangleGuard(Renderer &renderer, int x, int y, int w, int h)
                : ClipRectangleGuard(renderer, SDL_Rect{x, y, w, h}) {}

        ClipRectangleGuard(Renderer &renderer, const Rectangle &clip) : mRenderer(renderer) {
            SDL_RenderGetClipRect(mRenderer.get(), &mOldClip);
            auto rect = clip.toSdlRect();
            SDL_RenderSetClipRect(mRenderer.get(), &rect);
        }

        ClipRectangleGuard &operator=(SDL_Rect &clip) {
            SDL_RenderSetClipRect(mRenderer.get(), &clip);
            return *this;
        }

        ClipRectangleGuard &operator=(Rectangle &clip) {
            auto rect = clip.toSdlRect();
            SDL_RenderSetClipRect(mRenderer.get(), &rect);
            return *this;
        }

        ClipRectangleGuard &intersection(Rectangle &clip) {
            SDL_Rect current;
            SDL_RenderGetClipRect(mRenderer.get(), &current);
            if (SDL_RectEmpty(&current)) {
                operator=(clip);
            } else {
                mOldClip = current;
                Rectangle r{current.x, current.y, current.w, current.h};
                current = r.intersection(clip).toSdlRect();
                SDL_RenderSetClipRect(mRenderer.get(), &current);
            }
            return *this;
        }
    };
}