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_gpu.h"
#include "SDL3pp_pixels.h"
#include "SDL3pp_video.h"
 
namespace SDL {

 
// Forward decl
struct Renderer;

using RendererRaw = SDL_Renderer*;
 
// Forward decl
struct Texture;

using TextureRaw = SDL_Texture*;

using TextureRawConst = const SDL_Texture*;

using TextureRef = ResourceRef<Texture>;

using TextureConstRef = ResourceConstRef<TextureRaw, TextureRawConst>;
 
#if SDL_VERSION_ATLEAST(3, 3, 6)
 
// Forward decl
struct GPURenderState;

using GPURenderStateRaw = SDL_GPURenderState*;

using GPURenderStateRef = ResourceRef<GPURenderState>;
 
#endif // SDL_VERSION_ATLEAST(3, 3, 6)
 
// Forward decl
struct TextureSurfaceLock;
 
// Forward decl
struct TextureLock;

constexpr auto SOFTWARE_RENDERER = SDL_SOFTWARE_RENDERER;
 
#if SDL_VERSION_ATLEAST(3, 4, 0)

constexpr auto GPU_RENDERER = SDL_GPU_RENDERER;
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)

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; 
 
#if SDL_VERSION_ATLEAST(3, 4, 0)

using TextureAddressMode = SDL_TextureAddressMode;
 
constexpr TextureAddressMode TEXTURE_ADDRESS_INVALID =
  SDL_TEXTURE_ADDRESS_INVALID; 

constexpr TextureAddressMode TEXTURE_ADDRESS_AUTO = SDL_TEXTURE_ADDRESS_AUTO;

constexpr TextureAddressMode TEXTURE_ADDRESS_CLAMP = SDL_TEXTURE_ADDRESS_CLAMP;
 
constexpr TextureAddressMode TEXTURE_ADDRESS_WRAP =
  SDL_TEXTURE_ADDRESS_WRAP; 
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)

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;
 
#if SDL_VERSION_ATLEAST(3, 4, 0)

using GPURenderStateCreateInfo = SDL_GPURenderStateCreateInfo;
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)

struct Renderer : ResourceBase<RendererRaw>
{
  using ResourceBase::ResourceBase;

  constexpr explicit Renderer(RendererRaw resource) noexcept
    : ResourceBase(resource)
  {
  }

  constexpr Renderer(const Renderer& other) = delete;

  constexpr Renderer(Renderer&& other) noexcept
    : Renderer(other.release())
  {
  }
 
  constexpr Renderer(const RendererRef& other) = delete;
 
  constexpr Renderer(RendererRef&& other) = delete;

  Renderer(WindowRef window, StringParam name = nullptr);

  Renderer(PropertiesRef props);

  Renderer(SurfaceRef surface);

  ~Renderer() { SDL_DestroyRenderer(get()); }

  constexpr Renderer& operator=(Renderer&& other) noexcept
  {
    swap(*this, other);
    return *this;
  }

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

  void Destroy();
 
#if SDL_VERSION_ATLEAST(3, 4, 0)

  GPUDeviceRef GetGPUDevice();
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)

  WindowRef GetWindow();

  const char* GetName() const;

  PropertiesRef GetProperties() const;

  void GetOutputSize(int* w, int* h) const;

  Point GetOutputSize() const;

  void GetCurrentOutputSize(int* w, int* h) const;

  Point GetCurrentOutputSize() const;

  Texture CreateTexture(PixelFormat format,
                        TextureAccess access,
                        const PointRaw& size);

  Texture CreateTextureFromSurface(SurfaceRef surface);

  Texture CreateTextureWithProperties(PropertiesRef props);

  void SetTarget(TextureRef texture);

  void ResetTarget();

  Texture GetTarget() const;

  void SetLogicalPresentation(const PointRaw& size,
                              RendererLogicalPresentation mode);

  void GetLogicalPresentation(int* w,
                              int* h,
                              RendererLogicalPresentation* mode) const;

  void GetLogicalPresentation(PointRaw* size,
                              RendererLogicalPresentation* mode);

  FRect GetLogicalPresentationRect() const;

  FPoint RenderCoordinatesFromWindow(const FPointRaw& window_coord) const;

  FPoint RenderCoordinatesToWindow(const FPointRaw& coord) const;

  void ConvertEventToRenderCoordinates(Event* event) const;

  void SetViewport(OptionalRef<const RectRaw> rect);

  void ResetViewport();

  Rect GetViewport() const;

  bool ViewportSet() const;

  Rect GetSafeArea() const;

  void SetClipRect(OptionalRef<const RectRaw> rect);

  void ResetClipRect();

  Rect GetClipRect() const;

  bool IsClipEnabled() const;

  void SetScale(const FPointRaw& scale);

  void GetScale(float* scaleX, float* scaleY) const;

  FPoint GetScale() const;

  void SetDrawColor(ColorRaw c);

  void SetDrawColorFloat(const FColorRaw& c);

  void GetDrawColor(Uint8* r, Uint8* g, Uint8* b, Uint8* a) const;

  Color GetDrawColor() const;

  void GetDrawColorFloat(float* r, float* g, float* b, float* a) const;

  FColor GetDrawColorFloat() const;

  void SetColorScale(float scale);

  float GetColorScale() const;

  void SetDrawBlendMode(BlendMode blendMode);

  BlendMode GetDrawBlendMode() const;

  void RenderClear();

  void RenderPoint(const FPointRaw& p);

  void RenderPoints(SpanRef<const FPointRaw> points);

  void RenderLine(const FPointRaw& p1, const FPointRaw& p2);

  void RenderLines(SpanRef<const FPointRaw> points);

  void RenderRect(OptionalRef<const FRectRaw> rect);

  void RenderRects(SpanRef<const FRectRaw> rects);

  void RenderFillRect(OptionalRef<const FRectRaw> rect);

  void RenderFillRects(SpanRef<const FRectRaw> rects);

  void RenderTexture(TextureRef texture,
                     OptionalRef<const FRectRaw> srcrect,
                     OptionalRef<const FRectRaw> dstrect);

  void RenderTextureRotated(TextureRef texture,
                            OptionalRef<const FRectRaw> srcrect,
                            OptionalRef<const FRectRaw> dstrect,
                            double angle,
                            OptionalRef<const FPointRaw> center,
                            FlipMode flip = FlipMode::SDL_FLIP_NONE);

  void RenderTextureAffine(TextureRef texture,
                           OptionalRef<const FRectRaw> srcrect,
                           OptionalRef<const FPointRaw> origin,
                           OptionalRef<const FPointRaw> right,
                           OptionalRef<const FPointRaw> down);

  void RenderTextureTiled(TextureRef texture,
                          OptionalRef<const FRectRaw> srcrect,
                          float scale,
                          OptionalRef<const FRectRaw> dstrect);

  void RenderTexture9Grid(TextureRef texture,
                          OptionalRef<const FRectRaw> srcrect,
                          float left_width,
                          float right_width,
                          float top_height,
                          float bottom_height,
                          float scale,
                          OptionalRef<const FRectRaw> dstrect);
 
#if SDL_VERSION_ATLEAST(3, 4, 0)

  void RenderTexture9GridTiled(TextureRef texture,
                               const FRectRaw& srcrect,
                               float left_width,
                               float right_width,
                               float top_height,
                               float bottom_height,
                               float scale,
                               const FRectRaw& dstrect,
                               float tileScale);
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)

  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);
 
#if SDL_VERSION_ATLEAST(3, 4, 0)

  void SetRenderTextureAddressMode(TextureAddressMode u_mode,
                                   TextureAddressMode v_mode);

  void GetRenderTextureAddressMode(TextureAddressMode* u_mode,
                                   TextureAddressMode* v_mode);
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)

  Surface ReadPixels(OptionalRef<const RectRaw> rect = {}) const;

  void Present();

  void Flush();

  void* GetRenderMetalLayer();

  void* GetRenderMetalCommandEncoder();

  void AddVulkanRenderSemaphores(Uint32 wait_stage_mask,
                                 Sint64 wait_semaphore,
                                 Sint64 signal_semaphore);

  void SetVSync(int vsync);

  int GetVSync() const;

  void RenderDebugText(const FPointRaw& p, StringParam str);

  template<class... ARGS>
  void RenderDebugTextFormat(const FPointRaw& p,
                             std::string_view fmt,
                             ARGS... args);
 
#if SDL_VERSION_ATLEAST(3, 4, 0)

  void SetDefaultTextureScaleMode(ScaleMode scale_mode);

  void GetDefaultTextureScaleMode(ScaleMode* scale_mode);

  GPURenderState CreateGPURenderState(
    const GPURenderStateCreateInfo& createinfo);

  void SetGPURenderState(GPURenderStateRef state);
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
};

struct Texture : ResourceBase<TextureRaw, TextureRawConst>
{
  using ResourceBase::ResourceBase;

  constexpr explicit Texture(TextureRaw resource) noexcept
    : ResourceBase(resource)
  {
  }

  constexpr Texture(const Texture& other)
    : Texture(other.get())
  {
    if (auto res = get()) ++res->refcount;
  }

  constexpr Texture(Texture&& other) noexcept
    : Texture(other.release())
  {
  }

  Texture(RendererRef renderer,
          PixelFormat format,
          TextureAccess access,
          const PointRaw& size);

  Texture(RendererRef renderer, SurfaceRef surface);

  Texture(RendererRef renderer, PropertiesRef props);

  Texture(RendererRef renderer, StringParam file);

  Texture(RendererRef renderer, IOStreamRef src, bool closeio = false);

  static Texture Borrow(TextureRaw resource)
  {
    if (resource) {
      ++resource->refcount;
      return Texture(resource);
    }
    return {};
  }

  constexpr operator TextureConstRef() const noexcept { return get(); }

  ~Texture() { SDL_DestroyTexture(get()); }

  constexpr Texture& operator=(Texture&& other) noexcept
  {
    swap(*this, other);
    return *this;
  }

  Texture& operator=(const Texture& other)
  {
    if (get() != other.get()) {
      Texture tmp(other);
      swap(*this, tmp);
    }
    return *this;
  }

  void Destroy();

  PropertiesRef GetProperties() const;

  RendererRef GetRenderer() const;

  void GetSize(float* w, float* h) const;

  Point GetSize() const;

  FPoint GetSizeFloat() const;

  int GetWidth() const;

  int GetHeight() const;

  PixelFormat GetFormat() const;
 
#if SDL_VERSION_ATLEAST(3, 4, 0)

  void SetPalette(PaletteRef palette);

  Palette GetPalette();
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)

  void SetColorMod(Uint8 r, Uint8 g, Uint8 b);

  void SetColorModFloat(float r, float g, float b);

  void GetColorMod(Uint8* r, Uint8* g, Uint8* b) const;

  void GetColorModFloat(float* r, float* g, float* b) const;

  void SetAlphaMod(Uint8 alpha);

  void SetAlphaModFloat(float alpha);

  Uint8 GetAlphaMod() const;

  float GetAlphaModFloat() const;

  void SetMod(Color c);

  void SetModFloat(FColor c);

  Color GetMod() const;

  FColor GetModFloat() const;

  void SetBlendMode(BlendMode blendMode);

  BlendMode GetBlendMode() const;

  void SetScaleMode(ScaleMode scaleMode);

  ScaleMode GetScaleMode() const;

  void Update(OptionalRef<const RectRaw> rect, const void* pixels, int pitch);

  void Update(SurfaceConstRef surface,
              OptionalRef<const RectRaw> rect = std::nullopt);

  void UpdateYUV(OptionalRef<const RectRaw> rect,
                 const Uint8* Yplane,
                 int Ypitch,
                 const Uint8* Uplane,
                 int Upitch,
                 const Uint8* Vplane,
                 int Vpitch);

  void UpdateNV(OptionalRef<const RectRaw> rect,
                const Uint8* Yplane,
                int Ypitch,
                const Uint8* UVplane,
                int UVpitch);

  TextureLock Lock(OptionalRef<const RectRaw> rect, void** pixels, int* pitch);

  TextureSurfaceLock LockToSurface(
    OptionalRef<const RectRaw> rect = std::nullopt);

  void Unlock(TextureLock&& lock);

  void Unlock(TextureSurfaceLock&& lock);
};

class TextureLock
{
  TextureRef m_lock;
 
public:
  TextureLock(TextureRef resource,
              OptionalRef<const RectRaw> rect,
              void** pixels,
              int* pitch);

  TextureLock(const TextureLock& other) = delete;

  TextureLock(TextureLock&& other) noexcept
    : m_lock(std::move(other.m_lock))
  {
  }

  ~TextureLock() { reset(); }
 
  TextureLock& operator=(const TextureLock& other) = delete;

  TextureLock& operator=(TextureLock&& other) noexcept
  {
    std::swap(m_lock, other.m_lock);
    return *this;
  }

  constexpr operator bool() const { return bool(m_lock); }

  void reset();

  TextureRef resource() const { return m_lock; }

  void release() { m_lock.release(); }
};

class TextureSurfaceLock : public Surface
{
  TextureRef m_lock;
 
public:
  TextureSurfaceLock(TextureRef resource,
                     OptionalRef<const RectRaw> rect = std::nullopt);

  TextureSurfaceLock(const TextureSurfaceLock& other) = delete;

  TextureSurfaceLock(TextureSurfaceLock&& other) noexcept
    : Surface(std::move(other))
    , m_lock(std::move(other.m_lock))
  {
  }

  ~TextureSurfaceLock() { reset(); }
 
  TextureSurfaceLock& operator=(const TextureSurfaceLock& other) = delete;

  TextureSurfaceLock& operator=(TextureSurfaceLock&& other) noexcept
  {
    std::swap(m_lock, other.m_lock);
    Surface::operator=(std::move(other));
    return *this;
  }

  void reset();

  TextureRef resource() const { return m_lock; }
};

inline int GetNumRenderDrivers() { return SDL_GetNumRenderDrivers(); }

inline const char* GetRenderDriver(int index)
{
  return SDL_GetRenderDriver(index);
}

inline void CreateWindowAndRendererRaw(StringParam title,
                                       const PointRaw& size,
                                       WindowFlags window_flags,
                                       WindowRaw* window,
                                       RendererRaw* renderer)
{
  CheckError(SDL_CreateWindowAndRenderer(
    title, size.x, size.y, window_flags, window, renderer));
}

inline void CreateWindowAndRenderer(StringParam title,
                                    const PointRaw& size,
                                    WindowFlags window_flags,
                                    Window* window,
                                    Renderer* renderer)
{
  SDL_Window* windowRaw = nullptr;
  SDL_Renderer* rendererRaw = nullptr;
  CreateWindowAndRendererRaw(
    std::move(title), size, window_flags, &windowRaw, &rendererRaw);
  if (window) *window = Window{windowRaw};
  if (renderer) *renderer = Renderer{rendererRaw};
}

inline std::pair<Window, Renderer> CreateWindowAndRenderer(
  StringParam title,
  const PointRaw& size,
  WindowFlags window_flags = 0)
{
  SDL_Window* window = nullptr;
  SDL_Renderer* renderer = nullptr;
  CreateWindowAndRendererRaw(
    std::move(title), size, window_flags, &window, &renderer);
  return {Window{window}, Renderer(renderer)};
}

inline Window CreateWindowAndRenderer(StringParam title,
                                      const PointRaw& size,
                                      WindowFlags window_flags,
                                      Renderer* renderer)
{
  Window window;
  CreateWindowAndRenderer(
    std::move(title), size, window_flags, &window, renderer);
  return window;
}
 
inline Window::Window(StringParam title,
                      const PointRaw& size,
                      WindowFlags window_flags,
                      RendererRef* renderer)
  : Window(
      CreateWindowAndRenderer(std::move(title), size, window_flags, renderer))
{
}

inline Renderer CreateRenderer(WindowRef window, StringParam name = nullptr)
{
  return Renderer(window, std::move(name));
}
 
inline Renderer::Renderer(WindowRef window, StringParam name)
  : Renderer(SDL_CreateRenderer(window, name))
{
}
 
inline Renderer::Renderer(PropertiesRef props)
  : Renderer(SDL_CreateRendererWithProperties(props))
{
}
 
inline Renderer::Renderer(SurfaceRef surface)
  : Renderer(SDL_CreateSoftwareRenderer(surface))
{
}

inline Renderer CreateRendererWithProperties(PropertiesRef props)
{
  return Renderer(props);
}

namespace prop::Renderer::Create {
 
constexpr auto NAME_STRING =
  SDL_PROP_RENDERER_CREATE_NAME_STRING; 
 
constexpr auto WINDOW_POINTER =
  SDL_PROP_RENDERER_CREATE_WINDOW_POINTER; 
 
constexpr auto SURFACE_POINTER =
  SDL_PROP_RENDERER_CREATE_SURFACE_POINTER; 
 
constexpr auto OUTPUT_COLORSPACE_NUMBER =
  SDL_PROP_RENDERER_CREATE_OUTPUT_COLORSPACE_NUMBER; 
 
constexpr auto PRESENT_VSYNC_NUMBER =
  SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_NUMBER; 
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto GPU_DEVICE_POINTER =
  SDL_PROP_RENDERER_CREATE_GPU_DEVICE_POINTER; 
 
constexpr auto GPU_SHADERS_SPIRV_BOOLEAN =
  SDL_PROP_RENDERER_CREATE_GPU_SHADERS_SPIRV_BOOLEAN; 
 
constexpr auto GPU_SHADERS_DXIL_BOOLEAN =
  SDL_PROP_RENDERER_CREATE_GPU_SHADERS_DXIL_BOOLEAN; 
 
constexpr auto GPU_SHADERS_MSL_BOOLEAN =
  SDL_PROP_RENDERER_CREATE_GPU_SHADERS_MSL_BOOLEAN; 
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto VULKAN_INSTANCE_POINTER =
  SDL_PROP_RENDERER_CREATE_VULKAN_INSTANCE_POINTER; 
 
constexpr auto VULKAN_SURFACE_NUMBER =
  SDL_PROP_RENDERER_CREATE_VULKAN_SURFACE_NUMBER; 
 
constexpr auto VULKAN_PHYSICAL_DEVICE_POINTER =
  SDL_PROP_RENDERER_CREATE_VULKAN_PHYSICAL_DEVICE_POINTER; 
 
constexpr auto VULKAN_DEVICE_POINTER =
  SDL_PROP_RENDERER_CREATE_VULKAN_DEVICE_POINTER; 
 
constexpr auto VULKAN_GRAPHICS_QUEUE_FAMILY_INDEX_NUMBER =
  SDL_PROP_RENDERER_CREATE_VULKAN_GRAPHICS_QUEUE_FAMILY_INDEX_NUMBER; 
 
constexpr auto VULKAN_PRESENT_QUEUE_FAMILY_INDEX_NUMBER =
  SDL_PROP_RENDERER_CREATE_VULKAN_PRESENT_QUEUE_FAMILY_INDEX_NUMBER; 
 
} // namespace prop::Renderer::Create
 
#if SDL_VERSION_ATLEAST(3, 4, 0)

inline RendererRef CreateGPURenderer(GPUDeviceRef device, WindowRef window)
{
  return SDL_CreateGPURenderer(device, window);
}

inline GPUDeviceRef GetGPURendererDevice(RendererRef renderer)
{
  return SDL_GetGPURendererDevice(renderer);
}
 
inline GPUDeviceRef Renderer::GetGPUDevice()
{
  return SDL::GetGPURendererDevice(get());
}
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)

inline Renderer CreateSoftwareRenderer(SurfaceRef surface)
{
  return Renderer(surface);
}
 
inline RendererRef Window::GetRenderer() const
{
  return CheckError(SDL_GetRenderer(get()));
}

inline WindowRef GetRenderWindow(RendererRef renderer)
{
  return CheckError(SDL_GetRenderWindow(renderer));
}
 
inline WindowRef Renderer::GetWindow() { return SDL::GetRenderWindow(get()); }

inline const char* GetRendererName(RendererRef renderer)
{
  return CheckError(SDL_GetRendererName(renderer));
}
 
inline const char* Renderer::GetName() const
{
  return SDL::GetRendererName(get());
}

inline PropertiesRef GetRendererProperties(RendererRef renderer)
{
  return CheckError(SDL_GetRendererProperties(renderer));
}
 
inline PropertiesRef Renderer::GetProperties() const
{
  return SDL::GetRendererProperties(get());
}

namespace prop::Renderer {
 
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; 
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto TEXTURE_WRAPPING_BOOLEAN =
  SDL_PROP_RENDERER_TEXTURE_WRAPPING_BOOLEAN; 
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
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 void GetRenderOutputSize(RendererRef renderer, int* w, int* h)
{
  CheckError(SDL_GetRenderOutputSize(renderer, w, h));
}

inline Point GetRenderOutputSize(RendererRef renderer)
{
  Point p;
  GetRenderOutputSize(renderer, &p.x, &p.y);
  return p;
}
 
inline void Renderer::GetOutputSize(int* w, int* h) const
{
  SDL::GetRenderOutputSize(get(), w, h);
}
 
inline Point Renderer::GetOutputSize() const
{
  return SDL::GetRenderOutputSize(get());
}

inline void GetCurrentRenderOutputSize(RendererRef renderer, int* w, int* h)
{
  CheckError(SDL_GetCurrentRenderOutputSize(renderer, w, h));
}

inline Point GetCurrentRenderOutputSize(RendererRef renderer)
{
  Point p;
  GetCurrentRenderOutputSize(renderer, &p.x, &p.y);
  return p;
}
 
inline void Renderer::GetCurrentOutputSize(int* w, int* h) const
{
  SDL::GetCurrentRenderOutputSize(get(), w, h);
}
 
inline Point Renderer::GetCurrentOutputSize() const
{
  return SDL::GetCurrentRenderOutputSize(get());
}

inline Texture CreateTexture(RendererRef renderer,
                             PixelFormat format,
                             TextureAccess access,
                             const PointRaw& size)
{
  return Texture(renderer, format, access, size);
}
 
inline Texture Renderer::CreateTexture(PixelFormat format,
                                       TextureAccess access,
                                       const PointRaw& size)
{
  return Texture(get(), format, access, size);
}
 
inline Texture::Texture(RendererRef renderer,
                        PixelFormat format,
                        TextureAccess access,
                        const PointRaw& size)
  : Texture(SDL_CreateTexture(renderer, format, access, size.x, size.y))
{
}
 
inline Texture::Texture(RendererRef renderer, SurfaceRef surface)
  : Texture(SDL_CreateTextureFromSurface(renderer, surface))
{
}
 
inline Texture::Texture(RendererRef renderer, PropertiesRef props)
  : Texture(SDL_CreateTextureWithProperties(renderer, props))
{
}

inline Texture CreateTextureFromSurface(RendererRef renderer,
                                        SurfaceRef surface)
{
  return Texture(renderer, surface);
}
 
inline Texture Renderer::CreateTextureFromSurface(SurfaceRef surface)
{
  return Texture(get(), surface);
}

inline Texture CreateTextureWithProperties(RendererRef renderer,
                                           PropertiesRef props)
{
  return Texture(renderer, props);
}
 
inline Texture Renderer::CreateTextureWithProperties(PropertiesRef props)
{
  return Texture(get(), props);
}

namespace prop::Texture::Create {
 
constexpr auto COLORSPACE_NUMBER =
  SDL_PROP_TEXTURE_CREATE_COLORSPACE_NUMBER; 
 
constexpr auto FORMAT_NUMBER =
  SDL_PROP_TEXTURE_CREATE_FORMAT_NUMBER; 
 
constexpr auto ACCESS_NUMBER =
  SDL_PROP_TEXTURE_CREATE_ACCESS_NUMBER; 
 
constexpr auto WIDTH_NUMBER =
  SDL_PROP_TEXTURE_CREATE_WIDTH_NUMBER; 
 
constexpr auto HEIGHT_NUMBER =
  SDL_PROP_TEXTURE_CREATE_HEIGHT_NUMBER; 
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto PALETTE_POINTER =
  SDL_PROP_TEXTURE_CREATE_PALETTE_POINTER; 
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto SDR_WHITE_POINT_FLOAT =
  SDL_PROP_TEXTURE_CREATE_SDR_WHITE_POINT_FLOAT; 
 
constexpr auto HDR_HEADROOM_FLOAT =
  SDL_PROP_TEXTURE_CREATE_HDR_HEADROOM_FLOAT; 
 
constexpr auto D3D11_TEXTURE_POINTER =
  SDL_PROP_TEXTURE_CREATE_D3D11_TEXTURE_POINTER; 
 
constexpr auto D3D11_TEXTURE_U_POINTER =
  SDL_PROP_TEXTURE_CREATE_D3D11_TEXTURE_U_POINTER; 
 
constexpr auto D3D11_TEXTURE_V_POINTER =
  SDL_PROP_TEXTURE_CREATE_D3D11_TEXTURE_V_POINTER; 
 
constexpr auto D3D12_TEXTURE_POINTER =
  SDL_PROP_TEXTURE_CREATE_D3D12_TEXTURE_POINTER; 
 
constexpr auto D3D12_TEXTURE_U_POINTER =
  SDL_PROP_TEXTURE_CREATE_D3D12_TEXTURE_U_POINTER; 
 
constexpr auto D3D12_TEXTURE_V_POINTER =
  SDL_PROP_TEXTURE_CREATE_D3D12_TEXTURE_V_POINTER; 
 
constexpr auto METAL_PIXELBUFFER_POINTER =
  SDL_PROP_TEXTURE_CREATE_METAL_PIXELBUFFER_POINTER; 
 
constexpr auto OPENGL_TEXTURE_NUMBER =
  SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_NUMBER; 
 
constexpr auto OPENGL_TEXTURE_UV_NUMBER =
  SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_UV_NUMBER; 
 
constexpr auto OPENGL_TEXTURE_U_NUMBER =
  SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_U_NUMBER; 
 
constexpr auto OPENGL_TEXTURE_V_NUMBER =
  SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_V_NUMBER; 
 
constexpr auto OPENGLES2_TEXTURE_NUMBER =
  SDL_PROP_TEXTURE_CREATE_OPENGLES2_TEXTURE_NUMBER; 
 
constexpr auto OPENGLES2_TEXTURE_UV_NUMBER =
  SDL_PROP_TEXTURE_CREATE_OPENGLES2_TEXTURE_UV_NUMBER; 
 
constexpr auto OPENGLES2_TEXTURE_U_NUMBER =
  SDL_PROP_TEXTURE_CREATE_OPENGLES2_TEXTURE_U_NUMBER; 
 
constexpr auto OPENGLES2_TEXTURE_V_NUMBER =
  SDL_PROP_TEXTURE_CREATE_OPENGLES2_TEXTURE_V_NUMBER; 
 
constexpr auto VULKAN_TEXTURE_NUMBER =
  SDL_PROP_TEXTURE_CREATE_VULKAN_TEXTURE_NUMBER; 
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto VULKAN_LAYOUT_NUMBER =
  SDL_PROP_TEXTURE_CREATE_VULKAN_LAYOUT_NUMBER; 
 
constexpr auto GPU_TEXTURE_POINTER =
  SDL_PROP_TEXTURE_CREATE_GPU_TEXTURE_POINTER; 
 
constexpr auto GPU_TEXTURE_UV_POINTER =
  SDL_PROP_TEXTURE_CREATE_GPU_TEXTURE_UV_POINTER; 
 
constexpr auto GPU_TEXTURE_U_POINTER =
  SDL_PROP_TEXTURE_CREATE_GPU_TEXTURE_U_POINTER; 
 
constexpr auto GPU_TEXTURE_V_POINTER =
  SDL_PROP_TEXTURE_CREATE_GPU_TEXTURE_V_POINTER; 
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
} // namespace prop::Texture::Create

inline PropertiesRef GetTextureProperties(TextureConstRef texture)
{
  return CheckError(SDL_GetTextureProperties(texture));
}
 
inline PropertiesRef Texture::GetProperties() const
{
  return SDL::GetTextureProperties(get());
}

namespace prop::Texture {
 
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; 
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto GPU_TEXTURE_POINTER =
  SDL_PROP_TEXTURE_GPU_TEXTURE_POINTER; 
 
constexpr auto GPU_TEXTURE_UV_POINTER =
  SDL_PROP_TEXTURE_GPU_TEXTURE_UV_POINTER; 
 
constexpr auto GPU_TEXTURE_U_POINTER =
  SDL_PROP_TEXTURE_GPU_TEXTURE_U_POINTER; 
 
constexpr auto GPU_TEXTURE_V_POINTER =
  SDL_PROP_TEXTURE_GPU_TEXTURE_V_POINTER; 
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
} // namespace prop::Texture

inline RendererRef GetRendererFromTexture(TextureConstRef texture)
{
  return CheckError(SDL_GetRendererFromTexture(texture));
}
 
inline RendererRef Texture::GetRenderer() const
{
  return SDL::GetRendererFromTexture(get());
}

inline void GetTextureSize(TextureConstRef texture, float* w, float* h)
{
  CheckError(SDL_GetTextureSize(texture, w, h));
}

inline Point GetTextureSize(TextureConstRef texture)
{
  return Point(texture->w, texture->h);
}
 
inline void Texture::GetSize(float* w, float* h) const
{
  SDL::GetTextureSize(get(), w, h);
}
 
inline Point Texture::GetSize() const { return SDL::GetTextureSize(get()); }

inline FPoint GetTextureSizeFloat(TextureConstRef texture)
{
  FPoint p;
  GetTextureSize(texture, &p.x, &p.y);
  return p;
}
 
inline FPoint Texture::GetSizeFloat() const
{
  return SDL::GetTextureSizeFloat(get());
}

inline int GetTextureWidth(TextureConstRef texture) { return texture->w; }
 
inline int Texture::GetWidth() const { return SDL::GetTextureWidth(get()); }

inline int GetTextureHeight(TextureConstRef texture) { return texture->h; }
 
inline int Texture::GetHeight() const { return SDL::GetTextureHeight(get()); }

inline PixelFormat GetTextureFormat(TextureConstRef texture)
{
  return texture->format;
}
 
inline PixelFormat Texture::GetFormat() const
{
  return SDL::GetTextureFormat(get());
}
 
#if SDL_VERSION_ATLEAST(3, 4, 0)

inline void SetTexturePalette(TextureRef texture, PaletteRef palette)
{
  CheckError(SDL_SetTexturePalette(texture, palette));
}
 
inline void Texture::SetPalette(PaletteRef palette)
{
  SDL::SetTexturePalette(get(), palette);
}

inline Palette GetTexturePalette(TextureRef texture)
{
  return Palette::Borrow(SDL_GetTexturePalette(texture));
}
 
inline Palette Texture::GetPalette() { return SDL::GetTexturePalette(get()); }
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)

inline void SetTextureColorMod(TextureRef texture, Uint8 r, Uint8 g, Uint8 b)
{
  CheckError(SDL_SetTextureColorMod(texture, r, g, b));
}
 
inline void Texture::SetColorMod(Uint8 r, Uint8 g, Uint8 b)
{
  SDL::SetTextureColorMod(get(), r, g, b);
}

inline void SetTextureColorModFloat(TextureRef texture,
                                    float r,
                                    float g,
                                    float b)
{
  CheckError(SDL_SetTextureColorModFloat(texture, r, g, b));
}
 
inline void Texture::SetColorModFloat(float r, float g, float b)
{
  SDL::SetTextureColorModFloat(get(), r, g, b);
}

inline void GetTextureColorMod(TextureConstRef texture,
                               Uint8* r,
                               Uint8* g,
                               Uint8* b)
{
  CheckError(SDL_GetTextureColorMod(texture, r, g, b));
}
 
inline void Texture::GetColorMod(Uint8* r, Uint8* g, Uint8* b) const
{
  SDL::GetTextureColorMod(get(), r, g, b);
}

inline void GetTextureColorModFloat(TextureConstRef texture,
                                    float* r,
                                    float* g,
                                    float* b)
{
  CheckError(SDL_GetTextureColorModFloat(texture, r, g, b));
}
 
inline void Texture::GetColorModFloat(float* r, float* g, float* b) const
{
  SDL::GetTextureColorModFloat(get(), r, g, b);
}

inline void SetTextureAlphaMod(TextureRef texture, Uint8 alpha)
{
  CheckError(SDL_SetTextureAlphaMod(texture, alpha));
}
 
inline void Texture::SetAlphaMod(Uint8 alpha)
{
  SDL::SetTextureAlphaMod(get(), alpha);
}

inline void SetTextureAlphaModFloat(TextureRef texture, float alpha)
{
  CheckError(SDL_SetTextureAlphaModFloat(texture, alpha));
}
 
inline void Texture::SetAlphaModFloat(float alpha)
{
  SDL::SetTextureAlphaModFloat(get(), alpha);
}

inline Uint8 GetTextureAlphaMod(TextureConstRef texture)
{
  Uint8 alpha;
  CheckError(SDL_GetTextureAlphaMod(texture, &alpha));
  return alpha;
}
 
inline Uint8 Texture::GetAlphaMod() const
{
  return SDL::GetTextureAlphaMod(get());
}

inline float GetTextureAlphaModFloat(TextureConstRef texture)
{
  float alpha;
  CheckError(SDL_GetTextureAlphaModFloat(texture, &alpha));
  return alpha;
}
 
inline float Texture::GetAlphaModFloat() const
{
  return SDL::GetTextureAlphaModFloat(get());
}

inline void SetTextureMod(TextureRef texture, Color c)
{
  SetTextureColorMod(texture, c.r, c.g, c.b);
  SetTextureAlphaMod(texture, c.a);
}
 
inline void Texture::SetMod(Color c) { SDL::SetTextureMod(get(), c); }

inline void SetTextureModFloat(TextureRef texture, FColor c)
{
  SetTextureColorModFloat(texture, c.r, c.g, c.b);
  SetTextureAlphaModFloat(texture, c.a);
}
 
inline void Texture::SetModFloat(FColor c)
{
  SDL::SetTextureModFloat(get(), c);
}

inline Color GetTextureMod(TextureConstRef texture)
{
  Color c;
  GetTextureColorMod(texture, &c.r, &c.g, &c.b);
  c.a = GetTextureAlphaMod(texture);
  return c;
}
 
inline Color Texture::GetMod() const { return SDL::GetTextureMod(get()); }

inline FColor GetTextureModFloat(TextureConstRef texture)
{
  FColor c;
  GetTextureColorModFloat(texture, &c.r, &c.g, &c.b);
  c.a = GetTextureAlphaModFloat(texture);
  return c;
}
 
inline FColor Texture::GetModFloat() const
{
  return SDL::GetTextureModFloat(get());
}

inline void SetTextureBlendMode(TextureRef texture, BlendMode blendMode)
{
  CheckError(SDL_SetTextureBlendMode(texture, blendMode));
}
 
inline void Texture::SetBlendMode(BlendMode blendMode)
{
  SDL::SetTextureBlendMode(get(), blendMode);
}

inline BlendMode GetTextureBlendMode(TextureConstRef texture)
{
  BlendMode blendMode;
  CheckError(SDL_GetTextureBlendMode(texture, &blendMode));
  return blendMode;
}
 
inline BlendMode Texture::GetBlendMode() const
{
  return SDL::GetTextureBlendMode(get());
}

inline void SetTextureScaleMode(TextureRef texture, ScaleMode scaleMode)
{
  CheckError(SDL_SetTextureScaleMode(texture, scaleMode));
}
 
inline void Texture::SetScaleMode(ScaleMode scaleMode)
{
  SDL::SetTextureScaleMode(get(), scaleMode);
}

inline ScaleMode GetTextureScaleMode(TextureConstRef texture)
{
  ScaleMode scaleMode;
  CheckError(SDL_GetTextureScaleMode(texture, &scaleMode));
  return scaleMode;
}
 
inline ScaleMode Texture::GetScaleMode() const
{
  return SDL::GetTextureScaleMode(get());
}

inline void UpdateTexture(TextureRef texture,
                          OptionalRef<const RectRaw> rect,
                          const void* pixels,
                          int pitch)
{
  CheckError(SDL_UpdateTexture(texture, rect, pixels, pitch));
}

inline void UpdateTexture(TextureRef texture,
                          SurfaceConstRef surface,
                          OptionalRef<const RectRaw> rect = std::nullopt)
{
  UpdateTexture(texture, rect, surface->pixels, surface->pitch);
}
 
inline void Texture::Update(OptionalRef<const RectRaw> rect,
                            const void* pixels,
                            int pitch)
{
  SDL::UpdateTexture(get(), rect, pixels, pitch);
}
 
inline void Texture::Update(SurfaceConstRef surface,
                            OptionalRef<const RectRaw> rect)
{
  SDL::UpdateTexture(get(), surface, rect);
}

inline void UpdateYUVTexture(TextureRef texture,
                             OptionalRef<const RectRaw> rect,
                             const Uint8* Yplane,
                             int Ypitch,
                             const Uint8* Uplane,
                             int Upitch,
                             const Uint8* Vplane,
                             int Vpitch)
{
  CheckError(SDL_UpdateYUVTexture(
    texture, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch));
}
 
inline void Texture::UpdateYUV(OptionalRef<const RectRaw> rect,
                               const Uint8* Yplane,
                               int Ypitch,
                               const Uint8* Uplane,
                               int Upitch,
                               const Uint8* Vplane,
                               int Vpitch)
{
  SDL::UpdateYUVTexture(
    get(), rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch);
}

inline void UpdateNVTexture(TextureRef texture,
                            OptionalRef<const RectRaw> rect,
                            const Uint8* Yplane,
                            int Ypitch,
                            const Uint8* UVplane,
                            int UVpitch)
{
  CheckError(
    SDL_UpdateNVTexture(texture, rect, Yplane, Ypitch, UVplane, UVpitch));
}
 
inline void Texture::UpdateNV(OptionalRef<const RectRaw> rect,
                              const Uint8* Yplane,
                              int Ypitch,
                              const Uint8* UVplane,
                              int UVpitch)
{
  SDL::UpdateNVTexture(get(), rect, Yplane, Ypitch, UVplane, UVpitch);
}

inline void LockTexture(TextureRef texture,
                        OptionalRef<const RectRaw> rect,
                        void** pixels,
                        int* pitch)
{
  CheckError(SDL_LockTexture(texture, rect, pixels, pitch));
}
 
inline TextureLock Texture::Lock(OptionalRef<const RectRaw> rect,
                                 void** pixels,
                                 int* pitch)
{
  return {TextureRef(*this), rect, pixels, pitch};
}
 
inline TextureLock::TextureLock(TextureRef resource,
                                OptionalRef<const RectRaw> rect,
                                void** pixels,
                                int* pitch)
  : m_lock(std::move(resource))
{
  LockTexture(m_lock, rect, pixels, pitch);
}

inline Surface LockTextureToSurface(
  TextureRef texture,
  OptionalRef<const RectRaw> rect = std::nullopt)
{
  SurfaceRaw surface = nullptr;
  CheckError(SDL_LockTextureToSurface(texture, rect, &surface));
  return Surface::Borrow(surface);
}
 
inline TextureSurfaceLock Texture::LockToSurface(
  OptionalRef<const RectRaw> rect)
{
  return {TextureRef(*this), rect};
}
 
inline TextureSurfaceLock::TextureSurfaceLock(TextureRef resource,
                                              OptionalRef<const RectRaw> rect)
  : Surface(LockTextureToSurface(resource, rect))
  , m_lock(std::move(resource))
{
}

inline void UnlockTexture(TextureRef texture) { SDL_UnlockTexture(texture); }
 
inline void Texture::Unlock(TextureLock&& lock)
{
  SDL_assert_paranoid(lock.resource() == *this);
  std::move(lock).reset();
}
 
inline void Texture::Unlock(TextureSurfaceLock&& lock)
{
  SDL_assert_paranoid(lock.resource() == *this);
  std::move(lock).reset();
}
 
inline void TextureSurfaceLock::reset()
{
  if (!m_lock) return;
  UnlockTexture(m_lock);
  m_lock = {};
}
 
inline void TextureLock::reset()
{
  if (!m_lock) return;
  UnlockTexture(m_lock);
  m_lock = {};
}

inline void SetRenderTarget(RendererRef renderer, TextureRef texture)
{
  CheckError(SDL_SetRenderTarget(renderer, texture));
}
 
inline void Renderer::SetTarget(TextureRef texture)
{
  SDL::SetRenderTarget(get(), texture);
}

inline void ResetRenderTarget(RendererRef renderer)
{
  SetRenderTarget(renderer, nullptr);
}
 
inline void Renderer::ResetTarget() { SDL::ResetRenderTarget(get()); }

inline Texture GetRenderTarget(RendererRef renderer)
{
  if (auto texture = SDL_GetRenderTarget(renderer))
    return Texture::Borrow(texture);
  return {};
}
 
inline Texture Renderer::GetTarget() const
{
  return SDL::GetRenderTarget(get());
}

inline void SetRenderLogicalPresentation(RendererRef renderer,
                                         const PointRaw& size,
                                         RendererLogicalPresentation mode)
{
  CheckError(SDL_SetRenderLogicalPresentation(renderer, size.x, size.y, mode));
}
 
inline void Renderer::SetLogicalPresentation(const PointRaw& size,
                                             RendererLogicalPresentation mode)
{
  SDL::SetRenderLogicalPresentation(get(), size, mode);
}

inline void GetRenderLogicalPresentation(RendererRef renderer,
                                         int* w,
                                         int* h,
                                         RendererLogicalPresentation* mode)
{
  CheckError(SDL_GetRenderLogicalPresentation(renderer, w, h, mode));
}

inline void GetRenderLogicalPresentation(RendererRef renderer,
                                         PointRaw* size,
                                         RendererLogicalPresentation* mode)
{
  if (size) {
    return GetRenderLogicalPresentation(renderer, &size->x, &size->y, mode);
  }
  return GetRenderLogicalPresentation(renderer, nullptr, nullptr, mode);
}
 
inline void Renderer::GetLogicalPresentation(
  int* w,
  int* h,
  RendererLogicalPresentation* mode) const
{
  SDL::GetRenderLogicalPresentation(get(), w, h, mode);
}
 
inline void Renderer::GetLogicalPresentation(PointRaw* size,
                                             RendererLogicalPresentation* mode)
{
  SDL::GetRenderLogicalPresentation(get(), size, mode);
}

inline FRect GetRenderLogicalPresentationRect(RendererRef renderer)
{
  FRect rect;
  CheckError(SDL_GetRenderLogicalPresentationRect(renderer, &rect));
  return rect;
}
 
inline FRect Renderer::GetLogicalPresentationRect() const
{
  return SDL::GetRenderLogicalPresentationRect(get());
}

inline FPoint RenderCoordinatesFromWindow(RendererRef renderer,
                                          const FPointRaw& window_coord)
{
  FPoint p;
  CheckError(SDL_RenderCoordinatesFromWindow(
    renderer, window_coord.x, window_coord.y, &p.x, &p.y));
  return p;
}
 
inline FPoint Renderer::RenderCoordinatesFromWindow(
  const FPointRaw& window_coord) const
{
  return SDL::RenderCoordinatesFromWindow(get(), window_coord);
}

inline FPoint RenderCoordinatesToWindow(RendererRef renderer,
                                        const FPointRaw& coord)
{
  FPoint p;
  CheckError(
    SDL_RenderCoordinatesToWindow(renderer, coord.x, coord.y, &p.x, &p.y));
  return p;
}
 
inline FPoint Renderer::RenderCoordinatesToWindow(const FPointRaw& coord) const
{
  return SDL::RenderCoordinatesToWindow(get(), coord);
}

inline void ConvertEventToRenderCoordinates(RendererRef renderer, Event* event)
{
  CheckError(SDL_ConvertEventToRenderCoordinates(renderer, event));
}
 
inline void Renderer::ConvertEventToRenderCoordinates(Event* event) const
{
  SDL::ConvertEventToRenderCoordinates(get(), event);
}

inline void SetRenderViewport(RendererRef renderer,
                              OptionalRef<const RectRaw> rect)
{
  CheckError(SDL_SetRenderViewport(renderer, rect));
}
 
inline void Renderer::SetViewport(OptionalRef<const RectRaw> rect)
{
  SDL::SetRenderViewport(get(), rect);
}

inline void ResetRenderViewport(RendererRef renderer)
{
  SetRenderViewport(renderer, std::nullopt);
}
 
inline void Renderer::ResetViewport() { SDL::ResetRenderViewport(get()); }

inline Rect GetRenderViewport(RendererRef renderer)
{
  Rect rect;
  CheckError(SDL_GetRenderViewport(renderer, &rect));
  return rect;
}
 
inline Rect Renderer::GetViewport() const
{
  return SDL::GetRenderViewport(get());
}

inline bool RenderViewportSet(RendererRef renderer)
{
  return SDL_RenderViewportSet(renderer);
}
 
inline bool Renderer::ViewportSet() const
{
  return SDL::RenderViewportSet(get());
}

inline Rect GetRenderSafeArea(RendererRef renderer)
{
  Rect rect;
  CheckError(SDL_GetRenderSafeArea(renderer, &rect));
  return rect;
}
 
inline Rect Renderer::GetSafeArea() const
{
  return SDL::GetRenderSafeArea(get());
}

inline void SetRenderClipRect(RendererRef renderer,
                              OptionalRef<const RectRaw> rect)
{
  CheckError(SDL_SetRenderClipRect(renderer, rect));
}
 
inline void Renderer::SetClipRect(OptionalRef<const RectRaw> rect)
{
  SDL::SetRenderClipRect(get(), rect);
}

inline void ResetRenderClipRect(RendererRef renderer)
{
  SetRenderClipRect(renderer, std::nullopt);
}
 
inline void Renderer::ResetClipRect() { SDL::ResetRenderClipRect(get()); }

inline Rect GetRenderClipRect(RendererRef renderer)
{
  Rect rect;
  CheckError(SDL_GetRenderClipRect(renderer, &rect));
  return rect;
}
 
inline Rect Renderer::GetClipRect() const
{
  return SDL::GetRenderClipRect(get());
}

inline bool RenderClipEnabled(RendererRef renderer)
{
  return SDL_RenderClipEnabled(renderer);
}
 
inline bool Renderer::IsClipEnabled() const
{
  return SDL::RenderClipEnabled(get());
}

inline void SetRenderScale(RendererRef renderer, const FPointRaw& scale)
{
  CheckError(SDL_SetRenderScale(renderer, scale.x, scale.y));
}
 
inline void Renderer::SetScale(const FPointRaw& scale)
{
  SDL::SetRenderScale(get(), scale);
}

inline void GetRenderScale(RendererRef renderer, float* scaleX, float* scaleY)
{
  CheckError(SDL_GetRenderScale(renderer, scaleX, scaleY));
}

inline FPoint GetRenderScale(RendererRef renderer)
{
  FPoint p;
  GetRenderScale(renderer, &p.x, &p.y);
  return p;
}
 
inline void Renderer::GetScale(float* scaleX, float* scaleY) const
{
  SDL::GetRenderScale(get(), scaleX, scaleY);
}
 
inline FPoint Renderer::GetScale() const { return SDL::GetRenderScale(get()); }

inline void SetRenderDrawColor(RendererRef renderer, ColorRaw c)
{
  CheckError(SDL_SetRenderDrawColor(renderer, c.r, c.g, c.b, c.a));
}
 
inline void Renderer::SetDrawColor(ColorRaw c)
{
  SDL::SetRenderDrawColor(get(), c);
}

inline void SetRenderDrawColorFloat(RendererRef renderer, const FColorRaw& c)
{
  CheckError(SDL_SetRenderDrawColorFloat(renderer, c.r, c.g, c.b, c.a));
}
 
inline void Renderer::SetDrawColorFloat(const FColorRaw& c)
{
  SDL::SetRenderDrawColorFloat(get(), c);
}

inline void GetRenderDrawColor(RendererRef renderer,
                               Uint8* r,
                               Uint8* g,
                               Uint8* b,
                               Uint8* a)
{
  CheckError(SDL_GetRenderDrawColor(renderer, r, g, b, a));
}

inline Color GetRenderDrawColor(RendererRef renderer)
{
  Color c;
  GetRenderDrawColor(renderer, &c.r, &c.g, &c.b, &c.a);
  return c;
}
 
inline void Renderer::GetDrawColor(Uint8* r, Uint8* g, Uint8* b, Uint8* a) const
{
  SDL::GetRenderDrawColor(get(), r, g, b, a);
}
 
inline Color Renderer::GetDrawColor() const
{
  return SDL::GetRenderDrawColor(get());
}

inline void GetRenderDrawColorFloat(RendererRef renderer,
                                    float* r,
                                    float* g,
                                    float* b,
                                    float* a)
{
  CheckError(SDL_GetRenderDrawColorFloat(renderer, r, g, b, a));
}

inline FColor GetRenderDrawColorFloat(RendererRef renderer)
{
  FColor c;
  GetRenderDrawColorFloat(renderer, &c.r, &c.g, &c.b, &c.a);
  return c;
}
 
inline void Renderer::GetDrawColorFloat(float* r,
                                        float* g,
                                        float* b,
                                        float* a) const
{
  SDL::GetRenderDrawColorFloat(get(), r, g, b, a);
}
 
inline FColor Renderer::GetDrawColorFloat() const
{
  return SDL::GetRenderDrawColorFloat(get());
}

inline void SetRenderColorScale(RendererRef renderer, float scale)
{
  CheckError(SDL_SetRenderColorScale(renderer, scale));
}
 
inline void Renderer::SetColorScale(float scale)
{
  SDL::SetRenderColorScale(get(), scale);
}

inline float GetRenderColorScale(RendererRef renderer)
{
  float scale;
  CheckError(SDL_GetRenderColorScale(renderer, &scale));
  return scale;
}
 
inline float Renderer::GetColorScale() const
{
  return SDL::GetRenderColorScale(get());
}

inline void SetRenderDrawBlendMode(RendererRef renderer, BlendMode blendMode)
{
  CheckError(SDL_SetRenderDrawBlendMode(renderer, blendMode));
}
 
inline void Renderer::SetDrawBlendMode(BlendMode blendMode)
{
  SDL::SetRenderDrawBlendMode(get(), blendMode);
}

inline BlendMode GetRenderDrawBlendMode(RendererRef renderer)
{
  BlendMode blendMode;
  CheckError(SDL_GetRenderDrawBlendMode(renderer, &blendMode));
  return blendMode;
}
 
inline BlendMode Renderer::GetDrawBlendMode() const
{
  return SDL::GetRenderDrawBlendMode(get());
}

inline void RenderClear(RendererRef renderer)
{
  CheckError(SDL_RenderClear(renderer));
}
 
inline void Renderer::RenderClear() { SDL::RenderClear(get()); }

inline void RenderPoint(RendererRef renderer, const FPointRaw& p)
{
  CheckError(SDL_RenderPoint(renderer, p.x, p.y));
}
 
inline void Renderer::RenderPoint(const FPointRaw& p)
{
  SDL::RenderPoint(get(), p);
}

inline void RenderPoints(RendererRef renderer, SpanRef<const FPointRaw> points)
{
  CheckError(
    SDL_RenderPoints(renderer, points.data(), narrowS32(points.size())));
}
 
inline void Renderer::RenderPoints(SpanRef<const FPointRaw> points)
{
  SDL::RenderPoints(get(), points);
}

inline void RenderLine(RendererRef renderer,
                       const FPointRaw& p1,
                       const FPointRaw& p2)
{
  CheckError(SDL_RenderLine(renderer, p1.x, p1.y, p2.x, p2.y));
}
 
inline void Renderer::RenderLine(const FPointRaw& p1, const FPointRaw& p2)
{
  SDL::RenderLine(get(), p1, p2);
}

inline void RenderLines(RendererRef renderer, SpanRef<const FPointRaw> points)
{
  CheckError(
    SDL_RenderLines(renderer, points.data(), narrowS32(points.size())));
}
 
inline void Renderer::RenderLines(SpanRef<const FPointRaw> points)
{
  SDL::RenderLines(get(), points);
}

inline void RenderRect(RendererRef renderer, OptionalRef<const FRectRaw> rect)
{
  CheckError(SDL_RenderRect(renderer, rect));
}
 
inline void Renderer::RenderRect(OptionalRef<const FRectRaw> rect)
{
  SDL::RenderRect(get(), rect);
}

inline void RenderRects(RendererRef renderer, SpanRef<const FRectRaw> rects)
{
  CheckError(SDL_RenderRects(renderer, rects.data(), narrowS32(rects.size())));
}
 
inline void Renderer::RenderRects(SpanRef<const FRectRaw> rects)
{
  SDL::RenderRects(get(), rects);
}

inline void RenderFillRect(RendererRef renderer,
                           OptionalRef<const FRectRaw> rect)
{
  CheckError(SDL_RenderFillRect(renderer, rect));
}
 
inline void Renderer::RenderFillRect(OptionalRef<const FRectRaw> rect)
{
  SDL::RenderFillRect(get(), rect);
}

inline void RenderFillRects(RendererRef renderer, SpanRef<const FRectRaw> rects)
{
  CheckError(
    SDL_RenderFillRects(renderer, rects.data(), narrowS32(rects.size())));
}
 
inline void Renderer::RenderFillRects(SpanRef<const FRectRaw> rects)
{
  SDL::RenderFillRects(get(), rects);
}

inline void RenderTexture(RendererRef renderer,
                          TextureRef texture,
                          OptionalRef<const FRectRaw> srcrect,
                          OptionalRef<const FRectRaw> dstrect)
{
  CheckError(SDL_RenderTexture(renderer, texture, srcrect, dstrect));
}
 
inline void Renderer::RenderTexture(TextureRef texture,
                                    OptionalRef<const FRectRaw> srcrect,
                                    OptionalRef<const FRectRaw> dstrect)
{
  SDL::RenderTexture(get(), texture, srcrect, dstrect);
}

inline void RenderTextureRotated(RendererRef renderer,
                                 TextureRef texture,
                                 OptionalRef<const FRectRaw> srcrect,
                                 OptionalRef<const FRectRaw> dstrect,
                                 double angle,
                                 OptionalRef<const FPointRaw> center,
                                 FlipMode flip = FlipMode::SDL_FLIP_NONE)
{
  CheckError(SDL_RenderTextureRotated(
    renderer, texture, srcrect, dstrect, angle, center, flip));
}
 
inline void Renderer::RenderTextureRotated(TextureRef texture,
                                           OptionalRef<const FRectRaw> srcrect,
                                           OptionalRef<const FRectRaw> dstrect,
                                           double angle,
                                           OptionalRef<const FPointRaw> center,
                                           FlipMode flip)
{
  SDL::RenderTextureRotated(
    get(), texture, srcrect, dstrect, angle, center, flip);
}

inline void RenderTextureAffine(RendererRef renderer,
                                TextureRef texture,
                                OptionalRef<const FRectRaw> srcrect,
                                OptionalRef<const FPointRaw> origin,
                                OptionalRef<const FPointRaw> right,
                                OptionalRef<const FPointRaw> down)
{
  CheckError(
    SDL_RenderTextureAffine(renderer, texture, srcrect, origin, right, down));
}
 
inline void Renderer::RenderTextureAffine(TextureRef texture,
                                          OptionalRef<const FRectRaw> srcrect,
                                          OptionalRef<const FPointRaw> origin,
                                          OptionalRef<const FPointRaw> right,
                                          OptionalRef<const FPointRaw> down)
{
  SDL::RenderTextureAffine(get(), texture, srcrect, origin, right, down);
}

inline void RenderTextureTiled(RendererRef renderer,
                               TextureRef texture,
                               OptionalRef<const FRectRaw> srcrect,
                               float scale,
                               OptionalRef<const FRectRaw> dstrect)
{
  CheckError(
    SDL_RenderTextureTiled(renderer, texture, srcrect, scale, dstrect));
}
 
inline void Renderer::RenderTextureTiled(TextureRef texture,
                                         OptionalRef<const FRectRaw> srcrect,
                                         float scale,
                                         OptionalRef<const FRectRaw> dstrect)
{
  SDL::RenderTextureTiled(get(), texture, srcrect, scale, dstrect);
}

inline void RenderTexture9Grid(RendererRef renderer,
                               TextureRef texture,
                               OptionalRef<const FRectRaw> srcrect,
                               float left_width,
                               float right_width,
                               float top_height,
                               float bottom_height,
                               float scale,
                               OptionalRef<const FRectRaw> dstrect)
{
  CheckError(SDL_RenderTexture9Grid(renderer,
                                    texture,
                                    srcrect,
                                    left_width,
                                    right_width,
                                    top_height,
                                    bottom_height,
                                    scale,
                                    dstrect));
}
 
inline void Renderer::RenderTexture9Grid(TextureRef texture,
                                         OptionalRef<const FRectRaw> srcrect,
                                         float left_width,
                                         float right_width,
                                         float top_height,
                                         float bottom_height,
                                         float scale,
                                         OptionalRef<const FRectRaw> dstrect)
{
  SDL::RenderTexture9Grid(get(),
                          texture,
                          srcrect,
                          left_width,
                          right_width,
                          top_height,
                          bottom_height,
                          scale,
                          dstrect);
}
 
#if SDL_VERSION_ATLEAST(3, 4, 0)

inline void RenderTexture9GridTiled(RendererRef renderer,
                                    TextureRef texture,
                                    const FRectRaw& srcrect,
                                    float left_width,
                                    float right_width,
                                    float top_height,
                                    float bottom_height,
                                    float scale,
                                    const FRectRaw& dstrect,
                                    float tileScale)
{
  CheckError(SDL_RenderTexture9GridTiled(renderer,
                                         texture,
                                         &srcrect,
                                         left_width,
                                         right_width,
                                         top_height,
                                         bottom_height,
                                         scale,
                                         &dstrect,
                                         tileScale));
}
 
inline void Renderer::RenderTexture9GridTiled(TextureRef texture,
                                              const FRectRaw& srcrect,
                                              float left_width,
                                              float right_width,
                                              float top_height,
                                              float bottom_height,
                                              float scale,
                                              const FRectRaw& dstrect,
                                              float tileScale)
{
  SDL::RenderTexture9GridTiled(get(),
                               texture,
                               srcrect,
                               left_width,
                               right_width,
                               top_height,
                               bottom_height,
                               scale,
                               dstrect,
                               tileScale);
}
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)

inline void RenderGeometry(RendererRef renderer,
                           TextureRef texture,
                           std::span<const Vertex> vertices,
                           std::span<const int> indices = {})
{
  CheckError(SDL_RenderGeometry(renderer,
                                texture,
                                vertices.data(),
                                narrowS32(vertices.size()),
                                indices.data(),
                                narrowS32(indices.size())));
}
 
inline void Renderer::RenderGeometry(TextureRef texture,
                                     std::span<const Vertex> vertices,
                                     std::span<const int> indices)
{
  SDL::RenderGeometry(get(), texture, vertices, indices);
}

inline void RenderGeometryRaw(RendererRef renderer,
                              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(renderer,
                                   texture,
                                   xy,
                                   xy_stride,
                                   color,
                                   color_stride,
                                   uv,
                                   uv_stride,
                                   num_vertices,
                                   indices,
                                   num_indices,
                                   size_indices));
}
 
inline void Renderer::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)
{
  SDL::RenderGeometryRaw(get(),
                         texture,
                         xy,
                         xy_stride,
                         color,
                         color_stride,
                         uv,
                         uv_stride,
                         num_vertices,
                         indices,
                         num_indices,
                         size_indices);
}
 
#if SDL_VERSION_ATLEAST(3, 4, 0)

inline void SetRenderTextureAddressMode(RendererRef renderer,
                                        TextureAddressMode u_mode,
                                        TextureAddressMode v_mode)
{
  CheckError(SDL_SetRenderTextureAddressMode(renderer, u_mode, v_mode));
}
 
inline void Renderer::SetRenderTextureAddressMode(TextureAddressMode u_mode,
                                                  TextureAddressMode v_mode)
{
  SDL::SetRenderTextureAddressMode(get(), u_mode, v_mode);
}

inline void GetRenderTextureAddressMode(RendererRef renderer,
                                        TextureAddressMode* u_mode,
                                        TextureAddressMode* v_mode)
{
  CheckError(SDL_GetRenderTextureAddressMode(renderer, u_mode, v_mode));
}
 
inline void Renderer::GetRenderTextureAddressMode(TextureAddressMode* u_mode,
                                                  TextureAddressMode* v_mode)
{
  SDL::GetRenderTextureAddressMode(get(), u_mode, v_mode);
}
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)

inline Surface RenderReadPixels(RendererRef renderer,
                                OptionalRef<const RectRaw> rect = {})
{
  return Surface{CheckError(SDL_RenderReadPixels(renderer, rect))};
}
 
inline Surface Renderer::ReadPixels(OptionalRef<const RectRaw> rect) const
{
  return SDL::RenderReadPixels(get(), rect);
}

inline void RenderPresent(RendererRef renderer)
{
  CheckError(SDL_RenderPresent(renderer));
}
 
inline void Renderer::Present() { SDL::RenderPresent(get()); }

inline void DestroyTexture(TextureRaw texture) { SDL_DestroyTexture(texture); }
 
inline void Texture::Destroy() { DestroyTexture(release()); }

inline void DestroyRenderer(RendererRaw renderer)
{
  SDL_DestroyRenderer(renderer);
}
 
inline void Renderer::Destroy() { DestroyRenderer(release()); }

inline void FlushRenderer(RendererRef renderer)
{
  CheckError(SDL_FlushRenderer(renderer));
}
 
inline void Renderer::Flush() { SDL::FlushRenderer(get()); }

inline void* GetRenderMetalLayer(RendererRef renderer)
{
  return SDL_GetRenderMetalLayer(renderer);
}
 
inline void* Renderer::GetRenderMetalLayer()
{
  return SDL::GetRenderMetalLayer(get());
}

inline void* GetRenderMetalCommandEncoder(RendererRef renderer)
{
  return SDL_GetRenderMetalCommandEncoder(renderer);
}
 
inline void* Renderer::GetRenderMetalCommandEncoder()
{
  return SDL::GetRenderMetalCommandEncoder(get());
}

inline void AddVulkanRenderSemaphores(RendererRef renderer,
                                      Uint32 wait_stage_mask,
                                      Sint64 wait_semaphore,
                                      Sint64 signal_semaphore)
{
  CheckError(SDL_AddVulkanRenderSemaphores(
    renderer, wait_stage_mask, wait_semaphore, signal_semaphore));
}
 
inline void Renderer::AddVulkanRenderSemaphores(Uint32 wait_stage_mask,
                                                Sint64 wait_semaphore,
                                                Sint64 signal_semaphore)
{
  SDL::AddVulkanRenderSemaphores(
    get(), wait_stage_mask, wait_semaphore, signal_semaphore);
}

inline void SetRenderVSync(RendererRef renderer, int vsync)
{
  CheckError(SDL_SetRenderVSync(renderer, vsync));
}
 
inline void Renderer::SetVSync(int vsync) { SDL::SetRenderVSync(get(), vsync); }

constexpr int RENDERER_VSYNC_DISABLED = SDL_RENDERER_VSYNC_DISABLED;

constexpr int RENDERER_VSYNC_ADAPTIVE = SDL_RENDERER_VSYNC_ADAPTIVE;

inline int GetRenderVSync(RendererRef renderer)
{
  int vsync;
  CheckError(SDL_GetRenderVSync(renderer, &vsync));
  return vsync;
}
 
inline int Renderer::GetVSync() const { return SDL::GetRenderVSync(get()); }

constexpr int DEBUG_TEXT_FONT_CHARACTER_SIZE =
  SDL_DEBUG_TEXT_FONT_CHARACTER_SIZE;

inline void RenderDebugText(RendererRef renderer,
                            const FPointRaw& p,
                            StringParam str)
{
  CheckError(SDL_RenderDebugText(renderer, p.x, p.y, str));
}
 
inline void Renderer::RenderDebugText(const FPointRaw& p, StringParam str)
{
  SDL::RenderDebugText(get(), p, std::move(str));
}

template<class... ARGS>
inline void RenderDebugTextFormat(RendererRef renderer,
                                  const FPointRaw& p,
                                  std::string_view fmt,
                                  ARGS... args)
{
  RenderDebugText(
    renderer, p, std::vformat(fmt, std::make_format_args(args...)));
}
 
template<class... ARGS>
inline void Renderer::RenderDebugTextFormat(const FPointRaw& p,
                                            std::string_view fmt,
                                            ARGS... args)
{
  SDL::RenderDebugTextFormat(get(), p, fmt, args...);
}
 
#if SDL_VERSION_ATLEAST(3, 4, 0)

inline void SetDefaultTextureScaleMode(RendererRef renderer,
                                       ScaleMode scale_mode)
{
  CheckError(SDL_SetDefaultTextureScaleMode(renderer, scale_mode));
}
 
inline void Renderer::SetDefaultTextureScaleMode(ScaleMode scale_mode)
{
  SDL::SetDefaultTextureScaleMode(get(), scale_mode);
}

inline void GetDefaultTextureScaleMode(RendererRef renderer,
                                       ScaleMode* scale_mode)
{
  CheckError(SDL_GetDefaultTextureScaleMode(renderer, scale_mode));
}
 
inline void Renderer::GetDefaultTextureScaleMode(ScaleMode* scale_mode)
{
  SDL::GetDefaultTextureScaleMode(get(), scale_mode);
}

struct GPURenderState : ResourceBase<GPURenderStateRaw>
{
  using ResourceBase::ResourceBase;

  constexpr explicit GPURenderState(GPURenderStateRaw resource) noexcept
    : ResourceBase(resource)
  {
  }

  constexpr GPURenderState(const GPURenderState& other) = delete;

  constexpr GPURenderState(GPURenderState&& other) noexcept
    : GPURenderState(other.release())
  {
  }
 
  constexpr GPURenderState(const GPURenderStateRef& other) = delete;
 
  constexpr GPURenderState(GPURenderStateRef&& other) = delete;

  GPURenderState(RendererRef renderer,
                 const GPURenderStateCreateInfo& createinfo);

  ~GPURenderState() { SDL_DestroyGPURenderState(get()); }

  constexpr GPURenderState& operator=(GPURenderState&& other) noexcept
  {
    swap(*this, other);
    return *this;
  }

  GPURenderState& operator=(const GPURenderState& other) = delete;

  void Destroy();

  void SetFragmentUniforms(Uint32 slot_index, const void* data, Uint32 length);
};

inline GPURenderState CreateGPURenderState(
  RendererRef renderer,
  const GPURenderStateCreateInfo& createinfo)
{
  return GPURenderState(renderer, createinfo);
}
 
inline GPURenderState Renderer::CreateGPURenderState(
  const GPURenderStateCreateInfo& createinfo)
{
  return GPURenderState(get(), createinfo);
}
 
inline GPURenderState::GPURenderState(
  RendererRef renderer,
  const GPURenderStateCreateInfo& createinfo)
  : GPURenderState(SDL_CreateGPURenderState(renderer, &createinfo))
{
}

inline void SetGPURenderStateFragmentUniforms(GPURenderStateRef state,
                                              Uint32 slot_index,
                                              const void* data,
                                              Uint32 length)
{
  CheckError(
    SDL_SetGPURenderStateFragmentUniforms(state, slot_index, data, length));
}
 
inline void GPURenderState::SetFragmentUniforms(Uint32 slot_index,
                                                const void* data,
                                                Uint32 length)
{
  SDL::SetGPURenderStateFragmentUniforms(get(), slot_index, data, length);
}

inline void SetGPURenderState(RendererRef renderer, GPURenderStateRef state)
{
  CheckError(SDL_SetGPURenderState(renderer, state));
}
 
inline void Renderer::SetGPURenderState(GPURenderStateRef state)
{
  SDL::SetGPURenderState(get(), state);
}

inline void DestroyGPURenderState(GPURenderStateRaw state)
{
  SDL_DestroyGPURenderState(state);
}
 
inline void GPURenderState::Destroy() { DestroyGPURenderState(release()); }
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)

 
} // namespace SDL
 
#endif /* SDL3PP_RENDER_H_ */