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 WindowBase;
 
// Forward decl
struct Window;

using WindowRaw = SDL_Window*;

using WindowRef = ResourceRefT<WindowBase>;
 
// Forward decl
struct GLContext;

using GLContextRaw = SDL_GLContext;
 
// Forward decl
struct GLContextScoped;

using GLContextRef = GLContext;
 
// Forward decl
struct RendererBase;
 
// Forward decl
struct Renderer;

using RendererRef = ResourceRefT<RendererBase>;

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)

struct WindowBase : ResourceBaseT<WindowRaw>
{
  using ResourceBaseT::ResourceBaseT;

  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(SurfaceRef 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);

  bool 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(WindowRef 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(SurfaceRef 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 StartTextInputWithProperties(PropertiesRef props);

  bool IsTextInputActive() const;

  void StopTextInput();

  void ClearComposition();

  void SetTextInputArea(const RectRaw& rect, int cursor);

  void GetTextInputArea(RectRaw* rect, int* cursor) const;

  bool IsScreenKeyboardShown() const;

  void WarpMouse(const FPointRaw& p);

  void SetRelativeMouseMode(bool enabled);

  bool GetRelativeMouseMode() const;

  RendererRef GetRenderer() const;
};

struct Window : WindowBase
{
  using WindowBase::WindowBase;

  constexpr explicit Window(WindowRaw resource) noexcept
    : WindowBase(resource)
  {
  }

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

  Window(StringParam title, const PointRaw& size, WindowFlags flags = 0);

  Window(WindowRef parent,
         const PointRaw& offset,
         const PointRaw& size,
         WindowFlags flags = 0);

  Window(PropertiesRef props);

  ~Window() { SDL_DestroyWindow(get()); }

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

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);
}

struct GLContext : ResourceBaseT<GLContextRaw>
{
  using ResourceBaseT::ResourceBaseT;

  GLContext(WindowRef window);

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

  void Destroy();

  void MakeCurrent(WindowRef window);
};

struct GLContextScoped : GLContext
{
  using GLContext::GLContext;
 
  constexpr GLContextScoped(const GLContextScoped& other) = delete;

  constexpr GLContextScoped(GLContextScoped&& other) noexcept
    : GLContext(other.release())
  {
  }

  constexpr GLContextScoped(GLContext&& other) noexcept
    : GLContext(std::move(other).release())
  {
  }

  ~GLContextScoped() { SDL_GL_DestroyContext(release()); }
};

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 = 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(WindowRef window)
{
  return CheckError(SDL_GetDisplayForWindow(window));
}
 
inline Display WindowBase::GetDisplay() const
{
  return SDL::GetDisplayForWindow(get());
}

inline float GetWindowPixelDensity(WindowRef window)
{
  return SDL_GetWindowPixelDensity(window);
}
 
inline float WindowBase::GetPixelDensity() const
{
  return SDL::GetWindowPixelDensity(get());
}

inline float GetWindowDisplayScale(WindowRef window)
{
  return SDL_GetWindowDisplayScale(window);
}
 
inline float WindowBase::GetDisplayScale() const
{
  return SDL::GetWindowDisplayScale(get());
}

inline void SetWindowFullscreenMode(WindowRef window,
                                    OptionalRef<const DisplayMode> mode)
{
  CheckError(SDL_SetWindowFullscreenMode(window, mode));
}
 
inline void WindowBase::SetFullscreenMode(OptionalRef<const DisplayMode> mode)
{
  SDL::SetWindowFullscreenMode(get(), mode);
}

inline const DisplayMode& GetWindowFullscreenMode(WindowRef window)
{
  return *SDL_GetWindowFullscreenMode(window);
}
 
inline const DisplayMode& WindowBase::GetFullscreenMode() const
{
  return SDL::GetWindowFullscreenMode(get());
}

inline OwnPtr<void> GetWindowICCProfile(WindowRef window)
{
  size_t size;
  return OwnPtr<void>{CheckError(SDL_GetWindowICCProfile(window, &size))};
}
 
inline OwnPtr<void> WindowBase::GetICCProfile() const
{
  return SDL::GetWindowICCProfile(get());
}

inline PixelFormat GetWindowPixelFormat(WindowRef window)
{
  return CheckError(SDL_GetWindowPixelFormat(window));
}
 
inline PixelFormat WindowBase::GetPixelFormat() const
{
  return SDL::GetWindowPixelFormat(get());
}

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::Window(StringParam title,
                      const PointRaw& size,
                      WindowFlags flags)
  : Window(SDL_CreateWindow(title, size.x, size.y, flags))
{
}
 
inline Window::Window(WindowRef parent,
                      const PointRaw& offset,
                      const PointRaw& size,
                      WindowFlags flags)
  : Window(
      SDL_CreatePopupWindow(parent, offset.x, offset.y, size.x, size.y, flags))
{
}
 
inline Window::Window(PropertiesRef props)
  : Window(SDL_CreateWindowWithProperties(props))
{
}

inline Window CreatePopupWindow(WindowRef parent,
                                const PointRaw& offset,
                                const PointRaw& size,
                                WindowFlags flags)
{
  return Window(parent, offset, size, flags);
}

inline Window CreateWindowWithProperties(PropertiesRef props)
{
  return Window(props);
}

namespace prop::Window::Create {
 
constexpr auto ALWAYS_ON_TOP_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_ALWAYS_ON_TOP_BOOLEAN; 
 
constexpr auto BORDERLESS_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_BORDERLESS_BOOLEAN; 
 
#if SDL_VERSION_ATLEAST(3, 2, 18)
 
constexpr auto CONSTRAIN_POPUP_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_CONSTRAIN_POPUP_BOOLEAN; 
 
#endif // SDL_VERSION_ATLEAST(3, 2, 18)
 
constexpr auto FOCUSABLE_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_FOCUSABLE_BOOLEAN; 
 
constexpr auto EXTERNAL_GRAPHICS_CONTEXT_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_EXTERNAL_GRAPHICS_CONTEXT_BOOLEAN; 
 
constexpr auto FLAGS_NUMBER =
  SDL_PROP_WINDOW_CREATE_FLAGS_NUMBER; 
 
constexpr auto FULLSCREEN_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_FULLSCREEN_BOOLEAN; 
 
constexpr auto HEIGHT_NUMBER =
  SDL_PROP_WINDOW_CREATE_HEIGHT_NUMBER; 
 
constexpr auto HIDDEN_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_HIDDEN_BOOLEAN; 
 
constexpr auto HIGH_PIXEL_DENSITY_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_HIGH_PIXEL_DENSITY_BOOLEAN; 
 
constexpr auto MAXIMIZED_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_MAXIMIZED_BOOLEAN; 
 
constexpr auto MENU_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_MENU_BOOLEAN; 
 
constexpr auto METAL_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_METAL_BOOLEAN; 
 
constexpr auto MINIMIZED_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_MINIMIZED_BOOLEAN; 
 
constexpr auto MODAL_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_MODAL_BOOLEAN; 
 
constexpr auto MOUSE_GRABBED_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_MOUSE_GRABBED_BOOLEAN; 
 
constexpr auto OPENGL_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_OPENGL_BOOLEAN; 
 
constexpr auto PARENT_POINTER =
  SDL_PROP_WINDOW_CREATE_PARENT_POINTER; 
 
constexpr auto RESIZABLE_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_RESIZABLE_BOOLEAN; 
 
constexpr auto TITLE_STRING =
  SDL_PROP_WINDOW_CREATE_TITLE_STRING; 
 
constexpr auto TRANSPARENT_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_TRANSPARENT_BOOLEAN; 
 
constexpr auto TOOLTIP_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_TOOLTIP_BOOLEAN; 
 
constexpr auto UTILITY_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_UTILITY_BOOLEAN; 
 
constexpr auto VULKAN_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_VULKAN_BOOLEAN; 
 
constexpr auto WIDTH_NUMBER =
  SDL_PROP_WINDOW_CREATE_WIDTH_NUMBER; 
 
constexpr auto X_NUMBER = SDL_PROP_WINDOW_CREATE_X_NUMBER; 
 
constexpr auto Y_NUMBER = SDL_PROP_WINDOW_CREATE_Y_NUMBER; 
 
constexpr auto COCOA_WINDOW_POINTER =
  SDL_PROP_WINDOW_CREATE_COCOA_WINDOW_POINTER; 
 
constexpr auto COCOA_VIEW_POINTER =
  SDL_PROP_WINDOW_CREATE_COCOA_VIEW_POINTER; 
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto WINDOWSCENE_POINTER =
  SDL_PROP_WINDOW_CREATE_WINDOWSCENE_POINTER; 
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto WAYLAND_SURFACE_ROLE_CUSTOM_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_WAYLAND_SURFACE_ROLE_CUSTOM_BOOLEAN; 
 
constexpr auto WAYLAND_CREATE_EGL_WINDOW_BOOLEAN =
  SDL_PROP_WINDOW_CREATE_WAYLAND_CREATE_EGL_WINDOW_BOOLEAN; 
 
constexpr auto WAYLAND_WL_SURFACE_POINTER =
  SDL_PROP_WINDOW_CREATE_WAYLAND_WL_SURFACE_POINTER; 
 
constexpr auto WIN32_HWND_POINTER =
  SDL_PROP_WINDOW_CREATE_WIN32_HWND_POINTER; 
 
constexpr auto WIN32_PIXEL_FORMAT_HWND_POINTER =
  SDL_PROP_WINDOW_CREATE_WIN32_PIXEL_FORMAT_HWND_POINTER; 
 
constexpr auto X11_WINDOW_NUMBER =
  SDL_PROP_WINDOW_CREATE_X11_WINDOW_NUMBER; 
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto EMSCRIPTEN_CANVAS_ID_STRING =
  SDL_PROP_WINDOW_CREATE_EMSCRIPTEN_CANVAS_ID_STRING; 
 
constexpr auto EMSCRIPTEN_KEYBOARD_ELEMENT_STRING =
  SDL_PROP_WINDOW_CREATE_EMSCRIPTEN_KEYBOARD_ELEMENT_STRING; 
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
} // namespace prop::Window::Create

inline WindowID GetWindowID(WindowRef window)
{
  return CheckError(SDL_GetWindowID(window));
}
 
inline WindowID WindowBase::GetID() const { return SDL::GetWindowID(get()); }

inline WindowRef GetWindowFromID(WindowID id)
{
  return SDL_GetWindowFromID(id);
}
 
inline WindowRef WindowBase::FromID(WindowID id)
{
  return SDL::GetWindowFromID(id);
}

inline WindowRef GetWindowParent(WindowRef window)
{
  return SDL_GetWindowParent(window);
}
 
inline WindowRef WindowBase::GetParent() const
{
  return SDL::GetWindowParent(get());
}

inline PropertiesRef GetWindowProperties(WindowRef window)
{
  return CheckError(SDL_GetWindowProperties(window));
}
 
inline PropertiesRef WindowBase::GetProperties() const
{
  return SDL::GetWindowProperties(get());
}

namespace prop::Window {
 
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 WindowFlags GetWindowFlags(WindowRef window)
{
  return SDL_GetWindowFlags(window);
}
 
inline WindowFlags WindowBase::GetFlags() const
{
  return SDL::GetWindowFlags(get());
}

inline void SetWindowTitle(WindowRef window, StringParam title)
{
  CheckError(SDL_SetWindowTitle(window, title));
}
 
inline void WindowBase::SetTitle(StringParam title)
{
  SDL::SetWindowTitle(get(), std::move(title));
}

inline const char* GetWindowTitle(WindowRef window)
{
  return SDL_GetWindowTitle(window);
}
 
inline const char* WindowBase::GetTitle() const
{
  return SDL::GetWindowTitle(get());
}

inline void SetWindowIcon(WindowRef window, SurfaceRef icon)
{
  CheckError(SDL_SetWindowIcon(window, icon));
}
 
inline void WindowBase::SetIcon(SurfaceRef icon)
{
  SDL::SetWindowIcon(get(), icon);
}

inline void SetWindowPosition(WindowRef window, const PointRaw& p)
{
  CheckError(SDL_SetWindowPosition(window, p.x, p.y));
}
 
inline void WindowBase::SetPosition(const PointRaw& p)
{
  SDL::SetWindowPosition(get(), p);
}

inline void GetWindowPosition(WindowRef window, int* x, int* y)
{
  CheckError(SDL_GetWindowPosition(window, x, y));
}

inline Point GetWindowPosition(WindowRef window)
{
  Point p;
  GetWindowPosition(window, &p.x, &p.y);
  return p;
}
 
inline void WindowBase::GetPosition(int* x, int* y) const
{
  SDL::GetWindowPosition(get(), x, y);
}
 
inline Point WindowBase::GetPosition() const
{
  return SDL::GetWindowPosition(get());
}

inline void SetWindowSize(WindowRef window, const PointRaw& size)
{
  CheckError(SDL_SetWindowSize(window, size.x, size.y));
}
 
inline void WindowBase::SetSize(const PointRaw& size)
{
  SDL::SetWindowSize(get(), size);
}

inline void GetWindowSize(WindowRef window, int* w, int* h)
{
  CheckError(SDL_GetWindowSize(window, w, h));
}

inline Point GetWindowSize(WindowRef window)
{
  Point p;
  GetWindowSize(window, &p.x, &p.y);
  return p;
}
 
inline void WindowBase::GetSize(int* w, int* h) const
{
  SDL::GetWindowSize(get(), w, h);
}
 
inline Point WindowBase::GetSize() const { return SDL::GetWindowSize(get()); }

inline void SetWindowRect(WindowRef window, Rect rect)
{
  SetWindowPosition(window, rect.GetTopLeft());
  SetWindowSize(window, rect.GetSize());
}
 
inline void WindowBase::SetRect(Rect rect) { SDL::SetWindowRect(get(), rect); }

inline Rect GetWindowRect(WindowRef window)
{
  return Rect{GetWindowPosition(window), GetWindowSize(window)};
}
 
inline Rect WindowBase::GetRect() const { return SDL::GetWindowRect(get()); }

inline Rect GetWindowSafeArea(WindowRef window)
{
  Rect rect;
  CheckError(SDL_GetWindowSafeArea(window, &rect));
  return rect;
}
 
inline Rect WindowBase::GetSafeArea() const
{
  return SDL::GetWindowSafeArea(get());
}

inline void SetWindowAspectRatio(WindowRef window,
                                 float min_aspect,
                                 float max_aspect)
{
  CheckError(SDL_SetWindowAspectRatio(window, min_aspect, max_aspect));
}
 
inline void WindowBase::SetAspectRatio(float min_aspect, float max_aspect)
{
  SDL::SetWindowAspectRatio(get(), min_aspect, max_aspect);
}

inline void GetWindowAspectRatio(WindowRef window,
                                 float* min_aspect,
                                 float* max_aspect)
{
  CheckError(SDL_GetWindowAspectRatio(window, min_aspect, max_aspect));
}
 
inline void WindowBase::GetAspectRatio(float* min_aspect,
                                       float* max_aspect) const
{
  SDL::GetWindowAspectRatio(get(), min_aspect, max_aspect);
}

inline void GetWindowBordersSize(WindowRef window,
                                 int* top,
                                 int* left,
                                 int* bottom,
                                 int* right)
{
  CheckError(SDL_GetWindowBordersSize(window, top, left, bottom, right));
}
 
inline void WindowBase::GetBordersSize(int* top,
                                       int* left,
                                       int* bottom,
                                       int* right) const
{
  SDL::GetWindowBordersSize(get(), top, left, bottom, right);
}

inline void GetWindowSizeInPixels(WindowRef window, int* w, int* h)
{
  CheckError(SDL_GetWindowSizeInPixels(window, w, h));
}

inline Point GetWindowSizeInPixels(WindowRef window)
{
  Point p;
  GetWindowSizeInPixels(window, &p.x, &p.y);
  return p;
}
 
inline void WindowBase::GetSizeInPixels(int* w, int* h) const
{
  SDL::GetWindowSizeInPixels(get(), w, h);
}
 
inline Point WindowBase::GetSizeInPixels() const
{
  return SDL::GetWindowSizeInPixels(get());
}

inline void SetWindowMinimumSize(WindowRef window, const PointRaw& p)
{
  CheckError(SDL_SetWindowMinimumSize(window, p.x, p.y));
}
 
inline void WindowBase::SetMinimumSize(const PointRaw& p)
{
  SDL::SetWindowMinimumSize(get(), p);
}

inline void GetWindowMinimumSize(WindowRef window, int* w, int* h)
{
  CheckError(SDL_GetWindowMinimumSize(window, w, h));
}
 
inline void WindowBase::GetMinimumSize(int* w, int* h) const
{
  SDL::GetWindowMinimumSize(get(), w, h);
}

inline void SetWindowMaximumSize(WindowRef window, const PointRaw& p)
{
  CheckError(SDL_SetWindowMaximumSize(window, p.x, p.y));
}
 
inline void WindowBase::SetMaximumSize(const PointRaw& p)
{
  SDL::SetWindowMaximumSize(get(), p);
}

inline void GetWindowMaximumSize(WindowRef window, int* w, int* h)
{
  CheckError(SDL_GetWindowMaximumSize(window, w, h));
}
 
inline void WindowBase::GetMaximumSize(int* w, int* h) const
{
  SDL::GetWindowMaximumSize(get(), w, h);
}

inline void SetWindowBordered(WindowRef window, bool bordered)
{
  CheckError(SDL_SetWindowBordered(window, bordered));
}
 
inline void WindowBase::SetBordered(bool bordered)
{
  SDL::SetWindowBordered(get(), bordered);
}

inline void SetWindowResizable(WindowRef window, bool resizable)
{
  CheckError(SDL_SetWindowResizable(window, resizable));
}
 
inline void WindowBase::SetResizable(bool resizable)
{
  SDL::SetWindowResizable(get(), resizable);
}

inline void SetWindowAlwaysOnTop(WindowRef window, bool on_top)
{
  CheckError(SDL_SetWindowAlwaysOnTop(window, on_top));
}
 
inline void WindowBase::SetAlwaysOnTop(bool on_top)
{
  SDL::SetWindowAlwaysOnTop(get(), on_top);
}
 
#if SDL_VERSION_ATLEAST(3, 4, 0)

inline void SetWindowFillDocument(WindowRef window, bool fill)
{
  CheckError(SDL_SetWindowFillDocument(window, fill));
}
 
inline void WindowBase::SetFillDocument(bool fill)
{
  SDL::SetWindowFillDocument(get(), fill);
}
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)

inline void ShowWindow(WindowRef window) { CheckError(SDL_ShowWindow(window)); }
 
inline void WindowBase::Show() { SDL::ShowWindow(get()); }

inline void HideWindow(WindowRef window) { CheckError(SDL_HideWindow(window)); }
 
inline void WindowBase::Hide() { SDL::HideWindow(get()); }

inline void RaiseWindow(WindowRef window)
{
  CheckError(SDL_RaiseWindow(window));
}
 
inline void WindowBase::Raise() { SDL::RaiseWindow(get()); }

inline void MaximizeWindow(WindowRef window)
{
  CheckError(SDL_MaximizeWindow(window));
}
 
inline void WindowBase::Maximize() { SDL::MaximizeWindow(get()); }

inline void MinimizeWindow(WindowRef window)
{
  CheckError(SDL_MinimizeWindow(window));
}
 
inline void WindowBase::Minimize() { SDL::MinimizeWindow(get()); }

inline void RestoreWindow(WindowRef window)
{
  CheckError(SDL_RestoreWindow(window));
}
 
inline void WindowBase::Restore() { SDL::RestoreWindow(get()); }

inline void SetWindowFullscreen(WindowRef window, bool fullscreen)
{
  CheckError(SDL_SetWindowFullscreen(window, fullscreen));
}
 
inline void WindowBase::SetFullscreen(bool fullscreen)
{
  SDL::SetWindowFullscreen(get(), fullscreen);
}

inline bool SyncWindow(WindowRef window) { return SDL_SyncWindow(window); }
 
inline bool WindowBase::Sync() { return SDL::SyncWindow(get()); }

inline bool WindowHasSurface(WindowRef window)
{
  return SDL_WindowHasSurface(window);
}
 
inline bool WindowBase::HasSurface() const
{
  return SDL::WindowHasSurface(get());
}

inline Surface GetWindowSurface(WindowRef window)
{
  return Surface::borrow(CheckError(SDL_GetWindowSurface(window)));
}
 
inline Surface WindowBase::GetSurface() { return SDL::GetWindowSurface(get()); }

inline void SetWindowSurfaceVSync(WindowRef window, int vsync)
{
  CheckError(SDL_SetWindowSurfaceVSync(window, vsync));
}
 
inline void WindowBase::SetSurfaceVSync(int vsync)
{
  SDL::SetWindowSurfaceVSync(get(), 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(WindowRef window)
{
  int vsync;
  CheckError(SDL_GetWindowSurfaceVSync(window, &vsync));
  return vsync;
}
 
inline int WindowBase::GetSurfaceVSync() const
{
  return SDL::GetWindowSurfaceVSync(get());
}

inline void UpdateWindowSurface(WindowRef window)
{
  CheckError(SDL_UpdateWindowSurface(window));
}
 
inline void WindowBase::UpdateSurface() { SDL::UpdateWindowSurface(get()); }

inline void UpdateWindowSurfaceRects(WindowRef window,
                                     SpanRef<const RectRaw> rects)
{
  CheckError(SDL_UpdateWindowSurfaceRects(
    window, rects.data(), narrowS32(rects.size())));
}
 
inline void WindowBase::UpdateSurfaceRects(SpanRef<const RectRaw> rects)
{
  SDL::UpdateWindowSurfaceRects(get(), rects);
}

inline void DestroyWindowSurface(WindowRef window)
{
  CheckError(SDL_DestroyWindowSurface(window));
}
 
inline void WindowBase::DestroySurface() { SDL::DestroyWindowSurface(get()); }

inline void SetWindowKeyboardGrab(WindowRef window, bool grabbed)
{
  CheckError(SDL_SetWindowKeyboardGrab(window, grabbed));
}
 
inline void WindowBase::SetKeyboardGrab(bool grabbed)
{
  SDL::SetWindowKeyboardGrab(get(), grabbed);
}

inline void SetWindowMouseGrab(WindowRef window, bool grabbed)
{
  CheckError(SDL_SetWindowMouseGrab(window, grabbed));
}
 
inline void WindowBase::SetMouseGrab(bool grabbed)
{
  SDL::SetWindowMouseGrab(get(), grabbed);
}

inline bool GetWindowKeyboardGrab(WindowRef window)
{
  return SDL_GetWindowKeyboardGrab(window);
}
 
inline bool WindowBase::GetKeyboardGrab() const
{
  return SDL::GetWindowKeyboardGrab(get());
}

inline bool GetWindowMouseGrab(WindowRef window)
{
  return SDL_GetWindowMouseGrab(window);
}
 
inline bool WindowBase::GetMouseGrab() const
{
  return SDL::GetWindowMouseGrab(get());
}

inline WindowRef GetGrabbedWindow() { return SDL_GetGrabbedWindow(); }
 
inline WindowRef WindowBase::GetGrabbed() { return SDL::GetGrabbedWindow(); }

inline void SetWindowMouseRect(WindowRef window, const RectRaw& rect)
{
  CheckError(SDL_SetWindowMouseRect(window, &rect));
}
 
inline void WindowBase::SetMouseRect(const RectRaw& rect)
{
  SDL::SetWindowMouseRect(get(), rect);
}

inline const RectRaw* GetWindowMouseRect(WindowRef window)
{
  return SDL_GetWindowMouseRect(window);
}
 
inline const RectRaw* WindowBase::GetMouseRect() const
{
  return SDL::GetWindowMouseRect(get());
}

inline void SetWindowOpacity(WindowRef window, float opacity)
{
  CheckError(SDL_SetWindowOpacity(window, opacity));
}
 
inline void WindowBase::SetOpacity(float opacity)
{
  SDL::SetWindowOpacity(get(), opacity);
}

inline float GetWindowOpacity(WindowRef window)
{
  return SDL_GetWindowOpacity(window);
}
 
inline float WindowBase::GetOpacity() const
{
  return SDL::GetWindowOpacity(get());
}

inline void SetWindowParent(WindowRef window, WindowRef parent)
{
  CheckError(SDL_SetWindowParent(window, parent));
}
 
inline void WindowBase::SetParent(WindowRef parent)
{
  SDL::SetWindowParent(get(), parent);
}

inline void SetWindowModal(WindowRef window, bool modal)
{
  CheckError(SDL_SetWindowModal(window, modal));
}
 
inline void WindowBase::SetModal(bool modal)
{
  SDL::SetWindowModal(get(), modal);
}

inline void SetWindowFocusable(WindowRef window, bool focusable)
{
  CheckError(SDL_SetWindowFocusable(window, focusable));
}
 
inline void WindowBase::SetFocusable(bool focusable)
{
  SDL::SetWindowFocusable(get(), focusable);
}

inline void ShowWindowSystemMenu(WindowRef window, const PointRaw& p)
{
  CheckError(SDL_ShowWindowSystemMenu(window, p.x, p.y));
}
 
inline void WindowBase::ShowSystemMenu(const PointRaw& p)
{
  SDL::ShowWindowSystemMenu(get(), p);
}

inline void SetWindowHitTest(WindowRef window,
                             HitTest callback,
                             void* callback_data)
{
  CheckError(SDL_SetWindowHitTest(window, callback, callback_data));
}

inline void SetWindowHitTest(WindowRef window, HitTestCB callback)
{
  SetWindowHitTest(window, callback.wrapper, callback.data);
}
 
inline void WindowBase::SetHitTest(HitTest callback, void* callback_data)
{
  SDL::SetWindowHitTest(get(), callback, callback_data);
}
 
inline void WindowBase::SetHitTest(HitTestCB callback)
{
  SDL::SetWindowHitTest(get(), callback);
}

inline void SetWindowShape(WindowRef window, SurfaceRef shape)
{
  CheckError(SDL_SetWindowShape(window, shape));
}
 
inline void WindowBase::SetShape(SurfaceRef shape)
{
  SDL::SetWindowShape(get(), shape);
}

inline void FlashWindow(WindowRef window, FlashOperation operation)
{
  CheckError(SDL_FlashWindow(window, operation));
}
 
inline void WindowBase::Flash(FlashOperation operation)
{
  SDL::FlashWindow(get(), operation);
}
 
#if SDL_VERSION_ATLEAST(3, 4, 0)

inline void SetWindowProgressState(WindowRef window, ProgressState state)
{
  CheckError(SDL_SetWindowProgressState(window, state));
}
 
inline void WindowBase::SetProgressState(ProgressState state)
{
  SDL::SetWindowProgressState(get(), state);
}

inline ProgressState GetWindowProgressState(WindowRef window)
{
  return SDL_GetWindowProgressState(window);
}
 
inline ProgressState WindowBase::GetProgressState()
{
  return SDL::GetWindowProgressState(get());
}

inline void SetWindowProgressValue(WindowRef window, float value)
{
  CheckError(SDL_SetWindowProgressValue(window, value));
}
 
inline void WindowBase::SetProgressValue(float value)
{
  SDL::SetWindowProgressValue(get(), value);
}

inline float GetWindowProgressValue(WindowRef window)
{
  return SDL_GetWindowProgressValue(window);
}
 
inline float WindowBase::GetProgressValue()
{
  return SDL::GetWindowProgressValue(get());
}
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)

inline void DestroyWindow(WindowRaw window) { SDL_DestroyWindow(window); }
 
inline void WindowBase::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(WindowRef window)
{
  return GLContext(window);
}
 
inline GLContext WindowBase::CreateGLContext() { return GLContext(get()); }
 
inline GLContext::GLContext(WindowRef window)
  : GLContext(SDL_GL_CreateContext(window))
{
}

inline void GL_MakeCurrent(WindowRef window, GLContext context)
{
  CheckError(SDL_GL_MakeCurrent(window, context));
}
 
inline void WindowBase::MakeCurrent(GLContext context)
{
  SDL::GL_MakeCurrent(get(), context);
}
 
inline void GLContext::MakeCurrent(WindowRef window)
{
  GL_MakeCurrent(window, get());
}

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(WindowRef window)
{
  return SDL_EGL_GetWindowSurface(window);
}
 
inline EGLSurface WindowBase::GetEGLSurface()
{
  return SDL::EGL_GetWindowSurface(get());
}

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(WindowRef window)
{
  CheckError(SDL_GL_SwapWindow(window));
}
 
inline void WindowBase::GL_Swap() { SDL::GL_SwapWindow(get()); }

inline void GL_DestroyContext(GLContextRaw context)
{
  CheckError(SDL_GL_DestroyContext(context));
}
 
inline void GLContext::Destroy() { GL_DestroyContext(release()); }

 
} // namespace SDL
 
#endif /* SDL3PP_VIDEO_H_ */