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_video.h"
 
namespace SDL {
 
// Forward decl
struct Renderer;
 
using RendererRaw = SDL_Renderer*;
 
// Forward decl
struct RendererRef;
 
struct RendererParam
{
  RendererRaw value; 
 
  constexpr RendererParam(RendererRaw value)
    : value(value)
  {
  }
 
  constexpr RendererParam(std::nullptr_t _ = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const RendererParam& other) const = default;
 
  constexpr operator RendererRaw() const { return value; }
};
 
// Forward decl
struct Texture;
 
using TextureRaw = SDL_Texture*;
 
struct TextureParam
{
  TextureRaw value; 
 
  constexpr TextureParam(TextureRaw value)
    : value(value)
  {
  }
 
  constexpr TextureParam(std::nullptr_t _ = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const TextureParam& other) const = default;
 
  constexpr operator TextureRaw() const { return value; }
 
  constexpr auto operator->() { return value; }
};
 
struct TextureConstParam
{
  const TextureRaw value; 
 
  constexpr TextureConstParam(const TextureRaw value)
    : value(value)
  {
  }
 
  constexpr TextureConstParam(TextureParam value)
    : value(value.value)
  {
  }
 
  constexpr TextureConstParam(std::nullptr_t _ = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const TextureConstParam& other) const = default;
 
  constexpr operator const TextureRaw() const { return value; }
 
  constexpr auto operator->() { return value; }
};
 
constexpr auto SOFTWARE_RENDERER = SDL_SOFTWARE_RENDERER;
 
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;
 
class Renderer
{
  RendererRaw m_resource = nullptr;
 
public:
  constexpr Renderer(std::nullptr_t = nullptr) noexcept
    : m_resource(0)
  {
  }
 
  constexpr explicit Renderer(const RendererRaw resource) noexcept
    : m_resource(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(WindowParam window)
    : m_resource(CheckError(SDL_CreateRenderer(window, nullptr)))
  {
  }
 
  Renderer(WindowParam window, StringParam name)
    : m_resource(CheckError(SDL_CreateRenderer(window, name)))
  {
  }
 
  Renderer(PropertiesParam props)
    : m_resource(CheckError(SDL_CreateRendererWithProperties(props)))
  {
  }
 
  Renderer(SurfaceParam surface)
    : m_resource(CheckError(SDL_CreateSoftwareRenderer(surface)))
  {
  }
 
  ~Renderer() { SDL_DestroyRenderer(m_resource); }
 
  constexpr Renderer& operator=(Renderer&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
protected:
  constexpr Renderer& operator=(const Renderer& other) noexcept = default;
 
public:
  constexpr RendererRaw get() const noexcept { return m_resource; }
 
  constexpr RendererRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Renderer& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  constexpr operator RendererParam() const noexcept { return {m_resource}; }
 
  void Destroy();
 
  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(SurfaceParam surface);
 
  Texture CreateTextureWithProperties(PropertiesParam props);
 
  void SetTarget(TextureParam 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(TextureParam texture,
                     OptionalRef<const FRectRaw> srcrect,
                     OptionalRef<const FRectRaw> dstrect);
 
  void RenderTextureRotated(TextureParam texture,
                            OptionalRef<const FRectRaw> srcrect,
                            OptionalRef<const FRectRaw> dstrect,
                            double angle,
                            OptionalRef<const FPointRaw> center,
                            FlipMode flip = FlipMode::SDL_FLIP_NONE);
 
  void RenderTextureAffine(TextureParam texture,
                           OptionalRef<const FRectRaw> srcrect,
                           OptionalRef<const FPointRaw> origin,
                           OptionalRef<const FPointRaw> right,
                           OptionalRef<const FPointRaw> down);
 
  void RenderTextureTiled(TextureParam texture,
                          OptionalRef<const FRectRaw> srcrect,
                          float scale,
                          OptionalRef<const FRectRaw> dstrect);
 
  void RenderTexture9Grid(TextureParam texture,
                          OptionalRef<const FRectRaw> srcrect,
                          float left_width,
                          float right_width,
                          float top_height,
                          float bottom_height,
                          float scale,
                          OptionalRef<const FRectRaw> dstrect);
 
  void RenderGeometry(TextureParam texture,
                      std::span<const Vertex> vertices,
                      std::span<const int> indices = {});
 
  void RenderGeometryRaw(TextureParam 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 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);
};
 
struct RendererRef : Renderer
{
  using Renderer::Renderer;
 
  RendererRef(RendererParam resource) noexcept
    : Renderer(resource.value)
  {
  }
 
  RendererRef(RendererRaw resource) noexcept
    : Renderer(resource)
  {
  }
 
  RendererRef(const RendererRef& other) noexcept
    : Renderer(other.get())
  {
  }
 
  ~RendererRef() { release(); }
};
 
class Texture
{
  TextureRaw m_resource = nullptr;
 
public:
  constexpr Texture(std::nullptr_t = nullptr) noexcept
    : m_resource(0)
  {
  }
 
  constexpr explicit Texture(const TextureRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
  constexpr Texture(const Texture& other) { ++m_resource->refcount; }
 
  constexpr Texture(Texture&& other) noexcept
    : Texture(other.release())
  {
  }
 
  Texture(RendererParam renderer,
          PixelFormat format,
          TextureAccess access,
          const PointRaw& size)
    : m_resource(
        CheckError(SDL_CreateTexture(renderer, format, access, size.x, size.y)))
  {
  }
 
  Texture(RendererParam renderer, SurfaceParam surface)
    : m_resource(CheckError(SDL_CreateTextureFromSurface(renderer, surface)))
  {
  }
 
  Texture(RendererParam renderer, PropertiesParam props)
    : m_resource(CheckError(SDL_CreateTextureWithProperties(renderer, props)))
  {
  }
 
  Texture(RendererParam renderer, StringParam file);
 
  Texture(RendererParam renderer, IOStreamParam src, bool closeio = false);
 
  static constexpr Texture Borrow(TextureParam resource)
  {
    if (resource) {
      ++resource.value->refcount;
      return Texture(resource.value);
    }
    return {};
  }
 
  constexpr const TextureRaw operator->() const noexcept { return m_resource; }
 
  constexpr TextureRaw operator->() noexcept { return m_resource; }
 
  ~Texture() { SDL_DestroyTexture(m_resource); }
 
  constexpr Texture& operator=(Texture&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  constexpr Texture& operator=(const Texture& other) noexcept = default;
 
  constexpr TextureRaw get() const noexcept { return m_resource; }
 
  constexpr TextureRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Texture& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  constexpr operator TextureParam() const noexcept { return {m_resource}; }
 
  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;
 
  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(SurfaceConstParam 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);
 
  void Lock(OptionalRef<const SDL_Rect> rect, void** pixels, int* pitch);
 
  Surface LockToSurface(OptionalRef<const SDL_Rect> rect = std::nullopt);
 
  void Unlock();
};
 
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 PointRaw& size,
  WindowFlags window_flags = 0)
{
  SDL_Window* window = nullptr;
  SDL_Renderer* renderer = nullptr;
  CheckError(SDL_CreateWindowAndRenderer(
    title, size.x, size.y, window_flags, &window, &renderer));
  return {Window{window}, Renderer(renderer)};
}
 
inline Renderer CreateRenderer(WindowParam window, StringParam name)
{
  return Renderer(window, std::move(name));
}
 
inline Renderer CreateRendererWithProperties(PropertiesParam props)
{
  return Renderer(props);
}
 
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 Renderer CreateSoftwareRenderer(SurfaceParam surface)
{
  return Renderer(surface);
}
 
inline RendererRef Window::GetRenderer() const
{
  return {CheckError(SDL_GetRenderer(m_resource))};
}
 
inline WindowRef GetRenderWindow(RendererParam renderer)
{
  return {CheckError(SDL_GetRenderWindow(renderer))};
}
 
inline WindowRef Renderer::GetWindow()
{
  return SDL::GetRenderWindow(m_resource);
}
 
inline const char* GetRendererName(RendererParam renderer)
{
  return SDL_GetRendererName(renderer);
}
 
inline const char* Renderer::GetName() const
{
  return SDL::GetRendererName(m_resource);
}
 
inline PropertiesRef GetRendererProperties(RendererParam renderer)
{
  return {CheckError(SDL_GetRendererProperties(renderer))};
}
 
inline PropertiesRef Renderer::GetProperties() const
{
  return SDL::GetRendererProperties(m_resource);
}
 
inline void GetRenderOutputSize(RendererParam renderer, int* w, int* h)
{
  CheckError(SDL_GetRenderOutputSize(renderer, w, h));
}
 
inline Point GetRenderOutputSize(RendererParam renderer)
{
  Point p;
  GetRenderOutputSize(renderer, &p.x, &p.y);
  return p;
}
 
inline void Renderer::GetOutputSize(int* w, int* h) const
{
  SDL::GetRenderOutputSize(m_resource, w, h);
}
 
inline Point Renderer::GetOutputSize() const
{
  return SDL::GetRenderOutputSize(m_resource);
}
 
inline void GetCurrentRenderOutputSize(RendererParam renderer, int* w, int* h)
{
  CheckError(SDL_GetCurrentRenderOutputSize(renderer, w, h));
}
 
inline Point GetCurrentRenderOutputSize(RendererParam renderer)
{
  Point p;
  GetCurrentRenderOutputSize(renderer, &p.x, &p.y);
  return p;
}
 
inline void Renderer::GetCurrentOutputSize(int* w, int* h) const
{
  SDL::GetCurrentRenderOutputSize(m_resource, w, h);
}
 
inline Point Renderer::GetCurrentOutputSize() const
{
  return SDL::GetCurrentRenderOutputSize(m_resource);
}
 
inline Texture CreateTexture(RendererParam 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(m_resource, format, access, size);
}
 
inline Texture CreateTextureFromSurface(RendererParam renderer,
                                        SurfaceParam surface)
{
  return Texture(renderer, surface);
}
 
inline Texture Renderer::CreateTextureFromSurface(SurfaceParam surface)
{
  return Texture(m_resource, surface);
}
 
inline Texture CreateTextureWithProperties(RendererParam renderer,
                                           PropertiesParam props)
{
  return Texture(renderer, props);
}
 
inline Texture Renderer::CreateTextureWithProperties(PropertiesParam props)
{
  return Texture(m_resource, props);
}
 
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 PropertiesRef GetTextureProperties(TextureConstParam texture)
{
  return {CheckError(SDL_GetTextureProperties(texture))};
}
 
inline PropertiesRef Texture::GetProperties() const
{
  return SDL::GetTextureProperties(m_resource);
}
 
inline RendererRef GetRendererFromTexture(TextureConstParam texture)
{
  return {SDL_GetRendererFromTexture(texture)};
}
 
inline RendererRef Texture::GetRenderer() const
{
  return SDL::GetRendererFromTexture(m_resource);
}
 
inline void GetTextureSize(TextureConstParam texture, float* w, float* h)
{
  CheckError(SDL_GetTextureSize(texture, w, h));
}
 
inline Point GetTextureSize(TextureConstParam texture)
{
  return Point(texture->w, texture->h);
}
 
inline void Texture::GetSize(float* w, float* h) const
{
  SDL::GetTextureSize(m_resource, w, h);
}
 
inline Point Texture::GetSize() const
{
  return SDL::GetTextureSize(m_resource);
}
 
inline FPoint GetTextureSizeFloat(TextureConstParam texture)
{
  FPoint p;
  GetTextureSize(texture, &p.x, &p.y);
  return p;
}
 
inline FPoint Texture::GetSizeFloat() const
{
  return SDL::GetTextureSizeFloat(m_resource);
}
 
inline int GetTextureWidth(TextureConstParam texture) { return texture->w; }
 
inline int Texture::GetWidth() const
{
  return SDL::GetTextureWidth(m_resource);
}
 
inline int GetTextureHeight(TextureConstParam texture) { return texture->h; }
 
inline int Texture::GetHeight() const
{
  return SDL::GetTextureHeight(m_resource);
}
 
inline PixelFormat GetTextureFormat(TextureConstParam texture)
{
  return texture->format;
}
 
inline PixelFormat Texture::GetFormat() const
{
  return SDL::GetTextureFormat(m_resource);
}
 
inline void SetTextureColorMod(TextureParam 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(m_resource, r, g, b);
}
 
inline void SetTextureColorModFloat(TextureParam 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(m_resource, r, g, b);
}
 
inline void GetTextureColorMod(TextureConstParam 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(m_resource, r, g, b);
}
 
inline void GetTextureColorModFloat(TextureConstParam 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(m_resource, r, g, b);
}
 
inline void SetTextureAlphaMod(TextureParam texture, Uint8 alpha)
{
  CheckError(SDL_SetTextureAlphaMod(texture, alpha));
}
 
inline void Texture::SetAlphaMod(Uint8 alpha)
{
  SDL::SetTextureAlphaMod(m_resource, alpha);
}
 
inline void SetTextureAlphaModFloat(TextureParam texture, float alpha)
{
  CheckError(SDL_SetTextureAlphaModFloat(texture, alpha));
}
 
inline void Texture::SetAlphaModFloat(float alpha)
{
  SDL::SetTextureAlphaModFloat(m_resource, alpha);
}
 
inline Uint8 GetTextureAlphaMod(TextureConstParam texture)
{
  Uint8 alpha;
  CheckError(SDL_GetTextureAlphaMod(texture, &alpha));
  return alpha;
}
 
inline Uint8 Texture::GetAlphaMod() const
{
  return SDL::GetTextureAlphaMod(m_resource);
}
 
inline float GetTextureAlphaModFloat(TextureConstParam texture)
{
  float alpha;
  CheckError(SDL_GetTextureAlphaModFloat(texture, &alpha));
  return alpha;
}
 
inline float Texture::GetAlphaModFloat() const
{
  return SDL::GetTextureAlphaModFloat(m_resource);
}
 
inline void SetTextureMod(TextureParam texture, Color c)
{
  SetTextureColorMod(texture, c.r, c.g, c.b);
  SetTextureAlphaMod(texture, c.a);
}
 
inline void Texture::SetMod(Color c) { SDL::SetTextureMod(m_resource, c); }
 
inline void SetTextureModFloat(TextureParam texture, FColor c)
{
  SetTextureColorModFloat(texture, c.r, c.g, c.b);
  SetTextureAlphaModFloat(texture, c.a);
}
 
inline void Texture::SetModFloat(FColor c)
{
  SDL::SetTextureModFloat(m_resource, c);
}
 
inline Color GetTextureMod(TextureConstParam 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(m_resource); }
 
inline FColor GetTextureModFloat(TextureConstParam 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(m_resource);
}
 
inline void SetTextureBlendMode(TextureParam texture, BlendMode blendMode)
{
  CheckError(SDL_SetTextureBlendMode(texture, blendMode));
}
 
inline void Texture::SetBlendMode(BlendMode blendMode)
{
  SDL::SetTextureBlendMode(m_resource, blendMode);
}
 
inline BlendMode GetTextureBlendMode(TextureConstParam texture)
{
  BlendMode blendMode;
  CheckError(SDL_GetTextureBlendMode(texture, &blendMode));
  return blendMode;
}
 
inline BlendMode Texture::GetBlendMode() const
{
  return SDL::GetTextureBlendMode(m_resource);
}
 
inline void SetTextureScaleMode(TextureParam texture, ScaleMode scaleMode)
{
  CheckError(SDL_SetTextureScaleMode(texture, scaleMode));
}
 
inline void Texture::SetScaleMode(ScaleMode scaleMode)
{
  SDL::SetTextureScaleMode(m_resource, scaleMode);
}
 
inline ScaleMode GetTextureScaleMode(TextureConstParam texture)
{
  ScaleMode scaleMode;
  CheckError(SDL_GetTextureScaleMode(texture, &scaleMode));
  return scaleMode;
}
 
inline ScaleMode Texture::GetScaleMode() const
{
  return SDL::GetTextureScaleMode(m_resource);
}
 
inline void UpdateTexture(TextureParam texture,
                          OptionalRef<const RectRaw> rect,
                          const void* pixels,
                          int pitch)
{
  CheckError(SDL_UpdateTexture(texture, rect, pixels, pitch));
}
 
inline void UpdateTexture(TextureParam texture,
                          SurfaceConstParam 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(m_resource, rect, pixels, pitch);
}
 
inline void Texture::Update(SurfaceConstParam surface,
                            OptionalRef<const RectRaw> rect)
{
  SDL::UpdateTexture(m_resource, surface, rect);
}
 
inline void UpdateYUVTexture(TextureParam 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(
    m_resource, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch);
}
 
inline void UpdateNVTexture(TextureParam 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(m_resource, rect, Yplane, Ypitch, UVplane, UVpitch);
}
 
inline void LockTexture(TextureParam texture,
                        OptionalRef<const SDL_Rect> rect,
                        void** pixels,
                        int* pitch)
{
  CheckError(SDL_LockTexture(texture, rect, pixels, pitch));
}
 
inline void Texture::Lock(OptionalRef<const SDL_Rect> rect,
                          void** pixels,
                          int* pitch)
{
  SDL::LockTexture(m_resource, rect, pixels, pitch);
}
 
inline Surface LockTextureToSurface(
  TextureParam texture,
  OptionalRef<const SDL_Rect> rect = std::nullopt)
{
  SurfaceRaw surface = nullptr;
  CheckError(SDL_LockTextureToSurface(texture, rect, &surface));
  return Surface::Borrow(surface);
}
 
inline Surface Texture::LockToSurface(OptionalRef<const SDL_Rect> rect)
{
  return SDL::LockTextureToSurface(m_resource, rect);
}
 
inline void UnlockTexture(TextureParam texture) { SDL_UnlockTexture(texture); }
 
inline void Texture::Unlock() { SDL::UnlockTexture(m_resource); }
 
inline void SetRenderTarget(RendererParam renderer, TextureParam texture)
{
  CheckError(SDL_SetRenderTarget(renderer, texture));
}
 
inline void Renderer::SetTarget(TextureParam texture)
{
  SDL::SetRenderTarget(m_resource, texture);
}
 
inline void ResetRenderTarget(RendererParam renderer)
{
  SetRenderTarget(renderer, nullptr);
}
 
inline void Renderer::ResetTarget() { SDL::ResetRenderTarget(m_resource); }
 
inline Texture GetRenderTarget(RendererParam renderer)
{
  TextureRaw texture = SDL_GetRenderTarget(renderer);
  if (texture) return Texture::Borrow(texture);
  return {};
}
 
inline Texture Renderer::GetTarget() const
{
  return SDL::GetRenderTarget(m_resource);
}
 
inline void SetRenderLogicalPresentation(RendererParam 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(m_resource, size, mode);
}
 
inline void GetRenderLogicalPresentation(RendererParam renderer,
                                         int* w,
                                         int* h,
                                         RendererLogicalPresentation* mode)
{
  CheckError(SDL_GetRenderLogicalPresentation(renderer, w, h, mode));
}
 
inline void GetRenderLogicalPresentation(RendererParam 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(m_resource, w, h, mode);
}
 
inline void Renderer::GetLogicalPresentation(PointRaw* size,
                                             RendererLogicalPresentation* mode)
{
  SDL::GetRenderLogicalPresentation(m_resource, size, mode);
}
 
inline FRect GetRenderLogicalPresentationRect(RendererParam renderer)
{
  FRect rect;
  CheckError(SDL_GetRenderLogicalPresentationRect(renderer, &rect));
  return rect;
}
 
inline FRect Renderer::GetLogicalPresentationRect() const
{
  return SDL::GetRenderLogicalPresentationRect(m_resource);
}
 
inline FPoint RenderCoordinatesFromWindow(RendererParam 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(m_resource, window_coord);
}
 
inline FPoint RenderCoordinatesToWindow(RendererParam 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(m_resource, coord);
}
 
inline void ConvertEventToRenderCoordinates(RendererParam renderer,
                                            Event* event)
{
  CheckError(SDL_ConvertEventToRenderCoordinates(renderer, event));
}
 
inline void Renderer::ConvertEventToRenderCoordinates(Event* event) const
{
  SDL::ConvertEventToRenderCoordinates(m_resource, event);
}
 
inline void SetRenderViewport(RendererParam renderer,
                              OptionalRef<const RectRaw> rect)
{
  CheckError(SDL_SetRenderViewport(renderer, rect));
}
 
inline void Renderer::SetViewport(OptionalRef<const RectRaw> rect)
{
  SDL::SetRenderViewport(m_resource, rect);
}
 
inline void ResetRenderViewport(RendererParam renderer)
{
  SetRenderViewport(renderer, std::nullopt);
}
 
inline void Renderer::ResetViewport() { SDL::ResetRenderViewport(m_resource); }
 
inline Rect GetRenderViewport(RendererParam renderer)
{
  Rect rect;
  CheckError(SDL_GetRenderViewport(renderer, &rect));
  return rect;
}
 
inline Rect Renderer::GetViewport() const
{
  return SDL::GetRenderViewport(m_resource);
}
 
inline bool RenderViewportSet(RendererParam renderer)
{
  return SDL_RenderViewportSet(renderer);
}
 
inline bool Renderer::ViewportSet() const
{
  return SDL::RenderViewportSet(m_resource);
}
 
inline Rect GetRenderSafeArea(RendererParam renderer)
{
  Rect rect;
  CheckError(SDL_GetRenderSafeArea(renderer, &rect));
  return rect;
}
 
inline Rect Renderer::GetSafeArea() const
{
  return SDL::GetRenderSafeArea(m_resource);
}
 
inline void SetRenderClipRect(RendererParam renderer,
                              OptionalRef<const RectRaw> rect)
{
  CheckError(SDL_SetRenderClipRect(renderer, rect));
}
 
inline void Renderer::SetClipRect(OptionalRef<const RectRaw> rect)
{
  SDL::SetRenderClipRect(m_resource, rect);
}
 
inline void ResetRenderClipRect(RendererParam renderer)
{
  SetRenderClipRect(renderer, std::nullopt);
}
 
inline void Renderer::ResetClipRect() { SDL::ResetRenderClipRect(m_resource); }
 
inline Rect GetRenderClipRect(RendererParam renderer)
{
  Rect rect;
  CheckError(SDL_GetRenderClipRect(renderer, &rect));
  return rect;
}
 
inline Rect Renderer::GetClipRect() const
{
  return SDL::GetRenderClipRect(m_resource);
}
 
inline bool RenderClipEnabled(RendererParam renderer)
{
  return SDL_RenderClipEnabled(renderer);
}
 
inline bool Renderer::IsClipEnabled() const
{
  return SDL::RenderClipEnabled(m_resource);
}
 
inline void SetRenderScale(RendererParam renderer, const FPointRaw& scale)
{
  CheckError(SDL_SetRenderScale(renderer, scale.x, scale.y));
}
 
inline void Renderer::SetScale(const FPointRaw& scale)
{
  SDL::SetRenderScale(m_resource, scale);
}
 
inline void GetRenderScale(RendererParam renderer, float* scaleX, float* scaleY)
{
  CheckError(SDL_GetRenderScale(renderer, scaleX, scaleY));
}
 
inline FPoint GetRenderScale(RendererParam renderer)
{
  FPoint p;
  GetRenderScale(renderer, &p.x, &p.y);
  return p;
}
 
inline void Renderer::GetScale(float* scaleX, float* scaleY) const
{
  SDL::GetRenderScale(m_resource, scaleX, scaleY);
}
 
inline FPoint Renderer::GetScale() const
{
  return SDL::GetRenderScale(m_resource);
}
 
inline void SetRenderDrawColor(RendererParam renderer, ColorRaw c)
{
  CheckError(SDL_SetRenderDrawColor(renderer, c.r, c.g, c.b, c.a));
}
 
inline void Renderer::SetDrawColor(ColorRaw c)
{
  SDL::SetRenderDrawColor(m_resource, c);
}
 
inline void SetRenderDrawColorFloat(RendererParam 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(m_resource, c);
}
 
inline void GetRenderDrawColor(RendererParam renderer,
                               Uint8* r,
                               Uint8* g,
                               Uint8* b,
                               Uint8* a)
{
  CheckError(SDL_GetRenderDrawColor(renderer, r, g, b, a));
}
 
inline Color GetRenderDrawColor(RendererParam 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(m_resource, r, g, b, a);
}
 
inline Color Renderer::GetDrawColor() const
{
  return SDL::GetRenderDrawColor(m_resource);
}
 
inline void GetRenderDrawColorFloat(RendererParam renderer,
                                    float* r,
                                    float* g,
                                    float* b,
                                    float* a)
{
  CheckError(SDL_GetRenderDrawColorFloat(renderer, r, g, b, a));
}
 
inline FColor GetRenderDrawColorFloat(RendererParam 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(m_resource, r, g, b, a);
}
 
inline FColor Renderer::GetDrawColorFloat() const
{
  return SDL::GetRenderDrawColorFloat(m_resource);
}
 
inline void SetRenderColorScale(RendererParam renderer, float scale)
{
  CheckError(SDL_SetRenderColorScale(renderer, scale));
}
 
inline void Renderer::SetColorScale(float scale)
{
  SDL::SetRenderColorScale(m_resource, scale);
}
 
inline float GetRenderColorScale(RendererParam renderer)
{
  float scale;
  CheckError(SDL_GetRenderColorScale(renderer, &scale));
  return scale;
}
 
inline float Renderer::GetColorScale() const
{
  return SDL::GetRenderColorScale(m_resource);
}
 
inline void SetRenderDrawBlendMode(RendererParam renderer, BlendMode blendMode)
{
  CheckError(SDL_SetRenderDrawBlendMode(renderer, blendMode));
}
 
inline void Renderer::SetDrawBlendMode(BlendMode blendMode)
{
  SDL::SetRenderDrawBlendMode(m_resource, blendMode);
}
 
inline BlendMode GetRenderDrawBlendMode(RendererParam renderer)
{
  BlendMode blendMode;
  CheckError(SDL_GetRenderDrawBlendMode(renderer, &blendMode));
  return blendMode;
}
 
inline BlendMode Renderer::GetDrawBlendMode() const
{
  return SDL::GetRenderDrawBlendMode(m_resource);
}
 
inline void RenderClear(RendererParam renderer)
{
  CheckError(SDL_RenderClear(renderer));
}
 
inline void Renderer::RenderClear() { SDL::RenderClear(m_resource); }
 
inline void RenderPoint(RendererParam renderer, const FPointRaw& p)
{
  CheckError(SDL_RenderPoint(renderer, p.x, p.y));
}
 
inline void Renderer::RenderPoint(const FPointRaw& p)
{
  SDL::RenderPoint(m_resource, p);
}
 
inline void RenderPoints(RendererParam renderer,
                         SpanRef<const FPointRaw> points)
{
  CheckError(SDL_RenderPoints(renderer, points.data(), points.size()));
}
 
inline void Renderer::RenderPoints(SpanRef<const FPointRaw> points)
{
  SDL::RenderPoints(m_resource, points);
}
 
inline void RenderLine(RendererParam 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(m_resource, p1, p2);
}
 
inline void RenderLines(RendererParam renderer, SpanRef<const FPointRaw> points)
{
  CheckError(SDL_RenderLines(renderer, points.data(), points.size()));
}
 
inline void Renderer::RenderLines(SpanRef<const FPointRaw> points)
{
  SDL::RenderLines(m_resource, points);
}
 
inline void RenderRect(RendererParam renderer, OptionalRef<const FRectRaw> rect)
{
  CheckError(SDL_RenderRect(renderer, rect));
}
 
inline void Renderer::RenderRect(OptionalRef<const FRectRaw> rect)
{
  SDL::RenderRect(m_resource, rect);
}
 
inline void RenderRects(RendererParam renderer, SpanRef<const FRectRaw> rects)
{
  CheckError(SDL_RenderRects(renderer, rects.data(), rects.size()));
}
 
inline void Renderer::RenderRects(SpanRef<const FRectRaw> rects)
{
  SDL::RenderRects(m_resource, rects);
}
 
inline void RenderFillRect(RendererParam renderer,
                           OptionalRef<const FRectRaw> rect)
{
  CheckError(SDL_RenderFillRect(renderer, rect));
}
 
inline void Renderer::RenderFillRect(OptionalRef<const FRectRaw> rect)
{
  SDL::RenderFillRect(m_resource, rect);
}
 
inline void RenderFillRects(RendererParam renderer,
                            SpanRef<const FRectRaw> rects)
{
  CheckError(SDL_RenderFillRects(renderer, rects.data(), rects.size()));
}
 
inline void Renderer::RenderFillRects(SpanRef<const FRectRaw> rects)
{
  SDL::RenderFillRects(m_resource, rects);
}
 
inline void RenderTexture(RendererParam renderer,
                          TextureParam texture,
                          OptionalRef<const FRectRaw> srcrect,
                          OptionalRef<const FRectRaw> dstrect)
{
  CheckError(SDL_RenderTexture(renderer, texture, srcrect, dstrect));
}
 
inline void Renderer::RenderTexture(TextureParam texture,
                                    OptionalRef<const FRectRaw> srcrect,
                                    OptionalRef<const FRectRaw> dstrect)
{
  SDL::RenderTexture(m_resource, texture, srcrect, dstrect);
}
 
inline void RenderTextureRotated(RendererParam renderer,
                                 TextureParam 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(TextureParam texture,
                                           OptionalRef<const FRectRaw> srcrect,
                                           OptionalRef<const FRectRaw> dstrect,
                                           double angle,
                                           OptionalRef<const FPointRaw> center,
                                           FlipMode flip)
{
  SDL::RenderTextureRotated(
    m_resource, texture, srcrect, dstrect, angle, center, flip);
}
 
inline void RenderTextureAffine(RendererParam renderer,
                                TextureParam 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(TextureParam texture,
                                          OptionalRef<const FRectRaw> srcrect,
                                          OptionalRef<const FPointRaw> origin,
                                          OptionalRef<const FPointRaw> right,
                                          OptionalRef<const FPointRaw> down)
{
  SDL::RenderTextureAffine(m_resource, texture, srcrect, origin, right, down);
}
 
inline void RenderTextureTiled(RendererParam renderer,
                               TextureParam texture,
                               OptionalRef<const FRectRaw> srcrect,
                               float scale,
                               OptionalRef<const FRectRaw> dstrect)
{
  CheckError(
    SDL_RenderTextureTiled(renderer, texture, srcrect, scale, dstrect));
}
 
inline void Renderer::RenderTextureTiled(TextureParam texture,
                                         OptionalRef<const FRectRaw> srcrect,
                                         float scale,
                                         OptionalRef<const FRectRaw> dstrect)
{
  SDL::RenderTextureTiled(m_resource, texture, srcrect, scale, dstrect);
}
 
inline void RenderTexture9Grid(RendererParam renderer,
                               TextureParam 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(TextureParam 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(m_resource,
                          texture,
                          srcrect,
                          left_width,
                          right_width,
                          top_height,
                          bottom_height,
                          scale,
                          dstrect);
}
 
inline void RenderGeometry(RendererParam renderer,
                           TextureParam texture,
                           std::span<const Vertex> vertices,
                           std::span<const int> indices = {})
{
  CheckError(SDL_RenderGeometry(renderer,
                                texture,
                                vertices.data(),
                                vertices.size(),
                                indices.data(),
                                indices.size()));
}
 
inline void Renderer::RenderGeometry(TextureParam texture,
                                     std::span<const Vertex> vertices,
                                     std::span<const int> indices)
{
  SDL::RenderGeometry(m_resource, texture, vertices, indices);
}
 
inline void RenderGeometryRaw(RendererParam renderer,
                              TextureParam 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(TextureParam 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(m_resource,
                         texture,
                         xy,
                         xy_stride,
                         color,
                         color_stride,
                         uv,
                         uv_stride,
                         num_vertices,
                         indices,
                         num_indices,
                         size_indices);
}
 
inline Surface RenderReadPixels(RendererParam renderer,
                                OptionalRef<const RectRaw> rect = {})
{
  return Surface{CheckError(SDL_RenderReadPixels(renderer, rect))};
}
 
inline Surface Renderer::ReadPixels(OptionalRef<const RectRaw> rect) const
{
  return SDL::RenderReadPixels(m_resource, rect);
}
 
inline void RenderPresent(RendererParam renderer)
{
  CheckError(SDL_RenderPresent(renderer));
}
 
inline void Renderer::Present() { SDL::RenderPresent(m_resource); }
 
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(RendererParam renderer)
{
  CheckError(SDL_FlushRenderer(renderer));
}
 
inline void Renderer::Flush() { SDL::FlushRenderer(m_resource); }
 
inline void* GetRenderMetalLayer(RendererParam renderer)
{
  return CheckError(SDL_GetRenderMetalLayer(renderer));
}
 
inline void* Renderer::GetRenderMetalLayer()
{
  return SDL::GetRenderMetalLayer(m_resource);
}
 
inline void* GetRenderMetalCommandEncoder(RendererParam renderer)
{
  return CheckError(SDL_GetRenderMetalCommandEncoder(renderer));
}
 
inline void* Renderer::GetRenderMetalCommandEncoder()
{
  return SDL::GetRenderMetalCommandEncoder(m_resource);
}
 
inline void AddVulkanRenderSemaphores(RendererParam 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(
    m_resource, wait_stage_mask, wait_semaphore, signal_semaphore);
}
 
inline void SetRenderVSync(RendererParam renderer, int vsync)
{
  CheckError(SDL_SetRenderVSync(renderer, vsync));
}
 
inline void Renderer::SetVSync(int vsync)
{
  SDL::SetRenderVSync(m_resource, vsync);
}
 
constexpr int RENDERER_VSYNC_DISABLED = SDL_RENDERER_VSYNC_DISABLED;
 
constexpr int RENDERER_VSYNC_ADAPTIVE = SDL_RENDERER_VSYNC_ADAPTIVE;
 
inline int GetRenderVSync(RendererParam renderer)
{
  int vsync;
  CheckError(SDL_GetRenderVSync(renderer, &vsync));
  return vsync;
}
 
inline int Renderer::GetVSync() const
{
  return SDL::GetRenderVSync(m_resource);
}
 
constexpr int DEBUG_TEXT_FONT_CHARACTER_SIZE =
  SDL_DEBUG_TEXT_FONT_CHARACTER_SIZE;
 
inline void RenderDebugText(RendererParam 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(m_resource, p, std::move(str));
}
 
template<class... ARGS>
inline void RenderDebugTextFormat(RendererParam 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(m_resource, p, fmt, args...);
}
 
 
} // namespace SDL
 
#endif /* SDL3PP_RENDER_H_ */