SDL3pp_video.h

#ifndef SDL3PP_VIDEO_H_
#define SDL3PP_VIDEO_H_
 
#include <SDL3/SDL_video.h>
#include "SDL3pp_properties.h"
#include "SDL3pp_rect.h"
#include "SDL3pp_surface.h"
 
namespace SDL {
 
using DisplayID = SDL_DisplayID;
 
// Forward decl
struct Display;
 
// Forward decl
struct Window;
 
using WindowRaw = SDL_Window*;
 
// Forward decl
struct WindowRef;
 
struct WindowParam
{
  WindowRaw value; 
 
  constexpr WindowParam(WindowRaw value)
    : value(value)
  {
  }
 
  constexpr WindowParam(std::nullptr_t = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const WindowParam& other) const = default;
 
  constexpr operator WindowRaw() const { return value; }
};
 
// Forward decl
struct GLContext;
 
using GLContextRaw = SDL_GLContext;
 
// Forward decl
struct GLContextScoped;
 
struct GLContextParam
{
  GLContextRaw value; 
 
  constexpr GLContextParam(GLContextRaw value)
    : value(value)
  {
  }
 
  constexpr GLContextParam(std::nullptr_t = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const GLContextParam& other) const = default;
 
  constexpr operator GLContextRaw() const { return value; }
};
 
// Forward decl
struct RendererRef;
 
using DisplayOrientation = SDL_DisplayOrientation;
 
constexpr DisplayOrientation ORIENTATION_UNKNOWN =
  SDL_ORIENTATION_UNKNOWN; 
 
constexpr DisplayOrientation ORIENTATION_LANDSCAPE = SDL_ORIENTATION_LANDSCAPE;
 
constexpr DisplayOrientation ORIENTATION_LANDSCAPE_FLIPPED =
  SDL_ORIENTATION_LANDSCAPE_FLIPPED;
 
constexpr DisplayOrientation ORIENTATION_PORTRAIT =
  SDL_ORIENTATION_PORTRAIT; 
 
constexpr DisplayOrientation ORIENTATION_PORTRAIT_FLIPPED =
  SDL_ORIENTATION_PORTRAIT_FLIPPED; 
 
using DisplayMode = SDL_DisplayMode;
 
class Display
{
  DisplayID m_displayID;
 
public:
  constexpr Display(DisplayID displayID = {}) noexcept
    : m_displayID(displayID)
  {
  }
 
  constexpr operator DisplayID() const noexcept { return m_displayID; }
 
  static Display GetPrimary();
 
  static Display GetForPoint(const PointRaw& point);
 
  static Display GetForRect(const RectRaw& rect);
 
  PropertiesRef GetProperties() const;
 
  const char* GetName() const;
 
  Rect GetBounds() const;
 
  Rect GetUsableBounds() const;
 
  DisplayOrientation GetNaturalOrientation() const;
 
  DisplayOrientation GetCurrentOrientation() const;
 
  float GetContentScale() const;
 
  OwnArray<DisplayMode*> GetFullscreenModes() const;
 
  DisplayMode GetClosestFullscreenMode(const PointRaw& size,
                                       float refresh_rate,
                                       bool include_high_density_modes) const;
 
  const DisplayMode& GetDesktopMode() const;
 
  const DisplayMode& GetCurrentMode() const;
};
 
using WindowID = SDL_WindowID;
 
namespace prop::Global {
 
constexpr auto VIDEO_WAYLAND_WL_DISPLAY_POINTER =
  SDL_PROP_GLOBAL_VIDEO_WAYLAND_WL_DISPLAY_POINTER;
 
} // namespace prop::Global
 
using SystemTheme = SDL_SystemTheme;
 
constexpr SystemTheme SYSTEM_THEME_UNKNOWN =
  SDL_SYSTEM_THEME_UNKNOWN; 
 
constexpr SystemTheme SYSTEM_THEME_LIGHT =
  SDL_SYSTEM_THEME_LIGHT; 
 
constexpr SystemTheme SYSTEM_THEME_DARK =
  SDL_SYSTEM_THEME_DARK; 
 
using DisplayModeData = SDL_DisplayModeData;
 
using WindowFlags = Uint64;
 
constexpr WindowFlags WINDOW_FULLSCREEN =
  SDL_WINDOW_FULLSCREEN; 
 
constexpr WindowFlags WINDOW_OPENGL =
  SDL_WINDOW_OPENGL; 
 
constexpr WindowFlags WINDOW_OCCLUDED =
  SDL_WINDOW_OCCLUDED; 
 
constexpr WindowFlags WINDOW_HIDDEN = SDL_WINDOW_HIDDEN;
 
constexpr WindowFlags WINDOW_BORDERLESS =
  SDL_WINDOW_BORDERLESS; 
 
constexpr WindowFlags WINDOW_RESIZABLE =
  SDL_WINDOW_RESIZABLE; 
 
constexpr WindowFlags WINDOW_MINIMIZED =
  SDL_WINDOW_MINIMIZED; 
 
constexpr WindowFlags WINDOW_MAXIMIZED =
  SDL_WINDOW_MAXIMIZED; 
 
constexpr WindowFlags WINDOW_MOUSE_GRABBED =
  SDL_WINDOW_MOUSE_GRABBED; 
 
constexpr WindowFlags WINDOW_INPUT_FOCUS =
  SDL_WINDOW_INPUT_FOCUS; 
 
constexpr WindowFlags WINDOW_MOUSE_FOCUS =
  SDL_WINDOW_MOUSE_FOCUS; 
 
constexpr WindowFlags WINDOW_EXTERNAL =
  SDL_WINDOW_EXTERNAL; 
 
constexpr WindowFlags WINDOW_MODAL = SDL_WINDOW_MODAL; 
 
constexpr WindowFlags WINDOW_HIGH_PIXEL_DENSITY = SDL_WINDOW_HIGH_PIXEL_DENSITY;
 
constexpr WindowFlags WINDOW_MOUSE_CAPTURE = SDL_WINDOW_MOUSE_CAPTURE;
 
constexpr WindowFlags WINDOW_MOUSE_RELATIVE_MODE =
  SDL_WINDOW_MOUSE_RELATIVE_MODE; 
 
constexpr WindowFlags WINDOW_ALWAYS_ON_TOP =
  SDL_WINDOW_ALWAYS_ON_TOP; 
 
constexpr WindowFlags WINDOW_UTILITY = SDL_WINDOW_UTILITY;
 
constexpr WindowFlags WINDOW_TOOLTIP = SDL_WINDOW_TOOLTIP;
 
constexpr WindowFlags WINDOW_POPUP_MENU = SDL_WINDOW_POPUP_MENU;
 
constexpr WindowFlags WINDOW_KEYBOARD_GRABBED =
  SDL_WINDOW_KEYBOARD_GRABBED; 
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr WindowFlags WINDOW_FILL_DOCUMENT = SDL_WINDOW_FILL_DOCUMENT;
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr WindowFlags WINDOW_VULKAN =
  SDL_WINDOW_VULKAN; 
 
constexpr WindowFlags WINDOW_METAL =
  SDL_WINDOW_METAL; 
 
constexpr WindowFlags WINDOW_TRANSPARENT =
  SDL_WINDOW_TRANSPARENT; 
 
constexpr WindowFlags WINDOW_NOT_FOCUSABLE =
  SDL_WINDOW_NOT_FOCUSABLE; 
 
using FlashOperation = SDL_FlashOperation;
 
constexpr FlashOperation FLASH_CANCEL =
  SDL_FLASH_CANCEL; 
 
constexpr FlashOperation FLASH_BRIEFLY =
  SDL_FLASH_BRIEFLY; 
 
constexpr FlashOperation FLASH_UNTIL_FOCUSED =
  SDL_FLASH_UNTIL_FOCUSED; 
 
using HitTestResult = SDL_HitTestResult;
 
constexpr HitTestResult HITTEST_NORMAL =
  SDL_HITTEST_NORMAL; 
 
constexpr HitTestResult HITTEST_DRAGGABLE =
  SDL_HITTEST_DRAGGABLE; 
 
constexpr HitTestResult HITTEST_RESIZE_TOPLEFT =
  SDL_HITTEST_RESIZE_TOPLEFT; 
 
constexpr HitTestResult HITTEST_RESIZE_TOP =
  SDL_HITTEST_RESIZE_TOP; 
 
constexpr HitTestResult HITTEST_RESIZE_TOPRIGHT =
  SDL_HITTEST_RESIZE_TOPRIGHT; 
 
constexpr HitTestResult HITTEST_RESIZE_RIGHT =
  SDL_HITTEST_RESIZE_RIGHT; 
 
constexpr HitTestResult HITTEST_RESIZE_BOTTOMRIGHT =
  SDL_HITTEST_RESIZE_BOTTOMRIGHT;
 
constexpr HitTestResult HITTEST_RESIZE_BOTTOM =
  SDL_HITTEST_RESIZE_BOTTOM; 
 
constexpr HitTestResult HITTEST_RESIZE_BOTTOMLEFT =
  SDL_HITTEST_RESIZE_BOTTOMLEFT; 
 
constexpr HitTestResult HITTEST_RESIZE_LEFT =
  SDL_HITTEST_RESIZE_LEFT; 
 
using HitTest = HitTestResult(SDLCALL*)(WindowRaw win,
                                        const PointRaw* area,
                                        void* data);
 
using HitTestCB =
  MakeTrailingCallback<HitTestResult(WindowRaw win, const PointRaw* area)>;
 
using EGLSurface = SDL_EGLSurface;
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
using ProgressState = SDL_ProgressState;
 
constexpr ProgressState PROGRESS_STATE_INVALID = SDL_PROGRESS_STATE_INVALID;
 
constexpr ProgressState PROGRESS_STATE_NONE =
  SDL_PROGRESS_STATE_NONE; 
 
constexpr ProgressState PROGRESS_STATE_INDETERMINATE =
  SDL_PROGRESS_STATE_INDETERMINATE; 
 
constexpr ProgressState PROGRESS_STATE_NORMAL =
  SDL_PROGRESS_STATE_NORMAL; 
 
constexpr ProgressState PROGRESS_STATE_PAUSED =
  SDL_PROGRESS_STATE_PAUSED; 
 
constexpr ProgressState PROGRESS_STATE_ERROR = SDL_PROGRESS_STATE_ERROR;
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
class Window
{
  WindowRaw m_resource = nullptr;
 
public:
  constexpr Window(std::nullptr_t = nullptr) noexcept
    : m_resource(0)
  {
  }
 
  constexpr explicit Window(const WindowRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
protected:
  constexpr Window(const Window& other) noexcept = default;
 
public:
  constexpr Window(Window&& other) noexcept
    : Window(other.release())
  {
  }
 
  constexpr Window(const WindowRef& other) = delete;
 
  constexpr Window(WindowRef&& other) = delete;
 
  Window(StringParam title,
         const PointRaw& size,
         WindowFlags window_flags,
         RendererRef* renderer);
 
  Window(StringParam title, const PointRaw& size, WindowFlags flags = 0)
    : m_resource(SDL_CreateWindow(title, size.x, size.y, flags))
  {
  }
 
  Window(WindowParam parent,
         const PointRaw& offset,
         const PointRaw& size,
         WindowFlags flags = 0)
    : m_resource(SDL_CreatePopupWindow(parent,
                                       offset.x,
                                       offset.y,
                                       size.x,
                                       size.y,
                                       flags))
  {
  }
 
  Window(PropertiesParam props)
    : m_resource(SDL_CreateWindowWithProperties(props))
  {
  }
 
  ~Window() { SDL_DestroyWindow(m_resource); }
 
  constexpr Window& operator=(Window&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
protected:
  constexpr Window& operator=(const Window& other) noexcept = default;
 
public:
  constexpr WindowRaw get() const noexcept { return m_resource; }
 
  constexpr WindowRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Window& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  constexpr operator WindowParam() const noexcept { return {m_resource}; }
 
  void Destroy();
 
  static WindowRef FromID(WindowID id);
 
  static WindowRef GetGrabbed();
 
  Display GetDisplay() const;
 
  float GetPixelDensity() const;
 
  float GetDisplayScale() const;
 
  void SetFullscreenMode(OptionalRef<const DisplayMode> mode);
 
  const DisplayMode& GetFullscreenMode() const;
 
  OwnPtr<void> GetICCProfile() const;
 
  PixelFormat GetPixelFormat() const;
 
  WindowID GetID() const;
 
  WindowRef GetParent() const;
 
  PropertiesRef GetProperties() const;
 
  WindowFlags GetFlags() const;
 
  void SetTitle(StringParam title);
 
  const char* GetTitle() const;
 
  void SetIcon(SurfaceParam icon);
 
  void SetPosition(const PointRaw& p);
 
  void GetPosition(int* x, int* y) const;
 
  Point GetPosition() const;
 
  void SetSize(const PointRaw& size);
 
  void GetSize(int* w, int* h) const;
 
  Point GetSize() const;
 
  void SetRect(Rect rect);
 
  Rect GetRect() const;
 
  Rect GetSafeArea() const;
 
  void SetAspectRatio(float min_aspect, float max_aspect);
 
  void GetAspectRatio(float* min_aspect, float* max_aspect) const;
 
  void GetBordersSize(int* top, int* left, int* bottom, int* right) const;
 
  void GetSizeInPixels(int* w, int* h) const;
 
  Point GetSizeInPixels() const;
 
  void SetMinimumSize(const PointRaw& p);
 
  void GetMinimumSize(int* w, int* h) const;
 
  void SetMaximumSize(const PointRaw& p);
 
  void GetMaximumSize(int* w, int* h) const;
 
  void SetBordered(bool bordered);
 
  void SetResizable(bool resizable);
 
  void SetAlwaysOnTop(bool on_top);
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
  void SetFillDocument(bool fill);
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
  void Show();
 
  void Hide();
 
  void Raise();
 
  void Maximize();
 
  void Minimize();
 
  void Restore();
 
  void SetFullscreen(bool fullscreen);
 
  void Sync();
 
  bool HasSurface() const;
 
  Surface GetSurface();
 
  void SetSurfaceVSync(int vsync);
 
  int GetSurfaceVSync() const;
 
  void UpdateSurface();
 
  void UpdateSurfaceRects(SpanRef<const RectRaw> rects);
 
  void DestroySurface();
 
  void SetKeyboardGrab(bool grabbed);
 
  void SetMouseGrab(bool grabbed);
 
  bool GetKeyboardGrab() const;
 
  bool GetMouseGrab() const;
 
  void SetMouseRect(const RectRaw& rect);
 
  const RectRaw* GetMouseRect() const;
 
  void SetOpacity(float opacity);
 
  float GetOpacity() const;
 
  void SetParent(WindowParam parent);
 
  void SetModal(bool modal);
 
  void SetFocusable(bool focusable);
 
  void ShowSystemMenu(const PointRaw& p);
 
  void SetHitTest(HitTest callback, void* callback_data);
 
  void SetHitTest(HitTestCB callback);
 
  void SetShape(SurfaceParam shape);
 
  void Flash(FlashOperation operation);
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
  void SetProgressState(ProgressState state);
 
  ProgressState GetProgressState();
 
  void SetProgressValue(float value);
 
  float GetProgressValue();
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
  GLContext CreateGLContext();
 
  void MakeCurrent(GLContext context);
 
  EGLSurface GetEGLSurface();
 
  void GL_Swap();
 
  void StartTextInput();
 
  void StartTextInput(PropertiesParam props);
 
  bool IsTextInputActive() const;
 
  void StopTextInput();
 
  void ClearComposition();
 
  void SetTextInputArea(const RectRaw& rect, int cursor);
 
  void GetTextInputArea(RectRaw* rect, int* cursor);
 
  bool IsScreenKeyboardShown() const;
 
  void WarpMouse(const FPointRaw& p);
 
  void SetRelativeMouseMode(bool enabled);
 
  bool GetRelativeMouseMode() const;
 
  RendererRef GetRenderer() const;
};
 
struct WindowRef : Window
{
  using Window::Window;
 
  WindowRef(WindowParam resource) noexcept
    : Window(resource.value)
  {
  }
 
  WindowRef(WindowRaw resource) noexcept
    : Window(resource)
  {
  }
 
  constexpr WindowRef(const WindowRef& other) noexcept = default;
 
  ~WindowRef() { release(); }
};
 
constexpr int WINDOWPOS_UNDEFINED_MASK = SDL_WINDOWPOS_UNDEFINED_MASK;
 
constexpr int WINDOWPOS_UNDEFINED_DISPLAY(int X)
{
  return SDL_WINDOWPOS_UNDEFINED_DISPLAY(X);
}
 
constexpr int WINDOWPOS_UNDEFINED = SDL_WINDOWPOS_UNDEFINED;
 
constexpr bool WINDOWPOS_ISUNDEFINED(int X)
{
  return SDL_WINDOWPOS_ISUNDEFINED(X);
}
 
constexpr int WINDOWPOS_CENTERED_MASK = SDL_WINDOWPOS_CENTERED_MASK;
 
constexpr int WINDOWPOS_CENTERED_DISPLAY(int X)
{
  return SDL_WINDOWPOS_CENTERED_DISPLAY(X);
}
 
constexpr int WINDOWPOS_CENTERED = SDL_WINDOWPOS_CENTERED;
 
constexpr bool WINDOWPOS_ISCENTERED(int X)
{
  return SDL_WINDOWPOS_ISCENTERED(X);
}
 
class GLContext
{
  GLContextRaw m_resource = nullptr;
 
public:
  constexpr GLContext(std::nullptr_t = nullptr) noexcept
    : m_resource(0)
  {
  }
 
  constexpr GLContext(const GLContextRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
  constexpr GLContext(const GLContext& other) noexcept = default;
 
  constexpr GLContext(GLContext&& other) noexcept
    : GLContext(other.release())
  {
  }
 
  GLContext(WindowParam window)
    : m_resource(SDL_GL_CreateContext(window))
  {
  }
 
  ~GLContext() {}
 
  constexpr GLContext& operator=(GLContext&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  constexpr GLContext& operator=(const GLContext& other) noexcept = default;
 
  constexpr GLContextRaw get() const noexcept { return m_resource; }
 
  constexpr GLContextRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const GLContext& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  constexpr operator GLContextParam() const noexcept { return {m_resource}; }
 
  void Destroy();
 
  void MakeCurrent(WindowParam window);
};
 
struct GLContextScoped : GLContext
{
  using GLContext::GLContext;
 
  constexpr GLContextScoped(const GLContext& other) = delete;
 
  constexpr GLContextScoped(GLContext&& other) noexcept
    : GLContext(other.release())
  {
  }
 
  ~GLContextScoped() { Destroy(); }
};
 
using EGLDisplay = SDL_EGLDisplay;
 
using EGLConfig = SDL_EGLConfig;
 
using EGLAttrib = SDL_EGLAttrib;
 
using EGLint = SDL_EGLint;
 
using EGLAttribArrayCallback = EGLAttrib*(SDLCALL*)(void* userdata);
 
using EGLIntArrayCallback = EGLint*(SDLCALL*)(void* userdata,
                                              EGLDisplay display,
                                              EGLConfig config);
 
using GLAttr = SDL_GLAttr;
 
constexpr GLAttr GL_RED_SIZE = SDL_GL_RED_SIZE;
 
constexpr GLAttr GL_GREEN_SIZE = SDL_GL_GREEN_SIZE;
 
constexpr GLAttr GL_BLUE_SIZE = SDL_GL_BLUE_SIZE;
 
constexpr GLAttr GL_ALPHA_SIZE = SDL_GL_ALPHA_SIZE;
 
constexpr GLAttr GL_BUFFER_SIZE = SDL_GL_BUFFER_SIZE;
 
constexpr GLAttr GL_DOUBLEBUFFER = SDL_GL_DOUBLEBUFFER;
 
constexpr GLAttr GL_DEPTH_SIZE = SDL_GL_DEPTH_SIZE;
 
constexpr GLAttr GL_STENCIL_SIZE = SDL_GL_STENCIL_SIZE;
 
constexpr GLAttr GL_ACCUM_RED_SIZE = SDL_GL_ACCUM_RED_SIZE;
 
constexpr GLAttr GL_ACCUM_GREEN_SIZE = SDL_GL_ACCUM_GREEN_SIZE;
 
constexpr GLAttr GL_ACCUM_BLUE_SIZE = SDL_GL_ACCUM_BLUE_SIZE;
 
constexpr GLAttr GL_ACCUM_ALPHA_SIZE = SDL_GL_ACCUM_ALPHA_SIZE;
 
constexpr GLAttr GL_STEREO =
  SDL_GL_STEREO; 
 
constexpr GLAttr GL_MULTISAMPLEBUFFERS = SDL_GL_MULTISAMPLEBUFFERS;
 
constexpr GLAttr GL_MULTISAMPLESAMPLES = SDL_GL_MULTISAMPLESAMPLES;
 
constexpr GLAttr GL_ACCELERATED_VISUAL = SDL_GL_ACCELERATED_VISUAL;
 
constexpr GLAttr GL_RETAINED_BACKING =
  SDL_GL_RETAINED_BACKING; 
 
constexpr GLAttr GL_CONTEXT_MAJOR_VERSION =
  SDL_GL_CONTEXT_MAJOR_VERSION; 
 
constexpr GLAttr GL_CONTEXT_MINOR_VERSION =
  SDL_GL_CONTEXT_MINOR_VERSION; 
 
constexpr GLAttr GL_CONTEXT_FLAGS = SDL_GL_CONTEXT_FLAGS;
 
constexpr GLAttr GL_CONTEXT_PROFILE_MASK = SDL_GL_CONTEXT_PROFILE_MASK;
 
constexpr GLAttr GL_SHARE_WITH_CURRENT_CONTEXT =
  SDL_GL_SHARE_WITH_CURRENT_CONTEXT; 
 
constexpr GLAttr GL_FRAMEBUFFER_SRGB_CAPABLE = SDL_GL_FRAMEBUFFER_SRGB_CAPABLE;
 
constexpr GLAttr GL_CONTEXT_RELEASE_BEHAVIOR = SDL_GL_CONTEXT_RELEASE_BEHAVIOR;
 
constexpr GLAttr GL_CONTEXT_RESET_NOTIFICATION =
  SDL_GL_CONTEXT_RESET_NOTIFICATION;
 
constexpr GLAttr GL_CONTEXT_NO_ERROR =
  SDL_GL_CONTEXT_NO_ERROR; 
 
constexpr GLAttr GL_FLOATBUFFERS = SDL_GL_FLOATBUFFERS; 
 
constexpr GLAttr GL_EGL_PLATFORM = SDL_GL_EGL_PLATFORM; 
 
using GLProfile = Uint32;
 
constexpr GLProfile GL_CONTEXT_PROFILE_CORE =
  SDL_GL_CONTEXT_PROFILE_CORE; 
 
constexpr GLProfile GL_CONTEXT_PROFILE_COMPATIBILITY =
  SDL_GL_CONTEXT_PROFILE_COMPATIBILITY; 
 
constexpr GLProfile GL_CONTEXT_PROFILE_ES =
  SDL_GL_CONTEXT_PROFILE_ES; 
 
using GLContextFlag = Uint32;
 
constexpr GLContextFlag GL_CONTEXT_DEBUG_FLAG =
  SDL_GL_CONTEXT_DEBUG_FLAG; 
 
constexpr GLContextFlag GL_CONTEXT_FORWARD_COMPATIBLE_FLAG =
  SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG; 
 
constexpr GLContextFlag GL_CONTEXT_ROBUST_ACCESS_FLAG =
  SDL_GL_CONTEXT_ROBUST_ACCESS_FLAG; 
 
constexpr GLContextFlag GL_CONTEXT_RESET_ISOLATION_FLAG =
  SDL_GL_CONTEXT_RESET_ISOLATION_FLAG; 
 
using GLContextReleaseFlag = Uint32;
 
constexpr GLContextReleaseFlag GL_CONTEXT_RELEASE_BEHAVIOR_NONE =
  SDL_GL_CONTEXT_RELEASE_BEHAVIOR_NONE; 
 
constexpr GLContextReleaseFlag GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH =
  SDL_GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH; 
 
using GLContextResetNotification = Uint32;
 
constexpr GLContextResetNotification GL_CONTEXT_RESET_NO_NOTIFICATION =
  SDL_GL_CONTEXT_RESET_NO_NOTIFICATION; 
 
constexpr GLContextResetNotification GL_CONTEXT_RESET_LOSE_CONTEXT =
  SDL_GL_CONTEXT_RESET_LOSE_CONTEXT; 
 
inline int GetNumVideoDrivers() { return SDL_GetNumVideoDrivers(); }
 
inline const char* GetVideoDriver(int index)
{
  return SDL_GetVideoDriver(index);
}
 
inline const char* GetCurrentVideoDriver()
{
  return SDL_GetCurrentVideoDriver();
}
 
inline SystemTheme GetSystemTheme() { return SDL_GetSystemTheme(); }
 
inline OwnArray<DisplayID> GetDisplays()
{
  int count = 0;
  auto data = reinterpret_cast<DisplayID*>(SDL_GetDisplays(&count));
  return OwnArray<DisplayID>{data, size_t(count)};
}
 
inline Display GetPrimaryDisplay()
{
  return CheckError(SDL_GetPrimaryDisplay());
}
 
inline Display Display::GetPrimary() { return SDL::GetPrimaryDisplay(); }
 
inline PropertiesRef GetDisplayProperties(DisplayID displayID)
{
  return {CheckError(SDL_GetDisplayProperties(displayID))};
}
 
inline PropertiesRef Display::GetProperties() const
{
  return SDL::GetDisplayProperties(m_displayID);
}
 
namespace prop::Display {
 
constexpr auto HDR_ENABLED_BOOLEAN = SDL_PROP_DISPLAY_HDR_ENABLED_BOOLEAN;
 
constexpr auto KMSDRM_PANEL_ORIENTATION_NUMBER =
  SDL_PROP_DISPLAY_KMSDRM_PANEL_ORIENTATION_NUMBER;
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto WAYLAND_WL_OUTPUT_POINTER =
  SDL_PROP_DISPLAY_WAYLAND_WL_OUTPUT_POINTER;
 
constexpr auto WINDOWS_HMONITOR_POINTER =
  SDL_PROP_DISPLAY_WINDOWS_HMONITOR_POINTER;
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
} // namespace prop::Display
 
inline const char* GetDisplayName(DisplayID displayID)
{
  return SDL_GetDisplayName(displayID);
}
 
inline const char* Display::GetName() const
{
  return SDL::GetDisplayName(m_displayID);
}
 
inline Rect GetDisplayBounds(Display displayID)
{
  Rect bounds;
  SDL_GetDisplayBounds(displayID, &bounds);
  return bounds;
}
 
inline Rect Display::GetBounds() const
{
  return SDL::GetDisplayBounds(m_displayID);
}
 
inline Rect GetDisplayUsableBounds(Display displayID)
{
  Rect bounds;
  SDL_GetDisplayUsableBounds(displayID, &bounds);
  return bounds;
}
 
inline Rect Display::GetUsableBounds() const
{
  return SDL::GetDisplayUsableBounds(m_displayID);
}
 
inline DisplayOrientation GetNaturalDisplayOrientation(DisplayID displayID)
{
  return SDL_GetNaturalDisplayOrientation(displayID);
}
 
inline DisplayOrientation Display::GetNaturalOrientation() const
{
  return SDL::GetNaturalDisplayOrientation(m_displayID);
}
 
inline DisplayOrientation GetCurrentDisplayOrientation(DisplayID displayID)
{
  return SDL_GetCurrentDisplayOrientation(displayID);
}
 
inline DisplayOrientation Display::GetCurrentOrientation() const
{
  return SDL::GetCurrentDisplayOrientation(m_displayID);
}
 
inline float GetDisplayContentScale(DisplayID displayID)
{
  return SDL_GetDisplayContentScale(displayID);
}
 
inline float Display::GetContentScale() const
{
  return SDL::GetDisplayContentScale(m_displayID);
}
 
inline OwnArray<DisplayMode*> GetFullscreenDisplayModes(Display displayID)
{
  int count = 0;
  auto data = CheckError(SDL_GetFullscreenDisplayModes(displayID, &count));
  return OwnArray<DisplayMode*>{data, size_t(count)};
}
 
inline OwnArray<DisplayMode*> Display::GetFullscreenModes() const
{
  return SDL::GetFullscreenDisplayModes(m_displayID);
}
 
inline DisplayMode GetClosestFullscreenDisplayMode(
  Display displayID,
  const PointRaw& size,
  float refresh_rate,
  bool include_high_density_modes)
{
  DisplayMode mode;
  CheckError(SDL_GetClosestFullscreenDisplayMode(displayID,
                                                 size.x,
                                                 size.y,
                                                 refresh_rate,
                                                 include_high_density_modes,
                                                 &mode));
  return mode;
}
 
inline DisplayMode Display::GetClosestFullscreenMode(
  const PointRaw& size,
  float refresh_rate,
  bool include_high_density_modes) const
{
  return SDL::GetClosestFullscreenDisplayMode(
    m_displayID, size, refresh_rate, include_high_density_modes);
}
 
inline const DisplayMode& GetDesktopDisplayMode(DisplayID displayID)
{
  return *SDL_GetDesktopDisplayMode(displayID);
}
 
inline const DisplayMode& Display::GetDesktopMode() const
{
  return SDL::GetDesktopDisplayMode(m_displayID);
}
 
inline const DisplayMode& GetCurrentDisplayMode(DisplayID displayID)
{
  return *SDL_GetCurrentDisplayMode(displayID);
}
 
inline const DisplayMode& Display::GetCurrentMode() const
{
  return SDL::GetCurrentDisplayMode(m_displayID);
}
 
inline Display GetDisplayForPoint(const PointRaw& point)
{
  return SDL_GetDisplayForPoint(&point);
}
 
inline Display Display::GetForPoint(const PointRaw& point)
{
  return SDL::GetDisplayForPoint(point);
}
 
inline Display GetDisplayForRect(const RectRaw& rect)
{
  return CheckError(SDL_GetDisplayForRect(&rect));
}
 
inline Display Display::GetForRect(const RectRaw& rect)
{
  return SDL::GetDisplayForRect(rect);
}
 
inline Display GetDisplayForWindow(WindowParam window)
{
  return CheckError(SDL_GetDisplayForWindow(window));
}
 
inline Display Window::GetDisplay() const
{
  return SDL::GetDisplayForWindow(m_resource);
}
 
inline float GetWindowPixelDensity(WindowParam window)
{
  return SDL_GetWindowPixelDensity(window);
}
 
inline float Window::GetPixelDensity() const
{
  return SDL::GetWindowPixelDensity(m_resource);
}
 
inline float GetWindowDisplayScale(WindowParam window)
{
  return SDL_GetWindowDisplayScale(window);
}
 
inline float Window::GetDisplayScale() const
{
  return SDL::GetWindowDisplayScale(m_resource);
}
 
inline void SetWindowFullscreenMode(WindowParam window,
                                    OptionalRef<const DisplayMode> mode)
{
  CheckError(SDL_SetWindowFullscreenMode(window, mode));
}
 
inline void Window::SetFullscreenMode(OptionalRef<const DisplayMode> mode)
{
  SDL::SetWindowFullscreenMode(m_resource, mode);
}
 
inline const DisplayMode& GetWindowFullscreenMode(WindowParam window)
{
  return *SDL_GetWindowFullscreenMode(window);
}
 
inline const DisplayMode& Window::GetFullscreenMode() const
{
  return SDL::GetWindowFullscreenMode(m_resource);
}
 
inline OwnPtr<void> GetWindowICCProfile(WindowParam window)
{
  size_t size;
  return OwnPtr<void>{CheckError(SDL_GetWindowICCProfile(window, &size))};
}
 
inline OwnPtr<void> Window::GetICCProfile() const
{
  return SDL::GetWindowICCProfile(m_resource);
}
 
inline PixelFormat GetWindowPixelFormat(WindowParam window)
{
  return CheckError(SDL_GetWindowPixelFormat(window));
}
 
inline PixelFormat Window::GetPixelFormat() const
{
  return SDL::GetWindowPixelFormat(m_resource);
}
 
inline OwnArray<WindowRef> GetWindows()
{
  int count = 0;
  auto data = CheckError(SDL_GetWindows(&count));
  return OwnArray<WindowRef>{reinterpret_cast<WindowRef*>(data), size_t(count)};
}
 
inline Window CreateWindow(StringParam title,
                           const PointRaw& size,
                           WindowFlags flags)
{
  return Window(std::move(title), size, flags);
}
 
inline Window CreatePopupWindow(WindowParam parent,
                                const PointRaw& offset,
                                const PointRaw& size,
                                WindowFlags flags)
{
  return Window(parent, offset, size, flags);
}
 
inline Window CreateWindowWithProperties(PropertiesParam props)
{
  return Window(props);
}
 
namespace prop::Window {
 
constexpr auto CREATE_ALWAYS_ON_TOP_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_ALWAYS_ON_TOP_BOOLEAN;
 
constexpr auto CREATE_BORDERLESS_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_BORDERLESS_BOOLEAN;
 
#if SDL_VERSION_ATLEAST(3, 2, 18)
 
constexpr auto CREATE_CONSTRAIN_POPUP_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_CONSTRAIN_POPUP_BOOLEAN;
 
#endif // SDL_VERSION_ATLEAST(3, 2, 18)
 
constexpr auto CREATE_FOCUSABLE_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_FOCUSABLE_BOOLEAN;
 
constexpr auto CREATE_EXTERNAL_GRAPHICS_CONTEXT_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_EXTERNAL_GRAPHICS_CONTEXT_BOOLEAN;
 
constexpr auto CREATE_FLAGS_NUMBER = SDL_PROP_WINDOW_CREATE_FLAGS_NUMBER;
 
constexpr auto CREATE_FULLSCREEN_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_FULLSCREEN_BOOLEAN;
 
constexpr auto CREATE_HEIGHT_NUMBER = SDL_PROP_WINDOW_CREATE_HEIGHT_NUMBER;
 
constexpr auto CREATE_HIDDEN_BOOLEAN = SDL_PROP_WINDOW_CREATE_HIDDEN_BOOLEAN;
 
constexpr auto CREATE_HIGH_PIXEL_DENSITY_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_HIGH_PIXEL_DENSITY_BOOLEAN;
 
constexpr auto CREATE_MAXIMIZED_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_MAXIMIZED_BOOLEAN;
 
constexpr auto CREATE_MENU_BOOLEAN = SDL_PROP_WINDOW_CREATE_MENU_BOOLEAN;
 
constexpr auto CREATE_METAL_BOOLEAN = SDL_PROP_WINDOW_CREATE_METAL_BOOLEAN;
 
constexpr auto CREATE_MINIMIZED_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_MINIMIZED_BOOLEAN;
 
constexpr auto CREATE_MODAL_BOOLEAN = SDL_PROP_WINDOW_CREATE_MODAL_BOOLEAN;
 
constexpr auto CREATE_MOUSE_GRABBED_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_MOUSE_GRABBED_BOOLEAN;
 
constexpr auto CREATE_OPENGL_BOOLEAN = SDL_PROP_WINDOW_CREATE_OPENGL_BOOLEAN;
 
constexpr auto CREATE_PARENT_POINTER = SDL_PROP_WINDOW_CREATE_PARENT_POINTER;
 
constexpr auto CREATE_RESIZABLE_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_RESIZABLE_BOOLEAN;
 
constexpr auto CREATE_TITLE_STRING = SDL_PROP_WINDOW_CREATE_TITLE_STRING;
 
constexpr auto CREATE_TRANSPARENT_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_TRANSPARENT_BOOLEAN;
 
constexpr auto CREATE_TOOLTIP_BOOLEAN = SDL_PROP_WINDOW_CREATE_TOOLTIP_BOOLEAN;
 
constexpr auto CREATE_UTILITY_BOOLEAN = SDL_PROP_WINDOW_CREATE_UTILITY_BOOLEAN;
 
constexpr auto CREATE_VULKAN_BOOLEAN = SDL_PROP_WINDOW_CREATE_VULKAN_BOOLEAN;
 
constexpr auto CREATE_WIDTH_NUMBER = SDL_PROP_WINDOW_CREATE_WIDTH_NUMBER;
 
constexpr auto CREATE_X_NUMBER = SDL_PROP_WINDOW_CREATE_X_NUMBER;
 
constexpr auto CREATE_Y_NUMBER = SDL_PROP_WINDOW_CREATE_Y_NUMBER;
 
constexpr auto CREATE_COCOA_WINDOW_POINTER =
  SDL_PROP_WINDOW_CREATE_COCOA_WINDOW_POINTER;
 
constexpr auto CREATE_COCOA_VIEW_POINTER =
  SDL_PROP_WINDOW_CREATE_COCOA_VIEW_POINTER;
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto CREATE_WINDOWSCENE_POINTER =
  SDL_PROP_WINDOW_CREATE_WINDOWSCENE_POINTER;
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto CREATE_WAYLAND_SURFACE_ROLE_CUSTOM_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_WAYLAND_SURFACE_ROLE_CUSTOM_BOOLEAN;
 
constexpr auto CREATE_WAYLAND_CREATE_EGL_WINDOW_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_WAYLAND_CREATE_EGL_WINDOW_BOOLEAN;
 
constexpr auto CREATE_WAYLAND_WL_SURFACE_POINTER =
  SDL_PROP_WINDOW_CREATE_WAYLAND_WL_SURFACE_POINTER;
 
constexpr auto CREATE_WIN32_HWND_POINTER =
  SDL_PROP_WINDOW_CREATE_WIN32_HWND_POINTER;
 
constexpr auto CREATE_WIN32_PIXEL_FORMAT_HWND_POINTER =
  SDL_PROP_WINDOW_CREATE_WIN32_PIXEL_FORMAT_HWND_POINTER;
 
constexpr auto CREATE_X11_WINDOW_NUMBER =
  SDL_PROP_WINDOW_CREATE_X11_WINDOW_NUMBER;
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto CREATE_EMSCRIPTEN_CANVAS_ID_STRING =
  SDL_PROP_WINDOW_CREATE_EMSCRIPTEN_CANVAS_ID_STRING;
 
constexpr auto CREATE_EMSCRIPTEN_KEYBOARD_ELEMENT_STRING =
  SDL_PROP_WINDOW_CREATE_EMSCRIPTEN_KEYBOARD_ELEMENT_STRING;
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto SHAPE_POINTER = SDL_PROP_WINDOW_SHAPE_POINTER;
 
constexpr auto HDR_ENABLED_BOOLEAN = SDL_PROP_WINDOW_HDR_ENABLED_BOOLEAN;
 
constexpr auto SDR_WHITE_LEVEL_FLOAT = SDL_PROP_WINDOW_SDR_WHITE_LEVEL_FLOAT;
 
constexpr auto HDR_HEADROOM_FLOAT = SDL_PROP_WINDOW_HDR_HEADROOM_FLOAT;
 
constexpr auto ANDROID_WINDOW_POINTER = SDL_PROP_WINDOW_ANDROID_WINDOW_POINTER;
 
constexpr auto ANDROID_SURFACE_POINTER =
  SDL_PROP_WINDOW_ANDROID_SURFACE_POINTER;
 
constexpr auto UIKIT_WINDOW_POINTER = SDL_PROP_WINDOW_UIKIT_WINDOW_POINTER;
 
constexpr auto UIKIT_METAL_VIEW_TAG_NUMBER =
  SDL_PROP_WINDOW_UIKIT_METAL_VIEW_TAG_NUMBER;
 
constexpr auto UIKIT_OPENGL_FRAMEBUFFER_NUMBER =
  SDL_PROP_WINDOW_UIKIT_OPENGL_FRAMEBUFFER_NUMBER;
 
constexpr auto UIKIT_OPENGL_RENDERBUFFER_NUMBER =
  SDL_PROP_WINDOW_UIKIT_OPENGL_RENDERBUFFER_NUMBER;
 
constexpr auto UIKIT_OPENGL_RESOLVE_FRAMEBUFFER_NUMBER =
  SDL_PROP_WINDOW_UIKIT_OPENGL_RESOLVE_FRAMEBUFFER_NUMBER;
 
constexpr auto KMSDRM_DEVICE_INDEX_NUMBER =
  SDL_PROP_WINDOW_KMSDRM_DEVICE_INDEX_NUMBER;
 
constexpr auto KMSDRM_DRM_FD_NUMBER = SDL_PROP_WINDOW_KMSDRM_DRM_FD_NUMBER;
 
constexpr auto KMSDRM_GBM_DEVICE_POINTER =
  SDL_PROP_WINDOW_KMSDRM_GBM_DEVICE_POINTER;
 
constexpr auto COCOA_WINDOW_POINTER = SDL_PROP_WINDOW_COCOA_WINDOW_POINTER;
 
constexpr auto COCOA_METAL_VIEW_TAG_NUMBER =
  SDL_PROP_WINDOW_COCOA_METAL_VIEW_TAG_NUMBER;
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto OPENVR_OVERLAY_ID_NUMBER =
  SDL_PROP_WINDOW_OPENVR_OVERLAY_ID_NUMBER;
 
#else
 
constexpr auto OPENVR_OVERLAY_ID_NUMBER = SDL_PROP_WINDOW_OPENVR_OVERLAY_ID;
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto VIVANTE_DISPLAY_POINTER =
  SDL_PROP_WINDOW_VIVANTE_DISPLAY_POINTER;
 
constexpr auto VIVANTE_WINDOW_POINTER = SDL_PROP_WINDOW_VIVANTE_WINDOW_POINTER;
 
constexpr auto VIVANTE_SURFACE_POINTER =
  SDL_PROP_WINDOW_VIVANTE_SURFACE_POINTER;
 
constexpr auto WIN32_HWND_POINTER = SDL_PROP_WINDOW_WIN32_HWND_POINTER;
 
constexpr auto WIN32_HDC_POINTER = SDL_PROP_WINDOW_WIN32_HDC_POINTER;
 
constexpr auto WIN32_INSTANCE_POINTER = SDL_PROP_WINDOW_WIN32_INSTANCE_POINTER;
 
constexpr auto WAYLAND_DISPLAY_POINTER =
  SDL_PROP_WINDOW_WAYLAND_DISPLAY_POINTER;
 
constexpr auto WAYLAND_SURFACE_POINTER =
  SDL_PROP_WINDOW_WAYLAND_SURFACE_POINTER;
 
constexpr auto WAYLAND_VIEWPORT_POINTER =
  SDL_PROP_WINDOW_WAYLAND_VIEWPORT_POINTER;
 
constexpr auto WAYLAND_EGL_WINDOW_POINTER =
  SDL_PROP_WINDOW_WAYLAND_EGL_WINDOW_POINTER;
 
constexpr auto WAYLAND_XDG_SURFACE_POINTER =
  SDL_PROP_WINDOW_WAYLAND_XDG_SURFACE_POINTER;
 
constexpr auto WAYLAND_XDG_TOPLEVEL_POINTER =
  SDL_PROP_WINDOW_WAYLAND_XDG_TOPLEVEL_POINTER;
 
constexpr auto WAYLAND_XDG_TOPLEVEL_EXPORT_HANDLE_STRING =
  SDL_PROP_WINDOW_WAYLAND_XDG_TOPLEVEL_EXPORT_HANDLE_STRING;
 
constexpr auto WAYLAND_XDG_POPUP_POINTER =
  SDL_PROP_WINDOW_WAYLAND_XDG_POPUP_POINTER;
 
constexpr auto WAYLAND_XDG_POSITIONER_POINTER =
  SDL_PROP_WINDOW_WAYLAND_XDG_POSITIONER_POINTER;
 
constexpr auto X11_DISPLAY_POINTER = SDL_PROP_WINDOW_X11_DISPLAY_POINTER;
 
constexpr auto X11_SCREEN_NUMBER = SDL_PROP_WINDOW_X11_SCREEN_NUMBER;
 
constexpr auto X11_WINDOW_NUMBER = SDL_PROP_WINDOW_X11_WINDOW_NUMBER;
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto EMSCRIPTEN_CANVAS_ID_STRING =
  SDL_PROP_WINDOW_EMSCRIPTEN_CANVAS_ID_STRING;
 
constexpr auto EMSCRIPTEN_KEYBOARD_ELEMENT_STRING =
  SDL_PROP_WINDOW_EMSCRIPTEN_KEYBOARD_ELEMENT_STRING;
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
} // namespace prop::Window
 
inline WindowID GetWindowID(WindowParam window)
{
  return CheckError(SDL_GetWindowID(window));
}
 
inline WindowID Window::GetID() const { return SDL::GetWindowID(m_resource); }
 
inline WindowRef GetWindowFromID(WindowID id)
{
  return {SDL_GetWindowFromID(id)};
}
 
inline WindowRef Window::FromID(WindowID id)
{
  return SDL::GetWindowFromID(id);
}
 
inline WindowRef GetWindowParent(WindowParam window)
{
  return {CheckError(SDL_GetWindowParent(window))};
}
 
inline WindowRef Window::GetParent() const
{
  return SDL::GetWindowParent(m_resource);
}
 
inline PropertiesRef GetWindowProperties(WindowParam window)
{
  return {CheckError(SDL_GetWindowProperties(window))};
}
 
inline PropertiesRef Window::GetProperties() const
{
  return SDL::GetWindowProperties(m_resource);
}
 
inline WindowFlags GetWindowFlags(WindowParam window)
{
  return SDL_GetWindowFlags(window);
}
 
inline WindowFlags Window::GetFlags() const
{
  return SDL::GetWindowFlags(m_resource);
}
 
inline void SetWindowTitle(WindowParam window, StringParam title)
{
  CheckError(SDL_SetWindowTitle(window, title));
}
 
inline void Window::SetTitle(StringParam title)
{
  SDL::SetWindowTitle(m_resource, std::move(title));
}
 
inline const char* GetWindowTitle(WindowParam window)
{
  return SDL_GetWindowTitle(window);
}
 
inline const char* Window::GetTitle() const
{
  return SDL::GetWindowTitle(m_resource);
}
 
inline void SetWindowIcon(WindowParam window, SurfaceParam icon)
{
  CheckError(SDL_SetWindowIcon(window, icon));
}
 
inline void Window::SetIcon(SurfaceParam icon)
{
  SDL::SetWindowIcon(m_resource, icon);
}
 
inline void SetWindowPosition(WindowParam window, const PointRaw& p)
{
  CheckError(SDL_SetWindowPosition(window, p.x, p.y));
}
 
inline void Window::SetPosition(const PointRaw& p)
{
  SDL::SetWindowPosition(m_resource, p);
}
 
inline void GetWindowPosition(WindowParam window, int* x, int* y)
{
  CheckError(SDL_GetWindowPosition(window, x, y));
}
 
inline Point GetWindowPosition(WindowParam window)
{
  Point p;
  GetWindowPosition(window, &p.x, &p.y);
  return p;
}
 
inline void Window::GetPosition(int* x, int* y) const
{
  SDL::GetWindowPosition(m_resource, x, y);
}
 
inline Point Window::GetPosition() const
{
  return SDL::GetWindowPosition(m_resource);
}
 
inline void SetWindowSize(WindowParam window, const PointRaw& size)
{
  CheckError(SDL_SetWindowSize(window, size.x, size.y));
}
 
inline void Window::SetSize(const PointRaw& size)
{
  SDL::SetWindowSize(m_resource, size);
}
 
inline void GetWindowSize(WindowParam window, int* w, int* h)
{
  CheckError(SDL_GetWindowSize(window, w, h));
}
 
inline Point GetWindowSize(WindowParam window)
{
  Point p;
  GetWindowSize(window, &p.x, &p.y);
  return p;
}
 
inline void Window::GetSize(int* w, int* h) const
{
  SDL::GetWindowSize(m_resource, w, h);
}
 
inline Point Window::GetSize() const { return SDL::GetWindowSize(m_resource); }
 
inline void SetWindowRect(WindowParam window, Rect rect)
{
  SetWindowPosition(window, rect.GetTopLeft());
  SetWindowSize(window, rect.GetSize());
}
 
inline void Window::SetRect(Rect rect) { SDL::SetWindowRect(m_resource, rect); }
 
inline Rect GetWindowRect(WindowParam window)
{
  return Rect{GetWindowPosition(window), GetWindowSize(window)};
}
 
inline Rect Window::GetRect() const { return SDL::GetWindowRect(m_resource); }
 
inline Rect GetWindowSafeArea(WindowParam window)
{
  Rect rect;
  CheckError(SDL_GetWindowSafeArea(window, &rect));
  return rect;
}
 
inline Rect Window::GetSafeArea() const
{
  return SDL::GetWindowSafeArea(m_resource);
}
 
inline void SetWindowAspectRatio(WindowParam window,
                                 float min_aspect,
                                 float max_aspect)
{
  CheckError(SDL_SetWindowAspectRatio(window, min_aspect, max_aspect));
}
 
inline void Window::SetAspectRatio(float min_aspect, float max_aspect)
{
  SDL::SetWindowAspectRatio(m_resource, min_aspect, max_aspect);
}
 
inline void GetWindowAspectRatio(WindowParam window,
                                 float* min_aspect,
                                 float* max_aspect)
{
  CheckError(SDL_GetWindowAspectRatio(window, min_aspect, max_aspect));
}
 
inline void Window::GetAspectRatio(float* min_aspect, float* max_aspect) const
{
  SDL::GetWindowAspectRatio(m_resource, min_aspect, max_aspect);
}
 
inline void GetWindowBordersSize(WindowParam window,
                                 int* top,
                                 int* left,
                                 int* bottom,
                                 int* right)
{
  CheckError(SDL_GetWindowBordersSize(window, top, left, bottom, right));
}
 
inline void Window::GetBordersSize(int* top,
                                   int* left,
                                   int* bottom,
                                   int* right) const
{
  SDL::GetWindowBordersSize(m_resource, top, left, bottom, right);
}
 
inline void GetWindowSizeInPixels(WindowParam window, int* w, int* h)
{
  CheckError(SDL_GetWindowSizeInPixels(window, w, h));
}
 
inline Point GetWindowSizeInPixels(WindowParam window)
{
  Point p;
  GetWindowSizeInPixels(window, &p.x, &p.y);
  return p;
}
 
inline void Window::GetSizeInPixels(int* w, int* h) const
{
  SDL::GetWindowSizeInPixels(m_resource, w, h);
}
 
inline Point Window::GetSizeInPixels() const
{
  return SDL::GetWindowSizeInPixels(m_resource);
}
 
inline void SetWindowMinimumSize(WindowParam window, const PointRaw& p)
{
  CheckError(SDL_SetWindowMinimumSize(window, p.x, p.y));
}
 
inline void Window::SetMinimumSize(const PointRaw& p)
{
  SDL::SetWindowMinimumSize(m_resource, p);
}
 
inline void GetWindowMinimumSize(WindowParam window, int* w, int* h)
{
  CheckError(SDL_GetWindowMinimumSize(window, w, h));
}
 
inline void Window::GetMinimumSize(int* w, int* h) const
{
  SDL::GetWindowMinimumSize(m_resource, w, h);
}
 
inline void SetWindowMaximumSize(WindowParam window, const PointRaw& p)
{
  CheckError(SDL_SetWindowMaximumSize(window, p.x, p.y));
}
 
inline void Window::SetMaximumSize(const PointRaw& p)
{
  SDL::SetWindowMaximumSize(m_resource, p);
}
 
inline void GetWindowMaximumSize(WindowParam window, int* w, int* h)
{
  CheckError(SDL_GetWindowMaximumSize(window, w, h));
}
 
inline void Window::GetMaximumSize(int* w, int* h) const
{
  SDL::GetWindowMaximumSize(m_resource, w, h);
}
 
inline void SetWindowBordered(WindowParam window, bool bordered)
{
  CheckError(SDL_SetWindowBordered(window, bordered));
}
 
inline void Window::SetBordered(bool bordered)
{
  SDL::SetWindowBordered(m_resource, bordered);
}
 
inline void SetWindowResizable(WindowParam window, bool resizable)
{
  CheckError(SDL_SetWindowResizable(window, resizable));
}
 
inline void Window::SetResizable(bool resizable)
{
  SDL::SetWindowResizable(m_resource, resizable);
}
 
inline void SetWindowAlwaysOnTop(WindowParam window, bool on_top)
{
  CheckError(SDL_SetWindowAlwaysOnTop(window, on_top));
}
 
inline void Window::SetAlwaysOnTop(bool on_top)
{
  SDL::SetWindowAlwaysOnTop(m_resource, on_top);
}
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
inline void SetWindowFillDocument(WindowParam window, bool fill)
{
  CheckError(SDL_SetWindowFillDocument(window, fill));
}
 
inline void Window::SetFillDocument(bool fill)
{
  SDL::SetWindowFillDocument(m_resource, fill);
}
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
inline void ShowWindow(WindowParam window)
{
  CheckError(SDL_ShowWindow(window));
}
 
inline void Window::Show() { SDL::ShowWindow(m_resource); }
 
inline void HideWindow(WindowParam window)
{
  CheckError(SDL_HideWindow(window));
}
 
inline void Window::Hide() { SDL::HideWindow(m_resource); }
 
inline void RaiseWindow(WindowParam window)
{
  CheckError(SDL_RaiseWindow(window));
}
 
inline void Window::Raise() { SDL::RaiseWindow(m_resource); }
 
inline void MaximizeWindow(WindowParam window)
{
  CheckError(SDL_MaximizeWindow(window));
}
 
inline void Window::Maximize() { SDL::MaximizeWindow(m_resource); }
 
inline void MinimizeWindow(WindowParam window)
{
  CheckError(SDL_MinimizeWindow(window));
}
 
inline void Window::Minimize() { SDL::MinimizeWindow(m_resource); }
 
inline void RestoreWindow(WindowParam window)
{
  CheckError(SDL_RestoreWindow(window));
}
 
inline void Window::Restore() { SDL::RestoreWindow(m_resource); }
 
inline void SetWindowFullscreen(WindowParam window, bool fullscreen)
{
  CheckError(SDL_SetWindowFullscreen(window, fullscreen));
}
 
inline void Window::SetFullscreen(bool fullscreen)
{
  SDL::SetWindowFullscreen(m_resource, fullscreen);
}
 
inline void SyncWindow(WindowParam window)
{
  CheckError(SDL_SyncWindow(window));
}
 
inline void Window::Sync() { SDL::SyncWindow(m_resource); }
 
inline bool WindowHasSurface(WindowParam window)
{
  return SDL_WindowHasSurface(window);
}
 
inline bool Window::HasSurface() const
{
  return SDL::WindowHasSurface(m_resource);
}
 
inline Surface GetWindowSurface(WindowParam window)
{
  return Surface::Borrow(SDL_GetWindowSurface(window));
}
 
inline Surface Window::GetSurface()
{
  return SDL::GetWindowSurface(m_resource);
}
 
inline void SetWindowSurfaceVSync(WindowParam window, int vsync)
{
  CheckError(SDL_SetWindowSurfaceVSync(window, vsync));
}
 
inline void Window::SetSurfaceVSync(int vsync)
{
  SDL::SetWindowSurfaceVSync(m_resource, vsync);
}
 
constexpr int WINDOW_SURFACE_VSYNC_DISABLED = SDL_WINDOW_SURFACE_VSYNC_DISABLED;
 
constexpr int WINDOW_SURFACE_VSYNC_ADAPTIVE = SDL_WINDOW_SURFACE_VSYNC_ADAPTIVE;
 
inline int GetWindowSurfaceVSync(WindowParam window)
{
  int vsync;
  CheckError(SDL_GetWindowSurfaceVSync(window, &vsync));
  return vsync;
}
 
inline int Window::GetSurfaceVSync() const
{
  return SDL::GetWindowSurfaceVSync(m_resource);
}
 
inline void UpdateWindowSurface(WindowParam window)
{
  CheckError(SDL_UpdateWindowSurface(window));
}
 
inline void Window::UpdateSurface() { SDL::UpdateWindowSurface(m_resource); }
 
inline void UpdateWindowSurfaceRects(WindowParam window,
                                     SpanRef<const RectRaw> rects)
{
  CheckError(SDL_UpdateWindowSurfaceRects(window, rects.data(), rects.size()));
}
 
inline void Window::UpdateSurfaceRects(SpanRef<const RectRaw> rects)
{
  SDL::UpdateWindowSurfaceRects(m_resource, rects);
}
 
inline void DestroyWindowSurface(WindowParam window)
{
  CheckError(SDL_DestroyWindowSurface(window));
}
 
inline void Window::DestroySurface() { SDL::DestroyWindowSurface(m_resource); }
 
inline void SetWindowKeyboardGrab(WindowParam window, bool grabbed)
{
  CheckError(SDL_SetWindowKeyboardGrab(window, grabbed));
}
 
inline void Window::SetKeyboardGrab(bool grabbed)
{
  SDL::SetWindowKeyboardGrab(m_resource, grabbed);
}
 
inline void SetWindowMouseGrab(WindowParam window, bool grabbed)
{
  CheckError(SDL_SetWindowMouseGrab(window, grabbed));
}
 
inline void Window::SetMouseGrab(bool grabbed)
{
  SDL::SetWindowMouseGrab(m_resource, grabbed);
}
 
inline bool GetWindowKeyboardGrab(WindowParam window)
{
  return SDL_GetWindowKeyboardGrab(window);
}
 
inline bool Window::GetKeyboardGrab() const
{
  return SDL::GetWindowKeyboardGrab(m_resource);
}
 
inline bool GetWindowMouseGrab(WindowParam window)
{
  return SDL_GetWindowMouseGrab(window);
}
 
inline bool Window::GetMouseGrab() const
{
  return SDL::GetWindowMouseGrab(m_resource);
}
 
inline WindowRef GetGrabbedWindow() { return {SDL_GetGrabbedWindow()}; }
 
inline WindowRef Window::GetGrabbed() { return SDL::GetGrabbedWindow(); }
 
inline void SetWindowMouseRect(WindowParam window, const RectRaw& rect)
{
  CheckError(SDL_SetWindowMouseRect(window, &rect));
}
 
inline void Window::SetMouseRect(const RectRaw& rect)
{
  SDL::SetWindowMouseRect(m_resource, rect);
}
 
inline const RectRaw* GetWindowMouseRect(WindowParam window)
{
  return SDL_GetWindowMouseRect(window);
}
 
inline const RectRaw* Window::GetMouseRect() const
{
  return SDL::GetWindowMouseRect(m_resource);
}
 
inline void SetWindowOpacity(WindowParam window, float opacity)
{
  CheckError(SDL_SetWindowOpacity(window, opacity));
}
 
inline void Window::SetOpacity(float opacity)
{
  SDL::SetWindowOpacity(m_resource, opacity);
}
 
inline float GetWindowOpacity(WindowParam window)
{
  return SDL_GetWindowOpacity(window);
}
 
inline float Window::GetOpacity() const
{
  return SDL::GetWindowOpacity(m_resource);
}
 
inline void SetWindowParent(WindowParam window, WindowParam parent)
{
  CheckError(SDL_SetWindowParent(window, parent));
}
 
inline void Window::SetParent(WindowParam parent)
{
  SDL::SetWindowParent(m_resource, parent);
}
 
inline void SetWindowModal(WindowParam window, bool modal)
{
  CheckError(SDL_SetWindowModal(window, modal));
}
 
inline void Window::SetModal(bool modal)
{
  SDL::SetWindowModal(m_resource, modal);
}
 
inline void SetWindowFocusable(WindowParam window, bool focusable)
{
  CheckError(SDL_SetWindowFocusable(window, focusable));
}
 
inline void Window::SetFocusable(bool focusable)
{
  SDL::SetWindowFocusable(m_resource, focusable);
}
 
inline void ShowWindowSystemMenu(WindowParam window, const PointRaw& p)
{
  CheckError(SDL_ShowWindowSystemMenu(window, p.x, p.y));
}
 
inline void Window::ShowSystemMenu(const PointRaw& p)
{
  SDL::ShowWindowSystemMenu(m_resource, p);
}
 
inline void SetWindowHitTest(WindowParam window,
                             HitTest callback,
                             void* callback_data)
{
  CheckError(SDL_SetWindowHitTest(window, callback, callback_data));
}
 
inline void SetWindowHitTest(WindowParam window, HitTestCB callback)
{
  SetWindowHitTest(window, callback.wrapper, callback.data);
}
 
inline void Window::SetHitTest(HitTest callback, void* callback_data)
{
  SDL::SetWindowHitTest(m_resource, callback, callback_data);
}
 
inline void Window::SetHitTest(HitTestCB callback)
{
  SDL::SetWindowHitTest(m_resource, callback);
}
 
inline void SetWindowShape(WindowParam window, SurfaceParam shape)
{
  CheckError(SDL_SetWindowShape(window, shape));
}
 
inline void Window::SetShape(SurfaceParam shape)
{
  SDL::SetWindowShape(m_resource, shape);
}
 
inline void FlashWindow(WindowParam window, FlashOperation operation)
{
  CheckError(SDL_FlashWindow(window, operation));
}
 
inline void Window::Flash(FlashOperation operation)
{
  SDL::FlashWindow(m_resource, operation);
}
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
inline void SetWindowProgressState(WindowParam window, ProgressState state)
{
  CheckError(SDL_SetWindowProgressState(window, state));
}
 
inline void Window::SetProgressState(ProgressState state)
{
  SDL::SetWindowProgressState(m_resource, state);
}
 
inline ProgressState GetWindowProgressState(WindowParam window)
{
  return SDL_GetWindowProgressState(window);
}
 
inline ProgressState Window::GetProgressState()
{
  return SDL::GetWindowProgressState(m_resource);
}
 
inline void SetWindowProgressValue(WindowParam window, float value)
{
  CheckError(SDL_SetWindowProgressValue(window, value));
}
 
inline void Window::SetProgressValue(float value)
{
  SDL::SetWindowProgressValue(m_resource, value);
}
 
inline float GetWindowProgressValue(WindowParam window)
{
  return SDL_GetWindowProgressValue(window);
}
 
inline float Window::GetProgressValue()
{
  return SDL::GetWindowProgressValue(m_resource);
}
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
inline void DestroyWindow(WindowRaw window) { SDL_DestroyWindow(window); }
 
inline void Window::Destroy() { DestroyWindow(release()); }
 
inline bool ScreenSaverEnabled() { return SDL_ScreenSaverEnabled(); }
 
inline void EnableScreenSaver() { CheckError(SDL_EnableScreenSaver()); }
 
inline void DisableScreenSaver() { CheckError(SDL_DisableScreenSaver()); }
 
inline void GL_LoadLibrary(StringParam path)
{
  CheckError(SDL_GL_LoadLibrary(path));
}
 
inline FunctionPointer GL_GetProcAddress(StringParam proc)
{
  return SDL_GL_GetProcAddress(proc);
}
 
inline FunctionPointer EGL_GetProcAddress(StringParam proc)
{
  return SDL_EGL_GetProcAddress(proc);
}
 
inline void GL_UnloadLibrary() { SDL_GL_UnloadLibrary(); }
 
inline bool GL_ExtensionSupported(StringParam extension)
{
  return SDL_GL_ExtensionSupported(extension);
}
 
inline void GL_ResetAttributes() { SDL_GL_ResetAttributes(); }
 
inline void GL_SetAttribute(GLAttr attr, int value)
{
  CheckError(SDL_GL_SetAttribute(attr, value));
}
 
inline void GL_GetAttribute(GLAttr attr, int* value)
{
  CheckError(SDL_GL_GetAttribute(attr, value));
}
 
inline GLContext GL_CreateContext(WindowParam window)
{
  return GLContext(window);
}
 
inline GLContext Window::CreateGLContext() { return GLContext(m_resource); }
 
inline void GL_MakeCurrent(WindowParam window, GLContext context)
{
  CheckError(SDL_GL_MakeCurrent(window, context.get()));
}
 
inline void Window::MakeCurrent(GLContext context)
{
  SDL::GL_MakeCurrent(m_resource, context);
}
 
inline void GLContext::MakeCurrent(WindowParam window)
{
  SDL::GL_MakeCurrent(window, m_resource);
}
 
inline WindowRef GL_GetCurrentWindow()
{
  return {CheckError(SDL_GL_GetCurrentWindow())};
}
 
inline GLContext GL_GetCurrentContext() { return SDL_GL_GetCurrentContext(); }
 
inline EGLDisplay EGL_GetCurrentDisplay()
{
  return SDL_EGL_GetCurrentDisplay();
}
 
inline EGLConfig EGL_GetCurrentConfig() { return SDL_EGL_GetCurrentConfig(); }
 
inline EGLSurface EGL_GetWindowSurface(WindowParam window)
{
  return SDL_EGL_GetWindowSurface(window);
}
 
inline EGLSurface Window::GetEGLSurface()
{
  return SDL::EGL_GetWindowSurface(m_resource);
}
 
inline void EGL_SetAttributeCallbacks(
  EGLAttribArrayCallback platformAttribCallback,
  EGLIntArrayCallback surfaceAttribCallback,
  EGLIntArrayCallback contextAttribCallback,
  void* userdata)
{
  SDL_EGL_SetAttributeCallbacks(platformAttribCallback,
                                surfaceAttribCallback,
                                contextAttribCallback,
                                userdata);
}
 
inline void GL_SetSwapInterval(int interval)
{
  CheckError(SDL_GL_SetSwapInterval(interval));
}
 
inline void GL_GetSwapInterval(int* interval)
{
  CheckError(SDL_GL_GetSwapInterval(interval));
}
 
inline void GL_SwapWindow(WindowParam window)
{
  CheckError(SDL_GL_SwapWindow(window));
}
 
inline void Window::GL_Swap() { SDL::GL_SwapWindow(m_resource); }
 
inline void GL_DestroyContext(GLContextRaw context)
{
  CheckError(SDL_GL_DestroyContext(context));
}
 
inline void GLContext::Destroy() { GL_DestroyContext(release()); }
 
 
} // namespace SDL
 
#endif /* SDL3PP_VIDEO_H_ */