Usage

# Load all symbols from SDL 2.0 shared library.
# This must be the first proc called.
if not open_sdl2_library():
  echo "Failed to load SDL 2.0 library: ", last_sdl2_error()
  quit QuitFailure
defer:
  close_sdl2_library()

# Initialize SDL 2.0.
if not Init INIT_VIDEO:
  echo "Failed to initialize SDL 2.0: ", GetError()
  quit QuitFailure
defer:
  Quit()

# SDL 2.0 calls follow…

Configuration

You can disable functions you don't use. All function groups are enabled by default.

Group	Define	Functions Defined In
Audio	`sdl2.audio=0`	`<SDL2/SDL_audio.h>`
Blend Mode	`sdl2.blendmode=0`	`<SDL2/SDL_blendmode.h>`
Clipboard	`sdl2.clipboard=0`	`<SDL2/SDL_clipboard.h>`
Game Controller	`sdl2.gamecontroller=0`	`<SDL2/SDL_gamecontroller.h>`
Gesture	`sdl2.gesture=0`	`<SDL2/SDL_gesture.h>`
Haptic	`sdl2.haptic=0`	`<SDL2/SDL_haptic.h>`
Hints	`sdl2.hints=0`	`<SDL2/SDL_hints.h>`
Joystick	`sdl2.joystick=0`	`<SDL2/SDL_joystick.h>`
Keyboard	`sdl2.keyboard=0`	`<SDL2/SDL_keyboard.h>`
Mouse	`sdl2.mouse=0`	`<SDL2/SDL_mouse.h>`
Sensor	`sdl2.sensor=0`	`<SDL2/SDL_sensor.h>`
Shape	`sdl2.shape=0`	`<SDL2/SDL_shape.h>`
Touch	`sdl2.touch=0`	`<SDL2/SDL_touch.h>`

For example if you don't need audio functions compile with:

nim c -d=sdl2.audio=0 file(s)

Procs

proc AddTimer(interval: uint32; callback: TimerCallback; param: pointer = nil): TimerID {. inline, ...raises: [], tags: [RootEffect], forbids: [].}: SDL_TimerID SDL_AddTimer(Uint32 interval, SDL_TimerCallback callback, void *param);
proc AudioInit(driver_name: string): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_AudioInit(const char *driver_name);
proc AudioQuit() {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_AudioQuit(void);
proc CaptureMouse(enabled: bool): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_CaptureMouse(SDL_bool enabled);
proc ClearError() {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_ClearError(void);
proc CloseAudio() {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_CloseAudio(void);
proc CloseAudioDevice(dev: AudioDeviceID) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_CloseAudioDevice(SDL_AudioDeviceID dev);
proc ConvertSurface(src: SurfacePtr; fmt: PixelFormat): SurfacePtr {....raises: [], tags: [RootEffect], forbids: [].}: SDL_Surface *SDL_ConvertSurface(SDL_Surface *src, const SDL_PixelFormat *fmt, Uint32 flags);
proc ConvertSurfaceFormat(src: SurfacePtr; pixel_format: PixelFormatEnum): SurfacePtr {. ...raises: [], tags: [RootEffect], forbids: [].}: SDL_Surface *SDL_ConvertSurfaceFormat(SDL_Surface *src, Uint32 pixel_format, Uint32 flags);
proc CreateColorCursor(surface: SurfacePtr; hot_x, hot_y: int): CursorPtr {. ...raises: [], tags: [RootEffect], forbids: [].}: SDL_Cursor *SDL_CreateColorCursor(SDL_Surface *surface, int hot_x, int hot_y);
proc CreateCursor(data: openArray[byte]; mask: openArray[byte]; w: int; h: int; hot_x: int; hot_y: int): CursorPtr {....raises: [], tags: [RootEffect], forbids: [].}: SDL_Cursor *SDL_CreateCursor(const Uint8 *data, const Uint8 *mask, int w, int h, int hot_x, int hot_y);
proc CreateRenderer(window: Window; flags = RendererFlags 0): Renderer {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: SDL_Renderer * SDL_CreateRenderer(SDL_Window *window, int index, Uint32 flags);
proc CreateRenderer(window: Window; index: int; flags = RendererFlags 0): Renderer {. ...raises: [], tags: [RootEffect], forbids: [].}: SDL_Renderer * SDL_CreateRenderer(SDL_Window *window, int index, Uint32 flags);
proc CreateRGBSurface(flags: SurfaceFlags; width: int; height: int; depth: int; rmask: uint32; gmask: uint32; bmask: uint32; amask: uint32): SurfacePtr {. ...raises: [], tags: [RootEffect], forbids: [].}: SDL_Surface *SDL_CreateRGBSurface(Uint32 flags, int width, int height, int depth, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
proc CreateRGBSurface(width: int; height: int; depth: int; rmask: uint32; gmask: uint32; bmask: uint32; amask: uint32): SurfacePtr {. inline, ...raises: [], tags: [RootEffect], forbids: [].}: SDL_Surface *SDL_CreateRGBSurface(Uint32 flags, int width, int height, int depth, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
proc CreateRGBSurfaceFrom(pixels: pointer; width: int; height: int; depth: int; pitch: int; rmask: uint32; gmask: uint32; bmask: uint32; amask: uint32): SurfacePtr {. ...raises: [], tags: [RootEffect], forbids: [].}: SDL_Surface *SDL_CreateRGBSurfaceFrom(void *pixels, int width, int height, int depth, int pitch, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
proc CreateRGBSurfaceWithFormat(width: int; height: int; depth: int; format: PixelFormatEnum): SurfacePtr {. ...raises: [], tags: [RootEffect], forbids: [].}: SDL_Surface *SDL_CreateRGBSurfaceWithFormat(Uint32 flags, int width, int height, int depth, Uint32 format);
proc CreateSoftwareRenderer(surface: SurfacePtr): Renderer {....raises: [], tags: [RootEffect], forbids: [].}: SDL_Renderer * SDL_CreateSoftwareRenderer(SDL_Surface *surface);
proc CreateSystemCursor(id: SystemCursor) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}
proc CreateTexture(renderer: Renderer; format: PixelFormatEnum; access: TextureAccess; width, height: int): Texture {. ...raises: [], tags: [RootEffect], forbids: [].}: SDL_Texture * SDL_CreateTexture(SDL_Renderer *renderer, Uint32 format, int access, int w, int h);
proc CreateTextureFromSurface(renderer: Renderer; surface: SurfacePtr): Texture {. ...raises: [], tags: [RootEffect], forbids: [].}: SDL_Texture * SDL_CreateTextureFromSurface(SDL_Renderer *renderer, SDL_Surface *surface);
proc CreateWindow(title: string; w: int; h: int; flags = WindowFlags 0): Window {. inline, ...raises: [], tags: [RootEffect], forbids: [].}: Create a window with the specified position, dimensions, and flags.

SDL_Window * SDL_CreateWindow(const char *title, int x, int y, int w, int h, Uint32 flags);
proc CreateWindow(title: string; x: int; y: int; w: int; h: int; flags = WindowFlags 0): Window {....raises: [], tags: [RootEffect], forbids: [].}: Create a window with the specified position, dimensions, and flags.

SDL_Window * SDL_CreateWindow(const char *title, int x, int y, int w, int h, Uint32 flags);
proc CreateWindowAndRenderer(width: int; height: int; window_flags: WindowFlags = WindowFlags 0): tuple[ window: Window, renderer: Renderer] {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_CreateWindowAndRenderer(int width, int height, Uint32 window_flags, SDL_Window **window, SDL_Renderer **renderer);
proc Delay(ms: uint32) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_Delay(Uint32 ms);
proc DestroyRenderer(renderer: Renderer) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Destroy the window rendering context and free all textures.

void SDL_DestroyRenderer(SDL_Renderer *renderer);
proc DestroyTexture(texture: Texture) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Destroy the texture.

void SDL_DestroyTexture(SDL_Texture *texture);
proc DestroyWindow(window: Window) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Destroy a window.

void SDL_DestroyWindow(SDL_Window *window);
proc DisableScreenSaver() {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Prevent the screen from being blanked by a screen saver.

void SDL_DisableScreenSaver(void);
proc EnableScreenSaver() {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Allow the screen to be blanked by a screen saver.

void SDL_EnableScreenSaver(void);
proc EventState(typ: EventType; state: bool): bool {.discardable, inline, ...raises: [], tags: [RootEffect], forbids: [].}: Set the state of processing events.

Return true if the event was enable prior calling this function, false otherwise.

Uint8 SDL_EventState(Uint32 type, int state);
proc FillRect(dst: SurfacePtr; color: uint32): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_FillRect (SDL_Surface *dst, const SDL_Rect *rect, Uint32 color);
proc FillRect(dst: SurfacePtr; rect: Rect; color: uint32): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_FillRect (SDL_Surface *dst, const SDL_Rect *rect, Uint32 color);
proc FlashWindow(window: Window; operation: FlashOperation): bool {....raises: [], tags: [RootEffect], forbids: [].}: Request a window to demand attention from the user.

This function is available since SDL 2.0.16.

int SDL_FlashWindow(SDL_Window *window, SDL_FlashOperation operation);
proc FlushEvent(typ: EventType) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_FlushEvent(Uint32 type);
proc FlushEvents(min_type, max_type: EventType) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_FlushEvents(Uint32 min_type, Uint32 max_type);
proc free_drop_event_file(event: var Event) {....raises: [], tags: [], forbids: [].}: Free memory allocated for EVENT_DROPFILE and EVENT_DROPTEXT.
proc FreeCursor(cursor: CursorPtr) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}
proc FreeSurface(surface: SurfacePtr) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_FreeSurface(SDL_Surface *surface);
proc FreeWAV(audio_buf: ptr UncheckedArray[byte]) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_FreeWAV(Uint8 *audio_buf);
proc GetAudioDeviceName(index: int; iscapture: bool): string {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: const char *SDL_GetAudioDeviceName(int index, int iscapture);
proc GetAudioDeviceSpec(index: int; iscapture: bool; spec: var AudioSpec): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_GetAudioDeviceSpec(int index, int iscapture, SDL_AudioSpec *spec);
proc GetAudioDeviceStatus(dev: AudioDeviceID): AudioStatus {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: SDL_AudioStatus SDL_GetAudioDeviceStatus(SDL_AudioDeviceID dev);
proc GetAudioDriver(index: int): string {....raises: [], tags: [RootEffect], forbids: [].}: const char* SDL_GetAudioDriver(int index);
proc GetAudioStatus(): AudioStatus {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: SDL_AudioStatus SDL_GetAudioStatus(void);
proc GetClipboardText(): string {....raises: [], tags: [RootEffect], forbids: [].}: Get UTF-8 text from the clipboard.
Note: Unlike SDL_GetClipboardText, the text returned by get_clipboard_text must not be freed with sdl_free.

char * SDL_GetClipboardText(void);
proc GetCurrentAudioDriver(): string {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: const char* SDL_GetCurrentAudioDriver(void);
proc GetCurrentDisplayMode(display_index: Natural; mode: var DisplayMode): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: Get information about the current display mode.

Returns 0 on success or a negative error code on failure; call get_error() for more information.

int SDL_GetCurrentDisplayMode(int displayIndex, SDL_DisplayMode *mode)
proc GetCurrentVideoDriver(): string {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Get the name of the currently initialized video driver.

Returns the name of the current video driver or "" if no driver has been initialized.

const char *SDL_GetCurrentVideoDriver(void);
proc GetCursor(): CursorPtr {....raises: [], tags: [RootEffect], forbids: [].}: SDL_Cursor *SDL_GetCursor(void);
proc GetDefaultAudioInfo(name: var string; spec: var AudioSpec; iscapture: bool): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_GetDefaultAudioInfo(char **name, SDL_AudioSpec *spec, int iscapture);
proc GetDesktopDisplayMode(display_index: Natural; mode: var DisplayMode): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: Get information about the desktop's display mode.

int SDL_GetDesktopDisplayMode(int displayIndex, SDL_DisplayMode *mode);
proc GetDisplayBounds(display_index: Natural; rect: var Rect): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: Get the desktop area represented by a display.

int SDL_GetDisplayBounds(int displayIndex, SDL_Rect *rect);
proc GetDisplayBounds(display_index: Natural; x: var int; y: var int; width: var int; height: var int): bool {....raises: [], tags: [RootEffect], forbids: [].}: Get the desktop area represented by a display.

int SDL_GetDisplayBounds(int displayIndex, SDL_Rect *rect);
proc GetDisplayDPI(display_index: int; ddpi: var float; hdpi: var float; vdpi: var float): bool {....raises: [], tags: [RootEffect], forbids: [].}: Get the dots/pixels-per-inch for a display.

This function is available since SDL 2.0.4.

int SDL_GetDisplayDPI(int displayIndex, float *ddpi, float *hdpi, float *vdpi);
proc GetDisplayMode(display_index: Natural; mode_index: int; mode: var DisplayMode): bool {....raises: [], tags: [RootEffect], forbids: [].}: Get information about a specific display mode.

int SDL_GetDisplayMode(int displayIndex, int modeIndex, SDL_DisplayMode *mode);
proc GetDisplayName(display_index: Natural): string {....raises: [], tags: [RootEffect], forbids: [].}: Get the name of a display in UTF-8 encoding.

const char * SDL_GetDisplayName(int displayIndex);
proc GetDisplayOrientation(display_index: Natural): DisplayOrientation {. ...raises: [], tags: [RootEffect], forbids: [].}: Get the orientation of a display.

This function is available since SDL 2.0.9. Returns ORIENTATION_UNKNOWN in SDL prior 2.0.9.

SDL_DisplayOrientation SDL_GetDisplayOrientation(int displayIndex);
proc GetDisplayUsableBounds(display_index: Natural; rect: var Rect): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: Get the usable desktop area represented by a display.

Available since SDL 2.0.5. Equal to GetDisplayBounds prior SDL 2.0.5.

int SDL_GetDisplayUsableBounds(int displayIndex, SDL_Rect *rect);
proc GetDisplayUsableBounds(display_index: Natural; x: var int; y: var int; width: var int; height: var int): bool {....raises: [], tags: [RootEffect], forbids: [].}: Get the usable desktop area represented by a display.

Available since SDL 2.0.5. Equal to GetDisplayBounds prior SDL 2.0.5.

int SDL_GetDisplayUsableBounds(int displayIndex, SDL_Rect *rect);
proc GetError(): string {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: const char *SDL_GetError(void);
proc GetGlobalMouseState(): tuple[x, y: int, state: uint32] {....raises: [], tags: [RootEffect], forbids: [].}: Note: This function returns tuple of (-1, -1, 0) on SDL prior 2.0.4.

Uint32 SDL_GetGlobalMouseState(int *x, int *y);
proc GetGrabbedWindow(): Window {....raises: [], tags: [RootEffect], forbids: [].}: Get the window that currently has an input grab enabled.

SDL_Window *SDL_GetGrabbedWindow(void);
proc GetHint(name: HintName): string {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: const char * SDL_GetHint(const char *name);
proc GetKeyboardFocus(): Window {.inline, ...raises: [], tags: [RootEffect], forbids: [].}
proc GetMouseFocus(): Window {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: SDL_Window * SDL_GetMouseFocus(void);
proc GetMouseState(): tuple[x, y: int, state: uint32] {....raises: [], tags: [RootEffect], forbids: [].}: Uint32 SDL_GetMouseState(int *x, int *y);
proc GetNumAudioDevices(iscapture: bool): int {.inline, ...raises: [], tags: [RootEffect], forbids: [].}
proc GetNumAudioDrivers(): int {.inline, ...raises: [], tags: [RootEffect], forbids: [].}
proc GetNumDisplayModes(display_index: Natural): int {....raises: [], tags: [RootEffect], forbids: [].}: Get the number of available display modes.

int SDL_GetNumDisplayModes(int displayIndex);
proc GetNumRenderDrivers(): int {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_GetNumRenderDrivers(void);
proc GetNumTouchDevices(): int {....raises: [], tags: [RootEffect], forbids: [].}
proc GetNumTouchFingers(touch_id: TouchID): int {....raises: [], tags: [RootEffect], forbids: [].}
proc GetNumVideoDisplays(): int {....raises: [], tags: [RootEffect], forbids: [].}: Get the number of available video displays.

int SDL_GetNumVideoDisplays(void);
proc GetNumVideoDrivers(): int {....raises: [], tags: [RootEffect], forbids: [].}: Get the number of video drivers compiled into SDL.

int SDL_GetNumVideoDrivers(void);
proc GetPerformanceCounter(): uint64 {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Uint64 SDL_GetPerformanceCounter(void);
proc GetPerformanceFrequency(): uint64 {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Uint64 SDL_GetPerformanceFrequency(void);
proc GetPixelFormatName(format: PixelFormatEnum): string {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: const char* SDL_GetPixelFormatName(Uint32 format);
proc GetQueuedAudioSize(dev: AudioDeviceID): uint32 {....raises: [], tags: [RootEffect], forbids: [].}: Uint32 SDL_GetQueuedAudioSize(SDL_AudioDeviceID dev);
proc GetRelativeMouseMode(): bool {.inline, ...raises: [], tags: [RootEffect], forbids: [].}
proc GetRelativeMouseState(): tuple[x, y: int, state: uint32] {....raises: [], tags: [RootEffect], forbids: [].}: Uint32 SDL_GetRelativeMouseState(int *x, int *y);
proc GetRenderDrawColor(renderer: Renderer; r: var byte; g: var byte; b: var byte; a: var byte): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_GetRenderDrawColor(SDL_Renderer *renderer, Uint8 *r, Uint8 *g, Uint8 *b, Uint8 *a);
proc GetRenderDriverInfo(index: int; info: var RendererInfo): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_GetRenderDriverInfo(int index, SDL_RendererInfo *info);
proc GetRenderer(window: Window): Renderer {....raises: [], tags: [RootEffect], forbids: [].}: SDL_Renderer * SDL_GetRenderer(SDL_Window *window);
proc GetRendererInfo(renderer: Renderer; info: var RendererInfo): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_GetRendererInfo(SDL_Renderer *renderer, SDL_RendererInfo *info);
proc GetRendererOutputSize(renderer: Renderer; w: var int; h: var int): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_GetRendererOutputSize(SDL_Renderer *renderer, int *w, int *h);
proc GetRenderTarget(renderer: Renderer): Texture {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: SDL_Texture * SDL_GetRenderTarget(SDL_Renderer *renderer);
proc GetRevision(): string {....raises: [], tags: [RootEffect], forbids: [].}: Get the code revision of SDL that is linked against your program.

const char *SDL_GetRevision(void);
proc GetTicks(): uint32 {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Get the number of milliseconds since SDL library initialization.

This value wraps if the program runs for more than ~49 days.

This function is not recommended as of SDL 2.0.18; use GetTicks64 instead, where the value doesn't wrap every ~49 days. There are places in SDL where we provide a 32-bit timestamp that can not change without breaking binary compatibility, though, so this function isn't officially deprecated.

Returns an unsigned 32-bit value representing the number of milliseconds since the SDL library initialized.

Original name: SDL_GetTicks
proc GetTicks64(): uint64 {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Get the number of milliseconds since SDL library initialization.

Note that you should not use the TICKS_PASSED macro with values returned by this function, as that macro does clever math to compensate for the 32-bit overflow every ~49 days that GetTicks suffers from. 64-bit values from this function can be safely compared directly.

For example, if you want to wait 100 ms, you could do this:

let timeout = get_ticks64() + 100 while get_ticks64() < timeout: # ... do work until timeout has elapsed

Returns an unsigned 64-bit value representing the number of milliseconds since the SDL library initialized.

This function is available since SDL 2.0.18.

Original name: SDL_GetTicks64
proc GetTouchDevice(index: int): TouchID {....raises: [], tags: [RootEffect], forbids: [].}: Get the touch ID with the given index.

SDL_TouchID SDL_GetTouchDevice(int index);
proc GetTouchDeviceType(touch_id: TouchID): TouchDeviceType {....raises: [], tags: [RootEffect], forbids: [].}: Get the type of the given touch device.

This function is available since SDL 2.0.10.

SDL_TouchDeviceType SDL_GetTouchDeviceType(SDL_TouchID touchID);
proc GetTouchFinger(touch_id: TouchID; index: int): ptr Finger {....raises: [], tags: [RootEffect], forbids: [].}: Get the finger object for specified touch device ID and finger index.

SDL_Finger * SDL_GetTouchFinger(SDL_TouchID touchID, int index);
proc GetTouchName(index: int): string {....raises: [], tags: [RootEffect], forbids: [].}: Get the touch device name as reported from the driver or "" if the index is invalid.

This function is available since SDL 2.0.22.

const char* SDL_GetTouchName(int index);
proc GetVersion(): tuple[major, minor, patch: int] {....raises: [], tags: [RootEffect], forbids: [].}: Get the version of SDL that is linked against your program.

void SDL_GetVersion(SDL_version *ver);
proc GetVideoDriver(index: int): string {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Get the name of a built in video driver.

const char *SDL_GetVideoDriver(int index);
proc GetWindowBordersSize(window: Window; top: var int; left: var int; bottom: var int; right: var int): bool {....raises: [], tags: [RootEffect], forbids: [].}: Get the size of a window's borders (decorations) around the client area.

This function is available since SDL 2.0.5.

int SDL_GetWindowBordersSize(SDL_Window *window, int *top, int *left, int *bottom, int *right);
proc GetWindowDisplayIndex(window: Window): int {....raises: [], tags: [RootEffect], forbids: [].}: Get the index of the display associated with a window.

int SDL_GetWindowDisplayIndex(SDL_Window *window)
proc GetWindowDisplayMode(window: Window; mode: var DisplayMode): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: Query the display mode to use when a window is visible at fullscreen.

int SDL_GetWindowDisplayMode(SDL_Window *window, SDL_DisplayMode *mode)
proc GetWindowFlags(window: Window): WindowFlags {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Get the window flags.

Uint32 SDL_GetWindowFlags(SDL_Window *window);
proc GetWindowFromID(id: uint32): Window {....raises: [], tags: [RootEffect], forbids: [].}: Get a window from a stored ID.

SDL_Window * SDL_GetWindowFromID(Uint32 id);
proc GetWindowGrab(window: Window): bool {.inline, ...raises: [], tags: [RootEffect], forbids: [].}
proc GetWindowID(window: Window): uint32 {....raises: [], tags: [RootEffect], forbids: [].}: Get the numeric ID of a window.

Uint32 SDL_GetWindowID(SDL_Window *window);
proc GetWindowKeyboardGrab(window: Window): bool {....raises: [], tags: [RootEffect], forbids: [].}
proc GetWindowMaximumSize(window: Window): tuple[w, h: int] {....raises: [], tags: [RootEffect], forbids: [].}: Get the maximum size of a window's client area.

void SDL_GetWindowMaximumSize(SDL_Window *window, int *w, int *h);
proc GetWindowMinimumSize(window: Window): tuple[w, h: int] {....raises: [], tags: [RootEffect], forbids: [].}: Get the minimum size of a window's client area.

void SDL_GetWindowMinimumSize(SDL_Window *window, int *w, int *h);
proc GetWindowMouseGrab(window: Window): bool {....raises: [], tags: [RootEffect], forbids: [].}
proc GetWindowMouseRect(window: Window): Rect {....raises: [], tags: [RootEffect], forbids: [].}: Get the mouse confinement rectangle of a window.

This function is available since SDL 2.0.18.

const SDL_Rect * SDL_GetWindowMouseRect(SDL_Window *window);
proc GetWindowOpacity(window: Window; opacity: var float): bool {....raises: [], tags: [RootEffect], forbids: [].}: Get the opacity of a window.

This function is available since SDL 2.0.5.

int SDL_GetWindowOpacity(SDL_Window *window, float *out_opacity);
proc GetWindowPixelFormat(window: Window): PixelFormatEnum {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Get the pixel format associated with the window.

Returns the pixel format of the window on success or PIXELFORMAT_UNKNOWN on failure; call get_error for more information.

Uint32 SDL_GetWindowPixelFormat(SDL_Window *window);
proc GetWindowPosition(window: Window): tuple[x, y: int] {....raises: [], tags: [RootEffect], forbids: [].}: Get the position of a window.

void SDL_GetWindowPosition(SDL_Window *window, int *x, int *y);
proc GetWindowSize(window: Window): tuple[w, h: int] {....raises: [], tags: [RootEffect], forbids: [].}: Get the size of a window's client area.

void SDL_GetWindowSize(SDL_Window *window, int *w, int *h);
proc GetWindowSizeInPixels(window: Window): tuple[w, h: int] {....raises: [], tags: [RootEffect], forbids: [].}: Get the size of a window in pixels.

This function is available since SDL 2.26.0.

void SDL_GetWindowSizeInPixels(SDL_Window *window, int *w, int *h);
proc GetWindowSurface(window: Window): SurfacePtr {....raises: [], tags: [RootEffect], forbids: [].}: Get the SDL surface associated with the window.

SDL_Surface * SDL_GetWindowSurface(SDL_Window *window);
proc GetWindowTitle(window: Window): string {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Get the title of a window.

Params:

window - the window to query

Returns the title of the window in UTF-8 format or "" if there is no title.

Original name: SDL_GetWindowTitle
proc HasWindowSurface(window: Window): bool {....raises: [], tags: [RootEffect], forbids: [].}
proc HideWindow(window: Window) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Hide a window.

Params:

window - the window to hide

Original name: SDL_HideWindow
proc Init(flags: InitFlags = 32'u or 1048576'u): bool {....raises: [], tags: [RootEffect], forbids: [].}: Initialize the SDL library.

Original name: SDL_Init
proc InitSubSystem(flags: InitFlags): bool {....raises: [], tags: [RootEffect], forbids: [].}: Compatibility function to initialize the SDL library.

In SDL2, this function and Init are interchangeable.

Params:

flags any of the flags used by Init; see Init for details.

Returns true on success or false on failure; call get_error for more information.

Original name: SDL_InitSubSystem
proc JoystickClose(joystick: Joystick) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Close a joystick previously opened with open_joystick.

Available since SDL 2.0.0.

See: SDL_JoystickClose
proc JoystickGetDeviceProduct(device_index: cint): uint16 {....raises: [], tags: [RootEffect], forbids: [].}: Get the USB product ID of a joystick, if available.

Returns the USB product ID of the selected joystick. If called on an invalid index, this function returns zero. Returns 0 on SDL prior to 2.0.6.

Available since SDL 2.0.6.

Note: This can be called before any joysticks are opened. If the product ID isn't available this function returns 0.

See: SDL_JoystickGetDeviceProduct
proc JoystickGetDeviceVendor(device_index: cint): uint16 {....raises: [], tags: [RootEffect], forbids: [].}: Get the USB vendor ID of a joystick, if available.

Returns the USB vendor ID of the selected joystick. If called on an invalid index, this function returns zero.

Available since SDL 2.0.6.

Note: This can be called before any joysticks are opened. If the vendor ID isn't available this function returns 0.

See: SDL_JoystickGetDeviceVendor
proc JoystickGetGUID(joystick: Joystick): JoystickGUID {....raises: [], tags: [RootEffect], forbids: [].}: Get the implementation-dependent GUID for the joystick.

Returns the GUID of the given joystick. If called on an invalid index, this function returns a zero GUID; call get_error() for more information.
proc JoystickGetGUIDString(guid: JoystickGUID): string {....raises: [], tags: [RootEffect], forbids: [].}: Get an ASCII string representation for a given JoystickGUID.

See: SDL_JoystickGetGUIDString.
proc JoystickGetGUIDString(joystick: Joystick): string {....raises: [], tags: [RootEffect], forbids: [].}
proc JoystickGetProduct(joystick: Joystick): uint16 {....raises: [], tags: [RootEffect], forbids: [].}: Get the USB product ID of a joystick, if available.

Returns the USB product ID of the selected joystick. If called on an invalid index, this function returns zero. Returns 0 on SDL prior to 2.0.6.

Available since SDL 2.0.6.
proc JoystickGetSerial(joystick: Joystick): string {....raises: [], tags: [RootEffect], forbids: [].}: Get the serial number of an opened joystick, if available.

Returns the serial number of the selected joystick, or "" if unavailable. Returns "" on SDL prior to 2.0.14.

Available since SDL 2.0.14.

See: SDL_JoystickGetSerial.
proc JoystickGetType(joystick: Joystick): JoystickType {....raises: [], tags: [RootEffect], forbids: [].}: Get the type of an opened joystick.

Returns the JoystickType <sdl2inc/joystick.html#JoystickType> of the selected joystick. Returns JOYSTICK_TYPE_UNKNOWN <sdl2inc/joystick#JoystickType,JOYSTICK_TYPE_UNKNOWN> on SDL prior to 2.0.6.

Available since SDL 2.0.6.

See: SDL_JoystickGetType.
proc JoystickGetVendor(joystick: Joystick): uint16 {....raises: [], tags: [RootEffect], forbids: [].}: Get the USB vendor ID of an opened joystick, if available.

Returns the USB vendor ID of the selected joystick, or 0 if unavailable.

Available since SDL 2.0.6.

See: SDL_JoystickGetVendor.
proc JoystickHasLED(joystick: Joystick): bool {....raises: [], tags: [RootEffect], forbids: [].}
proc JoystickHasRumble(joystick: Joystick): bool {....raises: [], tags: [RootEffect], forbids: [].}
proc JoystickHasRumbleTriggers(joystick: Joystick): bool {....raises: [], tags: [RootEffect], forbids: [].}
proc JoystickName(joystick: Joystick): string {....raises: [], tags: [RootEffect], forbids: [].}: Get the implementation dependent name of a joystick.

Available since SDL 2.0.0.

Returns the name of the selected joystick. If no name can be found, this function returns ""; call get_error() for more information.
proc JoystickNumAxes(joystick: Joystick): int {....raises: [], tags: [RootEffect], forbids: [].}: Get the number of general axis controls on a joystick.

Returns the number of axis controls/number of axes on success or a negative error code on failure; call get_error() for more information.

Available since SDL 2.0.0.

See: SDL_JoystickNumAxes
proc JoystickNumBalls(joystick: Joystick): int {....raises: [], tags: [RootEffect], forbids: [].}: Get the number of trackballs on a joystick.

Returns the number of trackballs on success or a negative error code on failure; call get_error() for more information.

Available since SDL 2.0.0.

See SDL_JoystickNumBalls
proc JoystickNumButtons(joystick: Joystick): int {....raises: [], tags: [RootEffect], forbids: [].}: Get the number of buttons on a joystick.

Returns the number of buttons on success or a negative error code on failure; call get_error() for more information.

Available since SDL 2.0.0.

See SDL_JoystickNumButtons
proc JoystickNumHats(joystick: Joystick): int {....raises: [], tags: [RootEffect], forbids: [].}: Get the number of POV hats on a joystick.

Returns the number of POV hats on success or a negative error code on failure; call get_error() for more information.

Available since SDL 2.0.0.

See: SDL_JoystickNumHats
proc JoystickOpen(device_index: int): Joystick {....raises: [], tags: [RootEffect], forbids: [].}: Open a joystick for use.

Returns a joystick identifier or nil if an error occurred.

Available since SDL 2.0.0.

See: SDL_JoystickOpen
proc JoystickPath(joystick: Joystick): string {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Get the implementation dependent path of a joystick.

Returns the path of the selected joystick. If no path can be found, this function returns nil; call get_error() for more information. Returns "" on SDL prior to 2.24.0.

Available since SDL 2.24.0.

See: SDL_JoystickPath
proc JoystickUpdate() {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Update the current state of the open joysticks.
Note: This is called automatically by the event loop if any joystick events are enabled.

Available since SDL 2.0.0.

See: SDL_JoystickUpdate
proc LoadBMP(file: string): SurfacePtr {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: #define SDL_LoadBMP(file) SDL_LoadBMP_RW(SDL_RWFromFile(file, "rb"), 1);
proc LoadBMP_RW(src: RWops; freesrc: bool): SurfacePtr {....raises: [], tags: [RootEffect], forbids: [].}: SDL_Surface *SDL_LoadBMP_RW(SDL_RWops *src, int freesrc);
proc LoadWAV(file: string; spec: var AudioSpec; audio_buf: var ptr UncheckedArray[byte]; audio_len: var uint32): ptr AudioSpec {. inline, ...raises: [], tags: [RootEffect], forbids: [].}: #define SDL_LoadWAV(file, spec, audio_buf, audio_len) \ SDL_LoadWAV_RW(SDL_RWFromFile(file, "rb"),1, spec,audio_buf,audio_len)
proc LoadWAV_RW(src: RWops; freesrc: bool; spec: var AudioSpec; audio_buf: var ptr UncheckedArray[byte]; audio_len: var uint32): ptr AudioSpec {. ...raises: [], tags: [RootEffect], forbids: [].}: SDL_AudioSpec * SDL_LoadWAV_RW(SDL_RWops *src, int freesrc, SDL_AudioSpec *spec, Uint8 ** audio_buf, Uint32 *audio_len);
proc LockSurface(surface: SurfacePtr): bool {.discardable, ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_LockSurface(SDL_Surface *surface);
proc Log(message: string) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_Log(const char *fmt, ...);
proc LogCritical(category: LogCategory; message: string) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_LogCritical(int category, const char *fmt, ...);
proc LogDebug(category: LogCategory; message: string) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_LogDebug(int category, const char *fmt, ...);
proc LogError(category: LogCategory; message: string) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_LogError(int category, const char *fmt, ...);
proc LogInfo(category: LogCategory; message: string) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_LogInfo(int category, const char *fmt, ...);
proc LogMessage(category: LogCategory; priority: LogPriority; message: string) {. ...raises: [], tags: [RootEffect], forbids: [].}
proc LogSetAllPriority(priority: LogPriority) {....raises: [], tags: [RootEffect], forbids: [].}: void SDL_LogSetAllPriority(SDL_LogPriority priority);
proc LogSetOutputFunction(callback: LogOutputFunction; userdata: pointer = nil) {. inline, ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_LogSetOutputFunction(SDL_LogOutputFunction callback, void *userdata);
proc LogSetPriority(category: LogCategory; priority: LogPriority) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_LogSetPriority(int category, SDL_LogPriority priority);
proc LogVerbose(category: LogCategory; message: string) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_LogVerbose(int category, const char *fmt, ...);
proc LogWarn(category: LogCategory; message: string) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_LogWarn(int category, const char *fmt, ...);
proc MapRGB(format: PixelFormat; r: byte; g: byte; b: byte): uint32 {. ...raises: [], tags: [RootEffect], forbids: [].}: Uint32 SDL_MapRGB(const SDL_PixelFormat *format, Uint8 r, Uint8 g, Uint8 b);
proc MapRGBA(format: PixelFormat; r: byte; g: byte; b: byte; a: byte): uint32 {. ...raises: [], tags: [RootEffect], forbids: [].}: Uint32 SDL_MapRGBA(const SDL_PixelFormat *format, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
proc MasksToPixelFormatEnum(bpp: int; rmask: uint32; gmask: uint32; bmask: uint32; amask: uint32): PixelFormatEnum {. ...raises: [], tags: [RootEffect], forbids: [].}: Uint32 SDL_MasksToPixelFormatEnum(int bpp, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
proc MaximizeWindow(window: Window) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Make a window as large as possible.

void SDL_MaximizeWindow(SDL_Window *window);
proc MinimizeWindow(window: Window) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Minimize a window to an iconic representation.

void SDL_MinimizeWindow(SDL_Window *window);
proc MixAudio(dst: ptr UncheckedArray[byte]; src: ptr byte or ptr UncheckedArray[byte]; len: uint32; volume: int) {....raises: [].}: void SDL_MixAudio(Uint8 *dst, const Uint8 *src, Uint32 len, int volume);
proc NumJoysticks(): int {....raises: [], tags: [RootEffect], forbids: [].}: Count the number of joysticks attached to the system.

Returns the number of attached joysticks on success or a negative error code on failure; call get_error() for more information.

Available since SDL 2.0.0.

See: SDL_NumJoysticks
proc OpenAudio(desired: AudioSpec; obtained: var AudioSpec): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_OpenAudio(SDL_AudioSpec * desired, SDL_AudioSpec * obtained);
proc OpenAudio(desired: var AudioSpec): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_OpenAudio(SDL_AudioSpec * desired, SDL_AudioSpec * obtained);
proc OpenAudioDevice(device: string; iscapture: bool; desired: AudioSpec; allowed_changes = AudioAllowFlags 0): AudioDeviceID {. ...raises: [], tags: [RootEffect], forbids: [].}: SDL_AudioDeviceID SDL_OpenAudioDevice(const char *device, int iscapture, const SDL_AudioSpec *desired, SDL_AudioSpec *obtained, int allowed_changes);
proc OpenAudioDevice(device: string; iscapture: bool; desired: AudioSpec; obtained: var AudioSpec; allowed_changes = AudioAllowFlags 0): AudioDeviceID {. ...raises: [], tags: [RootEffect], forbids: [].}: SDL_AudioDeviceID SDL_OpenAudioDevice(const char *device, int iscapture, const SDL_AudioSpec *desired, SDL_AudioSpec *obtained, int allowed_changes);
proc PauseAudio(pause_on: bool) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}
proc PauseAudioDevice(dev: AudioDeviceID; pause_on: bool) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_PauseAudioDevice(SDL_AudioDeviceID dev, int pause_on);
proc PeepEvents(events: var openArray[Event]; action: EventAction; min_type: EventType; max_type: EventType): int {.inline, ...raises: [], tags: [], forbids: [].}
proc PeepEvents(events: var openArray[Event]; numevents: int; action: EventAction; min_type: EventType; max_type: EventType): int {. ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_PeepEvents(SDL_Event *events, int numevents, SDL_eventaction action, Uint32 minType, Uint32 maxType);
proc PixelFormatEnumToMasks(format: PixelFormatEnum): tuple[bpp: int, rmask, gmask, bmask, amask: uint32] {....raises: [], tags: [RootEffect], forbids: [].}: Return tuple of (0, 0, 0, 0) on error.

SDL_bool SDL_PixelFormatEnumToMasks(Uint32 format, int *bpp, Uint32 *Rmask, Uint32 *Gmask, Uint32 *Bmask, Uint32 *Amask);
proc PollEvent(): bool {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_PollEvent(SDL_Event *event);
proc PollEvent(event: var Event): bool {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_PollEvent(SDL_Event *event);
proc PremultiplyAlpha(width: int; height: int; src_format: PixelFormatEnum; src: pointer; src_pitch: int; dst_format: PixelFormatEnum; dst: pointer; dst_pitch: int): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_PremultiplyAlpha(int width, int height, Uint32 src_format, const void *src, int src_pitch, Uint32 dst_format, void *dst, int dst_pitch);
proc PumpEvents() {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_PumpEvents(void);
proc PushEvent(event: var Event): bool {.discardable, inline, ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_PushEvent(SDL_Event *event);
proc QueryTexture(texture: Texture; format: var uint32; access: var int; w: var int; h: var int): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_QueryTexture(SDL_Texture *texture, Uint32 *format, int *access, int *w, int *h);
proc QueueAudio(dev: AudioDeviceID; data: pointer; len: uint32): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_QueueAudio(SDL_AudioDeviceID dev, const void *data, Uint32 len);
proc Quit() {....raises: [], tags: [RootEffect], forbids: [].}: Clean up all initialized subsystems.

You should call this function even if you have already shutdown each initialized subsystem with QuitSubSystem. It is safe to call this function even in the case of errors in initialization.

If you start a subsystem using a call to that subsystem's init function (for example VideoInit instead of Init or InitSubSystem, then you must use that subsystem's quit function (video) to shut it down before calling Quit. But generally, you should not be using those functions directly anyhow; use Init instead.

You can use this function with atexit() to ensure that it is run when your application is shutdown, but it is not wise to do this from a library or other dynamically loaded code.

Original name: SDL_Quit
proc QuitRequested(): bool {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: #define SDL_QuitRequested() \ SDL_PumpEvents(), \ (SDL_PeepEvents(NULL,0,SDL_PEEKEVENT,SDL_QUIT,SDL_QUIT) > 0))
proc QuitSubSystem(flags: InitFlags) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Shut down specific SDL subsystems.

If you start a subsystem using a call to that subsystem's init function (for example VideoInit instead of Init or InitSubSystem, SDL_QuitSubSystem() and WasInit will not work. You will need to use that subsystem's quit function (VideoInit) directly instead. But generally, you should not be using those functions directly anyhow; use Init instead.

You still need to call Quit even if you close all open subsystems with InitSubSystem.

Params:

flags - any of the flags used by Init; see Init for details.

Original name: SDL_QuitSubSystem
proc RaiseWindow(window: Window) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Raise a window above other windows and set the input focus.

void SDL_RaiseWindow(SDL_Window *window);
proc RemoveTimer(id: TimerID): bool {.discardable, inline, ...raises: [], raises: [], tags: [RootEffect], forbids: [].}
proc RenderClear(renderer: Renderer): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_RenderClear(SDL_Renderer *renderer);
proc RenderCopy(renderer: Renderer; texture: Texture): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_RenderCopy(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *srcrect, const SDL_Rect *dstrect);
proc RenderCopy(renderer: Renderer; texture: Texture; dst: Rect): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_RenderCopy(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *srcrect, const SDL_Rect *dstrect);
proc RenderCopy(renderer: Renderer; texture: Texture; src: Rect; dst: Rect): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_RenderCopy(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *srcrect, const SDL_Rect *dstrect);
proc RenderCopy(renderer: Renderer; texture: Texture; x: int; y: int; w: int; h: int): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_RenderCopy(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *srcrect, const SDL_Rect *dstrect);
proc RenderCopyEx(renderer: Renderer; texture: Texture; src: Rect; dst: Rect; angle: float; center: Point; flip: RendererFlip): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: SDL_RenderCopyEx(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *srcrect, const SDL_Rect *dstrect, const double angle, const SDL_Point *center, const SDL_RendererFlip flip);
proc RenderDrawLine(renderer: Renderer; x1: int; y1: int; x2: int; y2: int): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_RenderDrawLine(SDL_Renderer *renderer, int x1, int y1, int x2, int y2);
proc RenderDrawPoint(renderer: Renderer; x: int; y: int): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_RenderDrawPoint(SDL_Renderer *renderer, int x, int y);
proc RenderDrawPointF(renderer: Renderer; x: float; y: float): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_RenderDrawPointF(SDL_Renderer *renderer, float x, float y);
proc RenderDrawRect(renderer: Renderer; rect: Rect): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_RenderDrawRect(SDL_Renderer *renderer, const SDL_Rect *rect);
proc RenderDrawRect(renderer: Renderer; x: int; y: int; w: int; h: int): bool {. inline, ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_RenderDrawRect(SDL_Renderer *renderer, const SDL_Rect *rect);
proc RenderFillRect(renderer: Renderer): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_RenderFillRect(SDL_Renderer *renderer, const SDL_Rect *rect);
proc RenderFillRect(renderer: Renderer; rect: Rect): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_RenderFillRect(SDL_Renderer *renderer, const SDL_Rect *rect);
proc RenderFillRect(renderer: Renderer; x, y: int; w, h: int): bool {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_RenderFillRect(SDL_Renderer *renderer, const SDL_FRect *rect);
proc RenderGeometry(renderer: Renderer; texture: Texture; vertices: openArray[Vertex]; num_vertices: int = 0): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_RenderGeometry(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Vertex *vertices, int num_vertices, const int *indices, int num_indices);
proc RenderGeometry(renderer: Renderer; vertices: openArray[Vertex]; num_vertices: int = 0): bool {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_RenderGeometry(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Vertex *vertices, int num_vertices, const int *indices, int num_indices);
proc RenderGetClipRect(renderer: Renderer; rect: var Rect) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_RenderGetClipRect(SDL_Renderer *renderer, SDL_Rect *rect);
proc RenderGetLogicalSize(renderer: Renderer; w: var int; h: var int) {. ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_RenderGetLogicalSize(SDL_Renderer *renderer, int *w, int *h)
proc RenderGetScale(renderer: Renderer; scale_x, scale_y: var float) {. ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_RenderGetScale(SDL_Renderer *renderer, float *scaleX, float *scaleY);
proc RenderGetViewport(renderer: Renderer; rect: var Rect) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_RenderGetViewport(SDL_Renderer *renderer, SDL_Rect *rect);
proc RenderGetWindow(renderer: Renderer): Window {....raises: [], tags: [RootEffect], forbids: [].}: SDL_Window *SDL_RenderGetWindow(SDL_Renderer *renderer);
proc RenderPresent(renderer: Renderer) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_RenderPresent(SDL_Renderer *renderer);
proc RenderReadPixels(renderer: Renderer; format: PixelFormatEnum; pixels: pointer; pitch: int): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect, Uint32 format, void *pixels, int pitch);
proc RenderReadPixels(renderer: Renderer; rect: Rect; format: PixelFormatEnum; pixels: pointer; pitch: int): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect, Uint32 format, void *pixels, int pitch);
proc RenderSetClipRect(renderer: Renderer): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_RenderSetClipRect(SDL_Renderer *renderer, const SDL_Rect *rect);
proc RenderSetClipRect(renderer: Renderer; rect: Rect): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_RenderSetClipRect(SDL_Renderer *renderer, const SDL_Rect *rect);
proc RenderSetLogicalSize(renderer: Renderer; w: int; h: int): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_RenderSetLogicalSize(SDL_Renderer *renderer, int w, int h);
proc RenderSetScale(renderer: Renderer; scale_x: float; scale_y: float): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_RenderSetScale(SDL_Renderer *renderer, float scaleX, float scaleY);
proc RenderSetViewport(renderer: Renderer): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_RenderSetViewport(SDL_Renderer *renderer, const SDL_Rect *rect);
proc RenderSetViewport(renderer: Renderer; rect: Rect): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_RenderSetViewport(SDL_Renderer *renderer, const SDL_Rect *rect);
proc RenderSetVSync(renderer: Renderer; vsync: bool): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_RenderSetVSync(SDL_Renderer* renderer, int vsync);
proc RenderTargetSupported(renderer: Renderer): bool {....raises: [], tags: [RootEffect], forbids: [].}
proc RenderWindowToLogical(renderer: Renderer; window_x: int; window_y: int; logical_x: var float; logical_y: var float): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_RenderWindowToLogical(SDL_Renderer *renderer, int windowX, int windowY, float *logicalX, float *logicalY);
proc RestoreWindow(window: Window) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Restore the size and position of a minimized or maximized window.

void SDL_RestoreWindow(SDL_Window *window);
proc RWFromFile(file, mode: string): RWops {....raises: [], tags: [RootEffect], forbids: [].}: SDL_RWops * SDL_RWFromFile(const char *file, const char *mode);
proc SaveBMP(surface: SurfacePtr; file: string): bool {....raises: [], tags: [RootEffect], forbids: [].}
proc sdl2_avail(flags = INIT_VIDEO): bool {....raises: [], tags: [RootEffect], forbids: [].}
proc SetClipboardText(text: string): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_SetClipboardText(const char *text);
proc SetColorKey(surface: SurfacePtr; flag: bool; key: uint32): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_SetColorKey(SDL_Surface *surface, int flag, Uint32 key);
proc SetCursor(cursor: CursorPtr) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: void SDL_SetCursor(SDL_Cursor *cursor);
proc SetError(msg: string): bool {.discardable, inline, ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_SetError(const char *fmt, ...);
proc SetHint(name: HintName; value: string): bool {.inline, ...raises: [], tags: [RootEffect], forbids: [].}
proc SetPixelFormatPalette(format: var PixelFormat; palette: Palette): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_SetPixelFormatPalette(SDL_PixelFormat *format, SDL_Palette *palette);
proc SetRelativeMouseMode(enable: bool): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_SetRelativeMouseMode(SDL_bool enabled);
proc SetRenderDrawBlendMode(renderer: Renderer; blend_mode: BlendMode): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_SetRenderDrawBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode);
proc SetRenderDrawColor(renderer: Renderer; r: byte; g: byte; b: byte; a: byte = 0x000000FF): bool {....raises: [], tags: [RootEffect], forbids: [].}: Set the color used for drawing operations (clear, line, rect, etc.).

int SDL_SetRenderDrawColor(SDL_Renderer *renderer, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
proc SetRenderTarget(renderer: Renderer; texture: Texture = nil): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture);
proc SetTextureAlphaMod(texture: Texture; a: byte): bool {....raises: [], tags: [RootEffect], forbids: [].}: int SDL_SetTextureAlphaMod(SDL_Texture *texture, Uint8 alpha);
proc SetTextureBlendMode(texture: Texture; blend_mode: BlendMode): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_SetTextureBlendMode(SDL_Texture *texture, SDL_BlendMode blendMode);
proc SetTextureColorMod(texture: Texture; r: byte; g: byte; b: byte): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_SetTextureColorMod(SDL_Texture *texture, Uint8 r, Uint8 g, Uint8 b);
proc SetWindowAlwaysOnTop(window: Window; on_top: bool): bool {....raises: [], tags: [RootEffect], forbids: [].}: Set the window to always be above the others.

This function is available since SDL 2.0.16.

void SDL_SetWindowAlwaysOnTop(SDL_Window *window, SDL_bool on_top);
proc SetWindowBordered(window: Window; bordered: bool) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Set the border state of a window.

void SDL_SetWindowBordered(SDL_Window *window, SDL_bool bordered);
proc SetWindowDisplayMode(window: Window; mode: DisplayMode): bool {....raises: [], tags: [RootEffect], forbids: [].}: Set the display mode to use when a window is visible at fullscreen.

int SDL_SetWindowDisplayMode(SDL_Window *window, const SDL_DisplayMode *mode);
proc SetWindowFullscreen(window: Window; flags = WindowFlags 0): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: Set a window's fullscreen state.

int SDL_SetWindowFullscreen(SDL_Window *window, Uint32 flags);
proc SetWindowGrab(window: Window; grabbed: bool) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Set a window's input grab mode.

void SDL_SetWindowGrab(SDL_Window *window, SDL_bool grabbed);
proc SetWindowHitTest(window: Window; callback: HitTest; callback_data: pointer): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: Provide a callback that decides if a window region has special properties.

This function is available since SDL 2.0.4.

int SDL_SetWindowHitTest(SDL_Window *window, SDL_HitTest callback, void *callback_data);
proc SetWindowIcon(window: Window; surface: SurfacePtr) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Set the icon for a window.

void SDL_SetWindowIcon(SDL_Window *window, SDL_Surface *icon);
proc SetWindowInputFocus(window: Window): bool {. ...deprecated: "use RaiseWindow instead", raises: [], tags: [], forbids: [].}: Deprecated: use RaiseWindow instead

Explicitly set input focus to the window.

int SDL_SetWindowInputFocus(SDL_Window *window);
proc SetWindowKeyboardGrab(window: Window; grabbed: bool): bool {....raises: [], tags: [RootEffect], forbids: [].}: Set a window's keyboard grab mode.

This function is available since SDL 2.0.16.

void SDL_SetWindowKeyboardGrab(SDL_Window *window, SDL_bool grabbed);
proc SetWindowMaximumSize(window: Window; max_w: int; max_h: int) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Set the maximum size of a window's client area.

void SDL_SetWindowMaximumSize(SDL_Window *window, int max_w, int max_h);
proc SetWindowMinimumSize(window: Window; min_w: int; min_h: int) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Set the minimum size of a window's client area.

void SDL_SetWindowMinimumSize(SDL_Window *window, int min_w, int min_h);
proc SetWindowModalFor(modal_window: Window; parent_window: Window): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: Set the window as a modal for another window.

This function is available since SDL 2.0.5.

int SDL_SetWindowModalFor(SDL_Window *modal_window, SDL_Window *parent_window);
proc SetWindowMouseGrab(window: Window; grabbed: bool): bool {.discardable, ...raises: [], tags: [RootEffect], forbids: [].}: Set a window's mouse grab mode.

This function is available since SDL 2.0.16.

void SDL_SetWindowMouseGrab(SDL_Window *window, SDL_bool grabbed);
proc SetWindowMouseRect(window: Window; rect: Rect): bool {....raises: [], tags: [RootEffect], forbids: [].}: Confines the cursor to the specified area of a window.

This function is available since SDL 2.0.18.

int SDL_SetWindowMouseRect(SDL_Window *window, const SDL_Rect *rect);
proc SetWindowOpacity(window: Window; opacity: float): bool {....raises: [], tags: [RootEffect], forbids: [].}: Set the opacity for a window.

This function is available since SDL 2.0.5.

int SDL_SetWindowOpacity(SDL_Window *window, float opacity);
proc SetWindowPosition(window: Window; x: int; y: int) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Set the position of a window.
Note: Centering the window after returning from full screen moves the window to primary display.

void SDL_SetWindowPosition(SDL_Window *window, int x, int y);
proc SetWindowResizable(window: Window; ontop: bool): bool {.discardable, ...raises: [], tags: [RootEffect], forbids: [].}: Set the user-resizable state of a window.

This function is available since SDL 2.0.5.

void SDL_SetWindowResizable(SDL_Window *window, SDL_bool resizable);
proc SetWindowSize(window: Window; x: int; y: int) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Set the size of a window's client area.

void SDL_SetWindowSize(SDL_Window *window, int w, int h);
proc SetWindowTitle(window: Window; title: string) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Set the title of a window.

This string is expected to be in UTF-8 encoding.

Params:

window - the window to change

title - the desired window title in UTF-8 format

Original name: SDL_SetWindowTitle
proc ShowCursor(toggle: EventState): bool {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_ShowCursor(int toggle);
proc ShowMessageBo(messageboxdata: var MessageBoxData; buttonid: var int): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid);
proc ShowSimpleMessageBox(flags: MessageBoxFlags; title: string; message: string; window: Window = nil): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_ShowSimpleMessageBox(Uint32 flags, const char *title, const char *message, SDL_Window *window);
proc ShowWindow(window: Window) {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Show a window.

Params:

window - the window to show

Original name: SDL_ShowWindow
proc UnlockSurface(surface: SurfacePtr) {....raises: [], tags: [RootEffect], forbids: [].}: void SDL_UnlockSurface(SDL_Surface *surface);
proc UpdateTexture(texture: Texture; pixels: pointer; pitch: int): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_UpdateTexture(SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int pitch);
proc UpdateTexture(texture: Texture; rect: Rect; pixels: pointer; pitch: int): bool {. ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_UpdateTexture(SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int pitch);
proc UpdateTexture[T: SomeUnsignedInt](texture: Texture; pixels: openArray[T]; pitch: int): bool {.inline, ...raises: [].}: int SDL_UpdateTexture(SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int pitch);
proc UpdateWindowSurface(window: Window): bool {....raises: [], tags: [RootEffect], forbids: [].}: Copy the window surface to the screen.

int SDL_UpdateWindowSurface(SDL_Window *window);
proc VideoInit(driver_name: string): bool {....raises: [], tags: [RootEffect], forbids: [].}: Initialize the video subsystem, optionally specifying a video driver.

int SDL_VideoInit(const char *driver_name);
proc VideoQuit() {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Shut down the video subsystem, if initialized with VideoInit().

void SDL_VideoQuit(void);
proc WaitEvent(): bool {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_WaitEvent(SDL_Event *event);
proc WaitEvent(event: var Event): bool {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_WaitEvent(SDL_Event *event);
proc WaitEventTimeout(event: var Event; timeout: int): bool {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_WaitEventTimeout(SDL_Event *event, int timeout);
proc WaitEventTimeout(timeout: int): bool {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: int SDL_WaitEventTimeout(SDL_Event *event, int timeout);
proc WasInit(flags: InitFlags = INIT_NONE): InitFlags {.inline, ...raises: [], tags: [RootEffect], forbids: [].}: Get a mask of the specified subsystems which are currently initialized.

Params:

flags - any of the flags used by Init; see Init for details.

Returns a mask of all initialized subsystems if flags is INIT_NONE, otherwise it returns the initialization status of the specified subsystems.

The return value does not include INIT_NOPARACHUTE.

Original name: SDL_WasInit

Exports

nsdl2

Usage

Configuration

Imports

Procs

Exports