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 RendererRef;
 
// Forward decl
struct Renderer;
 
using RendererShared = ResourceShared<Renderer>;
 
using RendererWeak = ResourceWeak<Renderer>;
 
// Forward decl
struct TextureRef;
 
// Forward decl
struct Texture;
 
using TextureShared = ResourceShared<Texture>;
 
using TextureWeak = ResourceWeak<Texture>;
 
// Forward decl
struct TextureLock;
 
#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 RendererRef : Resource<SDL_Renderer*>
{
  using Resource::Resource;
 
  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(TextureRef texture);
 
  TextureRef GetTarget() const;
 
  void SetLogicalPresentation(const 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(const 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(const 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(const SDL_FPoint& p1, const 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(TextureRef texture,
                     OptionalRef<const SDL_FRect> srcrect,
                     OptionalRef<const SDL_FRect> dstrect);
 
  void RenderTextureRotated(TextureRef 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(TextureRef texture,
                           OptionalRef<const SDL_FRect> srcrect,
                           OptionalRef<const SDL_FPoint> origin,
                           OptionalRef<const SDL_FPoint> right,
                           OptionalRef<const SDL_FPoint> down);
 
  void RenderTextureTiled(TextureRef texture,
                          OptionalRef<const SDL_FRect> srcrect,
                          float scale,
                          OptionalRef<const SDL_FRect> dstrect);
 
  void RenderTexture9Grid(TextureRef 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(TextureRef texture,
                      std::span<const Vertex> vertices,
                      std::span<const int> indices = {});
 
  void RenderGeometryRaw(TextureRef 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...)));
  }
 
  static void reset(SDL_Renderer* resource) { SDL_DestroyRenderer(resource); }
};
 
struct Renderer : ResourceUnique<RendererRef>
{
  using ResourceUnique::ResourceUnique;
 
  static Renderer Create(WindowRef window)
  {
    return Renderer(CheckError(SDL_CreateRenderer(window, nullptr)));
  }
 
  static Renderer Create(WindowRef window, StringParam name)
  {
    return Renderer(CheckError(SDL_CreateRenderer(window, name)));
  }
 
  static Renderer CreateWithProperties(PropertiesRef props)
  {
    return Renderer(CheckError(SDL_CreateRendererWithProperties(props)));
  }
 
  static Renderer CreateSoftware(SurfaceRef surface)
  {
    return Renderer(CheckError(SDL_CreateSoftwareRenderer(surface)));
  }
 
  void Destroy() { reset(); }
  RendererShared share();
 
};
 
 
inline RendererShared Renderer::share()
{
  return RendererShared(std::move(*this));
}
 
struct RendererUnsafe : ResourceUnsafe<RendererRef>
{
  using ResourceUnsafe::ResourceUnsafe;
 
  constexpr explicit RendererUnsafe(Renderer&& other)
    : RendererUnsafe(other.release())
  {
  }
};
 
struct TextureRef : Resource<SDL_Texture*>
{
  using Resource::Resource;
 
  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; }
 
  static void reset(SDL_Texture* resource) { SDL_DestroyTexture(resource); }
};
 
struct Texture : ResourceUnique<TextureRef>
{
  using ResourceUnique::ResourceUnique;
 
  static Texture Load(RendererRef renderer, StringParam file);
 
  static Texture Load(RendererRef renderer, IOStreamRef src);
 
  static Texture LoadBMP(RendererRef renderer, StringParam file)
  {
    Surface surface{SDL_LoadBMP(file)};
    return Texture::CreateFromSurface(renderer, surface);
  }
 
  static Texture LoadBMP(RendererRef renderer, IOStreamRef src)
  {
    auto surface{Surface::LoadBMP(src)};
    return Texture::CreateFromSurface(renderer, surface);
  }
 
  static Texture Create(RendererRef renderer,
                        PixelFormat format,
                        TextureAccess access,
                        const SDL_Point& size)
  {
    return Texture(
      CheckError(SDL_CreateTexture(renderer, format, access, size.x, size.y)));
  }
 
  static Texture CreateFromSurface(RendererRef renderer, SurfaceRef surface)
  {
    return Texture(CheckError(SDL_CreateTextureFromSurface(renderer, surface)));
  }
 
  static Texture CreateWithProperties(RendererRef renderer, PropertiesRef props)
  {
    return Texture(
      CheckError(SDL_CreateTextureWithProperties(renderer, props)));
  }
 
  void Destroy() { reset(); }
  TextureShared share();
 
};
 
 
inline TextureShared Texture::share()
{
  return TextureShared(std::move(*this));
}
 
struct TextureUnsafe : ResourceUnsafe<TextureRef>
{
  using ResourceUnsafe::ResourceUnsafe;
 
  constexpr explicit TextureUnsafe(Texture&& other)
    : TextureUnsafe(other.release())
  {
  }
};
 
class TextureLock : public LockBase<SurfaceRef>
{
public:
  constexpr TextureLock() = default;
 
  constexpr TextureLock(TextureLock&& other)
    : LockBase(other.release())
  {
  }
 
  TextureLock(TextureRef texture, OptionalRef<const SDL_Rect> rect)
    : LockBase<SurfaceRef>(doLock(texture, rect))
    , texture(std::move(texture))
  {
  }
 
  ~TextureLock() { Unlock(); }
 
  void Unlock()
  {
    if (texture) {
      release();
      SDL_UnlockTexture(texture);
      texture = nullptr;
    }
  }
 
  void reset() { Unlock(); }
 
private:
  TextureRef texture;
 
  SurfaceRef doLock(TextureRef texture, OptionalRef<const SDL_Rect> rect)
  {
    SDL_Surface* surface = nullptr;
    CheckError(SDL_LockTextureToSurface(texture, rect, &surface));
    return surface;
  }
};
 
inline int GetNumRenderDrivers() { return SDL_GetNumRenderDrivers(); }
 
inline const char* GetRenderDriver(int index)
{
  return SDL_GetRenderDriver(index);
}
 
inline std::pair<Window, Renderer> CreateWindowAndRenderer(
  StringParam title,
  const 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 WindowRef::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 TextureLock TextureRef::Lock(OptionalRef<const SDL_Rect> rect) &
{
  return TextureLock(get(), rect);
}
 
inline void RendererRef::SetTarget(TextureRef texture)
{
  CheckError(SDL_SetRenderTarget(get(), texture.get()));
}
 
inline TextureRef RendererRef::GetTarget() const
{
  return SDL_GetRenderTarget(get());
}
 
inline void RendererRef::RenderTexture(TextureRef texture,
                                       OptionalRef<const SDL_FRect> srcrect,
                                       OptionalRef<const SDL_FRect> dstrect)
{
  CheckError(SDL_RenderTexture(get(), texture.get(), srcrect, dstrect));
}
 
inline void RendererRef::RenderTextureRotated(
  TextureRef 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 RendererRef::RenderTextureAffine(
  TextureRef 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 RendererRef::RenderTextureTiled(
  TextureRef texture,
  OptionalRef<const SDL_FRect> srcrect,
  float scale,
  OptionalRef<const SDL_FRect> dstrect)
{
  CheckError(
    SDL_RenderTextureTiled(get(), texture.get(), srcrect, scale, dstrect));
}
 
inline void RendererRef::RenderTexture9Grid(
  TextureRef 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 RendererRef::RenderGeometry(TextureRef 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 RendererRef::RenderGeometryRaw(TextureRef 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(RendererRef renderer)
{
  return CheckError(SDL_GetRenderMetalLayer(renderer.get()));
}
 
inline void* GetRenderMetalCommandEncoder(RendererRef renderer)
{
  return CheckError(SDL_GetRenderMetalCommandEncoder(renderer.get()));
}
 
inline void AddVulkanRenderSemaphores(RendererRef 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 RendererRef::ResetTarget() { return SetTarget(nullptr); }
 
inline Texture LoadTextureBMP(RendererRef& renderer, IOStreamRef& src)
{
  auto surface{Surface::LoadBMP(src)};
  return Texture::CreateFromSurface(renderer, surface);
}
 
inline Texture LoadTextureBMP(RendererRef& renderer, StringParam file)
{
  Surface surface{SDL_LoadBMP(file)};
  return Texture::CreateFromSurface(renderer, surface);
}
 
#pragma endregion impl
 
 
} // namespace SDL
 
#endif /* SDL3PP_RENDER_H_ */