SDL3pp_render.h

#ifndef SDL3PP_RENDER_H_
#define SDL3PP_RENDER_H_
 
#include <SDL3/SDL_render.h>
#include "SDL3pp_blendmode.h"
#include "SDL3pp_events.h"
#include "SDL3pp_pixels.h"
#include "SDL3pp_properties.h"
#include "SDL3pp_rect.h"
#include "SDL3pp_stdinc.h"
#include "SDL3pp_surface.h"
#include "SDL3pp_video.h"
 
namespace SDL {
 
// Forward decl
struct TextureLock;
 
// Forward decl
struct RendererBase;
 
// Forward decl
struct RendererRef;
 
// Forward decl
struct Renderer;
 
// Forward decl
struct TextureBase;
 
// Forward decl
struct TextureRef;
 
// Forward decl
struct Texture;
 
using OptionalTexture = OptionalResource<TextureRef, Texture>;
 
#ifdef SDL3PP_DOC
 
#define SDL_SOFTWARE_RENDERER "software"
 
#endif // SDL3PP_DOC
 
using Vertex = SDL_Vertex;
 
using TextureAccess = SDL_TextureAccess;
 
constexpr TextureAccess TEXTUREACCESS_STATIC =
  SDL_TEXTUREACCESS_STATIC; 
 
constexpr TextureAccess TEXTUREACCESS_STREAMING =
  SDL_TEXTUREACCESS_STREAMING; 
 
constexpr TextureAccess TEXTUREACCESS_TARGET =
  SDL_TEXTUREACCESS_TARGET; 
 
using RendererLogicalPresentation = SDL_RendererLogicalPresentation;
 
constexpr RendererLogicalPresentation LOGICAL_PRESENTATION_DISABLED =
  SDL_LOGICAL_PRESENTATION_DISABLED; 
 
constexpr RendererLogicalPresentation LOGICAL_PRESENTATION_STRETCH =
  SDL_LOGICAL_PRESENTATION_STRETCH;
 
constexpr RendererLogicalPresentation LOGICAL_PRESENTATION_LETTERBOX =
  SDL_LOGICAL_PRESENTATION_LETTERBOX;
 
constexpr RendererLogicalPresentation LOGICAL_PRESENTATION_OVERSCAN =
  SDL_LOGICAL_PRESENTATION_OVERSCAN;
 
constexpr RendererLogicalPresentation LOGICAL_PRESENTATION_INTEGER_SCALE =
  SDL_LOGICAL_PRESENTATION_INTEGER_SCALE;
 
struct RendererBase : Resource<SDL_Renderer*>
{
  using Resource::Resource;
 
  RendererBase(WindowRef window)
    : Resource(SDL_CreateRenderer(window.get(), nullptr))
  {
  }
 
  RendererBase(WindowBase& window, StringParam name)
    : Resource(CheckError(SDL_CreateRenderer(window.get(), name)))
  {
  }
 
  RendererBase(PropertiesBase& props)
    : Resource(CheckError(SDL_CreateRendererWithProperties(props.get())))
  {
  }
 
  RendererBase(SurfaceBase& surface)
    : Resource(CheckError(SDL_CreateSoftwareRenderer(surface.get())))
  {
  }
 
  WindowRef GetWindow() { return CheckError(SDL_GetRenderWindow(get())); }
 
  const char* GetName() const { return CheckError(SDL_GetRendererName(get())); }
 
  Point GetOutputSize() const
  {
    Point p;
    GetOutputSize(&p.x, &p.y);
    return p;
  }
 
  void GetOutputSize(int* w, int* h) const
  {
    CheckError(SDL_GetRenderOutputSize(get(), w, h));
  }
 
  Point GetCurrentOutputSize() const
  {
    Point p;
    GetCurrentOutputSize(&p.x, &p.y);
    return p;
  }
 
  void GetCurrentOutputSize(int* w, int* h) const
  {
    CheckError(SDL_GetCurrentRenderOutputSize(get(), w, h));
  }
 
  PropertiesRef GetProperties() const
  {
    return CheckError(SDL_GetRendererProperties(get()));
  }
 
  void ResetTarget();
 
  void SetTarget(OptionalTexture texture);
 
  TextureRef GetTarget() const;
 
  void SetLogicalPresentation(SDL_Point size, RendererLogicalPresentation mode)
  {
    CheckError(SDL_SetRenderLogicalPresentation(get(), size.x, size.y, mode));
  }
 
  void GetLogicalPresentation(SDL_Point* size,
                              RendererLogicalPresentation* mode)
  {
    if (!size) return GetLogicalPresentation(nullptr, nullptr, mode);
    return GetLogicalPresentation(&size->x, &size->y, mode);
  }
 
  void GetLogicalPresentation(int* w,
                              int* h,
                              RendererLogicalPresentation* mode) const
  {
    CheckError(SDL_GetRenderLogicalPresentation(get(), w, h, mode));
  }
 
  FRect GetLogicalPresentationRect() const
  {
    FRect rect;
    CheckError(SDL_GetRenderLogicalPresentationRect(get(), &rect));
    return rect;
  }
 
  FPoint RenderCoordinatesFromWindow(const SDL_FPoint& window_coord) const
  {
    FPoint p;
    CheckError(SDL_RenderCoordinatesFromWindow(
      get(), window_coord.x, window_coord.y, &p.x, &p.y));
    return p;
  }
 
  FPoint RenderCoordinatesToWindow(const SDL_FPoint& coord) const
  {
    FPoint p;
    CheckError(
      SDL_RenderCoordinatesToWindow(get(), coord.x, coord.y, &p.x, &p.y));
    return p;
  }
 
  void ConvertEventToRenderCoordinates(Event* event) const
  {
    CheckError(SDL_ConvertEventToRenderCoordinates(get(), event));
  }
 
  void ResetViewport() { SetViewport(std::nullopt); }
 
  void SetViewport(OptionalRef<const SDL_Rect> rect)
  {
    CheckError(SDL_SetRenderViewport(get(), rect));
  }
 
  Rect GetViewport() const
  {
    Rect rect;
    CheckError(SDL_GetRenderViewport(get(), &rect));
    return rect;
  }
 
  bool IsViewportSet() const { return SDL_RenderViewportSet(get()); }
 
  Rect GetSafeArea() const
  {
    Rect rect;
    CheckError(SDL_GetRenderSafeArea(get(), &rect));
    return rect;
  }
 
  void ResetClipRect() { SetClipRect({}); }
 
  void SetClipRect(OptionalRef<const SDL_Rect> rect)
  {
    CheckError(SDL_SetRenderClipRect(get(), rect));
  }
 
  Rect GetClipRect() const
  {
    Rect rect;
    CheckError(SDL_GetRenderClipRect(get(), &rect));
    return rect;
  }
 
  bool IsClipEnabled() const { return SDL_RenderClipEnabled(get()); }
 
  void SetScale(SDL_FPoint scale)
  {
    CheckError(SDL_SetRenderScale(get(), scale.x, scale.y));
  }
 
  FPoint GetScale() const
  {
    FPoint p;
    GetScale(&p.x, &p.y);
    return p;
  }
 
  void GetScale(float* scaleX, float* scaleY) const
  {
    CheckError(SDL_GetRenderScale(get(), scaleX, scaleY));
  }
 
  void SetDrawColor(SDL_Color c)
  {
    CheckError(SDL_SetRenderDrawColor(get(), c.r, c.g, c.b, c.a));
  }
 
  void SetDrawColor(SDL_FColor c)
  {
    CheckError(SDL_SetRenderDrawColorFloat(get(), c.r, c.g, c.b, c.a));
  }
 
  FColor GetDrawColor() const
  {
    FColor color;
    GetDrawColor(&color);
    return color;
  }
 
  void GetDrawColor(SDL_Color* c) const
  {
    GetDrawColor(&c->r, &c->g, &c->b, &c->a);
  }
 
  void GetDrawColor(SDL_FColor* c) const
  {
    GetDrawColor(&c->r, &c->g, &c->b, &c->a);
  }
 
  void GetDrawColor(Uint8* r, Uint8* g, Uint8* b, Uint8* a) const
  {
    CheckError(SDL_GetRenderDrawColor(get(), r, g, b, a));
  }
 
  void GetDrawColor(float* r, float* g, float* b, float* a) const
  {
    CheckError(SDL_GetRenderDrawColorFloat(get(), r, g, b, a));
  }
 
  void SetColorScale(float scale)
  {
    CheckError(SDL_SetRenderColorScale(get(), scale));
  }
 
  float GetColorScale() const
  {
    float scale;
    CheckError(SDL_GetRenderColorScale(get(), &scale));
    return scale;
  }
 
  void SetDrawBlendMode(BlendMode blendMode)
  {
    CheckError(SDL_SetRenderDrawBlendMode(get(), blendMode));
  }
 
  BlendMode GetDrawBlendMode() const
  {
    BlendMode blendMode;
    CheckError(SDL_GetRenderDrawBlendMode(get(), &blendMode));
    return blendMode;
  }
 
  void RenderClear() { CheckError(SDL_RenderClear(get())); }
 
  void RenderPoint(SDL_FPoint p)
  {
    CheckError(SDL_RenderPoint(get(), p.x, p.y));
  }
 
  void RenderPoints(SpanRef<const SDL_FPoint> points)
  {
    SDL_assert_paranoid(points.size() < SDL_MAX_SINT32);
    CheckError(SDL_RenderPoints(get(), points.data(), points.size()));
  }
 
  void RenderLine(SDL_FPoint p1, SDL_FPoint p2)
  {
    CheckError(SDL_RenderLine(get(), p1.x, p1.y, p2.x, p2.y));
  }
 
  void RenderLines(SpanRef<const SDL_FPoint> points)
  {
    SDL_assert_paranoid(points.size() < SDL_MAX_SINT32);
    CheckError(SDL_RenderLines(get(), points.data(), points.size()));
  }
 
  void RenderRect(OptionalRef<const SDL_FRect> rect)
  {
    CheckError(SDL_RenderRect(get(), rect));
  }
 
  void RenderRects(SpanRef<const SDL_FRect> rects)
  {
    SDL_assert_paranoid(rects.size() < SDL_MAX_SINT32);
    CheckError(SDL_RenderRects(get(), rects.data(), rects.size()));
  }
 
  void RenderFillRect(OptionalRef<const SDL_FRect> rect)
  {
    CheckError(SDL_RenderFillRect(get(), rect));
  }
 
  void RenderFillRects(SpanRef<const SDL_FRect> rects)
  {
    SDL_assert_paranoid(rects.size() < SDL_MAX_SINT32);
    CheckError(SDL_RenderFillRects(get(), rects.data(), rects.size()));
  }
 
  void RenderTexture(TextureBase& texture,
                     OptionalRef<const SDL_FRect> srcrect,
                     OptionalRef<const SDL_FRect> dstrect);
 
  void RenderTextureRotated(TextureBase& texture,
                            OptionalRef<const SDL_FRect> srcrect,
                            OptionalRef<const SDL_FRect> dstrect,
                            double angle,
                            OptionalRef<const SDL_FPoint> center = {},
                            FlipMode flip = SDL_FLIP_NONE);
 
  void RenderTextureAffine(TextureBase& texture,
                           OptionalRef<const SDL_FRect> srcrect,
                           OptionalRef<const SDL_FPoint> origin,
                           OptionalRef<const SDL_FPoint> right,
                           OptionalRef<const SDL_FPoint> down);
 
  void RenderTextureTiled(TextureBase& texture,
                          OptionalRef<const SDL_FRect> srcrect,
                          float scale,
                          OptionalRef<const SDL_FRect> dstrect);
 
  void RenderTexture9Grid(TextureBase& texture,
                          OptionalRef<const SDL_FRect> srcrect,
                          float left_width,
                          float right_width,
                          float top_height,
                          float bottom_height,
                          float scale,
                          OptionalRef<const SDL_FRect> dstrect);
 
  void RenderGeometry(OptionalTexture texture,
                      std::span<const Vertex> vertices,
                      std::span<const int> indices = {});
 
  void RenderGeometryRaw(OptionalTexture texture,
                         const float* xy,
                         int xy_stride,
                         const FColor* color,
                         int color_stride,
                         const float* uv,
                         int uv_stride,
                         int num_vertices,
                         const void* indices,
                         int num_indices,
                         int size_indices);
 
  Surface ReadPixels(OptionalRef<const SDL_Rect> rect = {}) const
  {
    return Surface(CheckError(SDL_RenderReadPixels(get(), rect)));
  }
 
  void Present() { CheckError(SDL_RenderPresent(get())); }
 
  void Flush() { CheckError(SDL_FlushRenderer(get())); }
 
  void SetVSync(int vsync) { CheckError(SDL_SetRenderVSync(get(), vsync)); }
 
  int GetVSync() const
  {
    int vsync;
    CheckError(SDL_GetRenderVSync(get(), &vsync));
    return vsync;
  }
 
  void RenderDebugText(FPoint p, StringParam str)
  {
    CheckError(SDL_RenderDebugText(get(), p.x, p.y, str));
  }
 
  template<class... ARGS>
  void RenderDebugTextFormat(FPoint p, std::string_view fmt, ARGS... args)
  {
    RenderDebugText(p, std::vformat(fmt, std::make_format_args(args...)));
  }
};
 
struct RendererRef : RendererBase
{
  using RendererBase::RendererBase;
 
  constexpr RendererRef(const RendererRef& other)
    : RendererBase(other.get())
  {
  }
 
  constexpr RendererRef(RendererRef&& other)
    : RendererBase(other.release())
  {
  }
 
  constexpr ~RendererRef() = default;
 
  RendererRef& operator=(RendererRef other)
  {
    release(other.release());
    return *this;
  }
 
  void reset(SDL_Renderer* newResource = {})
  {
    SDL_DestroyRenderer(release(newResource));
  }
};
 
struct Renderer : RendererRef
{
  using RendererRef::RendererRef;
 
  constexpr explicit Renderer(SDL_Renderer* resource = {})
    : RendererRef(resource)
  {
  }
 
  constexpr Renderer(const Renderer& other) = delete;
 
  constexpr Renderer(Renderer&& other) = default;
 
  ~Renderer() { reset(); }
 
  Renderer& operator=(Renderer other)
  {
    reset(other.release());
    return *this;
  }
};
 
struct TextureBase : Resource<SDL_Texture*>
{
  using Resource::Resource;
 
  TextureBase(RendererBase& renderer, StringParam file);
 
  TextureBase(RendererBase& renderer, IOStream& src);
 
  TextureBase(RendererBase& renderer,
              PixelFormat format,
              TextureAccess access,
              const SDL_Point& size)
    : Resource(CheckError(
        SDL_CreateTexture(renderer.get(), format, access, size.x, size.y)))
  {
  }
 
  TextureBase(RendererBase& renderer, SurfaceBase& surface)
    : Resource(
        CheckError(SDL_CreateTextureFromSurface(renderer.get(), surface.get())))
  {
  }
 
  TextureBase(RendererBase& renderer, PropertiesBase& props)
    : Resource(CheckError(
        SDL_CreateTextureWithProperties(renderer.get(), props.get())))
  {
  }
 
  PropertiesRef GetProperties() const
  {
    return CheckError(SDL_GetTextureProperties(get()));
  }
 
  RendererRef GetRenderer() const { return SDL_GetRendererFromTexture(get()); }
 
  void SetMod(Color c)
  {
    SetColorMod(c.r, c.g, c.b);
    SetAlphaMod(c.a);
  }
 
  void SetMod(FColor c)
  {
    SetColorMod(c.r, c.g, c.b);
    SetAlphaMod(c.a);
  }
 
  FColor GetMod() const
  {
    FColor color;
    GetMod(&color);
    return color;
  }
 
  void GetMod(Color* c) const
  {
    SDL_assert_paranoid(c != nullptr);
    GetColorMod(&c->r, &c->g, &c->b);
    GetAlphaMod(&c->a);
  }
 
  void GetMod(FColor* c) const
  {
    SDL_assert_paranoid(c != nullptr);
    GetColorMod(&c->r, &c->g, &c->b);
    GetAlphaMod(&c->a);
  }
 
  void SetColorMod(Uint8 r, Uint8 g, Uint8 b)
  {
    CheckError(SDL_SetTextureColorMod(get(), r, g, b));
  }
 
  void SetColorMod(float r, float g, float b)
  {
    CheckError(SDL_SetTextureColorModFloat(get(), r, g, b));
  }
 
  void GetColorMod(Uint8* r, Uint8* g, Uint8* b) const
  {
    CheckError(SDL_GetTextureColorMod(get(), r, g, b));
  }
 
  void GetColorMod(float* r, float* g, float* b) const
  {
    CheckError(SDL_GetTextureColorModFloat(get(), r, g, b));
  }
 
  void SetAlphaMod(Uint8 alpha)
  {
    CheckError(SDL_SetTextureAlphaMod(get(), alpha));
  }
 
  void SetAlphaMod(float alpha)
  {
    CheckError(SDL_SetTextureAlphaModFloat(get(), alpha));
  }
 
  float GetAlphaMod() const
  {
    float alpha;
    GetAlphaMod(&alpha);
    return alpha;
  }
 
  void GetAlphaMod(Uint8* alpha) const
  {
    CheckError(SDL_GetTextureAlphaMod(get(), alpha));
  }
 
  void GetAlphaMod(float* alpha) const
  {
    CheckError(SDL_GetTextureAlphaModFloat(get(), alpha));
  }
 
  void SetBlendMode(BlendMode blendMode)
  {
    CheckError(SDL_SetTextureBlendMode(get(), blendMode));
  }
 
  BlendMode GetBlendMode() const
  {
    BlendMode blendMode;
    CheckError(SDL_GetTextureBlendMode(get(), &blendMode));
    return blendMode;
  }
 
  void SetScaleMode(ScaleMode scaleMode)
  {
    CheckError(SDL_SetTextureScaleMode(get(), scaleMode));
  }
 
  ScaleMode GetScaleMode() const
  {
    ScaleMode scaleMode;
    CheckError(SDL_GetTextureScaleMode(get(), &scaleMode));
    return scaleMode;
  }
 
  void Update(OptionalRef<const SDL_Rect> rect, const void* pixels, int pitch)
  {
    CheckError(SDL_UpdateTexture(get(), rect, pixels, pitch));
  }
 
  void UpdateYUV(OptionalRef<const SDL_Rect> rect,
                 const Uint8* Yplane,
                 int Ypitch,
                 const Uint8* Uplane,
                 int Upitch,
                 const Uint8* Vplane,
                 int Vpitch)
  {
    CheckError(SDL_UpdateYUVTexture(
      get(), rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch));
  }
 
  void UpdateNV(OptionalRef<const SDL_Rect> rect,
                const Uint8* Yplane,
                int Ypitch,
                const Uint8* UVplane,
                int UVpitch)
  {
    CheckError(
      SDL_UpdateNVTexture(get(), rect, Yplane, Ypitch, UVplane, UVpitch));
  }
 
  TextureLock Lock(OptionalRef<const SDL_Rect> rect = {}) &;
 
  int GetWidth() const { return get()->w; }
 
  int GetHeight() const { return get()->h; }
 
  Point GetSize() const { return Point(GetWidth(), GetHeight()); }
 
  PixelFormat GetFormat() const { return get()->format; }
};
 
struct TextureRef : TextureBase
{
  using TextureBase::TextureBase;
 
  constexpr TextureRef(const TextureRef& other)
    : TextureBase(other.get())
  {
  }
 
  constexpr TextureRef(TextureRef&& other)
    : TextureBase(other.release())
  {
  }
 
  constexpr ~TextureRef() = default;
 
  TextureRef& operator=(TextureRef other)
  {
    release(other.release());
    return *this;
  }
 
  void reset(SDL_Texture* newResource = {})
  {
    SDL_DestroyTexture(release(newResource));
  }
};
 
struct Texture : TextureRef
{
  using TextureRef::TextureRef;
 
  constexpr explicit Texture(SDL_Texture* resource = {})
    : TextureRef(resource)
  {
  }
 
  constexpr Texture(const Texture& other) = delete;
 
  constexpr Texture(Texture&& other) = default;
 
  ~Texture() { reset(); }
 
  Texture& operator=(Texture other)
  {
    reset(other.release());
    return *this;
  }
};
 
class TextureLock : public SurfaceBase
{
  TextureRef texture;
 
  explicit TextureLock(TextureRef texture, OptionalRef<const SDL_Rect> rect)
    : texture(std::move(texture))
  {
    SDL_Surface* maybeLock;
    if (SDL_LockTextureToSurface(this->texture.get(), rect, &maybeLock)) {
      release(maybeLock);
    } else {
      texture.release();
    }
  }
 
public:
  constexpr TextureLock() = default;
 
  // Copy ctor
  TextureLock(const TextureLock& other) = delete;
 
  TextureLock(TextureLock&& other)
    : SurfaceBase(other.release())
    , texture(other.texture.release())
  {
  }
 
  ~TextureLock() { Unlock(); }
 
  TextureLock& operator=(TextureLock other)
  {
    Unlock();
    SurfaceBase::release(other.get());
    std::swap(texture, other.texture);
    return *this;
  }
 
  void Unlock()
  {
    if (texture) {
      SurfaceBase::release();
      SDL_UnlockTexture(texture.release());
    }
  }
 
  void* GetPixels() const { return get()->pixels; }
 
  int GetPitch() const { return get()->pitch; }
 
  void reset() { Unlock(); }
 
  friend class TextureBase;
};
 
inline int GetNumRenderDrivers() { return SDL_GetNumRenderDrivers(); }
 
inline const char* GetRenderDriver(int index)
{
  return SDL_GetRenderDriver(index);
}
 
inline std::pair<Window, Renderer> CreateWindowAndRenderer(
  StringParam title,
  SDL_Point size,
  WindowFlags window_flags = 0)
{
  SDL_Window* window;
  SDL_Renderer* renderer;
  CheckError(SDL_CreateWindowAndRenderer(
    title, size.x, size.y, window_flags, &window, &renderer));
  return {Window{window}, Renderer{renderer}};
}
 
namespace prop::Renderer {
 
constexpr auto CREATE_NAME_STRING = SDL_PROP_RENDERER_CREATE_NAME_STRING;
 
constexpr auto CREATE_WINDOW_POINTER = SDL_PROP_RENDERER_CREATE_WINDOW_POINTER;
 
constexpr auto CREATE_SURFACE_POINTER =
  SDL_PROP_RENDERER_CREATE_SURFACE_POINTER;
 
constexpr auto CREATE_OUTPUT_COLORSPACE_NUMBER =
  SDL_PROP_RENDERER_CREATE_OUTPUT_COLORSPACE_NUMBER;
 
constexpr auto CREATE_PRESENT_VSYNC_NUMBER =
  SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_NUMBER;
 
constexpr auto CREATE_VULKAN_INSTANCE_POINTER =
  SDL_PROP_RENDERER_CREATE_VULKAN_INSTANCE_POINTER;
 
constexpr auto CREATE_VULKAN_SURFACE_NUMBER =
  SDL_PROP_RENDERER_CREATE_VULKAN_SURFACE_NUMBER;
 
constexpr auto CREATE_VULKAN_PHYSICAL_DEVICE_POINTER =
  SDL_PROP_RENDERER_CREATE_VULKAN_PHYSICAL_DEVICE_POINTER;
 
constexpr auto CREATE_VULKAN_DEVICE_POINTER =
  SDL_PROP_RENDERER_CREATE_VULKAN_DEVICE_POINTER;
 
constexpr auto CREATE_VULKAN_GRAPHICS_QUEUE_FAMILY_INDEX_NUMBER =
  SDL_PROP_RENDERER_CREATE_VULKAN_GRAPHICS_QUEUE_FAMILY_INDEX_NUMBER;
 
constexpr auto CREATE_VULKAN_PRESENT_QUEUE_FAMILY_INDEX_NUMBER =
  SDL_PROP_RENDERER_CREATE_VULKAN_PRESENT_QUEUE_FAMILY_INDEX_NUMBER;
 
constexpr auto NAME_STRING = SDL_PROP_RENDERER_NAME_STRING;
 
constexpr auto WINDOW_POINTER = SDL_PROP_RENDERER_WINDOW_POINTER;
 
constexpr auto SURFACE_POINTER = SDL_PROP_RENDERER_SURFACE_POINTER;
 
constexpr auto VSYNC_NUMBER = SDL_PROP_RENDERER_VSYNC_NUMBER;
 
constexpr auto MAX_TEXTURE_SIZE_NUMBER =
  SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER;
 
constexpr auto TEXTURE_FORMATS_POINTER =
  SDL_PROP_RENDERER_TEXTURE_FORMATS_POINTER;
 
constexpr auto OUTPUT_COLORSPACE_NUMBER =
  SDL_PROP_RENDERER_OUTPUT_COLORSPACE_NUMBER;
 
constexpr auto HDR_ENABLED_BOOLEAN = SDL_PROP_RENDERER_HDR_ENABLED_BOOLEAN;
 
constexpr auto SDR_WHITE_POINT_FLOAT = SDL_PROP_RENDERER_SDR_WHITE_POINT_FLOAT;
 
constexpr auto HDR_HEADROOM_FLOAT = SDL_PROP_RENDERER_HDR_HEADROOM_FLOAT;
 
constexpr auto D3D9_DEVICE_POINTER = SDL_PROP_RENDERER_D3D9_DEVICE_POINTER;
 
constexpr auto D3D11_DEVICE_POINTER = SDL_PROP_RENDERER_D3D11_DEVICE_POINTER;
 
constexpr auto D3D11_SWAPCHAIN_POINTER =
  SDL_PROP_RENDERER_D3D11_SWAPCHAIN_POINTER;
 
constexpr auto D3D12_DEVICE_POINTER = SDL_PROP_RENDERER_D3D12_DEVICE_POINTER;
 
constexpr auto D3D12_SWAPCHAIN_POINTER =
  SDL_PROP_RENDERER_D3D12_SWAPCHAIN_POINTER;
 
constexpr auto D3D12_COMMAND_QUEUE_POINTER =
  SDL_PROP_RENDERER_D3D12_COMMAND_QUEUE_POINTER;
 
constexpr auto VULKAN_INSTANCE_POINTER =
  SDL_PROP_RENDERER_VULKAN_INSTANCE_POINTER;
 
constexpr auto VULKAN_SURFACE_NUMBER = SDL_PROP_RENDERER_VULKAN_SURFACE_NUMBER;
 
constexpr auto VULKAN_PHYSICAL_DEVICE_POINTER =
  SDL_PROP_RENDERER_VULKAN_PHYSICAL_DEVICE_POINTER;
 
constexpr auto VULKAN_DEVICE_POINTER = SDL_PROP_RENDERER_VULKAN_DEVICE_POINTER;
 
constexpr auto VULKAN_GRAPHICS_QUEUE_FAMILY_INDEX_NUMBER =
  SDL_PROP_RENDERER_VULKAN_GRAPHICS_QUEUE_FAMILY_INDEX_NUMBER;
 
constexpr auto VULKAN_PRESENT_QUEUE_FAMILY_INDEX_NUMBER =
  SDL_PROP_RENDERER_VULKAN_PRESENT_QUEUE_FAMILY_INDEX_NUMBER;
 
constexpr auto VULKAN_SWAPCHAIN_IMAGE_COUNT_NUMBER =
  SDL_PROP_RENDERER_VULKAN_SWAPCHAIN_IMAGE_COUNT_NUMBER;
 
constexpr auto GPU_DEVICE_POINTER = SDL_PROP_RENDERER_GPU_DEVICE_POINTER;
 
} // namespace prop::Renderer
 
inline RendererRef WindowBase::GetRenderer() const
{
  return CheckError(SDL_GetRenderer(get()));
}
 
namespace prop::Texture {
 
constexpr auto CREATE_COLORSPACE_NUMBER =
  SDL_PROP_TEXTURE_CREATE_COLORSPACE_NUMBER;
 
constexpr auto CREATE_FORMAT_NUMBER = SDL_PROP_TEXTURE_CREATE_FORMAT_NUMBER;
 
constexpr auto CREATE_ACCESS_NUMBER = SDL_PROP_TEXTURE_CREATE_ACCESS_NUMBER;
 
constexpr auto CREATE_WIDTH_NUMBER = SDL_PROP_TEXTURE_CREATE_WIDTH_NUMBER;
 
constexpr auto CREATE_HEIGHT_NUMBER = SDL_PROP_TEXTURE_CREATE_HEIGHT_NUMBER;
 
constexpr auto CREATE_SDR_WHITE_POINT_FLOAT =
  SDL_PROP_TEXTURE_CREATE_SDR_WHITE_POINT_FLOAT;
 
constexpr auto CREATE_HDR_HEADROOM_FLOAT =
  SDL_PROP_TEXTURE_CREATE_HDR_HEADROOM_FLOAT;
 
constexpr auto CREATE_D3D11_TEXTURE_POINTER =
  SDL_PROP_TEXTURE_CREATE_D3D11_TEXTURE_POINTER;
 
constexpr auto CREATE_D3D11_TEXTURE_U_POINTER =
  SDL_PROP_TEXTURE_CREATE_D3D11_TEXTURE_U_POINTER;
 
constexpr auto CREATE_D3D11_TEXTURE_V_POINTER =
  SDL_PROP_TEXTURE_CREATE_D3D11_TEXTURE_V_POINTER;
 
constexpr auto CREATE_D3D12_TEXTURE_POINTER =
  SDL_PROP_TEXTURE_CREATE_D3D12_TEXTURE_POINTER;
 
constexpr auto CREATE_D3D12_TEXTURE_U_POINTER =
  SDL_PROP_TEXTURE_CREATE_D3D12_TEXTURE_U_POINTER;
 
constexpr auto CREATE_D3D12_TEXTURE_V_POINTER =
  SDL_PROP_TEXTURE_CREATE_D3D12_TEXTURE_V_POINTER;
 
constexpr auto CREATE_METAL_PIXELBUFFER_POINTER =
  SDL_PROP_TEXTURE_CREATE_METAL_PIXELBUFFER_POINTER;
 
constexpr auto CREATE_OPENGL_TEXTURE_NUMBER =
  SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_NUMBER;
 
constexpr auto CREATE_OPENGL_TEXTURE_UV_NUMBER =
  SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_UV_NUMBER;
 
constexpr auto CREATE_OPENGL_TEXTURE_U_NUMBER =
  SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_U_NUMBER;
 
constexpr auto CREATE_OPENGL_TEXTURE_V_NUMBER =
  SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_V_NUMBER;
 
constexpr auto CREATE_OPENGLES2_TEXTURE_NUMBER =
  SDL_PROP_TEXTURE_CREATE_OPENGLES2_TEXTURE_NUMBER;
 
constexpr auto CREATE_OPENGLES2_TEXTURE_UV_NUMBER =
  SDL_PROP_TEXTURE_CREATE_OPENGLES2_TEXTURE_UV_NUMBER;
 
constexpr auto CREATE_OPENGLES2_TEXTURE_U_NUMBER =
  SDL_PROP_TEXTURE_CREATE_OPENGLES2_TEXTURE_U_NUMBER;
 
constexpr auto CREATE_OPENGLES2_TEXTURE_V_NUMBER =
  SDL_PROP_TEXTURE_CREATE_OPENGLES2_TEXTURE_V_NUMBER;
 
constexpr auto CREATE_VULKAN_TEXTURE_NUMBER =
  SDL_PROP_TEXTURE_CREATE_VULKAN_TEXTURE_NUMBER;
 
constexpr auto COLORSPACE_NUMBER = SDL_PROP_TEXTURE_COLORSPACE_NUMBER;
 
constexpr auto FORMAT_NUMBER = SDL_PROP_TEXTURE_FORMAT_NUMBER;
 
constexpr auto ACCESS_NUMBER = SDL_PROP_TEXTURE_ACCESS_NUMBER;
 
constexpr auto WIDTH_NUMBER = SDL_PROP_TEXTURE_WIDTH_NUMBER;
 
constexpr auto HEIGHT_NUMBER = SDL_PROP_TEXTURE_HEIGHT_NUMBER;
 
constexpr auto SDR_WHITE_POINT_FLOAT = SDL_PROP_TEXTURE_SDR_WHITE_POINT_FLOAT;
 
constexpr auto HDR_HEADROOM_FLOAT = SDL_PROP_TEXTURE_HDR_HEADROOM_FLOAT;
 
constexpr auto D3D11_TEXTURE_POINTER = SDL_PROP_TEXTURE_D3D11_TEXTURE_POINTER;
 
constexpr auto D3D11_TEXTURE_U_POINTER =
  SDL_PROP_TEXTURE_D3D11_TEXTURE_U_POINTER;
 
constexpr auto D3D11_TEXTURE_V_POINTER =
  SDL_PROP_TEXTURE_D3D11_TEXTURE_V_POINTER;
 
constexpr auto D3D12_TEXTURE_POINTER = SDL_PROP_TEXTURE_D3D12_TEXTURE_POINTER;
 
constexpr auto D3D12_TEXTURE_U_POINTER =
  SDL_PROP_TEXTURE_D3D12_TEXTURE_U_POINTER;
 
constexpr auto D3D12_TEXTURE_V_POINTER =
  SDL_PROP_TEXTURE_D3D12_TEXTURE_V_POINTER;
 
constexpr auto OPENGL_TEXTURE_NUMBER = SDL_PROP_TEXTURE_OPENGL_TEXTURE_NUMBER;
 
constexpr auto OPENGL_TEXTURE_UV_NUMBER =
  SDL_PROP_TEXTURE_OPENGL_TEXTURE_UV_NUMBER;
 
constexpr auto OPENGL_TEXTURE_U_NUMBER =
  SDL_PROP_TEXTURE_OPENGL_TEXTURE_U_NUMBER;
 
constexpr auto OPENGL_TEXTURE_V_NUMBER =
  SDL_PROP_TEXTURE_OPENGL_TEXTURE_V_NUMBER;
 
constexpr auto OPENGL_TEXTURE_TARGET_NUMBER =
  SDL_PROP_TEXTURE_OPENGL_TEXTURE_TARGET_NUMBER;
 
constexpr auto OPENGL_TEX_W_FLOAT = SDL_PROP_TEXTURE_OPENGL_TEX_W_FLOAT;
 
constexpr auto OPENGL_TEX_H_FLOAT = SDL_PROP_TEXTURE_OPENGL_TEX_H_FLOAT;
 
constexpr auto OPENGLES2_TEXTURE_NUMBER =
  SDL_PROP_TEXTURE_OPENGLES2_TEXTURE_NUMBER;
 
constexpr auto OPENGLES2_TEXTURE_UV_NUMBER =
  SDL_PROP_TEXTURE_OPENGLES2_TEXTURE_UV_NUMBER;
 
constexpr auto OPENGLES2_TEXTURE_U_NUMBER =
  SDL_PROP_TEXTURE_OPENGLES2_TEXTURE_U_NUMBER;
 
constexpr auto OPENGLES2_TEXTURE_V_NUMBER =
  SDL_PROP_TEXTURE_OPENGLES2_TEXTURE_V_NUMBER;
 
constexpr auto OPENGLES2_TEXTURE_TARGET_NUMBER =
  SDL_PROP_TEXTURE_OPENGLES2_TEXTURE_TARGET_NUMBER;
 
constexpr auto VULKAN_TEXTURE_NUMBER = SDL_PROP_TEXTURE_VULKAN_TEXTURE_NUMBER;
 
} // namespace prop::Texture
 
inline void RendererBase::SetTarget(OptionalTexture texture)
{
  CheckError(SDL_SetRenderTarget(get(), texture.get()));
}
 
inline TextureRef RendererBase::GetTarget() const
{
  return SDL_GetRenderTarget(get());
}
 
inline void RendererBase::RenderTexture(TextureBase& texture,
                                        OptionalRef<const SDL_FRect> srcrect,
                                        OptionalRef<const SDL_FRect> dstrect)
{
  CheckError(SDL_RenderTexture(get(), texture.get(), srcrect, dstrect));
}
 
inline void RendererBase::RenderTextureRotated(
  TextureBase& texture,
  OptionalRef<const SDL_FRect> srcrect,
  OptionalRef<const SDL_FRect> dstrect,
  double angle,
  OptionalRef<const SDL_FPoint> center,
  FlipMode flip)
{
  CheckError(SDL_RenderTextureRotated(
    get(), texture.get(), srcrect, dstrect, angle, center, flip));
}
 
inline void RendererBase::RenderTextureAffine(
  TextureBase& texture,
  OptionalRef<const SDL_FRect> srcrect,
  OptionalRef<const SDL_FPoint> origin,
  OptionalRef<const SDL_FPoint> right,
  OptionalRef<const SDL_FPoint> down)
{
  CheckError(SDL_RenderTextureAffine(
    get(), texture.get(), srcrect, origin, right, down));
}
 
inline void RendererBase::RenderTextureTiled(
  TextureBase& texture,
  OptionalRef<const SDL_FRect> srcrect,
  float scale,
  OptionalRef<const SDL_FRect> dstrect)
{
  CheckError(
    SDL_RenderTextureTiled(get(), texture.get(), srcrect, scale, dstrect));
}
 
inline void RendererBase::RenderTexture9Grid(
  TextureBase& texture,
  OptionalRef<const SDL_FRect> srcrect,
  float left_width,
  float right_width,
  float top_height,
  float bottom_height,
  float scale,
  OptionalRef<const SDL_FRect> dstrect)
{
  CheckError(SDL_RenderTexture9Grid(get(),
                                    texture.get(),
                                    srcrect,
                                    left_width,
                                    right_width,
                                    top_height,
                                    bottom_height,
                                    scale,
                                    dstrect));
}
 
inline void RendererBase::RenderGeometry(OptionalTexture texture,
                                         std::span<const Vertex> vertices,
                                         std::span<const int> indices)
{
  CheckError(SDL_RenderGeometry(get(),
                                texture.get(),
                                vertices.data(),
                                vertices.size(),
                                indices.data(),
                                indices.size()));
}
 
inline void RendererBase::RenderGeometryRaw(OptionalTexture texture,
                                            const float* xy,
                                            int xy_stride,
                                            const FColor* color,
                                            int color_stride,
                                            const float* uv,
                                            int uv_stride,
                                            int num_vertices,
                                            const void* indices,
                                            int num_indices,
                                            int size_indices)
{
  CheckError(SDL_RenderGeometryRaw(get(),
                                   texture.get(),
                                   xy,
                                   xy_stride,
                                   color,
                                   color_stride,
                                   uv,
                                   uv_stride,
                                   num_vertices,
                                   indices,
                                   num_indices,
                                   size_indices));
}
 
inline void* GetRenderMetalLayer(RendererBase& renderer)
{
  return CheckError(SDL_GetRenderMetalLayer(renderer.get()));
}
 
inline void* GetRenderMetalCommandEncoder(RendererBase& renderer)
{
  return CheckError(SDL_GetRenderMetalCommandEncoder(renderer.get()));
}
 
inline void AddVulkanRenderSemaphores(RendererBase& renderer,
                                      Uint32 wait_stage_mask,
                                      Sint64 wait_semaphore,
                                      Sint64 signal_semaphore)
{
  CheckError(SDL_AddVulkanRenderSemaphores(
    renderer.get(), wait_stage_mask, wait_semaphore, signal_semaphore));
}
 
#ifdef SDL3PP_DOC
 
#define SDL_RENDERER_VSYNC_DISABLED 0
 
#define SDL_RENDERER_VSYNC_ADAPTIVE (-1)
 
#define SDL_DEBUG_TEXT_FONT_CHARACTER_SIZE 8
 
#endif // SDL3PP_DOC
 
#pragma region impl
 
inline void RendererBase::ResetTarget() { return SetTarget(nullptr); }
 
inline TextureLock TextureBase::Lock(OptionalRef<const SDL_Rect> rect) &
{
  return TextureLock{get(), rect};
}
 
inline Texture LoadTextureBMP(RendererBase& renderer, IOStreamBase& src)
{
  Surface surface{LoadBMP(src)};
  return Texture(renderer, surface);
}
 
inline Texture LoadTextureBMP(RendererBase& renderer, StringParam file)
{
  Surface surface{SDL_LoadBMP(file)};
  return Texture(renderer, surface);
}
 
#pragma endregion impl
 
 
} // namespace SDL
 
#endif /* SDL3PP_RENDER_H_ */