renderer.hpp

Go to the documentation of this file.

#pragma once

#include "color.hpp"
#include "exception.hpp"
#include "rect.hpp"
#include "surface.hpp"
#include "texture.hpp"

#include <SDL.h>
#include <SDL_render.h>

#include <utility>
#include <vector>

namespace sdl
{
class Renderer
{
public:
    explicit Renderer(SDL_Renderer* renderer) : renderer_{renderer} {}

    Renderer() {}

    Renderer(Renderer&& other) noexcept { *this = std::move(other); }

    Renderer& operator=(Renderer&& other) noexcept
    {
        if (renderer_ != other.renderer_)
        {
            SDL_DestroyRenderer(renderer_);
            renderer_       = other.renderer_;
            other.renderer_ = nullptr;
        }
        return *this;
    }

    ~Renderer() { SDL_DestroyRenderer(renderer_); }

    Renderer(Renderer const&) = delete;

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

    SDL_Renderer* ptr() const { return renderer_; }

    void get_info(SDL_RendererInfo& info) const
    {
        if (SDL_GetRendererInfo(renderer_, &info) != 0) throw Exception{"SDL_GetRendererInfo"};
    }

    SDL_RendererInfo info() const
    {
        SDL_RendererInfo info;
        get_info(info);
        return info;
    }

    // Get the current draw color
    Color drawcolor() const
    {
        Color c;
        if (SDL_GetRenderDrawColor(renderer_, &c.r, &c.g, &c.b, &c.a) != 0)
            throw Exception{"SDL_GetRenderDrawColor"};
        return c;
    }

    void set_drawcolor(Uint8 r, Uint8 g, Uint8 b, Uint8 a = SDL_ALPHA_OPAQUE) const
    {
        if (SDL_SetRenderDrawColor(renderer_, r, g, b, a) != 0)
            throw Exception{"SDL_SetRenderDrawColor"};
    }

    void set_drawcolor(Color const& c) const { set_drawcolor(c.r, c.g, c.b, c.a); }

    Rect cliprect() const
    {
        Rect r;
        SDL_RenderGetClipRect(renderer_, &r);
        return r;
    }

    void set_cliprect(Rect const& r) const
    {
        if (SDL_RenderSetClipRect(renderer_, &r) != 0) throw Exception{"SDL_RenderSetClipRect"};
    }

    bool clip_enabled() const { return SDL_RenderIsClipEnabled(renderer_); }

    void disable_clip() const
    {
        if (SDL_RenderSetClipRect(renderer_, nullptr) != 0)
            throw Exception{"SDL_RenderSetClipRect"};
    }

    bool intscale() const { return SDL_RenderGetIntegerScale(renderer_); }

    void set_intscale(bool intscale) const
    {
        if (SDL_RenderSetIntegerScale(renderer_, SDL_bool(intscale)) != 0)
            throw Exception{"SDL_RenderSetIntegerScale"};
    }

    Texture make_texture(Uint32 format, SDL_TextureAccess access, int w, int h) const
    {
        return Texture{renderer_, format, access, w, h};
    }

    Texture make_texture(Uint32 format, SDL_TextureAccess access, Vec2i size) const
    {
        return Texture{renderer_, format, access, size.x, size.y};
    }

    Texture make_texture(Surface const& surface) const { return Texture{renderer_, surface}; }

    Texture make_texture(std::string const& filename) const { return Texture{renderer_, filename}; }

    void render_copy(Texture const& tex, Rect const& source_rect, Rect const& dest_rect) const
    {
        // SDL will *not* modify the texture or the rects here, but the
        // signature has a non-const pointer So we are forced to cast away our
        // const ref on texture
        SDL_RenderCopy(renderer_, const_cast<Texture&>(tex).ptr(), &source_rect, &dest_rect);
    }

    void present() const { SDL_RenderPresent(renderer_); }

    void clear() const
    {
        if (SDL_RenderClear(renderer_) != 0) throw Exception{"SDL_RenderClear"};
    }

    void clear(Color const& c) const
    {
        set_drawcolor(c);
        clear();
    }

    void draw_line(Vec2i const& pos1, Vec2i const& pos2) const
    {
        if (SDL_RenderDrawLine(renderer_, pos1.x, pos1.y, pos2.x, pos2.y) != 0)
            throw Exception{"SDL_RenderDrawLine"};
    }

    void draw_line(Vec2i const& pos1, Vec2i const& pos2, Color const& c) const
    {
        set_drawcolor(c);
        draw_line(pos1, pos2);
    }

    void draw_lines(std::vector<Vec2i> const& points) const
    {
        if (SDL_RenderDrawLines(renderer_, &points[0], (int)points.size()) != 0)
            throw Exception{"SDL_RenderDrawLines"};
    }

    void draw_lines(std::vector<Vec2i> const& points, Color const& c) const
    {
        set_drawcolor(c);
        draw_lines(points);
    }

    void draw_point(Vec2i const& point) const
    {
        if (SDL_RenderDrawPoint(renderer_, point.x, point.y) != 0)
            throw Exception{"SDL_RenderDrawPoint"};
    }

    void draw_point(Vec2i const& point, Color const& c) const
    {
        set_drawcolor(c);
        draw_point(point);
    }

    void draw_points(std::vector<Vec2i> const& points) const
    {
        if (SDL_RenderDrawPoints(renderer_, &points[0], (int)points.size()) != 0)
            throw Exception{"SDL_RenderDrawPoints"};
    }

    void draw_points(std::vector<Vec2i> const& points, Color const& c) const
    {
        set_drawcolor(c);
        draw_points(points);
    }

    void draw_ray(Vec2i const& orig, Vec2i const& ray) const { draw_line(orig, orig + ray); }
    void draw_ray(Vec2i const& orig, Vec2i const& ray, Color const& c) const
    {
        draw_line(orig, orig + ray, c);
    }

    void draw_rect(Rect const& rect) const
    {
        if (SDL_RenderDrawRect(renderer_, &rect) != 0) throw Exception{"SDL_RenderDrawRect"};
    }

    void draw_rect(Rect const& rect, Color const& c) const
    {
        set_drawcolor(c);
        draw_rect(rect);
    }

    void draw_rects(std::vector<Rect> const& rects) const
    {
        if (SDL_RenderDrawRects(renderer_, &rects[0], (int)rects.size()) != 0)
            throw Exception{"SDL_RenderDrawRects"};
    }
    void draw_rects(std::vector<Rect> const& rects, const Color& c) const
    {
        set_drawcolor(c);
        draw_rects(rects);
    }

    void fill_rect(Rect const& rect) const
    {
        if (SDL_RenderFillRect(renderer_, &rect) != 0) throw Exception{"SDL_RenderFillRect"};
    }
    void fill_rect(Rect const& rect, Color const& c) const
    {
        set_drawcolor(c);
        fill_rect(rect);
    }

    void fill_rects(std::vector<Rect> const& rects) const
    {
        if (SDL_RenderFillRects(renderer_, &rects[0], (int)rects.size()) != 0)
            throw Exception{"SDL_RenderDrawRects"};
    }
    void fill_rects(std::vector<Rect> const& rects, Color const& c)
    {
        set_drawcolor(c);
        fill_rects(rects);
    }

private:
    SDL_Renderer* renderer_ = nullptr;
};

} // namespace sdl