SDL3pp_video.h

#ifndef SDL3PP_VIDEO_H_
#define SDL3PP_VIDEO_H_
 
#include <memory>
#include <optional>
#include <vector>
#include <SDL3/SDL_render.h>
#include <SDL3/SDL_video.h>
#include "SDL3pp_properties.h"
#include "SDL3pp_rect.h"
#include "SDL3pp_surface.h"
 
namespace SDL {
// Forward decl
struct WindowBase;
 
// Forward decl
struct WindowRef;
 
// Forward decl
struct Window;
 
// Forward decl
struct RendererBase;
 
// 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 DisplayModeData = SDL_DisplayModeData;
 
using DisplayMode = SDL_DisplayMode;
 
using WindowFlags = SDL_WindowFlags;
 
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; 
 
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 = SDL_HitTest;
 
using HitTestCB =
  std::function<HitTestResult(WindowRef window, const Point& area)>;
 
using OptionalWindow = OptionalResource<WindowRef, Window>;
 
 
// Forward decl
struct GLContextBase;
 
// Forward decl
struct GLContextRef;
 
// Forward decl
struct GLContext;
 
class Display
{
  SDL_DisplayID m_displayID;
 
public:
  constexpr Display(SDL_DisplayID displayID = {})
    : m_displayID(displayID)
  {
  }
 
  constexpr bool operator==(const Display& other) const = default;
 
  constexpr bool operator==(SDL_DisplayID displayID) const
  {
    return operator==(Display(displayID));
  }
 
  constexpr operator SDL_DisplayID() const { return m_displayID; }
 
  constexpr explicit operator bool() const { return m_displayID != 0; }
 
  static OwnArray<Display> GetAll()
  {
    int count = 0;
    auto data = reinterpret_cast<Display*>(SDL_GetDisplays(&count));
    return OwnArray<Display>{data, size_t(count)};
  }
 
  static Display GetPrimary() { return CheckError(SDL_GetPrimaryDisplay()); }
 
  PropertiesRef GetProperties() const
  {
    return CheckError(SDL_GetDisplayProperties(m_displayID));
  }
 
  const char* GetName() const { return SDL_GetDisplayName(m_displayID); }
 
  Rect GetBounds() const
  {
    Rect bounds;
    SDL_GetDisplayBounds(m_displayID, &bounds);
    return bounds;
  }
 
  Rect GetUsableBounds() const
  {
    Rect bounds;
    CheckError(SDL_GetDisplayUsableBounds(m_displayID, &bounds));
    return bounds;
  }
 
  DisplayOrientation GetNaturalOrientation() const
  {
    return SDL_GetNaturalDisplayOrientation(m_displayID);
  }
 
  DisplayOrientation GetCurrentOrientation() const
  {
    return SDL_GetCurrentDisplayOrientation(m_displayID);
  }
 
  float GetContentScale() const
  {
    return SDL_GetDisplayContentScale(m_displayID);
  }
 
  OwnArray<DisplayMode*> GetFullscreenModes() const
  {
    int count = 0;
    auto data = CheckError(SDL_GetFullscreenDisplayModes(m_displayID, &count));
    return OwnArray<DisplayMode*>{data, size_t(count)};
  }
 
  DisplayMode GetClosestFullscreenMode(int w,
                                       int h,
                                       float refresh_rate,
                                       bool include_high_density_modes) const
  {
    SDL_DisplayMode closest;
    CheckError(SDL_GetClosestFullscreenDisplayMode(
      m_displayID, w, h, refresh_rate, include_high_density_modes, &closest));
    return closest;
  }
 
  const DisplayMode* GetDesktopMode() const
  {
    return CheckError(SDL_GetDesktopDisplayMode(m_displayID));
  }
 
  const DisplayMode* GetCurrentMode() const
  {
    return SDL_GetCurrentDisplayMode(m_displayID);
  }
 
  static Display GetForPoint(const SDL_Point& point)
  {
    return {SDL_GetDisplayForPoint(&point)};
  }
 
  static Display GetForRect(const SDL_Rect& rect)
  {
    return SDL_GetDisplayForRect(&rect);
  }
 
  static Display GetForWindow(WindowBase& window);
};
 
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; 
 
 
struct WindowBase : Resource<SDL_Window*>
{
  using Resource::Resource;
 
  WindowBase(StringParam title, SDL_Point size, WindowFlags flags = 0)
    : Resource(CheckError(SDL_CreateWindow(title, size.x, size.y, flags)))
  {
  }
 
  WindowBase(WindowBase& parent,
             SDL_Point offset,
             SDL_Point size,
             WindowFlags flags = 0)
    : Resource(CheckError(SDL_CreatePopupWindow(parent.get(),
                                                offset.x,
                                                offset.y,
                                                size.x,
                                                size.y,
                                                flags)))
  {
  }
 
  WindowBase(PropertiesBase& props)
    : Resource(CheckError(SDL_CreateWindowWithProperties(props.get())))
  {
  }
 
  Display GetDisplay() const { return SDL_GetDisplayForWindow(get()); }
 
  float GetPixelDensity() const { return SDL_GetWindowPixelDensity(get()); }
 
  float GetDisplayScale() const { return SDL_GetWindowDisplayScale(get()); }
 
  void SetFullscreenMode(OptionalRef<const DisplayMode> mode)
  {
    CheckError(SDL_SetWindowFullscreenMode(get(), mode));
  }
 
  const DisplayMode* GetFullscreenMode() const
  {
    return SDL_GetWindowFullscreenMode(get());
  }
 
  OwnPtr<void> GetICCProfile(size_t* size) const
  {
    return OwnPtr<void>{CheckError(SDL_GetWindowICCProfile(get(), size))};
  }
 
  PixelFormat GetPixelFormat() const
  {
    return CheckError(SDL_GetWindowPixelFormat(get()));
  }
 
  WindowID GetID() const { return CheckError(SDL_GetWindowID(get())); }
 
  WindowRef GetParent() const;
 
  PropertiesRef GetProperties() const
  {
    return CheckError(SDL_GetWindowProperties(get()));
  }
 
  WindowFlags GetFlags() const { return SDL_GetWindowFlags(get()); }
 
  void SetTitle(StringParam title)
  {
    CheckError(SDL_SetWindowTitle(get(), title));
  }
 
  const char* GetTitle() const { return SDL_GetWindowTitle(get()); }
 
  void SetIcon(SurfaceBase& icon)
  {
    CheckError(SDL_SetWindowIcon(get(), icon.get()));
  }
 
  void SetRect(Rect rect)
  {
    SetPosition(rect.GetTopLeft());
    SetSize(rect.GetSize());
  }
 
  Rect GetRect() const { return Rect{GetPosition(), GetSize()}; }
 
  void SetPosition(SDL_Point p)
  {
    CheckError(SDL_SetWindowPosition(get(), p.x, p.y));
  }
 
  Point GetPosition() const
  {
    Point p;
    GetPosition(&p.x, &p.y);
    return p;
  }
 
  void GetPosition(int* x, int* y) const
  {
    CheckError(SDL_GetWindowPosition(get(), x, y));
  }
 
  void SetSize(SDL_Point p) { CheckError(SDL_SetWindowSize(get(), p.x, p.y)); }
 
  Point GetSize() const
  {
    Point p;
    GetSize(&p.x, &p.y);
    return p;
  }
 
  void GetSize(int* w, int* h) const
  {
    CheckError(SDL_GetWindowSize(get(), w, h));
  }
 
  Rect GetSafeArea() const
  {
    Rect rect;
    CheckError(SDL_GetWindowSafeArea(get(), &rect));
    return rect;
  }
 
  void SetAspectRatio(float min_aspect, float max_aspect)
  {
    CheckError(SDL_SetWindowAspectRatio(get(), min_aspect, max_aspect));
  }
 
  void GetAspectRatio(float* min_aspect, float* max_aspect) const
  {
    CheckError(SDL_GetWindowAspectRatio(get(), min_aspect, max_aspect));
  }
 
  void GetBordersSize(int* top, int* left, int* bottom, int* right) const
  {
    CheckError(SDL_GetWindowBordersSize(get(), top, left, bottom, right));
  }
 
  Point GetSizeInPixels() const
  {
    Point p;
    GetSizeInPixels(&p.x, &p.y);
    return p;
  }
 
  void GetSizeInPixels(int* w, int* h) const
  {
    CheckError(SDL_GetWindowSizeInPixels(get(), w, h));
  }
 
  void SetMinimumSize(SDL_Point p)
  {
    CheckError(SDL_SetWindowMinimumSize(get(), p.x, p.y));
  }
 
  void GetMinimumSize(int* w, int* h) const
  {
    CheckError(SDL_GetWindowMinimumSize(get(), w, h));
  }
 
  void SetMaximumSize(SDL_Point p)
  {
    CheckError(SDL_SetWindowMaximumSize(get(), p.x, p.y));
  }
 
  void GetMaximumSize(int* w, int* h) const
  {
    CheckError(SDL_GetWindowMaximumSize(get(), w, h));
  }
 
  void SetBordered(bool bordered)
  {
    CheckError(SDL_SetWindowBordered(get(), bordered));
  }
 
  void SetResizable(bool resizable)
  {
    CheckError(SDL_SetWindowResizable(get(), resizable));
  }
 
  void SetAlwaysOnTop(bool on_top)
  {
    CheckError(SDL_SetWindowAlwaysOnTop(get(), on_top));
  }
 
  void Show() { CheckError(SDL_ShowWindow(get())); }
 
  void Hide() { CheckError(SDL_HideWindow(get())); }
 
  void Raise() { CheckError(SDL_RaiseWindow(get())); }
 
  void Maximize() { CheckError(SDL_MaximizeWindow(get())); }
 
  void Minimize() { CheckError(SDL_MinimizeWindow(get())); }
 
  void Restore() { CheckError(SDL_RestoreWindow(get())); }
 
  void SetFullscreen(bool fullscreen)
  {
    CheckError(SDL_SetWindowFullscreen(get(), fullscreen));
  }
 
  void Sync() { CheckError(SDL_SyncWindow(get())); }
 
  bool HasSurface() const { return SDL_WindowHasSurface(get()); }
 
  SurfaceRef GetSurface() { return SDL_GetWindowSurface(get()); }
 
  void SetSurfaceVSync(int vsync)
  {
    CheckError(SDL_SetWindowSurfaceVSync(get(), vsync));
  }
 
  int GetSurfaceVSync() const
  {
    int vsync;
    CheckError(SDL_GetWindowSurfaceVSync(get(), &vsync));
    return vsync;
  }
 
  void UpdateSurface() { CheckError(SDL_UpdateWindowSurface(get())); }
 
  void UpdateSurfaceRects(SpanRef<const SDL_Rect> rects)
  {
    SDL_assert_paranoid(rects.size() < SDL_MAX_SINT32);
    CheckError(SDL_UpdateWindowSurfaceRects(get(), rects.data(), rects.size()));
  }
 
  void DestroySurface() { CheckError(SDL_DestroyWindowSurface(get())); }
 
  void SetKeyboardGrab(bool grabbed)
  {
    CheckError(SDL_SetWindowKeyboardGrab(get(), grabbed));
  }
 
  void SetMouseGrab(bool grabbed)
  {
    CheckError(SDL_SetWindowMouseGrab(get(), grabbed));
  }
 
  bool GetKeyboardGrab() const { return SDL_GetWindowKeyboardGrab(get()); }
 
  bool GetMouseGrab() const { return SDL_GetWindowMouseGrab(get()); }
 
  void SetMouseRect(const SDL_Rect& rect)
  {
    CheckError(SDL_SetWindowMouseRect(get(), &rect));
  }
 
  const SDL_Rect* GetMouseRect() const { return SDL_GetWindowMouseRect(get()); }
 
  void SetOpacity(float opacity)
  {
    CheckError(SDL_SetWindowOpacity(get(), opacity));
  }
 
  float GetOpacity() const { return SDL_GetWindowOpacity(get()); }
 
  void SetParent(OptionalWindow parent);
 
  void SetModal(bool modal) { CheckError(SDL_SetWindowModal(get(), modal)); }
 
  void SetFocusable(bool focusable)
  {
    CheckError(SDL_SetWindowFocusable(get(), focusable));
  }
 
  void ShowSystemMenu(SDL_Point p)
  {
    CheckError(SDL_ShowWindowSystemMenu(get(), p.x, p.y));
  }
 
  void SetHitTest(HitTestCB callback);
 
  void SetHitTest(HitTest callback, void* callback_data)
  {
    CheckError(SDL_SetWindowHitTest(get(), callback, callback_data));
  }
 
  void SetShape(SurfaceBase& shape)
  {
    CheckError(SDL_SetWindowShape(get(), shape.get()));
  }
 
  void Flash(FlashOperation operation)
  {
    CheckError(SDL_FlashWindow(get(), operation));
  }
 
  RendererRef GetRenderer() const;
 
  void StartTextInput();
 
  void StartTextInput(PropertiesBase& props);
 
  bool IsTextInputActive() const;
 
  void StopTextInput();
 
  void ClearComposition();
 
  void SetTextInputArea(const SDL_Rect& rect, int cursor);
 
  void GetTextInputArea(Rect* rect, int* cursor);
 
  bool IsScreenKeyboardShown() const;
 
  void WarpMouse(float x, float y);
 
  void SetRelativeMouseMode(bool enabled);
 
  bool GetRelativeMouseMode() const;
};
 
struct WindowRef : WindowBase
{
  using WindowBase::WindowBase;
 
  constexpr WindowRef(const WindowRef& other)
    : WindowBase(other.get())
  {
  }
 
  constexpr WindowRef(WindowRef&& other)
    : WindowBase(other.release())
  {
  }
 
  constexpr ~WindowRef() = default;
 
  WindowRef& operator=(WindowRef other)
  {
    release(other.release());
    return *this;
  }
 
  void reset(SDL_Window* newResource = {})
  {
    SDL_DestroyWindow(release(newResource));
  }
 
  static WindowRef FromID(WindowID id);
 
  static WindowRef GetGrabbed();
};
 
struct Window : WindowRef
{
  using WindowRef::WindowRef;
 
  constexpr explicit Window(SDL_Window* resource = {})
    : WindowRef(resource)
  {
  }
 
  constexpr Window(const Window& other) = delete;
 
  constexpr Window(Window&& other) = default;
 
  ~Window() { reset(); }
 
  Window& operator=(Window other)
  {
    reset(other.release());
    return *this;
  }
};
 
#ifdef SDL3PP_DOC
 
#define SDL_WINDOWPOS_UNDEFINED_MASK 0x1FFF0000u
 
#define SDL_WINDOWPOS_UNDEFINED_DISPLAY(X) (SDL_WINDOWPOS_UNDEFINED_MASK | (X))
 
#define SDL_WINDOWPOS_UNDEFINED SDL_WINDOWPOS_UNDEFINED_DISPLAY(0)
 
#define SDL_WINDOWPOS_ISUNDEFINED(X)                                           \
  (((X) & 0xFFFF0000) == SDL_WINDOWPOS_UNDEFINED_MASK)
 
#define SDL_WINDOWPOS_CENTERED_MASK 0x2FFF0000u
 
#define SDL_WINDOWPOS_CENTERED_DISPLAY(X) (SDL_WINDOWPOS_CENTERED_MASK | (X))
 
#define SDL_WINDOWPOS_CENTERED SDL_WINDOWPOS_CENTERED_DISPLAY(0)
 
#define SDL_WINDOWPOS_ISCENTERED(X)                                            \
  (((X) & 0xFFFF0000) == SDL_WINDOWPOS_CENTERED_MASK)
 
#endif // SDL3PP_DOC
 
struct GLContextBase : Resource<SDL_GLContextState*>
{
  using Resource::Resource;
 
  GLContextBase(WindowBase& window)
    : Resource(CheckError(SDL_GL_CreateContext(window.get())))
  {
  }
 
  void MakeCurrent(WindowBase& window)
  {
    CheckError(SDL_GL_MakeCurrent(window.get(), get()));
  }
};
 
struct GLContextRef : GLContextBase
{
  using GLContextBase::GLContextBase;
 
  constexpr GLContextRef(const GLContextRef& other)
    : GLContextBase(other.get())
  {
  }
 
  constexpr GLContextRef(GLContextRef&& other)
    : GLContextBase(other.release())
  {
  }
 
  constexpr ~GLContextRef() = default;
 
  GLContextRef& operator=(GLContextRef other)
  {
    release(other.release());
    return *this;
  }
 
  bool reset(SDL_GLContextState* newResource = {})
  {
    return SDL_GL_DestroyContext(release(newResource));
  }
};
 
struct GLContext : GLContextRef
{
  using GLContextRef::GLContextRef;
 
  constexpr explicit GLContext(SDL_GLContextState* resource = {})
    : GLContextRef(resource)
  {
  }
 
  constexpr GLContext(const GLContext& other) = delete;
 
  constexpr GLContext(GLContext&& other) = default;
 
  ~GLContext() { reset(); }
 
  GLContext& operator=(GLContext other)
  {
    reset(other.release());
    return *this;
  }
};
 
using EGLDisplay = SDL_EGLDisplay;
 
using EGLConfig = SDL_EGLConfig;
 
using EGLSurface = SDL_EGLSurface;
 
using EGLAttrib = SDL_EGLAttrib;
 
using EGLint = SDL_EGLint;
 
using EGLAttribArrayCallback = SDL_EGLAttribArrayCallback;
 
using EGLAttribArrayCB = std::function<SDL_EGLAttrib*()>;
 
using EGLIntArrayCallback = SDL_EGLIntArrayCallback;
 
using EGLIntArrayCB = std::function<SDL_EGLint*(SDL_EGLDisplay, SDL_EGLConfig)>;
 
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(); }
 
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;
 
} // namespace prop::Display
 
inline OwnArray<WindowRef> GetWindows()
{
  int count = 0;
  auto data = CheckError(reinterpret_cast<WindowRef*>(SDL_GetWindows(&count)));
  return OwnArray<WindowRef>{data, size_t(count)};
}
 
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;
 
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;
 
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;
 
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;
 
constexpr auto OPENVR_OVERLAY_ID = SDL_PROP_WINDOW_OPENVR_OVERLAY_ID;
 
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;
 
} // namespace prop::Window
 
inline WindowRef WindowRef::FromID(WindowID id)
{
  return SDL_GetWindowFromID(id);
}
 
inline WindowRef WindowBase::GetParent() const
{
  return SDL_GetWindowParent(get());
}
 
#ifdef SDL3PP_DOC
 
#define SDL_WINDOW_SURFACE_VSYNC_DISABLED 0
 
#define SDL_WINDOW_SURFACE_VSYNC_ADAPTIVE (-1)
 
#endif // SDL3PP_DOC
 
inline WindowRef WindowRef::GetGrabbed() { return SDL_GetGrabbedWindow(); }
 
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 WindowRef GL_GetCurrentWindow()
{
  return CheckError(SDL_GL_GetCurrentWindow());
}
 
inline GLContextRef GL_GetCurrentContext()
{
  return CheckError(SDL_GL_GetCurrentContext());
}
 
inline EGLDisplay EGL_GetCurrentDisplay()
{
  return CheckError(SDL_EGL_GetCurrentDisplay());
}
 
inline EGLConfig EGL_GetCurrentConfig()
{
  return CheckError(SDL_EGL_GetCurrentConfig());
}
 
inline EGLSurface EGL_GetWindowSurface(WindowBase& window)
{
  return CheckError(SDL_EGL_GetWindowSurface(window.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(WindowBase& window)
{
  CheckError(SDL_GL_SwapWindow(window.get()));
}
 
#pragma region impl
 
 
inline void WindowBase::SetHitTest(HitTestCB callback)
{
  using Wrapper = KeyValueCallbackWrapper<SDL_Window*, HitTestCB>;
  void* cbHandle = Wrapper::Wrap(get(), std::move(callback));
  SetHitTest(
    [](SDL_Window* win, const SDL_Point* area, void* data) {
      return Wrapper::Call(data, WindowRef{win}, Point(*area));
    },
    cbHandle);
}
 
#pragma endregion impl
 
} // namespace SDL
 
#endif /* SDL3PP_VIDEO_H_ */