GraphicsModel.h

Go to the documentation of this file.

#pragma once

#include "Configuration.h"

#include <SDL.h>

#include <memory>
#include <functional>
#include <Utilities.h>
#include "Visual.h"
#include "Color.h"
#include "Texture.h"
#include "CommonSignals.h"


namespace rose {
    class Application;
}

namespace rose::gm {

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

    using SdlWindow = std::unique_ptr<SDL_Window, SdlWindowDestroy>;   

    enum class RoseErrorCode {
        OK,                         
        ROSE_EXCEPTION,             
        SDL_WINDOW_CREATE,          
        SDL_RENDERER_CREATE,        
        XDG_PATH_FAIL,              
    };

    struct RenderFlip {
        SDL_RendererFlip mFlip;

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

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

    class Context {
        friend class RenderTargetGuard;

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

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

        SDL_Texture *mCurrentRenderTarget{nullptr};

    public:

        Context() = default;

        Context(const Context &context) = delete;

        Context(Context &&context) noexcept = default;

        Context &operator=(const Context &context) = delete;

        Context &operator=(Context &&context) = default;

        explicit Context(SdlWindow &window, int index, Uint32 flags) : Context()
        { mRenderer.reset(SDL_CreateRenderer(window.get(), index, flags)); }

        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);
        }

        void copyFullTexture(Texture &source, 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 renderCopyEx(Texture &texture, Rectangle src, Rectangle dst, double angle, RenderFlip renderFlip,
                         std::optional<Position<int>> point = std::nullopt) const;

        int setDrawColor(color::RGBA color);

        int setDrawColor(color::HSVA color) {
            return setDrawColor(color.toRGBA());
        }

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

        int drawPoint(const Position<int> &p, const color::RGBA &color);

        int drawLine(const Position<int> &p0, const Position<int> &p1);
    };

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

        explicit RenderTargetGuardException(const char *what_arg) : std::runtime_error(what_arg) {}
    };

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

        explicit DrawColorGuardException(const char *what_arg) : std::runtime_error(what_arg) {}
    };

    class RenderTargetGuard {
    protected:
        Context &mContext;                      
        bool popped{false};                     
        SDL_Texture *mLastTexture{nullptr};     
        int status{0};                          

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

        ~RenderTargetGuard() noexcept(false);

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

        RenderTargetGuard(Context &context, Texture &texture);

        int setRenderTarget(Texture &texture);
    };

    class DrawColorGuard {
    protected:
        Context &mContext;      
        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(mContext.get(), mOldColor.r, mOldColor.g, mOldColor.b, mOldColor.a)) {
                throw DrawColorGuardException(StringCompositor("Call to SDL_XxxRenderDrawColor failed:",
                                                                     SDL_GetError()));
            }
        }

        DrawColorGuard(Context &context, SDL_Color color);

        DrawColorGuard(Context &context, 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:
        Context &mContext;    
        SDL_Rect mOldClip{};    
        int mStatus{0};

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

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

        ~ClipRectangleGuard() {
            if (mOldClip.w == 0 && mOldClip.y == 0)
                mStatus = SDL_RenderSetClipRect(mContext.get(), nullptr);
            else
                mStatus = SDL_RenderSetClipRect(mContext.get(), &mOldClip);
        }

        explicit ClipRectangleGuard(Context &context) : mContext(context) {
            SDL_RenderGetClipRect(mContext.get(), &mOldClip);
        }

        ClipRectangleGuard(Context &context, const SDL_Rect &clip) : mContext(context) {
            SDL_RenderGetClipRect(mContext.get(), &mOldClip);
            mStatus = SDL_RenderSetClipRect(mContext.get(), &clip);
        }

        ClipRectangleGuard(Context &context, int x, int y, int w, int h)
                : ClipRectangleGuard(context, SDL_Rect{x, y, w, h}) {}

        ClipRectangleGuard(Context &context, const Rectangle &clip) : mContext(context) {
            SDL_RenderGetClipRect(mContext.get(), &mOldClip);
            SDL_Rect rect{clip.x, clip.y, clip.w, clip.h};
            mStatus = SDL_RenderSetClipRect(mContext.get(), &rect);
        }

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

        ClipRectangleGuard &operator=(Rectangle &clip) {
            SDL_Rect rect{clip.x, clip.y, clip.w, clip.h};
            mStatus = SDL_RenderSetClipRect(mContext.get(), &rect);
            return *this;
        }

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

    class GraphicsModel {
    protected:
        SdlWindow mSdlWindow{};         

        Context mContext{};             

        bool mRunEventLoop{true};       

        bool mRedrawBackground{true};   

        Texture mBackground{};          

        uint32_t mFrame{};              

        std::vector<Rectangle> mDisplayBounds{};

    public:
        RoseErrorCode ErrorCode{RoseErrorCode::OK};

        bool initialize(const std::string &title, Size initialSize, const Position<int>& initialPosition, uint32_t extraFlags);

        void eventLoop(std::shared_ptr<Screen> &screen);

        void drawAll(std::shared_ptr<Screen> &screen);

        std::function<void(SDL_Event)> eventCallback{};

        Context& context() { return mContext; }

        [[nodiscard]] int currentDisplayIndex() const { return SDL_GetWindowDisplayIndex(mSdlWindow.get()); }

        Rectangle displayBounds(int displayIndex = -1) {
            if (displayIndex < 0)
                displayIndex = currentDisplayIndex();

            if (displayIndex < 0 || displayIndex >= mDisplayBounds.size())
                displayIndex = 0;

            return mDisplayBounds.at(displayIndex);
        }

        Rectangle screenRectangle() {
            Rectangle screenRectangle{};
            SDL_GetWindowSize(mSdlWindow.get(), &screenRectangle.w, &screenRectangle.h);
            return screenRectangle;
        }

        void redrawBackground() { mRedrawBackground = true; }

        [[nodiscard]] Padding windowBorders() const noexcept {
            Padding p{};
            SDL_GetWindowBordersSize(mSdlWindow.get(), &p.t, &p.l, &p.b, &p.r);
            return p;
        }

        SdlWindow& getSdlWindow() {
            return mSdlWindow;
        }
    };

    uint32_t mapRGBA(SDL_PixelFormat *format, const color::RGBA &color);

    color::RGBA getRGBA(SDL_PixelFormat *format, uint32_t pixel);
}