bwidgets/src/core/renderer.cpp

#include <basic_widgets/core/renderer.hpp>
#include <basic_widgets/core/texture.hpp>

using namespace bwidgets;

Renderer::Renderer(SDL_Renderer* r)
  : Wrapper(ptr_or_throw<SDLError>(r, __FILE__, __FUNCTION__, __LINE__),
            [r](SDL_Renderer*) noexcept { SDL_DestroyRenderer(r); }),
    info(_info(r))
{}

Renderer::Renderer(SDL_Window* w, const int index, const uint32_t flags = 0)
  : Renderer(ptr_or_throw<SDLError>(SDL_CreateRenderer(w, index, flags), __FILE__,
                                    __FUNCTION__, __LINE__))
{}

auto Renderer::blend_mode() -> SDL_BlendMode
{
    SDL_BlendMode mode {};
    SDLError::success_or_throw(SDL_GetRenderDrawBlendMode(_data(), &mode), __FILE__,
                               __FUNCTION__, __LINE__);

    return mode;
}

auto Renderer::blend_mode(const SDL_BlendMode mode) -> Renderer*
{
    SDLError::success_or_throw(SDL_SetRenderDrawBlendMode(_data(), mode), __FILE__,
                               __FUNCTION__, __LINE__);

    return this;
}

auto Renderer::clear() -> Renderer*
{
    SDLError::success_or_throw(SDL_RenderClear(_data()), __FILE__, __FUNCTION__,
                               __LINE__);

    return this;
}

auto Renderer::copy(const Texture* t, const SDL_Rect* src, const SDL_Rect* dst)
  -> Renderer*
{
    SDLError::success_or_throw(SDL_RenderCopy(_data(), t->_data(), src, dst), __FILE__,
                               __FUNCTION__, __LINE__);

    return this;
}

auto Renderer::draw_color() -> Color
{
    Color c;
    SDLError::success_or_throw(
      SDL_GetRenderDrawColor(_data(), &c().r, &c().g, &c().b, &c().a), __FILE__,
      __FUNCTION__, __LINE__);

    return c;
}

auto Renderer::draw_color(const Color& c) -> Renderer*
{
    SDLError::success_or_throw(
      SDL_SetRenderDrawColor(_data(), c().r, c().g, c().b, c().a), __FILE__,
      __FUNCTION__, __LINE__);

    return this;
}

auto Renderer::draw_line(const SDL_Point& a, const SDL_Point& b) -> Renderer*
{
    SDLError::success_or_throw(SDL_RenderDrawLine(_data(), a.x, a.y, b.x, b.y), __FILE__,
                               __FUNCTION__, __LINE__);

    return this;
}

auto Renderer::draw_lines(const std::vector<SDL_Point>& pts) -> Renderer*
{
    SDLError::success_or_throw(SDL_RenderDrawLines(_data(), pts.data(), (int)pts.size()),
                               __FILE__, __FUNCTION__, __LINE__);

    return this;
}

auto Renderer::draw_point(const SDL_Point& p) -> Renderer*
{
    SDLError::success_or_throw(SDL_RenderDrawPoint(_data(), p.x, p.y), __FILE__,
                               __FUNCTION__, __LINE__);

    return this;
}

auto Renderer::draw_points(const std::vector<SDL_Point>& pts) -> Renderer*
{
    SDLError::success_or_throw(
      SDL_RenderDrawPoints(_data(), pts.data(), (int)pts.size()), __FILE__, __FUNCTION__,
      __LINE__);

    return this;
}

auto Renderer::draw_rect(const SDL_Rect* r) -> Renderer*
{
    auto vp = viewport();
    // Has glitch at top-left and bottom-right corner.
    // The first corner has an extra pixel at y-1 and surimpression.
    // The second corner is missing a pixel.
    if (r != nullptr)
        viewport({vp.x + r->x, vp.y + r->y, r->w - 1, r->h - 1}); // crop extra pixel
    SDLError::success_or_throw(SDL_RenderDrawRect(_data(), nullptr), __FILE__,
                               __FUNCTION__, __LINE__);
    // add missing pixel. works sometimes…
    if (r != nullptr) draw_point({r->w - 1, r->h - 1});
    else draw_point({vp.w - 1, vp.h - 1});

    viewport(vp);

    return this;
}

auto Renderer::draw_rects(const std::vector<SDL_Rect>& rs) -> Renderer*
{
    SDLError::success_or_throw(SDL_RenderDrawRects(_data(), rs.data(), (int)rs.size()),
                               __FILE__, __FUNCTION__, __LINE__);

    return this;
}

auto Renderer::fill_rect(const SDL_Rect* r) -> Renderer*
{
    SDLError::success_or_throw(SDL_RenderFillRect(_data(), r), __FILE__, __FUNCTION__,
                               __LINE__);

    return this;
}

auto Renderer::fill_rects(const std::vector<SDL_Rect>& rs) -> Renderer*
{
    SDLError::success_or_throw(SDL_RenderFillRects(_data(), rs.data(), (int)rs.size()),
                               __FILE__, __FUNCTION__, __LINE__);

    return this;
}

auto Renderer::output_size() -> Size
{
    Size s {};
    SDLError::success_or_throw(SDL_GetRendererOutputSize(_data(), &s.w, &s.h), __FILE__,
                               __FUNCTION__, __LINE__);

    return s;
}

void Renderer::present() noexcept
{
    SDL_RenderPresent(_data());
}

auto Renderer::viewport() noexcept -> SDL_Rect
{
    SDL_Rect vp;
    SDL_RenderGetViewport(_data(), &vp);

    return vp;
}

auto Renderer::viewport(const SDL_Rect* vp) -> Renderer*
{
    SDLError::success_or_throw(SDL_RenderSetViewport(_data(), vp), __FILE__,
                               __FUNCTION__, __LINE__);

    return this;
}