Skip to content

Instantly share code, notes, and snippets.

@terickson001

terickson001/sdl.odin

Last active March 4, 2021 04:20
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save terickson001/a0934c0796bf3c893107641b8f678bc2 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save terickson001/a0934c0796bf3c893107641b8f678bc2 to your computer and use it in GitHub Desktop.
Download ZIP
SDL bindings generated with bind-odin-port
Raw
sdl.odin
package sdl
import _c "core:c"
/* Macros */
ASSERT_LEVEL :: 2;
SIZEOF_VOIDP :: 8;
HAVE_GCC_ATOMICS :: 1;
HAVE_LIBC :: 1;
STDC_HEADERS :: 1;
HAVE_ALLOCA_H :: 1;
HAVE_CTYPE_H :: 1;
HAVE_ICONV_H :: 1;
LIL_ENDIAN :: 1234;
BIG_ENDIAN :: 4321;
RELEASED :: 0;
PRESSED :: 1;
HAVE_INTTYPES_H :: 1;
HAVE_LIMITS_H :: 1;
HAVE_MALLOC_H :: 1;
HAVE_MATH_H :: 1;
HAVE_MEMORY_H :: 1;
HAVE_SIGNAL_H :: 1;
HINT_FRAMEBUFFER_ACCELERATION :: "SDL_FRAMEBUFFER_ACCELERATION";
HAVE_STDARG_H :: 1;
HAVE_STDINT_H :: 1;
INIT_TIMER :: 0x1;
INIT_AUDIO :: 0x10;
INIT_VIDEO :: 0x20;
INIT_JOYSTICK :: 0x200;
INIT_HAPTIC :: 0x1000;
INIT_GAMECONTROLLER :: 0x2000;
INIT_EVENTS :: 0x4000;
INIT_SENSOR :: 0x8000;
INIT_NOPARACHUTE :: 0x100000;
INIT_EVERYTHING :: (INIT_TIMER | INIT_AUDIO | INIT_VIDEO | INIT_EVENTS | INIT_JOYSTICK | INIT_HAPTIC | INIT_GAMECONTROLLER | INIT_SENSOR);
HAVE_STDIO_H :: 1;
HAVE_STDLIB_H :: 1;
HAVE_STRINGS_H :: 1;
NULL_WHILE_LOOP_CONDITION :: (0);
AUDIO_MASK_BITSIZE :: (0xFF);
HAVE_STRING_H :: 1;
AUDIO_MASK_DATATYPE :: (1 << 8);
HAVE_SYS_TYPES_H :: 1;
AUDIO_MASK_ENDIAN :: (1 << 12);
HAVE_WCHAR_H :: 1;
AUDIO_MASK_SIGNED :: (1 << 15);
HAVE_LIBUNWIND_H :: 1;
HAVE_MALLOC :: 1;
HAVE_CALLOC :: 1;
HAVE_REALLOC :: 1;
HAVE_FREE :: 1;
HAVE_ALLOCA :: 1;
HAVE_GETENV :: 1;
HAVE_SETENV :: 1;
HAVE_PUTENV :: 1;
HAVE_UNSETENV :: 1;
HINT_RENDER_DRIVER :: "SDL_RENDER_DRIVER";
AUDIO_U8 :: 0x8;
HAVE_QSORT :: 1;
AUDIO_S8 :: 0x8008;
HAVE_ABS :: 1;
AUDIO_U16LSB :: 0x10;
HAVE_BCOPY :: 1;
AUDIO_S16LSB :: 0x8010;
HAVE_MEMSET :: 1;
AUDIO_U16MSB :: 0x1010;
HAVE_MEMCPY :: 1;
AUDIO_S16MSB :: 0x9010;
HAVE_MEMMOVE :: 1;
AUDIO_U16 :: AUDIO_U16LSB;
HAVE_MEMCMP :: 1;
AUDIO_S16 :: AUDIO_S16LSB;
HAVE_WCSLEN :: 1;
HAVE_WCSDUP :: 1;
HAVE_WCSSTR :: 1;
HAVE_WCSCMP :: 1;
HAVE_WCSNCMP :: 1;
AUDIO_S32LSB :: 0x8020;
HAVE_WCSCASECMP :: 1;
AUDIO_S32MSB :: 0x9020;
AUDIO_S32 :: AUDIO_S32LSB;
HAVE_WCSNCASECMP :: 1;
HAVE_STRLEN :: 1;
AUDIO_F32LSB :: 0x8120;
AUDIO_F32MSB :: 0x9120;
AUDIO_F32 :: AUDIO_F32LSB;
HAVE_STRCHR :: 1;
HAVE_STRRCHR :: 1;
HAVE_STRSTR :: 1;
HAVE_STRTOK_R :: 1;
AUDIO_U16SYS :: AUDIO_U16LSB;
AUDIO_S16SYS :: AUDIO_S16LSB;
AUDIO_S32SYS :: AUDIO_S32LSB;
HAVE_STRTOL :: 1;
AUDIO_F32SYS :: AUDIO_F32LSB;
HAVE_STRTOUL :: 1;
HAVE_STRTOLL :: 1;
HAVE_STRTOULL :: 1;
HAVE_STRTOD :: 1;
HAVE_ATOI :: 1;
HAVE_ATOF :: 1;
HAVE_STRCMP :: 1;
HAVE_STRNCMP :: 1;
HAVE_STRCASECMP :: 1;
HAVE_STRNCASECMP :: 1;
HAVE_SSCANF :: 1;
AUDIO_ALLOW_FREQUENCY_CHANGE :: 0x1;
HAVE_VSSCANF :: 1;
AUDIO_ALLOW_FORMAT_CHANGE :: 0x2;
HAVE_VSNPRINTF :: 1;
AUDIO_ALLOW_CHANNELS_CHANGE :: 0x4;
HAVE_M_PI :: 1;
AUDIO_ALLOW_SAMPLES_CHANGE :: 0x8;
HAVE_ACOS :: 1;
AUDIO_ALLOW_ANY_CHANGE :: (AUDIO_ALLOW_FREQUENCY_CHANGE | AUDIO_ALLOW_FORMAT_CHANGE | AUDIO_ALLOW_CHANNELS_CHANGE | AUDIO_ALLOW_SAMPLES_CHANGE);
HAVE_ACOSF :: 1;
HAVE_ASIN :: 1;
HAVE_ASINF :: 1;
HAVE_ATAN :: 1;
HAVE_ATANF :: 1;
HAVE_ATAN2 :: 1;
HAVE_ATAN2F :: 1;
HAVE_CEIL :: 1;
HAVE_CEILF :: 1;
HAVE_COPYSIGN :: 1;
HAVE_COPYSIGNF :: 1;
HAVE_COS :: 1;
HAVE_COSF :: 1;
HAVE_EXP :: 1;
HAVE_EXPF :: 1;
HAVE_FABS :: 1;
HAVE_FABSF :: 1;
HAVE_FLOOR :: 1;
HAVE_FLOORF :: 1;
HAVE_FMOD :: 1;
HAVE_FMODF :: 1;
HAVE_LOG :: 1;
HAVE_LOGF :: 1;
HAVE_LOG10 :: 1;
HAVE_LOG10F :: 1;
HAVE_POW :: 1;
HAVE_POWF :: 1;
HAVE_SCALBN :: 1;
HAVE_SCALBNF :: 1;
HAVE_SIN :: 1;
HAVE_SINF :: 1;
HAVE_SQRT :: 1;
HAVE_SQRTF :: 1;
HAVE_TAN :: 1;
HAVE_TANF :: 1;
HAVE_TRUNC :: 1;
HAVE_TRUNCF :: 1;
HAVE_FSEEKO :: 1;
HAVE_SIGACTION :: 1;
HAVE_SA_SIGACTION :: 1;
HAVE_SETJMP :: 1;
HAVE_NANOSLEEP :: 1;
HAVE_SYSCONF :: 1;
HAVE_CLOCK_GETTIME :: 1;
HAVE_MPROTECT :: 1;
HAVE_ICONV :: 1;
HAVE_SEM_TIMEDWAIT :: 1;
HAVE_GETAUXVAL :: 1;
HAVE_POLL :: 1;
HAVE__EXIT :: 1;
AUDIOCVT_MAX_FILTERS :: 9;
HAVE_DBUS_DBUS_H :: 1;
HAVE_FCITX :: 1;
HAVE_IBUS_IBUS_H :: 1;
HAVE_SYS_INOTIFY_H :: 1;
HAVE_INOTIFY_INIT :: 1;
HAVE_INOTIFY_INIT1 :: 1;
HAVE_INOTIFY :: 1;
HAVE_IMMINTRIN_H :: 1;
HAVE_LIBUDEV_H :: 1;
HAVE_LIBSAMPLERATE_H :: 1;
HAVE_XINPUT_H :: 1;
AUDIO_DRIVER_ALSA :: 1;
AUDIO_DRIVER_ALSA_DYNAMIC :: "libasound.so.2";
AUDIO_DRIVER_DISK :: 1;
AUDIO_DRIVER_DUMMY :: 1;
CACHELINE_SIZE :: 128;
HINT_RENDER_OPENGL_SHADERS :: "SDL_RENDER_OPENGL_SHADERS";
TEXTEDITINGEVENT_TEXT_SIZE :: (32);
TEXTINPUTEVENT_TEXT_SIZE :: (32);
HAPTIC_CONSTANT :: (1 << 0);
HAPTIC_SINE :: (1 << 1);
HAPTIC_LEFTRIGHT :: (1 << 2);
HAPTIC_TRIANGLE :: (1 << 3);
HAPTIC_SAWTOOTHUP :: (1 << 4);
HAPTIC_SAWTOOTHDOWN :: (1 << 5);
HAPTIC_RAMP :: (1 << 6);
HAPTIC_SPRING :: (1 << 7);
HAPTIC_DAMPER :: (1 << 8);
HAPTIC_INERTIA :: (1 << 9);
HINT_RENDER_DIRECT3D_THREADSAFE :: "SDL_RENDER_DIRECT3D_THREADSAFE";
IPHONE_MAX_GFORCE :: 5.000;
HINT_RENDER_DIRECT3D11_DEBUG :: "SDL_RENDER_DIRECT3D11_DEBUG";
HINT_RENDER_LOGICAL_SIZE_MODE :: "SDL_RENDER_LOGICAL_SIZE_MODE";
HAPTIC_FRICTION :: (1 << 10);
HAPTIC_CUSTOM :: (1 << 11);
HINT_RENDER_SCALE_QUALITY :: "SDL_RENDER_SCALE_QUALITY";
HINT_RENDER_VSYNC :: "SDL_RENDER_VSYNC";
HINT_VIDEO_ALLOW_SCREENSAVER :: "SDL_VIDEO_ALLOW_SCREENSAVER";
HINT_VIDEO_EXTERNAL_CONTEXT :: "SDL_VIDEO_EXTERNAL_CONTEXT";
HINT_VIDEO_X11_XVIDMODE :: "SDL_VIDEO_X11_XVIDMODE";
HINT_VIDEO_X11_XINERAMA :: "SDL_VIDEO_X11_XINERAMA";
HINT_VIDEO_X11_XRANDR :: "SDL_VIDEO_X11_XRANDR";
HINT_VIDEO_X11_WINDOW_VISUALID :: "SDL_VIDEO_X11_WINDOW_VISUALID";
HINT_VIDEO_X11_NET_WM_PING :: "SDL_VIDEO_X11_NET_WM_PING";
HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR :: "SDL_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR";
HINT_VIDEO_X11_FORCE_EGL :: "SDL_VIDEO_X11_FORCE_EGL";
HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN :: "SDL_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN";
HINT_WINDOWS_INTRESOURCE_ICON :: "SDL_WINDOWS_INTRESOURCE_ICON";
HINT_WINDOWS_INTRESOURCE_ICON_SMALL :: "SDL_WINDOWS_INTRESOURCE_ICON_SMALL";
AUDIO_DRIVER_JACK :: 1;
AUDIO_DRIVER_JACK_DYNAMIC :: "libjack.so.0";
AUDIO_DRIVER_OSS :: 1;
AUDIO_DRIVER_PULSEAUDIO :: 1;
AUDIO_DRIVER_PULSEAUDIO_DYNAMIC :: "libpulse-simple.so.0";
INPUT_LINUXEV :: 1;
INPUT_LINUXKD :: 1;
JOYSTICK_LINUX :: 1;
JOYSTICK_HIDAPI :: 1;
JOYSTICK_VIRTUAL :: 1;
HAPTIC_LINUX :: 1;
LIBUSB_DYNAMIC :: "";
SENSOR_DUMMY :: 1;
LOADSO_DLOPEN :: 1;
THREAD_PTHREAD :: 1;
THREAD_PTHREAD_RECURSIVE_MUTEX :: 1;
TIMER_UNIX :: 1;
VIDEO_DRIVER_DUMMY :: 1;
VIDEO_DRIVER_WAYLAND :: 1;
VIDEO_DRIVER_KMSDRM :: 1;
VIDEO_DRIVER_KMSDRM_DYNAMIC :: "libdrm.so.2";
VIDEO_DRIVER_KMSDRM_DYNAMIC_GBM :: "libgbm.so.1";
VIDEO_DRIVER_WAYLAND_QT_TOUCH :: 1;
VIDEO_DRIVER_WAYLAND_DYNAMIC :: "libwayland-client.so.0";
VIDEO_DRIVER_WAYLAND_DYNAMIC_EGL :: "libwayland-egl.so.1";
VIDEO_DRIVER_WAYLAND_DYNAMIC_CURSOR :: "libwayland-cursor.so.0";
VIDEO_DRIVER_WAYLAND_DYNAMIC_XKBCOMMON :: "libxkbcommon.so.0";
VIDEO_DRIVER_X11 :: 1;
VIDEO_DRIVER_X11_DYNAMIC :: "libX11.so.6";
VIDEO_DRIVER_X11_DYNAMIC_XEXT :: "libXext.so.6";
VIDEO_DRIVER_X11_DYNAMIC_XCURSOR :: "libXcursor.so.1";
VIDEO_DRIVER_X11_DYNAMIC_XINERAMA :: "libXinerama.so.1";
VIDEO_DRIVER_X11_DYNAMIC_XINPUT2 :: "libXi.so.6";
VIDEO_DRIVER_X11_DYNAMIC_XRANDR :: "libXrandr.so.2";
VIDEO_DRIVER_X11_DYNAMIC_XSS :: "libXss.so.1";
VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE :: "libXxf86vm.so.1";
VIDEO_DRIVER_X11_XCURSOR :: 1;
VIDEO_DRIVER_X11_XINERAMA :: 1;
VIDEO_DRIVER_X11_XINPUT2 :: 1;
VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH :: 1;
VIDEO_DRIVER_X11_XRANDR :: 1;
VIDEO_DRIVER_X11_XSCRNSAVER :: 1;
VIDEO_DRIVER_X11_XSHAPE :: 1;
VIDEO_DRIVER_X11_XVIDMODE :: 1;
VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS :: 1;
VIDEO_DRIVER_X11_CONST_PARAM_XEXTADDDISPLAY :: 1;
VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM :: 1;
VIDEO_RENDER_OGL :: 1;
VIDEO_RENDER_OGL_ES2 :: 1;
VIDEO_OPENGL :: 1;
VIDEO_OPENGL_ES2 :: 1;
VIDEO_OPENGL_GLX :: 1;
VIDEO_OPENGL_EGL :: 1;
VIDEO_VULKAN :: 1;
POWER_LINUX :: 1;
FILESYSTEM_UNIX :: 1;
ASSEMBLY_ROUTINES :: 1;
LIBSAMPLERATE_DYNAMIC :: "libsamplerate.so.0";
MIX_MAXVOLUME :: 128;
HAPTIC_GAIN :: (1 << 12);
HINT_WINDOWS_ENABLE_MESSAGELOOP :: "SDL_WINDOWS_ENABLE_MESSAGELOOP";
HAPTIC_AUTOCENTER :: (1 << 13);
HINT_GRAB_KEYBOARD :: "SDL_GRAB_KEYBOARD";
HAPTIC_STATUS :: (1 << 14);
HINT_MOUSE_DOUBLE_CLICK_TIME :: "SDL_MOUSE_DOUBLE_CLICK_TIME";
HINT_MOUSE_DOUBLE_CLICK_RADIUS :: "SDL_MOUSE_DOUBLE_CLICK_RADIUS";
HAPTIC_PAUSE :: (1 << 15);
HINT_MOUSE_NORMAL_SPEED_SCALE :: "SDL_MOUSE_NORMAL_SPEED_SCALE";
QUERY :: -1;
IGNORE :: 0;
DISABLE :: 0;
ENABLE :: 1;
HINT_MOUSE_RELATIVE_SPEED_SCALE :: "SDL_MOUSE_RELATIVE_SPEED_SCALE";
HAPTIC_POLAR :: 0;
HINT_MOUSE_RELATIVE_SCALING :: "SDL_MOUSE_RELATIVE_SCALING";
HAPTIC_CARTESIAN :: 1;
HAPTIC_SPHERICAL :: 2;
HINT_MOUSE_RELATIVE_MODE_WARP :: "SDL_MOUSE_RELATIVE_MODE_WARP";
HAPTIC_STEERING_AXIS :: 3;
HINT_MOUSE_FOCUS_CLICKTHROUGH :: "SDL_MOUSE_FOCUS_CLICKTHROUGH";
HINT_TOUCH_MOUSE_EVENTS :: "SDL_TOUCH_MOUSE_EVENTS";
HAPTIC_INFINITY :: 4294967295;
JOYSTICK_AXIS_MAX :: 32767;
JOYSTICK_AXIS_MIN :: -32768;
HINT_MOUSE_TOUCH_EVENTS :: "SDL_MOUSE_TOUCH_EVENTS";
HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS :: "SDL_VIDEO_MINIMIZE_ON_FOCUS_LOSS";
HINT_IDLE_TIMER_DISABLED :: "SDL_IOS_IDLE_TIMER_DISABLED";
HINT_ORIENTATIONS :: "SDL_IOS_ORIENTATIONS";
HINT_APPLE_TV_CONTROLLER_UI_EVENTS :: "SDL_APPLE_TV_CONTROLLER_UI_EVENTS";
HINT_APPLE_TV_REMOTE_ALLOW_ROTATION :: "SDL_APPLE_TV_REMOTE_ALLOW_ROTATION";
HINT_IOS_HIDE_HOME_INDICATOR :: "SDL_IOS_HIDE_HOME_INDICATOR";
HINT_ACCELEROMETER_AS_JOYSTICK :: "SDL_ACCELEROMETER_AS_JOYSTICK";
HAT_CENTERED :: 0x0;
HAT_UP :: 0x1;
HAT_RIGHT :: 0x2;
HAT_DOWN :: 0x4;
HAT_LEFT :: 0x8;
HAT_RIGHTUP :: (HAT_RIGHT | HAT_UP);
HAT_RIGHTDOWN :: (HAT_RIGHT | HAT_DOWN);
HAT_LEFTUP :: (HAT_LEFT | HAT_UP);
HAT_LEFTDOWN :: (HAT_LEFT | HAT_DOWN);
HINT_TV_REMOTE_AS_JOYSTICK :: "SDL_TV_REMOTE_AS_JOYSTICK";
HINT_XINPUT_ENABLED :: "SDL_XINPUT_ENABLED";
HINT_XINPUT_USE_OLD_JOYSTICK_MAPPING :: "SDL_XINPUT_USE_OLD_JOYSTICK_MAPPING";
HINT_GAMECONTROLLERTYPE :: "SDL_GAMECONTROLLERTYPE";
HINT_GAMECONTROLLERCONFIG :: "SDL_GAMECONTROLLERCONFIG";
HINT_GAMECONTROLLERCONFIG_FILE :: "SDL_GAMECONTROLLERCONFIG_FILE";
HINT_GAMECONTROLLER_IGNORE_DEVICES :: "SDL_GAMECONTROLLER_IGNORE_DEVICES";
HINT_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT :: "SDL_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT";
HINT_GAMECONTROLLER_USE_BUTTON_LABELS :: "SDL_GAMECONTROLLER_USE_BUTTON_LABELS";
HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS :: "SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS";
HINT_JOYSTICK_HIDAPI :: "SDL_JOYSTICK_HIDAPI";
HINT_JOYSTICK_HIDAPI_PS4 :: "SDL_JOYSTICK_HIDAPI_PS4";
HINT_JOYSTICK_HIDAPI_PS5 :: "SDL_JOYSTICK_HIDAPI_PS5";
HINT_JOYSTICK_HIDAPI_PS4_RUMBLE :: "SDL_JOYSTICK_HIDAPI_PS4_RUMBLE";
HINT_JOYSTICK_HIDAPI_STEAM :: "SDL_JOYSTICK_HIDAPI_STEAM";
HINT_JOYSTICK_HIDAPI_SWITCH :: "SDL_JOYSTICK_HIDAPI_SWITCH";
HINT_JOYSTICK_HIDAPI_XBOX :: "SDL_JOYSTICK_HIDAPI_XBOX";
HINT_JOYSTICK_HIDAPI_CORRELATE_XINPUT :: "SDL_JOYSTICK_HIDAPI_CORRELATE_XINPUT";
HINT_JOYSTICK_HIDAPI_GAMECUBE :: "SDL_JOYSTICK_HIDAPI_GAMECUBE";
HINT_ENABLE_STEAM_CONTROLLERS :: "SDL_ENABLE_STEAM_CONTROLLERS";
HINT_JOYSTICK_RAWINPUT :: "SDL_JOYSTICK_RAWINPUT";
HINT_JOYSTICK_THREAD :: "SDL_JOYSTICK_THREAD";
HINT_LINUX_JOYSTICK_DEADZONES :: "SDL_LINUX_JOYSTICK_DEADZONES";
HINT_ALLOW_TOPMOST :: "SDL_ALLOW_TOPMOST";
HINT_TIMER_RESOLUTION :: "SDL_TIMER_RESOLUTION";
HINT_QTWAYLAND_CONTENT_ORIENTATION :: "SDL_QTWAYLAND_CONTENT_ORIENTATION";
HINT_QTWAYLAND_WINDOW_FLAGS :: "SDL_QTWAYLAND_WINDOW_FLAGS";
HINT_THREAD_STACK_SIZE :: "SDL_THREAD_STACK_SIZE";
HINT_THREAD_PRIORITY_POLICY :: "SDL_THREAD_PRIORITY_POLICY";
HINT_THREAD_FORCE_REALTIME_TIME_CRITICAL :: "SDL_THREAD_FORCE_REALTIME_TIME_CRITICAL";
HINT_VIDEO_HIGHDPI_DISABLED :: "SDL_VIDEO_HIGHDPI_DISABLED";
HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK :: "SDL_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK";
HINT_VIDEO_WIN_D3DCOMPILER :: "SDL_VIDEO_WIN_D3DCOMPILER";
HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT :: "SDL_VIDEO_WINDOW_SHARE_PIXEL_FORMAT";
HINT_WINRT_PRIVACY_POLICY_URL :: "SDL_WINRT_PRIVACY_POLICY_URL";
HINT_WINRT_PRIVACY_POLICY_LABEL :: "SDL_WINRT_PRIVACY_POLICY_LABEL";
HINT_WINRT_HANDLE_BACK_BUTTON :: "SDL_WINRT_HANDLE_BACK_BUTTON";
HINT_VIDEO_MAC_FULLSCREEN_SPACES :: "SDL_VIDEO_MAC_FULLSCREEN_SPACES";
HINT_MAC_BACKGROUND_APP :: "SDL_MAC_BACKGROUND_APP";
HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION :: "SDL_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION";
HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION :: "SDL_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION";
HINT_IME_INTERNAL_EDITING :: "SDL_IME_INTERNAL_EDITING";
HINT_ANDROID_TRAP_BACK_BUTTON :: "SDL_ANDROID_TRAP_BACK_BUTTON";
HINT_ANDROID_BLOCK_ON_PAUSE :: "SDL_ANDROID_BLOCK_ON_PAUSE";
HINT_ANDROID_BLOCK_ON_PAUSE_PAUSEAUDIO :: "SDL_ANDROID_BLOCK_ON_PAUSE_PAUSEAUDIO";
HINT_RETURN_KEY_HIDES_IME :: "SDL_RETURN_KEY_HIDES_IME";
HINT_EMSCRIPTEN_KEYBOARD_ELEMENT :: "SDL_EMSCRIPTEN_KEYBOARD_ELEMENT";
HINT_EMSCRIPTEN_ASYNCIFY :: "SDL_EMSCRIPTEN_ASYNCIFY";
HINT_NO_SIGNAL_HANDLERS :: "SDL_NO_SIGNAL_HANDLERS";
HINT_WINDOWS_NO_CLOSE_ON_ALT_F4 :: "SDL_WINDOWS_NO_CLOSE_ON_ALT_F4";
HINT_BMP_SAVE_LEGACY_FORMAT :: "SDL_BMP_SAVE_LEGACY_FORMAT";
HINT_WINDOWS_DISABLE_THREAD_NAMING :: "SDL_WINDOWS_DISABLE_THREAD_NAMING";
HINT_RPI_VIDEO_LAYER :: "SDL_RPI_VIDEO_LAYER";
HINT_VIDEO_DOUBLE_BUFFER :: "SDL_VIDEO_DOUBLE_BUFFER";
HINT_OPENGL_ES_DRIVER :: "SDL_OPENGL_ES_DRIVER";
HINT_AUDIO_RESAMPLING_MODE :: "SDL_AUDIO_RESAMPLING_MODE";
HINT_AUDIO_CATEGORY :: "SDL_AUDIO_CATEGORY";
HINT_RENDER_BATCHING :: "SDL_RENDER_BATCHING";
HINT_AUTO_UPDATE_JOYSTICKS :: "SDL_AUTO_UPDATE_JOYSTICKS";
HINT_AUTO_UPDATE_SENSORS :: "SDL_AUTO_UPDATE_SENSORS";
HINT_EVENT_LOGGING :: "SDL_EVENT_LOGGING";
HINT_WAVE_RIFF_CHUNK_SIZE :: "SDL_WAVE_RIFF_CHUNK_SIZE";
HINT_WAVE_TRUNCATION :: "SDL_WAVE_TRUNCATION";
HINT_WAVE_FACT_CHUNK :: "SDL_WAVE_FACT_CHUNK";
HINT_DISPLAY_USABLE_BOUNDS :: "SDL_DISPLAY_USABLE_BOUNDS";
HINT_AUDIO_DEVICE_APP_NAME :: "SDL_AUDIO_DEVICE_APP_NAME";
HINT_AUDIO_DEVICE_STREAM_NAME :: "SDL_AUDIO_DEVICE_STREAM_NAME";
HINT_PREFERRED_LOCALES :: "SDL_PREFERRED_LOCALES";
MUTEX_TIMEDOUT :: 1;
RWOPS_UNKNOWN :: 0;
NONSHAPEABLE_WINDOW :: -1;
RWOPS_WINFILE :: 1;
RWOPS_STDFILE :: 2;
K_SCANCODE_MASK :: (1 << 30);
RWOPS_JNIFILE :: 3;
ALPHA_OPAQUE :: 255;
ALPHA_TRANSPARENT :: 0;
RWOPS_MEMORY :: 4;
RWOPS_MEMORY_RO :: 5;
MUTEX_MAXWAIT :: (~(Uint32)(0));
MAX_LOG_MESSAGE :: 4096;
__LINUX__ :: 1;
BUTTON_LEFT :: 1;
BUTTON_MIDDLE :: 2;
BUTTON_RIGHT :: 3;
BUTTON_X1 :: 4;
BUTTON_X2 :: 5;
RW_SEEK_SET :: 0;
RW_SEEK_CUR :: 1;
RW_SEEK_END :: 2;
INVALID_SHAPE_ARGUMENT :: -2;
WINDOW_LACKS_SHAPE :: -3;
SWSURFACE :: 0;
PREALLOC :: 0x1;
RLEACCEL :: 0x2;
DONTFREE :: 0x4;
SIMD_ALIGNED :: 0x8;
MAJOR_VERSION :: 2;
TOUCH_MOUSEID :: (~(Uint32)(0));
MINOR_VERSION :: 0;
PATCHLEVEL :: 14;
STANDARD_GRAVITY :: 9.807;
MAX_SINT8 :: ((Sint8)(0x7F));
MIN_SINT8 :: (~(Sint8)(0x7F));
MAX_UINT8 :: ((Uint8)(0xFF));
MIN_UINT8 :: ((Uint8)(0x0));
MAX_SINT16 :: ((Sint16)(0x7FFF));
MIN_SINT16 :: (~(Sint16)(0x7FFF));
MAX_UINT16 :: ((Uint16)(0xFFFF));
MIN_UINT16 :: ((Uint16)(0x0));
MAX_SINT32 :: ((Sint32)(0x7FFFFFFF));
MIN_SINT32 :: (~(Sint32)(0x7FFFFFFF));
MAX_UINT32 :: ((Uint32)(0xFFFFFFFF));
MIN_UINT32 :: ((Uint32)(0x0));
MAX_SINT64 :: ((Sint64)(0x7FFFFFFFFFFFFFFF));
MIN_SINT64 :: (~(Sint64)(0x7FFFFFFFFFFFFFFF));
MAX_UINT64 :: ((Uint64)(0xFFFFFFFFFFFFFFFF));
MIN_UINT64 :: ((Uint64)(0x0));
PRIs64 :: "ld";
ICONV_ERROR :: ~(uint)(0);
ICONV_E2BIG :: ~(uint)(1);
ICONV_EILSEQ :: ~(uint)(2);
ICONV_EINVAL :: ~(uint)(3);
MOUSE_TOUCHID :: ((Sint64)(-1));
WINDOWPOS_UNDEFINED_MASK :: 0x1FFF0000;
WINDOWPOS_CENTERED_MASK :: 0x2FFF0000;
_GameController :: struct {};
FILE :: _IO_FILE;
_IO_FILE :: struct {};
BlendMode :: _c.int;
/* <ENUM> :: enum { */
BLENDMODE_NONE :: 0x0;
BLENDMODE_BLEND :: 0x1;
BLENDMODE_ADD :: 0x2;
BLENDMODE_MOD :: 0x4;
BLENDMODE_MUL :: 0x8;
BLENDMODE_INVALID :: 0x7FFFFFFF;
/* } */;
BlendOperation :: _c.int;
/* <ENUM> :: enum { */
BLENDOPERATION_ADD :: 0x1;
BLENDOPERATION_SUBTRACT :: 0x2;
BLENDOPERATION_REV_SUBTRACT :: 0x3;
BLENDOPERATION_MINIMUM :: 0x4;
BLENDOPERATION_MAXIMUM :: 0x5;
/* } */;
GestureID :: Sint64;
EventType :: _c.int;
/* <ENUM> :: enum { */
FIRSTEVENT :: 0;
QUIT :: 0x100;
APP_TERMINATING :: 0x101;
APP_LOWMEMORY :: 0x102;
APP_WILLENTERBACKGROUND :: 0x103;
APP_DIDENTERBACKGROUND :: 0x104;
APP_WILLENTERFOREGROUND :: 0x105;
APP_DIDENTERFOREGROUND :: 0x106;
LOCALECHANGED :: 0x107;
DISPLAYEVENT :: 0x150;
WINDOWEVENT :: 0x200;
SYSWMEVENT :: 0x201;
KEYDOWN :: 0x300;
KEYUP :: 0x301;
TEXTEDITING :: 0x302;
TEXTINPUT :: 0x303;
KEYMAPCHANGED :: 0x304;
MOUSEMOTION :: 0x400;
MOUSEBUTTONDOWN :: 0x401;
MOUSEBUTTONUP :: 0x402;
MOUSEWHEEL :: 0x403;
JOYAXISMOTION :: 0x600;
JOYBALLMOTION :: 0x601;
JOYHATMOTION :: 0x602;
JOYBUTTONDOWN :: 0x603;
JOYBUTTONUP :: 0x604;
JOYDEVICEADDED :: 0x605;
JOYDEVICEREMOVED :: 0x606;
CONTROLLERAXISMOTION :: 0x650;
CONTROLLERBUTTONDOWN :: 0x651;
CONTROLLERBUTTONUP :: 0x652;
CONTROLLERDEVICEADDED :: 0x653;
CONTROLLERDEVICEREMOVED :: 0x654;
CONTROLLERDEVICEREMAPPED :: 0x655;
CONTROLLERTOUCHPADDOWN :: 0x656;
CONTROLLERTOUCHPADMOTION :: 0x657;
CONTROLLERTOUCHPADUP :: 0x658;
CONTROLLERSENSORUPDATE :: 0x659;
FINGERDOWN :: 0x700;
FINGERUP :: 0x701;
FINGERMOTION :: 0x702;
DOLLARGESTURE :: 0x800;
DOLLARRECORD :: 0x801;
MULTIGESTURE :: 0x802;
CLIPBOARDUPDATE :: 0x900;
DROPFILE :: 0x1000;
DROPTEXT :: 0x1001;
DROPBEGIN :: 0x1002;
DROPCOMPLETE :: 0x1003;
AUDIODEVICEADDED :: 0x1100;
AUDIODEVICEREMOVED :: 0x1101;
SENSORUPDATE :: 0x1200;
RENDER_TARGETS_RESET :: 0x2000;
RENDER_DEVICE_RESET :: 0x2001;
USEREVENT :: 0x8000;
LASTEVENT :: 0xFFFF;
/* } */;
GameController :: _GameController;
_Joystick :: struct {};
AudioFormat :: Uint16;
GameControllerType :: _c.int;
/* <ENUM> :: enum { */
CONTROLLER_TYPE_UNKNOWN :: 0;
CONTROLLER_TYPE_XBOX360 :: 1;
CONTROLLER_TYPE_XBOXONE :: 2;
CONTROLLER_TYPE_PS3 :: 3;
CONTROLLER_TYPE_PS4 :: 4;
CONTROLLER_TYPE_NINTENDO_SWITCH_PRO :: 5;
CONTROLLER_TYPE_VIRTUAL :: 6;
CONTROLLER_TYPE_PS5 :: 7;
/* } */;
Joystick :: _Joystick;
_Haptic :: struct {};
JoystickGUID :: struct {
data : [16]Uint8,
};
SpinLock :: _c.int;
AssertState :: _c.int;
/* <ENUM> :: enum { */
ASSERTION_RETRY :: 0;
ASSERTION_BREAK :: 1;
ASSERTION_ABORT :: 2;
ASSERTION_IGNORE :: 3;
ASSERTION_ALWAYS_IGNORE :: 4;
/* } */;
AssertData :: struct {
always_ignore : _c.int,
trigger_count : _c.uint,
condition : cstring,
filename : cstring,
linenum : _c.int,
function : cstring,
next : ^AssertData,
};
atomic_t :: struct {
value : _c.int,
};
GameControllerBindType :: _c.int;
/* <ENUM> :: enum { */
CONTROLLER_BINDTYPE_NONE :: 0;
CONTROLLER_BINDTYPE_BUTTON :: 1;
CONTROLLER_BINDTYPE_AXIS :: 2;
CONTROLLER_BINDTYPE_HAT :: 3;
/* } */;
BlendFactor :: _c.int;
/* <ENUM> :: enum { */
BLENDFACTOR_ZERO :: 0x1;
BLENDFACTOR_ONE :: 0x2;
BLENDFACTOR_SRC_COLOR :: 0x3;
BLENDFACTOR_ONE_MINUS_SRC_COLOR :: 0x4;
BLENDFACTOR_SRC_ALPHA :: 0x5;
BLENDFACTOR_ONE_MINUS_SRC_ALPHA :: 0x6;
BLENDFACTOR_DST_COLOR :: 0x7;
BLENDFACTOR_ONE_MINUS_DST_COLOR :: 0x8;
BLENDFACTOR_DST_ALPHA :: 0x9;
BLENDFACTOR_ONE_MINUS_DST_ALPHA :: 0xA;
/* } */;
JoystickID :: Sint32;
JoystickType :: _c.int;
/* <ENUM> :: enum { */
JOYSTICK_TYPE_UNKNOWN :: 0;
JOYSTICK_TYPE_GAMECONTROLLER :: 1;
JOYSTICK_TYPE_WHEEL :: 2;
JOYSTICK_TYPE_ARCADE_STICK :: 3;
JOYSTICK_TYPE_FLIGHT_STICK :: 4;
JOYSTICK_TYPE_DANCE_PAD :: 5;
JOYSTICK_TYPE_GUITAR :: 6;
JOYSTICK_TYPE_DRUM_KIT :: 7;
JOYSTICK_TYPE_ARCADE_PAD :: 8;
JOYSTICK_TYPE_THROTTLE :: 9;
/* } */;
GameControllerButtonBind :: struct {
bindType : GameControllerBindType,
value : struct #raw_union {
button : _c.int,
axis : _c.int,
hat : struct {
hat : _c.int,
hat_mask : _c.int,
},
},
};
errorcode :: _c.int;
/* <ENUM> :: enum { */
ENOMEM :: 0;
EFREAD :: 1;
EFWRITE :: 2;
EFSEEK :: 3;
UNSUPPORTED :: 4;
LASTERROR :: 5;
/* } */;
AudioSpec :: struct {
freq : _c.int,
format : AudioFormat,
channels : Uint8,
silence : Uint8,
samples : Uint16,
padding : Uint16,
size : Uint32,
callback : AudioCallback,
userdata : rawptr,
};
AudioCVT :: struct {
needed : _c.int,
src_format : AudioFormat,
dst_format : AudioFormat,
rate_incr : _c.double,
buf : ^Uint8,
len : _c.int,
len_cvt : _c.int,
len_mult : _c.int,
len_ratio : _c.double,
filters : [9 + 1]AudioFilter,
filter_index : _c.int,
};
Haptic :: _Haptic;
CommonEvent :: struct {
type : Uint32,
timestamp : Uint32,
};
DisplayEvent :: struct {
type : Uint32,
timestamp : Uint32,
display : Uint32,
event : Uint8,
padding1 : Uint8,
padding2 : Uint8,
padding3 : Uint8,
data1 : Sint32,
};
WindowEvent :: struct {
type : Uint32,
timestamp : Uint32,
windowID : Uint32,
event : Uint8,
padding1 : Uint8,
padding2 : Uint8,
padding3 : Uint8,
data1 : Sint32,
data2 : Sint32,
};
KeyboardEvent :: struct {
type : Uint32,
timestamp : Uint32,
windowID : Uint32,
state : Uint8,
repeat : Uint8,
padding2 : Uint8,
padding3 : Uint8,
keysym : Keysym,
};
JoystickPowerLevel :: _c.int;
/* <ENUM> :: enum { */
JOYSTICK_POWER_UNKNOWN :: -1;
JOYSTICK_POWER_EMPTY :: 0;
JOYSTICK_POWER_LOW :: 1;
JOYSTICK_POWER_MEDIUM :: 2;
JOYSTICK_POWER_FULL :: 3;
JOYSTICK_POWER_WIRED :: 4;
JOYSTICK_POWER_MAX :: 5;
/* } */;
TextEditingEvent :: struct {
type : Uint32,
timestamp : Uint32,
windowID : Uint32,
text : [(32)]_c.char,
start : Sint32,
length : Sint32,
};
TextInputEvent :: struct {
type : Uint32,
timestamp : Uint32,
windowID : Uint32,
text : [(32)]_c.char,
};
MouseMotionEvent :: struct {
type : Uint32,
timestamp : Uint32,
windowID : Uint32,
which : Uint32,
state : Uint32,
x : Sint32,
y : Sint32,
xrel : Sint32,
yrel : Sint32,
};
bool :: _c.int;
/* <ENUM> :: enum { */
FALSE :: 0;
TRUE :: 1;
/* } */;
Sint8 :: i8;
Uint8 :: u8;
Sint16 :: i16;
Uint16 :: u16;
Sint32 :: i32;
Uint32 :: u32;
Sint64 :: i64;
Uint64 :: u64;
DUMMY_ENUM :: _c.int;
/* <ENUM> :: enum { */
DUMMY_ENUM_VALUE :: 0;
/* } */;
AssertionHandler :: (proc(data : ^AssertData, userdata : rawptr) -> AssertState);
semaphore :: struct {};
AudioCallback :: proc(userdata : rawptr, stream : ^Uint8, len : _c.int);
AudioFilter :: proc(cvt : ^AudioCVT, format : AudioFormat);
AudioDeviceID :: Uint32;
AudioStatus :: _c.int;
/* <ENUM> :: enum { */
AUDIO_STOPPED :: 0;
AUDIO_PLAYING :: 1;
AUDIO_PAUSED :: 2;
/* } */;
_AudioStream :: struct {};
AudioStream :: _AudioStream;
Locale :: struct {
language : cstring,
country : cstring,
};
MessageBoxFlags :: _c.int;
/* <ENUM> :: enum { */
MESSAGEBOX_ERROR :: 0x10;
MESSAGEBOX_WARNING :: 0x20;
MESSAGEBOX_INFORMATION :: 0x40;
MESSAGEBOX_BUTTONS_LEFT_TO_RIGHT :: 0x80;
MESSAGEBOX_BUTTONS_RIGHT_TO_LEFT :: 0x100;
/* } */;
MetalView :: rawptr;
MouseButtonEvent :: struct {
type : Uint32,
timestamp : Uint32,
windowID : Uint32,
which : Uint32,
button : Uint8,
state : Uint8,
clicks : Uint8,
padding1 : Uint8,
x : Sint32,
y : Sint32,
};
MouseWheelEvent :: struct {
type : Uint32,
timestamp : Uint32,
windowID : Uint32,
which : Uint32,
x : Sint32,
y : Sint32,
direction : Uint32,
};
JoyAxisEvent :: struct {
type : Uint32,
timestamp : Uint32,
which : JoystickID,
axis : Uint8,
padding1 : Uint8,
padding2 : Uint8,
padding3 : Uint8,
value : Sint16,
padding4 : Uint16,
};
JoyBallEvent :: struct {
type : Uint32,
timestamp : Uint32,
which : JoystickID,
ball : Uint8,
padding1 : Uint8,
padding2 : Uint8,
padding3 : Uint8,
xrel : Sint16,
yrel : Sint16,
};
JoyHatEvent :: struct {
type : Uint32,
timestamp : Uint32,
which : JoystickID,
hat : Uint8,
value : Uint8,
padding1 : Uint8,
padding2 : Uint8,
};
JoyButtonEvent :: struct {
type : Uint32,
timestamp : Uint32,
which : JoystickID,
button : Uint8,
state : Uint8,
padding1 : Uint8,
padding2 : Uint8,
};
JoyDeviceEvent :: struct {
type : Uint32,
timestamp : Uint32,
which : Sint32,
};
ControllerAxisEvent :: struct {
type : Uint32,
timestamp : Uint32,
which : JoystickID,
axis : Uint8,
padding1 : Uint8,
padding2 : Uint8,
padding3 : Uint8,
value : Sint16,
padding4 : Uint16,
};
ControllerButtonEvent :: struct {
type : Uint32,
timestamp : Uint32,
which : JoystickID,
button : Uint8,
state : Uint8,
padding1 : Uint8,
padding2 : Uint8,
};
ControllerDeviceEvent :: struct {
type : Uint32,
timestamp : Uint32,
which : Sint32,
};
ControllerTouchpadEvent :: struct {
type : Uint32,
timestamp : Uint32,
which : JoystickID,
touchpad : Sint32,
finger : Sint32,
x : _c.float,
y : _c.float,
pressure : _c.float,
};
ControllerSensorEvent :: struct {
type : Uint32,
timestamp : Uint32,
which : JoystickID,
sensor : Sint32,
data : [3]_c.float,
};
AudioDeviceEvent :: struct {
type : Uint32,
timestamp : Uint32,
which : Uint32,
iscapture : Uint8,
padding1 : Uint8,
padding2 : Uint8,
padding3 : Uint8,
};
TouchFingerEvent :: struct {
type : Uint32,
timestamp : Uint32,
touchId : TouchID,
fingerId : FingerID,
x : _c.float,
y : _c.float,
dx : _c.float,
dy : _c.float,
pressure : _c.float,
windowID : Uint32,
};
MultiGestureEvent :: struct {
type : Uint32,
timestamp : Uint32,
touchId : TouchID,
dTheta : _c.float,
dDist : _c.float,
x : _c.float,
y : _c.float,
numFingers : Uint16,
padding : Uint16,
};
DollarGestureEvent :: struct {
type : Uint32,
timestamp : Uint32,
touchId : TouchID,
gestureId : GestureID,
numFingers : Uint32,
error : _c.float,
x : _c.float,
y : _c.float,
};
DropEvent :: struct {
type : Uint32,
timestamp : Uint32,
file : cstring,
windowID : Uint32,
};
SensorEvent :: struct {
type : Uint32,
timestamp : Uint32,
which : Sint32,
data : [6]_c.float,
};
QuitEvent :: struct {
type : Uint32,
timestamp : Uint32,
};
UserEvent :: struct {
type : Uint32,
timestamp : Uint32,
windowID : Uint32,
code : Sint32,
data1 : rawptr,
data2 : rawptr,
};
SysWMmsg :: struct {};
SysWMEvent :: struct {
type : Uint32,
timestamp : Uint32,
msg : ^SysWMmsg,
};
Event :: struct #raw_union {
type : Uint32,
common : CommonEvent,
display : DisplayEvent,
window : WindowEvent,
key : KeyboardEvent,
edit : TextEditingEvent,
text : TextInputEvent,
motion : MouseMotionEvent,
button : MouseButtonEvent,
wheel : MouseWheelEvent,
jaxis : JoyAxisEvent,
jball : JoyBallEvent,
jhat : JoyHatEvent,
jbutton : JoyButtonEvent,
jdevice : JoyDeviceEvent,
caxis : ControllerAxisEvent,
cbutton : ControllerButtonEvent,
cdevice : ControllerDeviceEvent,
ctouchpad : ControllerTouchpadEvent,
csensor : ControllerSensorEvent,
adevice : AudioDeviceEvent,
sensor : SensorEvent,
quit : QuitEvent,
user : UserEvent,
syswm : SysWMEvent,
tfinger : TouchFingerEvent,
mgesture : MultiGestureEvent,
dgesture : DollarGestureEvent,
drop : DropEvent,
padding : [56]Uint8,
};
eventaction :: _c.int;
/* <ENUM> :: enum { */
ADDEVENT :: 0;
PEEKEVENT :: 1;
GETEVENT :: 2;
/* } */;
GameControllerAxis :: _c.int;
/* <ENUM> :: enum { */
CONTROLLER_AXIS_INVALID :: -1;
CONTROLLER_AXIS_LEFTX :: 0;
CONTROLLER_AXIS_LEFTY :: 1;
CONTROLLER_AXIS_RIGHTX :: 2;
CONTROLLER_AXIS_RIGHTY :: 3;
CONTROLLER_AXIS_TRIGGERLEFT :: 4;
CONTROLLER_AXIS_TRIGGERRIGHT :: 5;
CONTROLLER_AXIS_MAX :: 6;
/* } */;
GameControllerButton :: _c.int;
/* <ENUM> :: enum { */
CONTROLLER_BUTTON_INVALID :: -1;
CONTROLLER_BUTTON_A :: 0;
CONTROLLER_BUTTON_B :: 1;
CONTROLLER_BUTTON_X :: 2;
CONTROLLER_BUTTON_Y :: 3;
CONTROLLER_BUTTON_BACK :: 4;
CONTROLLER_BUTTON_GUIDE :: 5;
CONTROLLER_BUTTON_START :: 6;
CONTROLLER_BUTTON_LEFTSTICK :: 7;
CONTROLLER_BUTTON_RIGHTSTICK :: 8;
CONTROLLER_BUTTON_LEFTSHOULDER :: 9;
CONTROLLER_BUTTON_RIGHTSHOULDER :: 10;
CONTROLLER_BUTTON_DPAD_UP :: 11;
CONTROLLER_BUTTON_DPAD_DOWN :: 12;
CONTROLLER_BUTTON_DPAD_LEFT :: 13;
CONTROLLER_BUTTON_DPAD_RIGHT :: 14;
CONTROLLER_BUTTON_MISC1 :: 15;
CONTROLLER_BUTTON_PADDLE1 :: 16;
CONTROLLER_BUTTON_PADDLE2 :: 17;
CONTROLLER_BUTTON_PADDLE3 :: 18;
CONTROLLER_BUTTON_PADDLE4 :: 19;
CONTROLLER_BUTTON_TOUCHPAD :: 20;
CONTROLLER_BUTTON_MAX :: 21;
/* } */;
HapticDirection :: struct {
type : Uint8,
dir : [3]Sint32,
};
HapticConstant :: struct {
type : Uint16,
direction : HapticDirection,
length : Uint32,
delay : Uint16,
button : Uint16,
interval : Uint16,
level : Sint16,
attack_length : Uint16,
attack_level : Uint16,
fade_length : Uint16,
fade_level : Uint16,
};
HapticPeriodic :: struct {
type : Uint16,
direction : HapticDirection,
length : Uint32,
delay : Uint16,
button : Uint16,
interval : Uint16,
period : Uint16,
magnitude : Sint16,
offset : Sint16,
phase : Uint16,
attack_length : Uint16,
attack_level : Uint16,
fade_length : Uint16,
fade_level : Uint16,
};
HapticCondition :: struct {
type : Uint16,
direction : HapticDirection,
length : Uint32,
delay : Uint16,
button : Uint16,
interval : Uint16,
right_sat : [3]Uint16,
left_sat : [3]Uint16,
right_coeff : [3]Sint16,
left_coeff : [3]Sint16,
deadband : [3]Uint16,
center : [3]Sint16,
};
HapticRamp :: struct {
type : Uint16,
direction : HapticDirection,
length : Uint32,
delay : Uint16,
button : Uint16,
interval : Uint16,
start : Sint16,
end : Sint16,
attack_length : Uint16,
attack_level : Uint16,
fade_length : Uint16,
fade_level : Uint16,
};
HapticLeftRight :: struct {
type : Uint16,
length : Uint32,
large_magnitude : Uint16,
small_magnitude : Uint16,
};
HapticCustom :: struct {
type : Uint16,
direction : HapticDirection,
length : Uint32,
delay : Uint16,
button : Uint16,
interval : Uint16,
channels : Uint8,
period : Uint16,
samples : Uint16,
data : ^Uint16,
attack_length : Uint16,
attack_level : Uint16,
fade_length : Uint16,
fade_level : Uint16,
};
HapticEffect :: struct #raw_union {
type : Uint16,
constant : HapticConstant,
periodic : HapticPeriodic,
condition : HapticCondition,
ramp : HapticRamp,
leftright : HapticLeftRight,
custom : HapticCustom,
};
HintPriority :: _c.int;
/* <ENUM> :: enum { */
HINT_DEFAULT :: 0;
HINT_NORMAL :: 1;
HINT_OVERRIDE :: 2;
/* } */;
_Sensor :: struct {};
BlitMap :: struct {};
EventFilter :: (proc(userdata : rawptr, event : ^Event) -> _c.int);
HintCallback :: proc(userdata : rawptr, name : cstring, oldValue : cstring, newValue : cstring);
Cursor :: struct {};
PowerState :: _c.int;
/* <ENUM> :: enum { */
POWERSTATE_UNKNOWN :: 0;
POWERSTATE_ON_BATTERY :: 1;
POWERSTATE_NO_BATTERY :: 2;
POWERSTATE_CHARGING :: 3;
POWERSTATE_CHARGED :: 4;
/* } */;
TouchID :: Sint64;
FingerID :: Sint64;
Keysym :: struct {
scancode : Scancode,
sym : Keycode,
mod : Uint16,
unused : Uint32,
};
Keycode :: Sint32;
MessageBoxButtonFlags :: _c.int;
/* <ENUM> :: enum { */
MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT :: 0x1;
MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT :: 0x2;
/* } */;
SystemCursor :: _c.int;
/* <ENUM> :: enum { */
SYSTEM_CURSOR_ARROW :: 0;
SYSTEM_CURSOR_IBEAM :: 1;
SYSTEM_CURSOR_WAIT :: 2;
SYSTEM_CURSOR_CROSSHAIR :: 3;
SYSTEM_CURSOR_WAITARROW :: 4;
SYSTEM_CURSOR_SIZENWSE :: 5;
SYSTEM_CURSOR_SIZENESW :: 6;
SYSTEM_CURSOR_SIZEWE :: 7;
SYSTEM_CURSOR_SIZENS :: 8;
SYSTEM_CURSOR_SIZEALL :: 9;
SYSTEM_CURSOR_NO :: 10;
SYSTEM_CURSOR_HAND :: 11;
NUM_SYSTEM_CURSORS :: 12;
/* } */;
Point :: struct {
x : _c.int,
y : _c.int,
};
KeyCode :: _c.int;
/* <ENUM> :: enum { */
K_UNKNOWN :: 0;
K_RETURN :: '\r';
K_ESCAPE :: '\e';
K_BACKSPACE :: '\b';
K_TAB :: '\t';
K_SPACE :: ' ';
K_EXCLAIM :: '!';
K_QUOTEDBL :: '"';
K_HASH :: '#';
K_PERCENT :: '%';
K_DOLLAR :: '$';
K_AMPERSAND :: '&';
K_QUOTE :: '\'';
K_LEFTPAREN :: '(';
K_RIGHTPAREN :: ')';
K_ASTERISK :: '*';
K_PLUS :: '+';
K_COMMA :: ',';
K_MINUS :: '-';
K_PERIOD :: '.';
K_SLASH :: '/';
K_0 :: '0';
K_1 :: '1';
K_2 :: '2';
K_3 :: '3';
K_4 :: '4';
K_5 :: '5';
K_6 :: '6';
K_7 :: '7';
K_8 :: '8';
K_9 :: '9';
K_COLON :: ':';
K_SEMICOLON :: ';';
K_LESS :: '<';
K_EQUALS :: '=';
K_GREATER :: '>';
K_QUESTION :: '?';
K_AT :: '@';
K_LEFTBRACKET :: '[';
K_BACKSLASH :: '\\';
K_RIGHTBRACKET :: ']';
K_CARET :: '^';
K_UNDERSCORE :: '_';
K_BACKQUOTE :: '`';
K_a :: 'a';
K_b :: 'b';
K_c :: 'c';
K_d :: 'd';
K_e :: 'e';
K_f :: 'f';
K_g :: 'g';
K_h :: 'h';
K_i :: 'i';
K_j :: 'j';
K_k :: 'k';
K_l :: 'l';
K_m :: 'm';
K_n :: 'n';
K_o :: 'o';
K_p :: 'p';
K_q :: 'q';
K_r :: 'r';
K_s :: 's';
K_t :: 't';
K_u :: 'u';
K_v :: 'v';
K_w :: 'w';
K_x :: 'x';
K_y :: 'y';
K_z :: 'z';
K_CAPSLOCK :: (SCANCODE_CAPSLOCK | (1 << 30));
K_F1 :: (SCANCODE_F1 | (1 << 30));
K_F2 :: (SCANCODE_F2 | (1 << 30));
K_F3 :: (SCANCODE_F3 | (1 << 30));
K_F4 :: (SCANCODE_F4 | (1 << 30));
K_F5 :: (SCANCODE_F5 | (1 << 30));
K_F6 :: (SCANCODE_F6 | (1 << 30));
K_F7 :: (SCANCODE_F7 | (1 << 30));
K_F8 :: (SCANCODE_F8 | (1 << 30));
K_F9 :: (SCANCODE_F9 | (1 << 30));
K_F10 :: (SCANCODE_F10 | (1 << 30));
K_F11 :: (SCANCODE_F11 | (1 << 30));
K_F12 :: (SCANCODE_F12 | (1 << 30));
K_PRINTSCREEN :: (SCANCODE_PRINTSCREEN | (1 << 30));
K_SCROLLLOCK :: (SCANCODE_SCROLLLOCK | (1 << 30));
K_PAUSE :: (SCANCODE_PAUSE | (1 << 30));
K_INSERT :: (SCANCODE_INSERT | (1 << 30));
K_HOME :: (SCANCODE_HOME | (1 << 30));
K_PAGEUP :: (SCANCODE_PAGEUP | (1 << 30));
K_DELETE :: '';
K_END :: (SCANCODE_END | (1 << 30));
K_PAGEDOWN :: (SCANCODE_PAGEDOWN | (1 << 30));
K_RIGHT :: (SCANCODE_RIGHT | (1 << 30));
K_LEFT :: (SCANCODE_LEFT | (1 << 30));
K_DOWN :: (SCANCODE_DOWN | (1 << 30));
K_UP :: (SCANCODE_UP | (1 << 30));
K_NUMLOCKCLEAR :: (SCANCODE_NUMLOCKCLEAR | (1 << 30));
K_KP_DIVIDE :: (SCANCODE_KP_DIVIDE | (1 << 30));
K_KP_MULTIPLY :: (SCANCODE_KP_MULTIPLY | (1 << 30));
K_KP_MINUS :: (SCANCODE_KP_MINUS | (1 << 30));
K_KP_PLUS :: (SCANCODE_KP_PLUS | (1 << 30));
K_KP_ENTER :: (SCANCODE_KP_ENTER | (1 << 30));
K_KP_1 :: (SCANCODE_KP_1 | (1 << 30));
K_KP_2 :: (SCANCODE_KP_2 | (1 << 30));
K_KP_3 :: (SCANCODE_KP_3 | (1 << 30));
K_KP_4 :: (SCANCODE_KP_4 | (1 << 30));
K_KP_5 :: (SCANCODE_KP_5 | (1 << 30));
K_KP_6 :: (SCANCODE_KP_6 | (1 << 30));
K_KP_7 :: (SCANCODE_KP_7 | (1 << 30));
K_KP_8 :: (SCANCODE_KP_8 | (1 << 30));
K_KP_9 :: (SCANCODE_KP_9 | (1 << 30));
K_KP_0 :: (SCANCODE_KP_0 | (1 << 30));
K_KP_PERIOD :: (SCANCODE_KP_PERIOD | (1 << 30));
K_APPLICATION :: (SCANCODE_APPLICATION | (1 << 30));
K_POWER :: (SCANCODE_POWER | (1 << 30));
K_KP_EQUALS :: (SCANCODE_KP_EQUALS | (1 << 30));
K_F13 :: (SCANCODE_F13 | (1 << 30));
K_F14 :: (SCANCODE_F14 | (1 << 30));
K_F15 :: (SCANCODE_F15 | (1 << 30));
K_F16 :: (SCANCODE_F16 | (1 << 30));
K_F17 :: (SCANCODE_F17 | (1 << 30));
K_F18 :: (SCANCODE_F18 | (1 << 30));
K_F19 :: (SCANCODE_F19 | (1 << 30));
K_F20 :: (SCANCODE_F20 | (1 << 30));
K_F21 :: (SCANCODE_F21 | (1 << 30));
K_F22 :: (SCANCODE_F22 | (1 << 30));
K_F23 :: (SCANCODE_F23 | (1 << 30));
K_F24 :: (SCANCODE_F24 | (1 << 30));
K_EXECUTE :: (SCANCODE_EXECUTE | (1 << 30));
K_HELP :: (SCANCODE_HELP | (1 << 30));
K_MENU :: (SCANCODE_MENU | (1 << 30));
K_SELECT :: (SCANCODE_SELECT | (1 << 30));
K_STOP :: (SCANCODE_STOP | (1 << 30));
K_AGAIN :: (SCANCODE_AGAIN | (1 << 30));
K_UNDO :: (SCANCODE_UNDO | (1 << 30));
K_CUT :: (SCANCODE_CUT | (1 << 30));
K_COPY :: (SCANCODE_COPY | (1 << 30));
K_PASTE :: (SCANCODE_PASTE | (1 << 30));
K_FIND :: (SCANCODE_FIND | (1 << 30));
K_MUTE :: (SCANCODE_MUTE | (1 << 30));
K_VOLUMEUP :: (SCANCODE_VOLUMEUP | (1 << 30));
K_VOLUMEDOWN :: (SCANCODE_VOLUMEDOWN | (1 << 30));
K_KP_COMMA :: (SCANCODE_KP_COMMA | (1 << 30));
K_KP_EQUALSAS400 :: (SCANCODE_KP_EQUALSAS400 | (1 << 30));
K_ALTERASE :: (SCANCODE_ALTERASE | (1 << 30));
K_SYSREQ :: (SCANCODE_SYSREQ | (1 << 30));
K_CANCEL :: (SCANCODE_CANCEL | (1 << 30));
K_CLEAR :: (SCANCODE_CLEAR | (1 << 30));
K_PRIOR :: (SCANCODE_PRIOR | (1 << 30));
K_RETURN2 :: (SCANCODE_RETURN2 | (1 << 30));
K_SEPARATOR :: (SCANCODE_SEPARATOR | (1 << 30));
K_OUT :: (SCANCODE_OUT | (1 << 30));
K_OPER :: (SCANCODE_OPER | (1 << 30));
K_CLEARAGAIN :: (SCANCODE_CLEARAGAIN | (1 << 30));
K_CRSEL :: (SCANCODE_CRSEL | (1 << 30));
K_EXSEL :: (SCANCODE_EXSEL | (1 << 30));
K_KP_00 :: (SCANCODE_KP_00 | (1 << 30));
K_KP_000 :: (SCANCODE_KP_000 | (1 << 30));
K_THOUSANDSSEPARATOR :: (SCANCODE_THOUSANDSSEPARATOR | (1 << 30));
K_DECIMALSEPARATOR :: (SCANCODE_DECIMALSEPARATOR | (1 << 30));
K_CURRENCYUNIT :: (SCANCODE_CURRENCYUNIT | (1 << 30));
K_CURRENCYSUBUNIT :: (SCANCODE_CURRENCYSUBUNIT | (1 << 30));
K_KP_LEFTPAREN :: (SCANCODE_KP_LEFTPAREN | (1 << 30));
K_KP_RIGHTPAREN :: (SCANCODE_KP_RIGHTPAREN | (1 << 30));
K_KP_LEFTBRACE :: (SCANCODE_KP_LEFTBRACE | (1 << 30));
K_KP_RIGHTBRACE :: (SCANCODE_KP_RIGHTBRACE | (1 << 30));
K_KP_TAB :: (SCANCODE_KP_TAB | (1 << 30));
K_KP_BACKSPACE :: (SCANCODE_KP_BACKSPACE | (1 << 30));
K_KP_A :: (SCANCODE_KP_A | (1 << 30));
K_KP_B :: (SCANCODE_KP_B | (1 << 30));
K_KP_C :: (SCANCODE_KP_C | (1 << 30));
K_KP_D :: (SCANCODE_KP_D | (1 << 30));
K_KP_E :: (SCANCODE_KP_E | (1 << 30));
K_KP_F :: (SCANCODE_KP_F | (1 << 30));
K_KP_XOR :: (SCANCODE_KP_XOR | (1 << 30));
K_KP_POWER :: (SCANCODE_KP_POWER | (1 << 30));
K_KP_PERCENT :: (SCANCODE_KP_PERCENT | (1 << 30));
K_KP_LESS :: (SCANCODE_KP_LESS | (1 << 30));
K_KP_GREATER :: (SCANCODE_KP_GREATER | (1 << 30));
K_KP_AMPERSAND :: (SCANCODE_KP_AMPERSAND | (1 << 30));
K_KP_DBLAMPERSAND :: (SCANCODE_KP_DBLAMPERSAND | (1 << 30));
K_KP_VERTICALBAR :: (SCANCODE_KP_VERTICALBAR | (1 << 30));
K_KP_DBLVERTICALBAR :: (SCANCODE_KP_DBLVERTICALBAR | (1 << 30));
K_KP_COLON :: (SCANCODE_KP_COLON | (1 << 30));
K_KP_HASH :: (SCANCODE_KP_HASH | (1 << 30));
K_KP_SPACE :: (SCANCODE_KP_SPACE | (1 << 30));
K_KP_AT :: (SCANCODE_KP_AT | (1 << 30));
K_KP_EXCLAM :: (SCANCODE_KP_EXCLAM | (1 << 30));
K_KP_MEMSTORE :: (SCANCODE_KP_MEMSTORE | (1 << 30));
K_KP_MEMRECALL :: (SCANCODE_KP_MEMRECALL | (1 << 30));
K_KP_MEMCLEAR :: (SCANCODE_KP_MEMCLEAR | (1 << 30));
K_KP_MEMADD :: (SCANCODE_KP_MEMADD | (1 << 30));
K_KP_MEMSUBTRACT :: (SCANCODE_KP_MEMSUBTRACT | (1 << 30));
K_KP_MEMMULTIPLY :: (SCANCODE_KP_MEMMULTIPLY | (1 << 30));
K_KP_MEMDIVIDE :: (SCANCODE_KP_MEMDIVIDE | (1 << 30));
K_KP_PLUSMINUS :: (SCANCODE_KP_PLUSMINUS | (1 << 30));
K_KP_CLEAR :: (SCANCODE_KP_CLEAR | (1 << 30));
K_KP_CLEARENTRY :: (SCANCODE_KP_CLEARENTRY | (1 << 30));
K_KP_BINARY :: (SCANCODE_KP_BINARY | (1 << 30));
K_KP_OCTAL :: (SCANCODE_KP_OCTAL | (1 << 30));
K_KP_DECIMAL :: (SCANCODE_KP_DECIMAL | (1 << 30));
K_KP_HEXADECIMAL :: (SCANCODE_KP_HEXADECIMAL | (1 << 30));
K_LCTRL :: (SCANCODE_LCTRL | (1 << 30));
K_LSHIFT :: (SCANCODE_LSHIFT | (1 << 30));
K_LALT :: (SCANCODE_LALT | (1 << 30));
K_LGUI :: (SCANCODE_LGUI | (1 << 30));
K_RCTRL :: (SCANCODE_RCTRL | (1 << 30));
K_RSHIFT :: (SCANCODE_RSHIFT | (1 << 30));
K_RALT :: (SCANCODE_RALT | (1 << 30));
K_RGUI :: (SCANCODE_RGUI | (1 << 30));
K_MODE :: (SCANCODE_MODE | (1 << 30));
K_AUDIONEXT :: (SCANCODE_AUDIONEXT | (1 << 30));
K_AUDIOPREV :: (SCANCODE_AUDIOPREV | (1 << 30));
K_AUDIOSTOP :: (SCANCODE_AUDIOSTOP | (1 << 30));
K_AUDIOPLAY :: (SCANCODE_AUDIOPLAY | (1 << 30));
K_AUDIOMUTE :: (SCANCODE_AUDIOMUTE | (1 << 30));
K_MEDIASELECT :: (SCANCODE_MEDIASELECT | (1 << 30));
K_WWW :: (SCANCODE_WWW | (1 << 30));
K_MAIL :: (SCANCODE_MAIL | (1 << 30));
K_CALCULATOR :: (SCANCODE_CALCULATOR | (1 << 30));
K_COMPUTER :: (SCANCODE_COMPUTER | (1 << 30));
K_AC_SEARCH :: (SCANCODE_AC_SEARCH | (1 << 30));
K_AC_HOME :: (SCANCODE_AC_HOME | (1 << 30));
K_AC_BACK :: (SCANCODE_AC_BACK | (1 << 30));
K_AC_FORWARD :: (SCANCODE_AC_FORWARD | (1 << 30));
K_AC_STOP :: (SCANCODE_AC_STOP | (1 << 30));
K_AC_REFRESH :: (SCANCODE_AC_REFRESH | (1 << 30));
K_AC_BOOKMARKS :: (SCANCODE_AC_BOOKMARKS | (1 << 30));
K_BRIGHTNESSDOWN :: (SCANCODE_BRIGHTNESSDOWN | (1 << 30));
K_BRIGHTNESSUP :: (SCANCODE_BRIGHTNESSUP | (1 << 30));
K_DISPLAYSWITCH :: (SCANCODE_DISPLAYSWITCH | (1 << 30));
K_KBDILLUMTOGGLE :: (SCANCODE_KBDILLUMTOGGLE | (1 << 30));
K_KBDILLUMDOWN :: (SCANCODE_KBDILLUMDOWN | (1 << 30));
K_KBDILLUMUP :: (SCANCODE_KBDILLUMUP | (1 << 30));
K_EJECT :: (SCANCODE_EJECT | (1 << 30));
K_SLEEP :: (SCANCODE_SLEEP | (1 << 30));
K_APP1 :: (SCANCODE_APP1 | (1 << 30));
K_APP2 :: (SCANCODE_APP2 | (1 << 30));
K_AUDIOREWIND :: (SCANCODE_AUDIOREWIND | (1 << 30));
K_AUDIOFASTFORWARD :: (SCANCODE_AUDIOFASTFORWARD | (1 << 30));
/* } */;
MessageBoxButtonData :: struct {
flags : Uint32,
buttonid : _c.int,
text : cstring,
};
mutex :: struct {};
LogCategory :: _c.int;
/* <ENUM> :: enum { */
LOG_CATEGORY_APPLICATION :: 0;
LOG_CATEGORY_ERROR :: 1;
LOG_CATEGORY_ASSERT :: 2;
LOG_CATEGORY_SYSTEM :: 3;
LOG_CATEGORY_AUDIO :: 4;
LOG_CATEGORY_VIDEO :: 5;
LOG_CATEGORY_RENDER :: 6;
LOG_CATEGORY_INPUT :: 7;
LOG_CATEGORY_TEST :: 8;
LOG_CATEGORY_RESERVED1 :: 9;
LOG_CATEGORY_RESERVED2 :: 10;
LOG_CATEGORY_RESERVED3 :: 11;
LOG_CATEGORY_RESERVED4 :: 12;
LOG_CATEGORY_RESERVED5 :: 13;
LOG_CATEGORY_RESERVED6 :: 14;
LOG_CATEGORY_RESERVED7 :: 15;
LOG_CATEGORY_RESERVED8 :: 16;
LOG_CATEGORY_RESERVED9 :: 17;
LOG_CATEGORY_RESERVED10 :: 18;
LOG_CATEGORY_CUSTOM :: 19;
/* } */;
MessageBoxColor :: struct {
r : Uint8,
g : Uint8,
b : Uint8,
};
MessageBoxColorType :: _c.int;
/* <ENUM> :: enum { */
MESSAGEBOX_COLOR_BACKGROUND :: 0;
MESSAGEBOX_COLOR_TEXT :: 1;
MESSAGEBOX_COLOR_BUTTON_BORDER :: 2;
MESSAGEBOX_COLOR_BUTTON_BACKGROUND :: 3;
MESSAGEBOX_COLOR_BUTTON_SELECTED :: 4;
MESSAGEBOX_COLOR_MAX :: 5;
/* } */;
MessageBoxColorScheme :: struct {
colors : [MESSAGEBOX_COLOR_MAX]MessageBoxColor,
};
MessageBoxData :: struct {
flags : Uint32,
window : ^Window,
title : cstring,
message : cstring,
numbuttons : _c.int,
buttons : ^MessageBoxButtonData,
colorScheme : ^MessageBoxColorScheme,
};
LogPriority :: _c.int;
/* <ENUM> :: enum { */
LOG_PRIORITY_VERBOSE :: 1;
LOG_PRIORITY_DEBUG :: 2;
LOG_PRIORITY_INFO :: 3;
LOG_PRIORITY_WARN :: 4;
LOG_PRIORITY_ERROR :: 5;
LOG_PRIORITY_CRITICAL :: 6;
NUM_LOG_PRIORITIES :: 7;
/* } */;
LogOutputFunction :: proc(userdata : rawptr, category : _c.int, priority : LogPriority, message : cstring);
PixelType :: _c.int;
/* <ENUM> :: enum { */
PIXELTYPE_UNKNOWN :: 0;
PIXELTYPE_INDEX1 :: 1;
PIXELTYPE_INDEX4 :: 2;
PIXELTYPE_INDEX8 :: 3;
PIXELTYPE_PACKED8 :: 4;
PIXELTYPE_PACKED16 :: 5;
PIXELTYPE_PACKED32 :: 6;
PIXELTYPE_ARRAYU8 :: 7;
PIXELTYPE_ARRAYU16 :: 8;
PIXELTYPE_ARRAYU32 :: 9;
PIXELTYPE_ARRAYF16 :: 10;
PIXELTYPE_ARRAYF32 :: 11;
/* } */;
RWops :: struct {
size : (proc(context_ : ^RWops) -> Sint64),
seek : (proc(context_ : ^RWops, offset : Sint64, whence : _c.int) -> Sint64),
read : (proc(context_ : ^RWops, ptr : rawptr, size : uint, maxnum : uint) -> uint),
write : (proc(context_ : ^RWops, ptr : rawptr, size : uint, num : uint) -> uint),
close : (proc(context_ : ^RWops) -> _c.int),
type : Uint32,
hidden : struct #raw_union {
stdio : struct {
autoclose : bool,
fp : ^FILE,
},
mem : struct {
base : ^Uint8,
here : ^Uint8,
stop : ^Uint8,
},
unknown : struct {
data1 : rawptr,
data2 : rawptr,
},
},
};
FPoint :: struct {
x : _c.float,
y : _c.float,
};
RendererFlags :: _c.int;
/* <ENUM> :: enum { */
RENDERER_SOFTWARE :: 0x1;
RENDERER_ACCELERATED :: 0x2;
RENDERER_PRESENTVSYNC :: 0x4;
RENDERER_TARGETTEXTURE :: 0x8;
/* } */;
MouseWheelDirection :: _c.int;
/* <ENUM> :: enum { */
MOUSEWHEEL_NORMAL :: 0;
MOUSEWHEEL_FLIPPED :: 1;
/* } */;
sem :: semaphore;
cond :: struct {};
BitmapOrder :: _c.int;
/* <ENUM> :: enum { */
BITMAPORDER_NONE :: 0;
BITMAPORDER_4321 :: 1;
BITMAPORDER_1234 :: 2;
/* } */;
PackedOrder :: _c.int;
/* <ENUM> :: enum { */
PACKEDORDER_NONE :: 0;
PACKEDORDER_XRGB :: 1;
PACKEDORDER_RGBX :: 2;
PACKEDORDER_ARGB :: 3;
PACKEDORDER_RGBA :: 4;
PACKEDORDER_XBGR :: 5;
PACKEDORDER_BGRX :: 6;
PACKEDORDER_ABGR :: 7;
PACKEDORDER_BGRA :: 8;
/* } */;
ArrayOrder :: _c.int;
/* <ENUM> :: enum { */
ARRAYORDER_NONE :: 0;
ARRAYORDER_RGB :: 1;
ARRAYORDER_RGBA :: 2;
ARRAYORDER_ARGB :: 3;
ARRAYORDER_BGR :: 4;
ARRAYORDER_BGRA :: 5;
ARRAYORDER_ABGR :: 6;
/* } */;
PackedLayout :: _c.int;
/* <ENUM> :: enum { */
PACKEDLAYOUT_NONE :: 0;
PACKEDLAYOUT_332 :: 1;
PACKEDLAYOUT_4444 :: 2;
PACKEDLAYOUT_1555 :: 3;
PACKEDLAYOUT_5551 :: 4;
PACKEDLAYOUT_565 :: 5;
PACKEDLAYOUT_8888 :: 6;
PACKEDLAYOUT_2101010 :: 7;
PACKEDLAYOUT_1010102 :: 8;
/* } */;
PixelFormatEnum :: _c.int;
/* <ENUM> :: enum { */
PIXELFORMAT_UNKNOWN :: 0;
PIXELFORMAT_INDEX1LSB :: ((1 << 28) | ((PIXELTYPE_INDEX1) << 24) | ((BITMAPORDER_4321) << 20) | ((0) << 16) | ((1) << 8) | ((0) << 0));
PIXELFORMAT_INDEX1MSB :: ((1 << 28) | ((PIXELTYPE_INDEX1) << 24) | ((BITMAPORDER_1234) << 20) | ((0) << 16) | ((1) << 8) | ((0) << 0));
PIXELFORMAT_INDEX4LSB :: ((1 << 28) | ((PIXELTYPE_INDEX4) << 24) | ((BITMAPORDER_4321) << 20) | ((0) << 16) | ((4) << 8) | ((0) << 0));
PIXELFORMAT_INDEX4MSB :: ((1 << 28) | ((PIXELTYPE_INDEX4) << 24) | ((BITMAPORDER_1234) << 20) | ((0) << 16) | ((4) << 8) | ((0) << 0));
PIXELFORMAT_INDEX8 :: ((1 << 28) | ((PIXELTYPE_INDEX8) << 24) | ((0) << 20) | ((0) << 16) | ((8) << 8) | ((1) << 0));
PIXELFORMAT_RGB332 :: ((1 << 28) | ((PIXELTYPE_PACKED8) << 24) | ((PACKEDORDER_XRGB) << 20) | ((PACKEDLAYOUT_332) << 16) | ((8) << 8) | ((1) << 0));
PIXELFORMAT_XRGB4444 :: ((1 << 28) | ((PIXELTYPE_PACKED16) << 24) | ((PACKEDORDER_XRGB) << 20) | ((PACKEDLAYOUT_4444) << 16) | ((12) << 8) | ((2) << 0));
PIXELFORMAT_RGB444 :: PIXELFORMAT_XRGB4444;
PIXELFORMAT_XBGR4444 :: ((1 << 28) | ((PIXELTYPE_PACKED16) << 24) | ((PACKEDORDER_XBGR) << 20) | ((PACKEDLAYOUT_4444) << 16) | ((12) << 8) | ((2) << 0));
PIXELFORMAT_BGR444 :: PIXELFORMAT_XBGR4444;
PIXELFORMAT_XRGB1555 :: ((1 << 28) | ((PIXELTYPE_PACKED16) << 24) | ((PACKEDORDER_XRGB) << 20) | ((PACKEDLAYOUT_1555) << 16) | ((15) << 8) | ((2) << 0));
PIXELFORMAT_RGB555 :: PIXELFORMAT_XRGB1555;
PIXELFORMAT_XBGR1555 :: ((1 << 28) | ((PIXELTYPE_PACKED16) << 24) | ((PACKEDORDER_XBGR) << 20) | ((PACKEDLAYOUT_1555) << 16) | ((15) << 8) | ((2) << 0));
PIXELFORMAT_BGR555 :: PIXELFORMAT_XBGR1555;
PIXELFORMAT_ARGB4444 :: ((1 << 28) | ((PIXELTYPE_PACKED16) << 24) | ((PACKEDORDER_ARGB) << 20) | ((PACKEDLAYOUT_4444) << 16) | ((16) << 8) | ((2) << 0));
PIXELFORMAT_RGBA4444 :: ((1 << 28) | ((PIXELTYPE_PACKED16) << 24) | ((PACKEDORDER_RGBA) << 20) | ((PACKEDLAYOUT_4444) << 16) | ((16) << 8) | ((2) << 0));
PIXELFORMAT_ABGR4444 :: ((1 << 28) | ((PIXELTYPE_PACKED16) << 24) | ((PACKEDORDER_ABGR) << 20) | ((PACKEDLAYOUT_4444) << 16) | ((16) << 8) | ((2) << 0));
PIXELFORMAT_BGRA4444 :: ((1 << 28) | ((PIXELTYPE_PACKED16) << 24) | ((PACKEDORDER_BGRA) << 20) | ((PACKEDLAYOUT_4444) << 16) | ((16) << 8) | ((2) << 0));
PIXELFORMAT_ARGB1555 :: ((1 << 28) | ((PIXELTYPE_PACKED16) << 24) | ((PACKEDORDER_ARGB) << 20) | ((PACKEDLAYOUT_1555) << 16) | ((16) << 8) | ((2) << 0));
PIXELFORMAT_RGBA5551 :: ((1 << 28) | ((PIXELTYPE_PACKED16) << 24) | ((PACKEDORDER_RGBA) << 20) | ((PACKEDLAYOUT_5551) << 16) | ((16) << 8) | ((2) << 0));
PIXELFORMAT_ABGR1555 :: ((1 << 28) | ((PIXELTYPE_PACKED16) << 24) | ((PACKEDORDER_ABGR) << 20) | ((PACKEDLAYOUT_1555) << 16) | ((16) << 8) | ((2) << 0));
PIXELFORMAT_BGRA5551 :: ((1 << 28) | ((PIXELTYPE_PACKED16) << 24) | ((PACKEDORDER_BGRA) << 20) | ((PACKEDLAYOUT_5551) << 16) | ((16) << 8) | ((2) << 0));
PIXELFORMAT_RGB565 :: ((1 << 28) | ((PIXELTYPE_PACKED16) << 24) | ((PACKEDORDER_XRGB) << 20) | ((PACKEDLAYOUT_565) << 16) | ((16) << 8) | ((2) << 0));
PIXELFORMAT_BGR565 :: ((1 << 28) | ((PIXELTYPE_PACKED16) << 24) | ((PACKEDORDER_XBGR) << 20) | ((PACKEDLAYOUT_565) << 16) | ((16) << 8) | ((2) << 0));
PIXELFORMAT_RGB24 :: ((1 << 28) | ((PIXELTYPE_ARRAYU8) << 24) | ((ARRAYORDER_RGB) << 20) | ((0) << 16) | ((24) << 8) | ((3) << 0));
PIXELFORMAT_BGR24 :: ((1 << 28) | ((PIXELTYPE_ARRAYU8) << 24) | ((ARRAYORDER_BGR) << 20) | ((0) << 16) | ((24) << 8) | ((3) << 0));
PIXELFORMAT_XRGB8888 :: ((1 << 28) | ((PIXELTYPE_PACKED32) << 24) | ((PACKEDORDER_XRGB) << 20) | ((PACKEDLAYOUT_8888) << 16) | ((24) << 8) | ((4) << 0));
PIXELFORMAT_RGB888 :: PIXELFORMAT_XRGB8888;
PIXELFORMAT_RGBX8888 :: ((1 << 28) | ((PIXELTYPE_PACKED32) << 24) | ((PACKEDORDER_RGBX) << 20) | ((PACKEDLAYOUT_8888) << 16) | ((24) << 8) | ((4) << 0));
PIXELFORMAT_XBGR8888 :: ((1 << 28) | ((PIXELTYPE_PACKED32) << 24) | ((PACKEDORDER_XBGR) << 20) | ((PACKEDLAYOUT_8888) << 16) | ((24) << 8) | ((4) << 0));
PIXELFORMAT_BGR888 :: PIXELFORMAT_XBGR8888;
PIXELFORMAT_BGRX8888 :: ((1 << 28) | ((PIXELTYPE_PACKED32) << 24) | ((PACKEDORDER_BGRX) << 20) | ((PACKEDLAYOUT_8888) << 16) | ((24) << 8) | ((4) << 0));
PIXELFORMAT_ARGB8888 :: ((1 << 28) | ((PIXELTYPE_PACKED32) << 24) | ((PACKEDORDER_ARGB) << 20) | ((PACKEDLAYOUT_8888) << 16) | ((32) << 8) | ((4) << 0));
PIXELFORMAT_RGBA8888 :: ((1 << 28) | ((PIXELTYPE_PACKED32) << 24) | ((PACKEDORDER_RGBA) << 20) | ((PACKEDLAYOUT_8888) << 16) | ((32) << 8) | ((4) << 0));
PIXELFORMAT_ABGR8888 :: ((1 << 28) | ((PIXELTYPE_PACKED32) << 24) | ((PACKEDORDER_ABGR) << 20) | ((PACKEDLAYOUT_8888) << 16) | ((32) << 8) | ((4) << 0));
PIXELFORMAT_BGRA8888 :: ((1 << 28) | ((PIXELTYPE_PACKED32) << 24) | ((PACKEDORDER_BGRA) << 20) | ((PACKEDLAYOUT_8888) << 16) | ((32) << 8) | ((4) << 0));
PIXELFORMAT_ARGB2101010 :: ((1 << 28) | ((PIXELTYPE_PACKED32) << 24) | ((PACKEDORDER_ARGB) << 20) | ((PACKEDLAYOUT_2101010) << 16) | ((32) << 8) | ((4) << 0));
PIXELFORMAT_RGBA32 :: PIXELFORMAT_ABGR8888;
PIXELFORMAT_ARGB32 :: PIXELFORMAT_BGRA8888;
PIXELFORMAT_BGRA32 :: PIXELFORMAT_ARGB8888;
PIXELFORMAT_ABGR32 :: PIXELFORMAT_RGBA8888;
PIXELFORMAT_YV12 :: ((((Uint32)(((Uint8)(('Y'))))) << 0) | (((Uint32)(((Uint8)(('V'))))) << 8) | (((Uint32)(((Uint8)(('1'))))) << 16) | (((Uint32)(((Uint8)(('2'))))) << 24));
PIXELFORMAT_IYUV :: ((((Uint32)(((Uint8)(('I'))))) << 0) | (((Uint32)(((Uint8)(('Y'))))) << 8) | (((Uint32)(((Uint8)(('U'))))) << 16) | (((Uint32)(((Uint8)(('V'))))) << 24));
PIXELFORMAT_YUY2 :: ((((Uint32)(((Uint8)(('Y'))))) << 0) | (((Uint32)(((Uint8)(('U'))))) << 8) | (((Uint32)(((Uint8)(('Y'))))) << 16) | (((Uint32)(((Uint8)(('2'))))) << 24));
PIXELFORMAT_UYVY :: ((((Uint32)(((Uint8)(('U'))))) << 0) | (((Uint32)(((Uint8)(('Y'))))) << 8) | (((Uint32)(((Uint8)(('V'))))) << 16) | (((Uint32)(((Uint8)(('Y'))))) << 24));
PIXELFORMAT_YVYU :: ((((Uint32)(((Uint8)(('Y'))))) << 0) | (((Uint32)(((Uint8)(('V'))))) << 8) | (((Uint32)(((Uint8)(('Y'))))) << 16) | (((Uint32)(((Uint8)(('U'))))) << 24));
PIXELFORMAT_NV12 :: ((((Uint32)(((Uint8)(('N'))))) << 0) | (((Uint32)(((Uint8)(('V'))))) << 8) | (((Uint32)(((Uint8)(('1'))))) << 16) | (((Uint32)(((Uint8)(('2'))))) << 24));
PIXELFORMAT_NV21 :: ((((Uint32)(((Uint8)(('N'))))) << 0) | (((Uint32)(((Uint8)(('V'))))) << 8) | (((Uint32)(((Uint8)(('2'))))) << 16) | (((Uint32)(((Uint8)(('1'))))) << 24));
PIXELFORMAT_EXTERNAL_OES :: ((((Uint32)(((Uint8)(('O'))))) << 0) | (((Uint32)(((Uint8)(('E'))))) << 8) | (((Uint32)(((Uint8)(('S'))))) << 16) | (((Uint32)(((Uint8)((' '))))) << 24));
/* } */;
Color :: struct {
r : Uint8,
g : Uint8,
b : Uint8,
a : Uint8,
};
Palette :: struct {
ncolors : _c.int,
colors : ^Color,
version : Uint32,
refcount : _c.int,
};
PixelFormat :: struct {
format : Uint32,
palette : ^Palette,
BitsPerPixel : Uint8,
BytesPerPixel : Uint8,
padding : [2]Uint8,
Rmask : Uint32,
Gmask : Uint32,
Bmask : Uint32,
Amask : Uint32,
Rloss : Uint8,
Gloss : Uint8,
Bloss : Uint8,
Aloss : Uint8,
Rshift : Uint8,
Gshift : Uint8,
Bshift : Uint8,
Ashift : Uint8,
refcount : _c.int,
next : ^PixelFormat,
};
Rect :: struct {
x : _c.int,
y : _c.int,
w : _c.int,
h : _c.int,
};
RendererInfo :: struct {
name : cstring,
flags : Uint32,
num_texture_formats : Uint32,
texture_formats : [16]Uint32,
max_texture_width : _c.int,
max_texture_height : _c.int,
};
FRect :: struct {
x : _c.float,
y : _c.float,
w : _c.float,
h : _c.float,
};
ScaleMode :: _c.int;
/* <ENUM> :: enum { */
ScaleModeNearest :: 0;
ScaleModeLinear :: 1;
ScaleModeBest :: 2;
/* } */;
TextureAccess :: _c.int;
/* <ENUM> :: enum { */
TEXTUREACCESS_STATIC :: 0;
TEXTUREACCESS_STREAMING :: 1;
TEXTUREACCESS_TARGET :: 2;
/* } */;
TextureModulate :: _c.int;
/* <ENUM> :: enum { */
TEXTUREMODULATE_NONE :: 0x0;
TEXTUREMODULATE_COLOR :: 0x1;
TEXTUREMODULATE_ALPHA :: 0x2;
/* } */;
RendererFlip :: _c.int;
/* <ENUM> :: enum { */
FLIP_NONE :: 0x0;
FLIP_HORIZONTAL :: 0x1;
FLIP_VERTICAL :: 0x2;
/* } */;
Renderer :: struct {};
Texture :: struct {};
Keymod :: _c.int;
/* <ENUM> :: enum { */
KMOD_NONE :: 0x0;
KMOD_LSHIFT :: 0x1;
KMOD_RSHIFT :: 0x2;
KMOD_LCTRL :: 0x40;
KMOD_RCTRL :: 0x80;
KMOD_LALT :: 0x100;
KMOD_RALT :: 0x200;
KMOD_LGUI :: 0x400;
KMOD_RGUI :: 0x800;
KMOD_NUM :: 0x1000;
KMOD_CAPS :: 0x2000;
KMOD_MODE :: 0x4000;
KMOD_RESERVED :: 0x8000;
KMOD_CTRL :: KMOD_LCTRL | KMOD_RCTRL;
KMOD_SHIFT :: KMOD_LSHIFT | KMOD_RSHIFT;
KMOD_ALT :: KMOD_LALT | KMOD_RALT;
KMOD_GUI :: KMOD_LGUI | KMOD_RGUI;
/* } */;
Scancode :: _c.int;
/* <ENUM> :: enum { */
SCANCODE_UNKNOWN :: 0;
SCANCODE_A :: 4;
SCANCODE_B :: 5;
SCANCODE_C :: 6;
SCANCODE_D :: 7;
SCANCODE_E :: 8;
SCANCODE_F :: 9;
SCANCODE_G :: 10;
SCANCODE_H :: 11;
SCANCODE_I :: 12;
SCANCODE_J :: 13;
SCANCODE_K :: 14;
SCANCODE_L :: 15;
SCANCODE_M :: 16;
SCANCODE_N :: 17;
SCANCODE_O :: 18;
SCANCODE_P :: 19;
SCANCODE_Q :: 20;
SCANCODE_R :: 21;
SCANCODE_S :: 22;
SCANCODE_T :: 23;
SCANCODE_U :: 24;
SCANCODE_V :: 25;
SCANCODE_W :: 26;
SCANCODE_X :: 27;
SCANCODE_Y :: 28;
SCANCODE_Z :: 29;
SCANCODE_1 :: 30;
SCANCODE_2 :: 31;
SCANCODE_3 :: 32;
SCANCODE_4 :: 33;
SCANCODE_5 :: 34;
SCANCODE_6 :: 35;
SCANCODE_7 :: 36;
SCANCODE_8 :: 37;
SCANCODE_9 :: 38;
SCANCODE_0 :: 39;
SCANCODE_RETURN :: 40;
SCANCODE_ESCAPE :: 41;
SCANCODE_BACKSPACE :: 42;
SCANCODE_TAB :: 43;
SCANCODE_SPACE :: 44;
SCANCODE_MINUS :: 45;
SCANCODE_EQUALS :: 46;
SCANCODE_LEFTBRACKET :: 47;
SCANCODE_RIGHTBRACKET :: 48;
SCANCODE_BACKSLASH :: 49;
SCANCODE_NONUSHASH :: 50;
SCANCODE_SEMICOLON :: 51;
SCANCODE_APOSTROPHE :: 52;
SCANCODE_GRAVE :: 53;
SCANCODE_COMMA :: 54;
SCANCODE_PERIOD :: 55;
SCANCODE_SLASH :: 56;
SCANCODE_CAPSLOCK :: 57;
SCANCODE_F1 :: 58;
SCANCODE_F2 :: 59;
SCANCODE_F3 :: 60;
SCANCODE_F4 :: 61;
SCANCODE_F5 :: 62;
SCANCODE_F6 :: 63;
SCANCODE_F7 :: 64;
SCANCODE_F8 :: 65;
SCANCODE_F9 :: 66;
SCANCODE_F10 :: 67;
SCANCODE_F11 :: 68;
SCANCODE_F12 :: 69;
SCANCODE_PRINTSCREEN :: 70;
SCANCODE_SCROLLLOCK :: 71;
SCANCODE_PAUSE :: 72;
SCANCODE_INSERT :: 73;
SCANCODE_HOME :: 74;
SCANCODE_PAGEUP :: 75;
SCANCODE_DELETE :: 76;
SCANCODE_END :: 77;
SCANCODE_PAGEDOWN :: 78;
SCANCODE_RIGHT :: 79;
SCANCODE_LEFT :: 80;
SCANCODE_DOWN :: 81;
SCANCODE_UP :: 82;
SCANCODE_NUMLOCKCLEAR :: 83;
SCANCODE_KP_DIVIDE :: 84;
SCANCODE_KP_MULTIPLY :: 85;
SCANCODE_KP_MINUS :: 86;
SCANCODE_KP_PLUS :: 87;
SCANCODE_KP_ENTER :: 88;
SCANCODE_KP_1 :: 89;
SCANCODE_KP_2 :: 90;
SCANCODE_KP_3 :: 91;
SCANCODE_KP_4 :: 92;
SCANCODE_KP_5 :: 93;
SCANCODE_KP_6 :: 94;
SCANCODE_KP_7 :: 95;
SCANCODE_KP_8 :: 96;
SCANCODE_KP_9 :: 97;
SCANCODE_KP_0 :: 98;
SCANCODE_KP_PERIOD :: 99;
SCANCODE_NONUSBACKSLASH :: 100;
SCANCODE_APPLICATION :: 101;
SCANCODE_POWER :: 102;
SCANCODE_KP_EQUALS :: 103;
SCANCODE_F13 :: 104;
SCANCODE_F14 :: 105;
SCANCODE_F15 :: 106;
SCANCODE_F16 :: 107;
SCANCODE_F17 :: 108;
SCANCODE_F18 :: 109;
SCANCODE_F19 :: 110;
SCANCODE_F20 :: 111;
SCANCODE_F21 :: 112;
SCANCODE_F22 :: 113;
SCANCODE_F23 :: 114;
SCANCODE_F24 :: 115;
SCANCODE_EXECUTE :: 116;
SCANCODE_HELP :: 117;
SCANCODE_MENU :: 118;
SCANCODE_SELECT :: 119;
SCANCODE_STOP :: 120;
SCANCODE_AGAIN :: 121;
SCANCODE_UNDO :: 122;
SCANCODE_CUT :: 123;
SCANCODE_COPY :: 124;
SCANCODE_PASTE :: 125;
SCANCODE_FIND :: 126;
SCANCODE_MUTE :: 127;
SCANCODE_VOLUMEUP :: 128;
SCANCODE_VOLUMEDOWN :: 129;
SCANCODE_KP_COMMA :: 133;
SCANCODE_KP_EQUALSAS400 :: 134;
SCANCODE_INTERNATIONAL1 :: 135;
SCANCODE_INTERNATIONAL2 :: 136;
SCANCODE_INTERNATIONAL3 :: 137;
SCANCODE_INTERNATIONAL4 :: 138;
SCANCODE_INTERNATIONAL5 :: 139;
SCANCODE_INTERNATIONAL6 :: 140;
SCANCODE_INTERNATIONAL7 :: 141;
SCANCODE_INTERNATIONAL8 :: 142;
SCANCODE_INTERNATIONAL9 :: 143;
SCANCODE_LANG1 :: 144;
SCANCODE_LANG2 :: 145;
SCANCODE_LANG3 :: 146;
SCANCODE_LANG4 :: 147;
SCANCODE_LANG5 :: 148;
SCANCODE_LANG6 :: 149;
SCANCODE_LANG7 :: 150;
SCANCODE_LANG8 :: 151;
SCANCODE_LANG9 :: 152;
SCANCODE_ALTERASE :: 153;
SCANCODE_SYSREQ :: 154;
SCANCODE_CANCEL :: 155;
SCANCODE_CLEAR :: 156;
SCANCODE_PRIOR :: 157;
SCANCODE_RETURN2 :: 158;
SCANCODE_SEPARATOR :: 159;
SCANCODE_OUT :: 160;
SCANCODE_OPER :: 161;
SCANCODE_CLEARAGAIN :: 162;
SCANCODE_CRSEL :: 163;
SCANCODE_EXSEL :: 164;
SCANCODE_KP_00 :: 176;
SCANCODE_KP_000 :: 177;
SCANCODE_THOUSANDSSEPARATOR :: 178;
SCANCODE_DECIMALSEPARATOR :: 179;
SCANCODE_CURRENCYUNIT :: 180;
SCANCODE_CURRENCYSUBUNIT :: 181;
SCANCODE_KP_LEFTPAREN :: 182;
SCANCODE_KP_RIGHTPAREN :: 183;
SCANCODE_KP_LEFTBRACE :: 184;
SCANCODE_KP_RIGHTBRACE :: 185;
SCANCODE_KP_TAB :: 186;
SCANCODE_KP_BACKSPACE :: 187;
SCANCODE_KP_A :: 188;
SCANCODE_KP_B :: 189;
SCANCODE_KP_C :: 190;
SCANCODE_KP_D :: 191;
SCANCODE_KP_E :: 192;
SCANCODE_KP_F :: 193;
SCANCODE_KP_XOR :: 194;
SCANCODE_KP_POWER :: 195;
SCANCODE_KP_PERCENT :: 196;
SCANCODE_KP_LESS :: 197;
SCANCODE_KP_GREATER :: 198;
SCANCODE_KP_AMPERSAND :: 199;
SCANCODE_KP_DBLAMPERSAND :: 200;
SCANCODE_KP_VERTICALBAR :: 201;
SCANCODE_KP_DBLVERTICALBAR :: 202;
SCANCODE_KP_COLON :: 203;
SCANCODE_KP_HASH :: 204;
SCANCODE_KP_SPACE :: 205;
SCANCODE_KP_AT :: 206;
SCANCODE_KP_EXCLAM :: 207;
SCANCODE_KP_MEMSTORE :: 208;
SCANCODE_KP_MEMRECALL :: 209;
SCANCODE_KP_MEMCLEAR :: 210;
SCANCODE_KP_MEMADD :: 211;
SCANCODE_KP_MEMSUBTRACT :: 212;
SCANCODE_KP_MEMMULTIPLY :: 213;
SCANCODE_KP_MEMDIVIDE :: 214;
SCANCODE_KP_PLUSMINUS :: 215;
SCANCODE_KP_CLEAR :: 216;
SCANCODE_KP_CLEARENTRY :: 217;
SCANCODE_KP_BINARY :: 218;
SCANCODE_KP_OCTAL :: 219;
SCANCODE_KP_DECIMAL :: 220;
SCANCODE_KP_HEXADECIMAL :: 221;
SCANCODE_LCTRL :: 224;
SCANCODE_LSHIFT :: 225;
SCANCODE_LALT :: 226;
SCANCODE_LGUI :: 227;
SCANCODE_RCTRL :: 228;
SCANCODE_RSHIFT :: 229;
SCANCODE_RALT :: 230;
SCANCODE_RGUI :: 231;
SCANCODE_MODE :: 257;
SCANCODE_AUDIONEXT :: 258;
SCANCODE_AUDIOPREV :: 259;
SCANCODE_AUDIOSTOP :: 260;
SCANCODE_AUDIOPLAY :: 261;
SCANCODE_AUDIOMUTE :: 262;
SCANCODE_MEDIASELECT :: 263;
SCANCODE_WWW :: 264;
SCANCODE_MAIL :: 265;
SCANCODE_CALCULATOR :: 266;
SCANCODE_COMPUTER :: 267;
SCANCODE_AC_SEARCH :: 268;
SCANCODE_AC_HOME :: 269;
SCANCODE_AC_BACK :: 270;
SCANCODE_AC_FORWARD :: 271;
SCANCODE_AC_STOP :: 272;
SCANCODE_AC_REFRESH :: 273;
SCANCODE_AC_BOOKMARKS :: 274;
SCANCODE_BRIGHTNESSDOWN :: 275;
SCANCODE_BRIGHTNESSUP :: 276;
SCANCODE_DISPLAYSWITCH :: 277;
SCANCODE_KBDILLUMTOGGLE :: 278;
SCANCODE_KBDILLUMDOWN :: 279;
SCANCODE_KBDILLUMUP :: 280;
SCANCODE_EJECT :: 281;
SCANCODE_SLEEP :: 282;
SCANCODE_APP1 :: 283;
SCANCODE_APP2 :: 284;
SCANCODE_AUDIOREWIND :: 285;
SCANCODE_AUDIOFASTFORWARD :: 286;
NUM_SCANCODES :: 512;
/* } */;
Thread :: struct {};
threadID :: _c.ulong;
TouchDeviceType :: _c.int;
/* <ENUM> :: enum { */
TOUCH_DEVICE_INVALID :: -1;
TOUCH_DEVICE_DIRECT :: 0;
TOUCH_DEVICE_INDIRECT_ABSOLUTE :: 1;
TOUCH_DEVICE_INDIRECT_RELATIVE :: 2;
/* } */;
version :: struct {
major : Uint8,
minor : Uint8,
patch : Uint8,
};
Sensor :: _Sensor;
TLSID :: _c.uint;
Finger :: struct {
id : FingerID,
x : _c.float,
y : _c.float,
pressure : _c.float,
};
SensorID :: Sint32;
SensorType :: _c.int;
/* <ENUM> :: enum { */
SENSOR_INVALID :: -1;
SENSOR_UNKNOWN :: 0;
SENSOR_ACCEL :: 1;
SENSOR_GYRO :: 2;
/* } */;
WindowShapeMode :: _c.int;
/* <ENUM> :: enum { */
ShapeModeDefault :: 0;
ShapeModeBinarizeAlpha :: 1;
ShapeModeReverseBinarizeAlpha :: 2;
ShapeModeColorKey :: 3;
/* } */;
WindowShapeParams :: struct #raw_union {
binarizationCutoff : Uint8,
colorKey : Color,
};
SDL_WindowShapeMode :: struct {
mode : WindowShapeMode,
parameters : WindowShapeParams,
};
_iconv_t :: struct {};
malloc_func :: (proc(size : uint) -> rawptr);
calloc_func :: (proc(nmemb : uint, size : uint) -> rawptr);
realloc_func :: (proc(mem : rawptr, size : uint) -> rawptr);
free_func :: proc(mem : rawptr);
iconv_t :: ^_iconv_t;
Surface :: struct {
flags : Uint32,
format : ^PixelFormat,
w : _c.int,
h : _c.int,
pitch : _c.int,
pixels : rawptr,
userdata : rawptr,
locked : _c.int,
list_blitmap : rawptr,
clip_rect : Rect,
map_ : ^BlitMap,
refcount : _c.int,
};
YUV_CONVERSION_MODE :: _c.int;
/* <ENUM> :: enum { */
YUV_CONVERSION_JPEG :: 0;
YUV_CONVERSION_BT601 :: 1;
YUV_CONVERSION_BT709 :: 2;
YUV_CONVERSION_AUTOMATIC :: 3;
/* } */;
DisplayMode :: struct {
format : Uint32,
w : _c.int,
h : _c.int,
refresh_rate : _c.int,
driverdata : rawptr,
};
ThreadPriority :: _c.int;
/* <ENUM> :: enum { */
THREAD_PRIORITY_LOW :: 0;
THREAD_PRIORITY_NORMAL :: 1;
THREAD_PRIORITY_HIGH :: 2;
THREAD_PRIORITY_TIME_CRITICAL :: 3;
/* } */;
ThreadFunction :: (proc(data : rawptr) -> _c.int);
TimerID :: _c.int;
TimerCallback :: (proc(interval : Uint32, param : rawptr) -> Uint32);
Window :: struct {};
WindowFlags :: _c.int;
/* <ENUM> :: enum { */
WINDOW_FULLSCREEN :: 0x1;
WINDOW_OPENGL :: 0x2;
WINDOW_SHOWN :: 0x4;
WINDOW_HIDDEN :: 0x8;
WINDOW_BORDERLESS :: 0x10;
WINDOW_RESIZABLE :: 0x20;
WINDOW_MINIMIZED :: 0x40;
WINDOW_MAXIMIZED :: 0x80;
WINDOW_INPUT_GRABBED :: 0x100;
WINDOW_INPUT_FOCUS :: 0x200;
WINDOW_MOUSE_FOCUS :: 0x400;
WINDOW_FULLSCREEN_DESKTOP :: (WINDOW_FULLSCREEN | 0x1000);
WINDOW_FOREIGN :: 0x800;
WINDOW_ALLOW_HIGHDPI :: 0x2000;
WINDOW_MOUSE_CAPTURE :: 0x4000;
WINDOW_ALWAYS_ON_TOP :: 0x8000;
WINDOW_SKIP_TASKBAR :: 0x10000;
WINDOW_UTILITY :: 0x20000;
WINDOW_TOOLTIP :: 0x40000;
WINDOW_POPUP_MENU :: 0x80000;
WINDOW_VULKAN :: 0x10000000;
WINDOW_METAL :: 0x20000000;
/* } */;
WindowEventID :: _c.int;
/* <ENUM> :: enum { */
WINDOWEVENT_NONE :: 0;
WINDOWEVENT_SHOWN :: 1;
WINDOWEVENT_HIDDEN :: 2;
WINDOWEVENT_EXPOSED :: 3;
WINDOWEVENT_MOVED :: 4;
WINDOWEVENT_RESIZED :: 5;
WINDOWEVENT_SIZE_CHANGED :: 6;
WINDOWEVENT_MINIMIZED :: 7;
WINDOWEVENT_MAXIMIZED :: 8;
WINDOWEVENT_RESTORED :: 9;
WINDOWEVENT_ENTER :: 10;
WINDOWEVENT_LEAVE :: 11;
WINDOWEVENT_FOCUS_GAINED :: 12;
WINDOWEVENT_FOCUS_LOST :: 13;
WINDOWEVENT_CLOSE :: 14;
WINDOWEVENT_TAKE_FOCUS :: 15;
WINDOWEVENT_HIT_TEST :: 16;
/* } */;
DisplayEventID :: _c.int;
/* <ENUM> :: enum { */
DISPLAYEVENT_NONE :: 0;
DISPLAYEVENT_ORIENTATION :: 1;
DISPLAYEVENT_CONNECTED :: 2;
DISPLAYEVENT_DISCONNECTED :: 3;
/* } */;
DisplayOrientation :: _c.int;
/* <ENUM> :: enum { */
ORIENTATION_UNKNOWN :: 0;
ORIENTATION_LANDSCAPE :: 1;
ORIENTATION_LANDSCAPE_FLIPPED :: 2;
ORIENTATION_PORTRAIT :: 3;
ORIENTATION_PORTRAIT_FLIPPED :: 4;
/* } */;
GLattr :: _c.int;
/* <ENUM> :: enum { */
GL_RED_SIZE :: 0;
GL_GREEN_SIZE :: 1;
GL_BLUE_SIZE :: 2;
GL_ALPHA_SIZE :: 3;
GL_BUFFER_SIZE :: 4;
GL_DOUBLEBUFFER :: 5;
GL_DEPTH_SIZE :: 6;
GL_STENCIL_SIZE :: 7;
GL_ACCUM_RED_SIZE :: 8;
GL_ACCUM_GREEN_SIZE :: 9;
GL_ACCUM_BLUE_SIZE :: 10;
GL_ACCUM_ALPHA_SIZE :: 11;
GL_STEREO :: 12;
GL_MULTISAMPLEBUFFERS :: 13;
GL_MULTISAMPLESAMPLES :: 14;
GL_ACCELERATED_VISUAL :: 15;
GL_RETAINED_BACKING :: 16;
GL_CONTEXT_MAJOR_VERSION :: 17;
GL_CONTEXT_MINOR_VERSION :: 18;
GL_CONTEXT_EGL :: 19;
GL_CONTEXT_FLAGS :: 20;
GL_CONTEXT_PROFILE_MASK :: 21;
GL_SHARE_WITH_CURRENT_CONTEXT :: 22;
GL_FRAMEBUFFER_SRGB_CAPABLE :: 23;
GL_CONTEXT_RELEASE_BEHAVIOR :: 24;
GL_CONTEXT_RESET_NOTIFICATION :: 25;
GL_CONTEXT_NO_ERROR :: 26;
/* } */;
GLprofile :: _c.int;
/* <ENUM> :: enum { */
GL_CONTEXT_PROFILE_CORE :: 0x1;
GL_CONTEXT_PROFILE_COMPATIBILITY :: 0x2;
GL_CONTEXT_PROFILE_ES :: 0x4;
/* } */;
GLcontextFlag :: _c.int;
/* <ENUM> :: enum { */
GL_CONTEXT_DEBUG_FLAG :: 0x1;
GL_CONTEXT_FORWARD_COMPATIBLE_FLAG :: 0x2;
GL_CONTEXT_ROBUST_ACCESS_FLAG :: 0x4;
GL_CONTEXT_RESET_ISOLATION_FLAG :: 0x8;
/* } */;
GLcontextReleaseFlag :: _c.int;
/* <ENUM> :: enum { */
GL_CONTEXT_RELEASE_BEHAVIOR_NONE :: 0x0;
GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH :: 0x1;
/* } */;
GLContextResetNotification :: _c.int;
/* <ENUM> :: enum { */
GL_CONTEXT_RESET_NO_NOTIFICATION :: 0x0;
GL_CONTEXT_RESET_LOSE_CONTEXT :: 0x1;
/* } */;
HitTestResult :: _c.int;
/* <ENUM> :: enum { */
HITTEST_NORMAL :: 0;
HITTEST_DRAGGABLE :: 1;
HITTEST_RESIZE_TOPLEFT :: 2;
HITTEST_RESIZE_TOP :: 3;
HITTEST_RESIZE_TOPRIGHT :: 4;
HITTEST_RESIZE_RIGHT :: 5;
HITTEST_RESIZE_BOTTOMRIGHT :: 6;
HITTEST_RESIZE_BOTTOM :: 7;
HITTEST_RESIZE_BOTTOMLEFT :: 8;
HITTEST_RESIZE_LEFT :: 9;
/* } */;
GLContext :: rawptr;
HitTest :: (proc(win : ^Window, area : ^Point, data : rawptr) -> HitTestResult);
/***** libSDL2 *****/
foreign import libSDL2 "system:libSDL2.so"
/* Procedures */
@(link_prefix="SDL")
foreign libSDL2 {
SetClipboardText :: proc(text : cstring) -> _c.int ---;
HasClipboardText :: proc() -> bool ---;
Init :: proc(flags : Uint32) -> _c.int ---;
InitSubSystem :: proc(flags : Uint32) -> _c.int ---;
QuitSubSystem :: proc(flags : Uint32) ---;
WasInit :: proc(flags : Uint32) -> Uint32 ---;
Quit :: proc() ---;
SetError :: proc(fmt : cstring, #c_vararg __args : ..any) -> _c.int ---;
RecordGesture :: proc(touchId : TouchID) -> _c.int ---;
SaveAllDollarTemplates :: proc(dst : ^RWops) -> _c.int ---;
SaveDollarTemplate :: proc(gestureId : GestureID, dst : ^RWops) -> _c.int ---;
AtomicTryLock :: proc(lock : ^SpinLock) -> bool ---;
AtomicLock :: proc(lock : ^SpinLock) ---;
AtomicUnlock :: proc(lock : ^SpinLock) ---;
ReportAssertion :: proc(^AssertData, cstring, cstring, _c.int) -> AssertState ---;
MemoryBarrierReleaseFunction :: proc() ---;
MemoryBarrierAcquireFunction :: proc() ---;
SetAssertionHandler :: proc(handler : AssertionHandler, userdata : rawptr) ---;
GetDefaultAssertionHandler :: proc() -> AssertionHandler ---;
AtomicCAS :: proc(a : ^atomic_t, oldval : _c.int, newval : _c.int) -> bool ---;
AtomicSet :: proc(a : ^atomic_t, v : _c.int) -> _c.int ---;
AtomicGet :: proc(a : ^atomic_t) -> _c.int ---;
GetAssertionHandler :: proc(puserdata : ^rawptr) -> AssertionHandler ---;
AtomicAdd :: proc(a : ^atomic_t, v : _c.int) -> _c.int ---;
LoadDollarTemplates :: proc(touchId : TouchID, src : ^RWops) -> _c.int ---;
ClearError :: proc() ---;
Error :: proc(code : errorcode) -> _c.int ---;
ComposeCustomBlendMode :: proc(srcColorFactor : BlendFactor, dstColorFactor : BlendFactor, colorOperation : BlendOperation, srcAlphaFactor : BlendFactor, dstAlphaFactor : BlendFactor, alphaOperation : BlendOperation) -> BlendMode ---;
GetNumAudioDrivers :: proc() -> _c.int ---;
AudioInit :: proc(driver_name : cstring) -> _c.int ---;
AudioQuit :: proc() ---;
GetCPUCount :: proc() -> _c.int ---;
GetCPUCacheLineSize :: proc() -> _c.int ---;
HasRDTSC :: proc() -> bool ---;
GameControllerAddMappingsFromRW :: proc(rw : ^RWops, freerw : _c.int) -> _c.int ---;
HasAltiVec :: proc() -> bool ---;
HasMMX :: proc() -> bool ---;
Has3DNow :: proc() -> bool ---;
GameControllerAddMapping :: proc(mappingString : cstring) -> _c.int ---;
HasSSE :: proc() -> bool ---;
GameControllerNumMappings :: proc() -> _c.int ---;
HasSSE2 :: proc() -> bool ---;
HasSSE3 :: proc() -> bool ---;
HasSSE41 :: proc() -> bool ---;
HasSSE42 :: proc() -> bool ---;
HasAVX :: proc() -> bool ---;
IsGameController :: proc(joystick_index : _c.int) -> bool ---;
HasAVX2 :: proc() -> bool ---;
HasAVX512F :: proc() -> bool ---;
HasARMSIMD :: proc() -> bool ---;
HasNEON :: proc() -> bool ---;
GetSystemRAM :: proc() -> _c.int ---;
SIMDGetAlignment :: proc() -> uint ---;
GameControllerTypeForIndex :: proc(joystick_index : _c.int) -> GameControllerType ---;
GameControllerGetType :: proc(gamecontroller : ^GameController) -> GameControllerType ---;
GameControllerGetPlayerIndex :: proc(gamecontroller : ^GameController) -> _c.int ---;
GameControllerSetPlayerIndex :: proc(gamecontroller : ^GameController, player_index : _c.int) ---;
GameControllerGetVendor :: proc(gamecontroller : ^GameController) -> Uint16 ---;
GameControllerGetProduct :: proc(gamecontroller : ^GameController) -> Uint16 ---;
GameControllerGetProductVersion :: proc(gamecontroller : ^GameController) -> Uint16 ---;
LockJoysticks :: proc() ---;
UnlockJoysticks :: proc() ---;
NumJoysticks :: proc() -> _c.int ---;
JoystickGetDevicePlayerIndex :: proc(device_index : _c.int) -> _c.int ---;
JoystickGetDeviceGUID :: proc(device_index : _c.int) -> JoystickGUID ---;
JoystickGetDeviceVendor :: proc(device_index : _c.int) -> Uint16 ---;
JoystickGetDeviceProduct :: proc(device_index : _c.int) -> Uint16 ---;
JoystickGetDeviceProductVersion :: proc(device_index : _c.int) -> Uint16 ---;
JoystickGetDeviceType :: proc(device_index : _c.int) -> JoystickType ---;
JoystickGetDeviceInstanceID :: proc(device_index : _c.int) -> JoystickID ---;
JoystickAttachVirtual :: proc(type : JoystickType, naxes : _c.int, nbuttons : _c.int, nhats : _c.int) -> _c.int ---;
JoystickDetachVirtual :: proc(device_index : _c.int) -> _c.int ---;
JoystickIsVirtual :: proc(device_index : _c.int) -> bool ---;
JoystickSetVirtualAxis :: proc(joystick : ^Joystick, axis : _c.int, value : Sint16) -> _c.int ---;
JoystickSetVirtualButton :: proc(joystick : ^Joystick, button : _c.int, value : Uint8) -> _c.int ---;
JoystickSetVirtualHat :: proc(joystick : ^Joystick, hat : _c.int, value : Uint8) -> _c.int ---;
JoystickGetPlayerIndex :: proc(joystick : ^Joystick) -> _c.int ---;
JoystickSetPlayerIndex :: proc(joystick : ^Joystick, player_index : _c.int) ---;
JoystickGetGUID :: proc(joystick : ^Joystick) -> JoystickGUID ---;
JoystickGetVendor :: proc(joystick : ^Joystick) -> Uint16 ---;
GetAssertionReport :: proc() -> ^AssertData ---;
ResetAssertionReport :: proc() ---;
AtomicCASPtr :: proc(a : ^rawptr, oldval : rawptr, newval : rawptr) -> bool ---;
AtomicSetPtr :: proc(a : ^rawptr, v : rawptr) -> rawptr ---;
AtomicGetPtr :: proc(a : ^rawptr) -> rawptr ---;
GetAudioDriver :: proc(index : _c.int) -> cstring ---;
GetCurrentAudioDriver :: proc() -> cstring ---;
OpenAudio :: proc(desired : ^AudioSpec, obtained : ^AudioSpec) -> _c.int ---;
GetNumAudioDevices :: proc(iscapture : _c.int) -> _c.int ---;
GetAudioDeviceName :: proc(index : _c.int, iscapture : _c.int) -> cstring ---;
OpenAudioDevice :: proc(device : cstring, iscapture : _c.int, desired : ^AudioSpec, obtained : ^AudioSpec, allowed_changes : _c.int) -> AudioDeviceID ---;
GetAudioStatus :: proc() -> AudioStatus ---;
GetAudioDeviceStatus :: proc(dev : AudioDeviceID) -> AudioStatus ---;
PauseAudio :: proc(pause_on : _c.int) ---;
PauseAudioDevice :: proc(dev : AudioDeviceID, pause_on : _c.int) ---;
LoadWAV_RW :: proc(src : ^RWops, freesrc : _c.int, spec : ^AudioSpec, audio_buf : ^^Uint8, audio_len : ^Uint32) -> ^AudioSpec ---;
FreeWAV :: proc(audio_buf : ^Uint8) ---;
BuildAudioCVT :: proc(cvt : ^AudioCVT, src_format : AudioFormat, src_channels : Uint8, src_rate : _c.int, dst_format : AudioFormat, dst_channels : Uint8, dst_rate : _c.int) -> _c.int ---;
ConvertAudio :: proc(cvt : ^AudioCVT) -> _c.int ---;
NewAudioStream :: proc(src_format : AudioFormat, src_channels : Uint8, src_rate : _c.int, dst_format : AudioFormat, dst_channels : Uint8, dst_rate : _c.int) -> ^AudioStream ---;
AudioStreamPut :: proc(stream : ^AudioStream, buf : rawptr, len : _c.int) -> _c.int ---;
AudioStreamGet :: proc(stream : ^AudioStream, buf : rawptr, len : _c.int) -> _c.int ---;
AudioStreamAvailable :: proc(stream : ^AudioStream) -> _c.int ---;
AudioStreamFlush :: proc(stream : ^AudioStream) -> _c.int ---;
AudioStreamClear :: proc(stream : ^AudioStream) ---;
FreeAudioStream :: proc(stream : ^AudioStream) ---;
MixAudio :: proc(dst : ^Uint8, src : ^Uint8, len : Uint32, volume : _c.int) ---;
MixAudioFormat :: proc(dst : ^Uint8, src : ^Uint8, format : AudioFormat, len : Uint32, volume : _c.int) ---;
QueueAudio :: proc(dev : AudioDeviceID, data : rawptr, len : Uint32) -> _c.int ---;
DequeueAudio :: proc(dev : AudioDeviceID, data : rawptr, len : Uint32) -> Uint32 ---;
GetQueuedAudioSize :: proc(dev : AudioDeviceID) -> Uint32 ---;
ClearQueuedAudio :: proc(dev : AudioDeviceID) ---;
LockAudio :: proc() ---;
LockAudioDevice :: proc(dev : AudioDeviceID) ---;
UnlockAudio :: proc() ---;
UnlockAudioDevice :: proc(dev : AudioDeviceID) ---;
CloseAudio :: proc() ---;
CloseAudioDevice :: proc(dev : AudioDeviceID) ---;
GetClipboardText :: proc() -> cstring ---;
GetError :: proc() -> cstring ---;
GetErrorMsg :: proc(errstr : cstring, maxlen : _c.int) -> cstring ---;
GetBasePath :: proc() -> cstring ---;
GetPrefPath :: proc(org : cstring, app : cstring) -> cstring ---;
SIMDAlloc :: proc(len : uint) -> rawptr ---;
SIMDRealloc :: proc(mem : rawptr, len : uint) -> rawptr ---;
SIMDFree :: proc(ptr : rawptr) ---;
PumpEvents :: proc() ---;
PeepEvents :: proc(events : ^Event, numevents : _c.int, action : eventaction, minType : Uint32, maxType : Uint32) -> _c.int ---;
HasEvent :: proc(type : Uint32) -> bool ---;
HasEvents :: proc(minType : Uint32, maxType : Uint32) -> bool ---;
FlushEvent :: proc(type : Uint32) ---;
GameControllerGetAttached :: proc(gamecontroller : ^GameController) -> bool ---;
GameControllerEventState :: proc(state : _c.int) -> _c.int ---;
GameControllerUpdate :: proc() ---;
GameControllerGetAxisFromString :: proc(pchString : cstring) -> GameControllerAxis ---;
GameControllerGetBindForAxis :: proc(gamecontroller : ^GameController, axis : GameControllerAxis) -> GameControllerButtonBind ---;
GameControllerHasAxis :: proc(gamecontroller : ^GameController, axis : GameControllerAxis) -> bool ---;
GameControllerGetAxis :: proc(gamecontroller : ^GameController, axis : GameControllerAxis) -> Sint16 ---;
GameControllerGetButtonFromString :: proc(pchString : cstring) -> GameControllerButton ---;
GameControllerGetBindForButton :: proc(gamecontroller : ^GameController, button : GameControllerButton) -> GameControllerButtonBind ---;
GameControllerHasButton :: proc(gamecontroller : ^GameController, button : GameControllerButton) -> bool ---;
GameControllerGetButton :: proc(gamecontroller : ^GameController, button : GameControllerButton) -> Uint8 ---;
GameControllerGetNumTouchpads :: proc(gamecontroller : ^GameController) -> _c.int ---;
GameControllerGetNumTouchpadFingers :: proc(gamecontroller : ^GameController, touchpad : _c.int) -> _c.int ---;
GameControllerGetTouchpadFinger :: proc(gamecontroller : ^GameController, touchpad : _c.int, finger : _c.int, state : ^Uint8, x : ^_c.float, y : ^_c.float, pressure : ^_c.float) -> _c.int ---;
GameControllerHasSensor :: proc(gamecontroller : ^GameController, type : SensorType) -> bool ---;
GameControllerSetSensorEnabled :: proc(gamecontroller : ^GameController, type : SensorType, enabled : bool) -> _c.int ---;
GameControllerIsSensorEnabled :: proc(gamecontroller : ^GameController, type : SensorType) -> bool ---;
GameControllerGetSensorData :: proc(gamecontroller : ^GameController, type : SensorType, data : ^_c.float, num_values : _c.int) -> _c.int ---;
GameControllerRumble :: proc(gamecontroller : ^GameController, low_frequency_rumble : Uint16, high_frequency_rumble : Uint16, duration_ms : Uint32) -> _c.int ---;
GameControllerRumbleTriggers :: proc(gamecontroller : ^GameController, left_rumble : Uint16, right_rumble : Uint16, duration_ms : Uint32) -> _c.int ---;
GameControllerHasLED :: proc(gamecontroller : ^GameController) -> bool ---;
GameControllerSetLED :: proc(gamecontroller : ^GameController, red : Uint8, green : Uint8, blue : Uint8) -> _c.int ---;
GameControllerClose :: proc(gamecontroller : ^GameController) ---;
GameControllerMappingForIndex :: proc(mapping_index : _c.int) -> cstring ---;
GameControllerMappingForGUID :: proc(guid : JoystickGUID) -> cstring ---;
GameControllerMapping :: proc(gamecontroller : ^GameController) -> cstring ---;
GameControllerMappingForDeviceIndex :: proc(joystick_index : _c.int) -> cstring ---;
GameControllerGetStringForAxis :: proc(axis : GameControllerAxis) -> cstring ---;
GameControllerGetStringForButton :: proc(button : GameControllerButton) -> cstring ---;
GameControllerNameForIndex :: proc(joystick_index : _c.int) -> cstring ---;
GameControllerName :: proc(gamecontroller : ^GameController) -> cstring ---;
GameControllerGetSerial :: proc(gamecontroller : ^GameController) -> cstring ---;
GameControllerGetJoystick :: proc(gamecontroller : ^GameController) -> ^Joystick ---;
GameControllerOpen :: proc(joystick_index : _c.int) -> ^GameController ---;
GameControllerFromInstanceID :: proc(joyid : JoystickID) -> ^GameController ---;
GameControllerFromPlayerIndex :: proc(player_index : _c.int) -> ^GameController ---;
JoystickGetProduct :: proc(joystick : ^Joystick) -> Uint16 ---;
JoystickGetProductVersion :: proc(joystick : ^Joystick) -> Uint16 ---;
JoystickGetType :: proc(joystick : ^Joystick) -> JoystickType ---;
JoystickGetGUIDString :: proc(guid : JoystickGUID, pszGUID : cstring, cbGUID : _c.int) ---;
JoystickGetGUIDFromString :: proc(pchGUID : cstring) -> JoystickGUID ---;
JoystickGetAttached :: proc(joystick : ^Joystick) -> bool ---;
JoystickInstanceID :: proc(joystick : ^Joystick) -> JoystickID ---;
JoystickNumAxes :: proc(joystick : ^Joystick) -> _c.int ---;
JoystickNumBalls :: proc(joystick : ^Joystick) -> _c.int ---;
JoystickNumHats :: proc(joystick : ^Joystick) -> _c.int ---;
JoystickNumButtons :: proc(joystick : ^Joystick) -> _c.int ---;
JoystickUpdate :: proc() ---;
JoystickEventState :: proc(state : _c.int) -> _c.int ---;
JoystickGetAxis :: proc(joystick : ^Joystick, axis : _c.int) -> Sint16 ---;
JoystickGetAxisInitialState :: proc(joystick : ^Joystick, axis : _c.int, state : ^Sint16) -> bool ---;
JoystickGetHat :: proc(joystick : ^Joystick, hat : _c.int) -> Uint8 ---;
JoystickGetBall :: proc(joystick : ^Joystick, ball : _c.int, dx : ^_c.int, dy : ^_c.int) -> _c.int ---;
JoystickGetButton :: proc(joystick : ^Joystick, button : _c.int) -> Uint8 ---;
JoystickRumble :: proc(joystick : ^Joystick, low_frequency_rumble : Uint16, high_frequency_rumble : Uint16, duration_ms : Uint32) -> _c.int ---;
JoystickRumbleTriggers :: proc(joystick : ^Joystick, left_rumble : Uint16, right_rumble : Uint16, duration_ms : Uint32) -> _c.int ---;
JoystickHasLED :: proc(joystick : ^Joystick) -> bool ---;
JoystickSetLED :: proc(joystick : ^Joystick, red : Uint8, green : Uint8, blue : Uint8) -> _c.int ---;
JoystickClose :: proc(joystick : ^Joystick) ---;
JoystickCurrentPowerLevel :: proc(joystick : ^Joystick) -> JoystickPowerLevel ---;
FlushEvents :: proc(minType : Uint32, maxType : Uint32) ---;
PollEvent :: proc(event : ^Event) -> _c.int ---;
WaitEvent :: proc(event : ^Event) -> _c.int ---;
WaitEventTimeout :: proc(event : ^Event, timeout : _c.int) -> _c.int ---;
PushEvent :: proc(event : ^Event) -> _c.int ---;
SetEventFilter :: proc(filter : EventFilter, userdata : rawptr) ---;
GetEventFilter :: proc(filter : ^EventFilter, userdata : ^rawptr) -> bool ---;
AddEventWatch :: proc(filter : EventFilter, userdata : rawptr) ---;
DelEventWatch :: proc(filter : EventFilter, userdata : rawptr) ---;
FilterEvents :: proc(filter : EventFilter, userdata : rawptr) ---;
EventState :: proc(type : Uint32, state : _c.int) -> Uint8 ---;
RegisterEvents :: proc(numevents : _c.int) -> Uint32 ---;
NumHaptics :: proc() -> _c.int ---;
HapticOpened :: proc(device_index : _c.int) -> _c.int ---;
HapticIndex :: proc(haptic : ^Haptic) -> _c.int ---;
MouseIsHaptic :: proc() -> _c.int ---;
JoystickIsHaptic :: proc(joystick : ^Joystick) -> _c.int ---;
HapticClose :: proc(haptic : ^Haptic) ---;
HapticNumEffects :: proc(haptic : ^Haptic) -> _c.int ---;
HapticNumEffectsPlaying :: proc(haptic : ^Haptic) -> _c.int ---;
HapticQuery :: proc(haptic : ^Haptic) -> _c.uint ---;
HapticNumAxes :: proc(haptic : ^Haptic) -> _c.int ---;
HapticEffectSupported :: proc(haptic : ^Haptic, effect : ^HapticEffect) -> _c.int ---;
HapticNewEffect :: proc(haptic : ^Haptic, effect : ^HapticEffect) -> _c.int ---;
HapticUpdateEffect :: proc(haptic : ^Haptic, effect : _c.int, data : ^HapticEffect) -> _c.int ---;
HapticRunEffect :: proc(haptic : ^Haptic, effect : _c.int, iterations : Uint32) -> _c.int ---;
HapticStopEffect :: proc(haptic : ^Haptic, effect : _c.int) -> _c.int ---;
HapticDestroyEffect :: proc(haptic : ^Haptic, effect : _c.int) ---;
HapticGetEffectStatus :: proc(haptic : ^Haptic, effect : _c.int) -> _c.int ---;
HapticSetGain :: proc(haptic : ^Haptic, gain : _c.int) -> _c.int ---;
HapticSetAutocenter :: proc(haptic : ^Haptic, autocenter : _c.int) -> _c.int ---;
HapticPause :: proc(haptic : ^Haptic) -> _c.int ---;
HapticUnpause :: proc(haptic : ^Haptic) -> _c.int ---;
HapticStopAll :: proc(haptic : ^Haptic) -> _c.int ---;
HapticRumbleSupported :: proc(haptic : ^Haptic) -> _c.int ---;
HapticRumbleInit :: proc(haptic : ^Haptic) -> _c.int ---;
HapticRumblePlay :: proc(haptic : ^Haptic, strength : _c.float, length : Uint32) -> _c.int ---;
HapticRumbleStop :: proc(haptic : ^Haptic) -> _c.int ---;
SetHintWithPriority :: proc(name : cstring, value : cstring, priority : HintPriority) -> bool ---;
SetHint :: proc(name : cstring, value : cstring) -> bool ---;
GetHintBoolean :: proc(name : cstring, default_value : bool) -> bool ---;
AddHintCallback :: proc(name : cstring, callback : HintCallback, userdata : rawptr) ---;
DelHintCallback :: proc(name : cstring, callback : HintCallback, userdata : rawptr) ---;
ClearHints :: proc() ---;
HapticName :: proc(device_index : _c.int) -> cstring ---;
HapticOpen :: proc(device_index : _c.int) -> ^Haptic ---;
HapticOpenFromMouse :: proc() -> ^Haptic ---;
HapticOpenFromJoystick :: proc(joystick : ^Joystick) -> ^Haptic ---;
GetHint :: proc(name : cstring) -> cstring ---;
JoystickNameForIndex :: proc(device_index : _c.int) -> cstring ---;
JoystickName :: proc(joystick : ^Joystick) -> cstring ---;
JoystickGetSerial :: proc(joystick : ^Joystick) -> cstring ---;
JoystickOpen :: proc(device_index : _c.int) -> ^Joystick ---;
JoystickFromInstanceID :: proc(instance_id : JoystickID) -> ^Joystick ---;
JoystickFromPlayerIndex :: proc(player_index : _c.int) -> ^Joystick ---;
GetModState :: proc() -> Keymod ---;
SetModState :: proc(modstate : Keymod) ---;
GetKeyFromScancode :: proc(scancode : Scancode) -> Keycode ---;
GetScancodeFromKey :: proc(key : Keycode) -> Scancode ---;
GetScancodeFromName :: proc(name : cstring) -> Scancode ---;
GetKeyFromName :: proc(name : cstring) -> Keycode ---;
StartTextInput :: proc() ---;
IsTextInputActive :: proc() -> bool ---;
StopTextInput :: proc() ---;
SetTextInputRect :: proc(rect : ^Rect) ---;
HasScreenKeyboardSupport :: proc() -> bool ---;
IsScreenKeyboardShown :: proc(window : ^Window) -> bool ---;
GetKeyboardFocus :: proc() -> ^Window ---;
GetScancodeName :: proc(scancode : Scancode) -> cstring ---;
GetKeyName :: proc(key : Keycode) -> cstring ---;
GetKeyboardState :: proc(numkeys : ^_c.int) -> ^Uint8 ---;
OpenURL :: proc(url : cstring) -> _c.int ---;
Metal_CreateView :: proc(window : ^Window) -> MetalView ---;
UnloadObject :: proc(handle : rawptr) ---;
Metal_DestroyView :: proc(view : MetalView) ---;
Metal_GetDrawableSize :: proc(window : ^Window, w : ^_c.int, h : ^_c.int) ---;
LogSetAllPriority :: proc(priority : LogPriority) ---;
ShowMessageBox :: proc(messageboxdata : ^MessageBoxData, buttonid : ^_c.int) -> _c.int ---;
LogSetPriority :: proc(category : _c.int, priority : LogPriority) ---;
LogGetPriority :: proc(category : _c.int) -> LogPriority ---;
SetMainReady :: proc() ---;
LogResetPriorities :: proc() ---;
ShowSimpleMessageBox :: proc(flags : Uint32, title : cstring, message : cstring, window : ^Window) -> _c.int ---;
Log :: proc(fmt : cstring, #c_vararg __args : ..any) ---;
LogVerbose :: proc(category : _c.int, fmt : cstring, #c_vararg __args : ..any) ---;
LogDebug :: proc(category : _c.int, fmt : cstring, #c_vararg __args : ..any) ---;
LogInfo :: proc(category : _c.int, fmt : cstring, #c_vararg __args : ..any) ---;
LogWarn :: proc(category : _c.int, fmt : cstring, #c_vararg __args : ..any) ---;
LogError :: proc(category : _c.int, fmt : cstring, #c_vararg __args : ..any) ---;
LogCritical :: proc(category : _c.int, fmt : cstring, #c_vararg __args : ..any) ---;
LogMessage :: proc(category : _c.int, priority : LogPriority, fmt : cstring, #c_vararg __args : ..any) ---;
LogGetOutputFunction :: proc(callback : ^LogOutputFunction, userdata : ^rawptr) ---;
LogSetOutputFunction :: proc(callback : LogOutputFunction, userdata : rawptr) ---;
LoadObject :: proc(sofile : cstring) -> rawptr ---;
CreateMutex :: proc() -> ^mutex ---;
LoadFunction :: proc(handle : rawptr, name : cstring) -> rawptr ---;
GetPreferredLocales :: proc() -> ^Locale ---;
Metal_GetLayer :: proc(view : MetalView) -> rawptr ---;
GetPowerInfo :: proc(secs : ^_c.int, pct : ^_c.int) -> PowerState ---;
LockMutex :: proc(mutex : ^mutex) -> _c.int ---;
TryLockMutex :: proc(mutex : ^mutex) -> _c.int ---;
GetMouseState :: proc(x : ^_c.int, y : ^_c.int) -> Uint32 ---;
UnlockMutex :: proc(mutex : ^mutex) -> _c.int ---;
DestroyMutex :: proc(mutex : ^mutex) ---;
GetGlobalMouseState :: proc(x : ^_c.int, y : ^_c.int) -> Uint32 ---;
CreateSemaphore :: proc(initial_value : Uint32) -> ^sem ---;
DestroySemaphore :: proc(sem : ^sem) ---;
GetRelativeMouseState :: proc(x : ^_c.int, y : ^_c.int) -> Uint32 ---;
SemWait :: proc(sem : ^sem) -> _c.int ---;
HasIntersection :: proc(A : ^Rect, B : ^Rect) -> bool ---;
WarpMouseInWindow :: proc(window : ^Window, x : _c.int, y : _c.int) ---;
SemTryWait :: proc(sem : ^sem) -> _c.int ---;
SemWaitTimeout :: proc(sem : ^sem, ms : Uint32) -> _c.int ---;
IntersectRect :: proc(A : ^Rect, B : ^Rect, result : ^Rect) -> bool ---;
UnionRect :: proc(A : ^Rect, B : ^Rect, result : ^Rect) ---;
WarpMouseGlobal :: proc(x : _c.int, y : _c.int) -> _c.int ---;
SemPost :: proc(sem : ^sem) -> _c.int ---;
SemValue :: proc(sem : ^sem) -> Uint32 ---;
RWFromFile :: proc(file : cstring, mode : cstring) -> ^RWops ---;
RWFromFP :: proc(fp : ^FILE, autoclose : bool) -> ^RWops ---;
EnclosePoints :: proc(points : ^Point, count : _c.int, clip : ^Rect, result : ^Rect) -> bool ---;
GetNumRenderDrivers :: proc() -> _c.int ---;
RWFromMem :: proc(mem : rawptr, size : _c.int) -> ^RWops ---;
RWFromConstMem :: proc(mem : rawptr, size : _c.int) -> ^RWops ---;
IntersectRectAndLine :: proc(rect : ^Rect, X1 : ^_c.int, Y1 : ^_c.int, X2 : ^_c.int, Y2 : ^_c.int) -> bool ---;
SetRelativeMouseMode :: proc(enabled : bool) -> _c.int ---;
AllocRW :: proc() -> ^RWops ---;
FreeRW :: proc(area : ^RWops) ---;
GetRenderDriverInfo :: proc(index : _c.int, info : ^RendererInfo) -> _c.int ---;
RWsize :: proc(context_ : ^RWops) -> Sint64 ---;
RWseek :: proc(context_ : ^RWops, offset : Sint64, whence : _c.int) -> Sint64 ---;
CreateWindowAndRenderer :: proc(width : _c.int, height : _c.int, window_flags : Uint32, window : ^^Window, renderer : ^^Renderer) -> _c.int ---;
RWtell :: proc(context_ : ^RWops) -> Sint64 ---;
CaptureMouse :: proc(enabled : bool) -> _c.int ---;
CreateCond :: proc() -> ^cond ---;
RWread :: proc(context_ : ^RWops, ptr : rawptr, size : uint, maxnum : uint) -> uint ---;
GetRelativeMouseMode :: proc() -> bool ---;
DestroyCond :: proc(cond : ^cond) ---;
CondSignal :: proc(cond : ^cond) -> _c.int ---;
CondBroadcast :: proc(cond : ^cond) -> _c.int ---;
CondWait :: proc(cond : ^cond, mutex : ^mutex) -> _c.int ---;
CondWaitTimeout :: proc(cond : ^cond, mutex : ^mutex, ms : Uint32) -> _c.int ---;
RWwrite :: proc(context_ : ^RWops, ptr : rawptr, size : uint, num : uint) -> uint ---;
RWclose :: proc(context_ : ^RWops) -> _c.int ---;
GetRendererInfo :: proc(renderer : ^Renderer, info : ^RendererInfo) -> _c.int ---;
LoadFile_RW :: proc(src : ^RWops, datasize : ^uint, freesrc : _c.int) -> rawptr ---;
GetRendererOutputSize :: proc(renderer : ^Renderer, w : ^_c.int, h : ^_c.int) -> _c.int ---;
LoadFile :: proc(file : cstring, datasize : ^uint) -> rawptr ---;
SetCursor :: proc(cursor : ^Cursor) ---;
ReadU8 :: proc(src : ^RWops) -> Uint8 ---;
ReadLE16 :: proc(src : ^RWops) -> Uint16 ---;
ReadBE16 :: proc(src : ^RWops) -> Uint16 ---;
ReadLE32 :: proc(src : ^RWops) -> Uint32 ---;
ReadBE32 :: proc(src : ^RWops) -> Uint32 ---;
ReadLE64 :: proc(src : ^RWops) -> Uint64 ---;
ReadBE64 :: proc(src : ^RWops) -> Uint64 ---;
FreeCursor :: proc(cursor : ^Cursor) ---;
WriteU8 :: proc(dst : ^RWops, value : Uint8) -> uint ---;
WriteLE16 :: proc(dst : ^RWops, value : Uint16) -> uint ---;
WriteBE16 :: proc(dst : ^RWops, value : Uint16) -> uint ---;
WriteLE32 :: proc(dst : ^RWops, value : Uint32) -> uint ---;
WriteBE32 :: proc(dst : ^RWops, value : Uint32) -> uint ---;
WriteLE64 :: proc(dst : ^RWops, value : Uint64) -> uint ---;
WriteBE64 :: proc(dst : ^RWops, value : Uint64) -> uint ---;
ShowCursor :: proc(toggle : _c.int) -> _c.int ---;
QueryTexture :: proc(texture : ^Texture, format : ^Uint32, access : ^_c.int, w : ^_c.int, h : ^_c.int) -> _c.int ---;
SetTextureColorMod :: proc(texture : ^Texture, r : Uint8, g : Uint8, b : Uint8) -> _c.int ---;
GetTextureColorMod :: proc(texture : ^Texture, r : ^Uint8, g : ^Uint8, b : ^Uint8) -> _c.int ---;
GetMouseFocus :: proc() -> ^Window ---;
GetPlatform :: proc() -> cstring ---;
CreateRenderer :: proc(window : ^Window, index : _c.int, flags : Uint32) -> ^Renderer ---;
CreateSoftwareRenderer :: proc(surface : ^Surface) -> ^Renderer ---;
GetRenderer :: proc(window : ^Window) -> ^Renderer ---;
CreateCursor :: proc(data : ^Uint8, mask : ^Uint8, w : _c.int, h : _c.int, hot_x : _c.int, hot_y : _c.int) -> ^Cursor ---;
CreateColorCursor :: proc(surface : ^Surface, hot_x : _c.int, hot_y : _c.int) -> ^Cursor ---;
CreateSystemCursor :: proc(id : SystemCursor) -> ^Cursor ---;
GetCursor :: proc() -> ^Cursor ---;
CreateTexture :: proc(renderer : ^Renderer, format : Uint32, access : _c.int, w : _c.int, h : _c.int) -> ^Texture ---;
GetDefaultCursor :: proc() -> ^Cursor ---;
CreateTextureFromSurface :: proc(renderer : ^Renderer, surface : ^Surface) -> ^Texture ---;
SetTextureAlphaMod :: proc(texture : ^Texture, alpha : Uint8) -> _c.int ---;
GetTextureAlphaMod :: proc(texture : ^Texture, alpha : ^Uint8) -> _c.int ---;
GetPixelFormatName :: proc(format : Uint32) -> cstring ---;
PixelFormatEnumToMasks :: proc(format : Uint32, bpp : ^_c.int, Rmask : ^Uint32, Gmask : ^Uint32, Bmask : ^Uint32, Amask : ^Uint32) -> bool ---;
SetTextureBlendMode :: proc(texture : ^Texture, blendMode : BlendMode) -> _c.int ---;
MasksToPixelFormatEnum :: proc(bpp : _c.int, Rmask : Uint32, Gmask : Uint32, Bmask : Uint32, Amask : Uint32) -> Uint32 ---;
GetTextureBlendMode :: proc(texture : ^Texture, blendMode : ^BlendMode) -> _c.int ---;
AllocFormat :: proc(pixel_format : Uint32) -> ^PixelFormat ---;
FreeFormat :: proc(format : ^PixelFormat) ---;
SetTextureScaleMode :: proc(texture : ^Texture, scaleMode : ScaleMode) -> _c.int ---;
AllocPalette :: proc(ncolors : _c.int) -> ^Palette ---;
SetPixelFormatPalette :: proc(format : ^PixelFormat, palette : ^Palette) -> _c.int ---;
GetTextureScaleMode :: proc(texture : ^Texture, scaleMode : ^ScaleMode) -> _c.int ---;
SetPaletteColors :: proc(palette : ^Palette, colors : ^Color, firstcolor : _c.int, ncolors : _c.int) -> _c.int ---;
UpdateTexture :: proc(texture : ^Texture, rect : ^Rect, pixels : rawptr, pitch : _c.int) -> _c.int ---;
FreePalette :: proc(palette : ^Palette) ---;
MapRGB :: proc(format : ^PixelFormat, r : Uint8, g : Uint8, b : Uint8) -> Uint32 ---;
MapRGBA :: proc(format : ^PixelFormat, r : Uint8, g : Uint8, b : Uint8, a : Uint8) -> Uint32 ---;
UpdateYUVTexture :: proc(texture : ^Texture, rect : ^Rect, Yplane : ^Uint8, Ypitch : _c.int, Uplane : ^Uint8, Upitch : _c.int, Vplane : ^Uint8, Vpitch : _c.int) -> _c.int ---;
GetRGB :: proc(pixel : Uint32, format : ^PixelFormat, r : ^Uint8, g : ^Uint8, b : ^Uint8) ---;
GetRGBA :: proc(pixel : Uint32, format : ^PixelFormat, r : ^Uint8, g : ^Uint8, b : ^Uint8, a : ^Uint8) ---;
CalculateGammaRamp :: proc(gamma : _c.float, ramp : ^Uint16) ---;
LockTexture :: proc(texture : ^Texture, rect : ^Rect, pixels : ^rawptr, pitch : ^_c.int) -> _c.int ---;
LockTextureToSurface :: proc(texture : ^Texture, rect : ^Rect, surface : ^^Surface) -> _c.int ---;
UnlockTexture :: proc(texture : ^Texture) ---;
RenderTargetSupported :: proc(renderer : ^Renderer) -> bool ---;
SetRenderTarget :: proc(renderer : ^Renderer, texture : ^Texture) -> _c.int ---;
RenderSetLogicalSize :: proc(renderer : ^Renderer, w : _c.int, h : _c.int) -> _c.int ---;
RenderGetLogicalSize :: proc(renderer : ^Renderer, w : ^_c.int, h : ^_c.int) ---;
RenderSetIntegerScale :: proc(renderer : ^Renderer, enable : bool) -> _c.int ---;
RenderGetIntegerScale :: proc(renderer : ^Renderer) -> bool ---;
RenderSetViewport :: proc(renderer : ^Renderer, rect : ^Rect) -> _c.int ---;
RenderGetViewport :: proc(renderer : ^Renderer, rect : ^Rect) ---;
RenderSetClipRect :: proc(renderer : ^Renderer, rect : ^Rect) -> _c.int ---;
RenderGetClipRect :: proc(renderer : ^Renderer, rect : ^Rect) ---;
RenderIsClipEnabled :: proc(renderer : ^Renderer) -> bool ---;
RenderSetScale :: proc(renderer : ^Renderer, scaleX : _c.float, scaleY : _c.float) -> _c.int ---;
RenderGetScale :: proc(renderer : ^Renderer, scaleX : ^_c.float, scaleY : ^_c.float) ---;
SetRenderDrawColor :: proc(renderer : ^Renderer, r : Uint8, g : Uint8, b : Uint8, a : Uint8) -> _c.int ---;
GetRenderDrawColor :: proc(renderer : ^Renderer, r : ^Uint8, g : ^Uint8, b : ^Uint8, a : ^Uint8) -> _c.int ---;
SetRenderDrawBlendMode :: proc(renderer : ^Renderer, blendMode : BlendMode) -> _c.int ---;
GetRenderDrawBlendMode :: proc(renderer : ^Renderer, blendMode : ^BlendMode) -> _c.int ---;
RenderClear :: proc(renderer : ^Renderer) -> _c.int ---;
RenderDrawPoint :: proc(renderer : ^Renderer, x : _c.int, y : _c.int) -> _c.int ---;
RenderDrawPoints :: proc(renderer : ^Renderer, points : ^Point, count : _c.int) -> _c.int ---;
RenderDrawLine :: proc(renderer : ^Renderer, x1 : _c.int, y1 : _c.int, x2 : _c.int, y2 : _c.int) -> _c.int ---;
RenderDrawLines :: proc(renderer : ^Renderer, points : ^Point, count : _c.int) -> _c.int ---;
RenderDrawRect :: proc(renderer : ^Renderer, rect : ^Rect) -> _c.int ---;
RenderDrawRects :: proc(renderer : ^Renderer, rects : ^Rect, count : _c.int) -> _c.int ---;
RenderFillRect :: proc(renderer : ^Renderer, rect : ^Rect) -> _c.int ---;
RenderFillRects :: proc(renderer : ^Renderer, rects : ^Rect, count : _c.int) -> _c.int ---;
RenderCopy :: proc(renderer : ^Renderer, texture : ^Texture, srcrect : ^Rect, dstrect : ^Rect) -> _c.int ---;
RenderCopyEx :: proc(renderer : ^Renderer, texture : ^Texture, srcrect : ^Rect, dstrect : ^Rect, angle : _c.double, center : ^Point, flip : RendererFlip) -> _c.int ---;
RenderDrawPointF :: proc(renderer : ^Renderer, x : _c.float, y : _c.float) -> _c.int ---;
RenderDrawPointsF :: proc(renderer : ^Renderer, points : ^FPoint, count : _c.int) -> _c.int ---;
RenderDrawLineF :: proc(renderer : ^Renderer, x1 : _c.float, y1 : _c.float, x2 : _c.float, y2 : _c.float) -> _c.int ---;
RenderDrawLinesF :: proc(renderer : ^Renderer, points : ^FPoint, count : _c.int) -> _c.int ---;
RenderDrawRectF :: proc(renderer : ^Renderer, rect : ^FRect) -> _c.int ---;
RenderDrawRectsF :: proc(renderer : ^Renderer, rects : ^FRect, count : _c.int) -> _c.int ---;
RenderFillRectF :: proc(renderer : ^Renderer, rect : ^FRect) -> _c.int ---;
RenderFillRectsF :: proc(renderer : ^Renderer, rects : ^FRect, count : _c.int) -> _c.int ---;
RenderCopyF :: proc(renderer : ^Renderer, texture : ^Texture, srcrect : ^Rect, dstrect : ^FRect) -> _c.int ---;
RenderCopyExF :: proc(renderer : ^Renderer, texture : ^Texture, srcrect : ^Rect, dstrect : ^FRect, angle : _c.double, center : ^FPoint, flip : RendererFlip) -> _c.int ---;
RenderReadPixels :: proc(renderer : ^Renderer, rect : ^Rect, format : Uint32, pixels : rawptr, pitch : _c.int) -> _c.int ---;
RenderPresent :: proc(renderer : ^Renderer) ---;
DestroyTexture :: proc(texture : ^Texture) ---;
DestroyRenderer :: proc(renderer : ^Renderer) ---;
RenderFlush :: proc(renderer : ^Renderer) -> _c.int ---;
GL_BindTexture :: proc(texture : ^Texture, texw : ^_c.float, texh : ^_c.float) -> _c.int ---;
GL_UnbindTexture :: proc(texture : ^Texture) -> _c.int ---;
RenderGetMetalLayer :: proc(renderer : ^Renderer) -> rawptr ---;
RenderGetMetalCommandEncoder :: proc(renderer : ^Renderer) -> rawptr ---;
GetRenderTarget :: proc(renderer : ^Renderer) -> ^Texture ---;
GetTicks :: proc() -> Uint32 ---;
GetPerformanceCounter :: proc() -> Uint64 ---;
CreateShapedWindow :: proc(title : cstring, x : _c.uint, y : _c.uint, w : _c.uint, h : _c.uint, flags : Uint32) -> ^Window ---;
IsShapedWindow :: proc(window : ^Window) -> bool ---;
SetWindowShape :: proc(window : ^Window, shape : ^Surface, shape_mode : ^SDL_WindowShapeMode) -> _c.int ---;
GetShapedWindowMode :: proc(window : ^Window, shape_mode : ^SDL_WindowShapeMode) -> _c.int ---;
LockSensors :: proc() ---;
UnlockSensors :: proc() ---;
NumSensors :: proc() -> _c.int ---;
SensorGetDeviceType :: proc(device_index : _c.int) -> SensorType ---;
SensorGetDeviceNonPortableType :: proc(device_index : _c.int) -> _c.int ---;
SensorGetDeviceInstanceID :: proc(device_index : _c.int) -> SensorID ---;
SensorGetType :: proc(sensor : ^Sensor) -> SensorType ---;
SensorGetNonPortableType :: proc(sensor : ^Sensor) -> _c.int ---;
SensorGetInstanceID :: proc(sensor : ^Sensor) -> SensorID ---;
SensorGetData :: proc(sensor : ^Sensor, data : ^_c.float, num_values : _c.int) -> _c.int ---;
SensorClose :: proc(sensor : ^Sensor) ---;
SensorUpdate :: proc() ---;
malloc :: proc(size : uint) -> rawptr ---;
calloc :: proc(nmemb : uint, size : uint) -> rawptr ---;
realloc :: proc(mem : rawptr, size : uint) -> rawptr ---;
free :: proc(mem : rawptr) ---;
GetMemoryFunctions :: proc(malloc_func : ^malloc_func, calloc_func : ^calloc_func, realloc_func : ^realloc_func, free_func : ^free_func) ---;
SetMemoryFunctions :: proc(malloc_func : malloc_func, calloc_func : calloc_func, realloc_func : realloc_func, free_func : free_func) -> _c.int ---;
GetNumAllocations :: proc() -> _c.int ---;
getenv :: proc(name : cstring) -> cstring ---;
setenv :: proc(name : cstring, value : cstring, overwrite : _c.int) -> _c.int ---;
qsort :: proc(base : rawptr, nmemb : uint, size : uint, compare : (proc(rawptr, rawptr) -> _c.int)) ---;
abs :: proc(x : _c.int) -> _c.int ---;
isdigit :: proc(x : _c.int) -> _c.int ---;
isspace :: proc(x : _c.int) -> _c.int ---;
isupper :: proc(x : _c.int) -> _c.int ---;
islower :: proc(x : _c.int) -> _c.int ---;
toupper :: proc(x : _c.int) -> _c.int ---;
tolower :: proc(x : _c.int) -> _c.int ---;
crc32 :: proc(crc : Uint32, data : rawptr, len : uint) -> Uint32 ---;
memset :: proc(dst : rawptr, c : _c.int, len : uint) -> rawptr ---;
memcpy :: proc(dst : rawptr, src : rawptr, len : uint) -> rawptr ---;
memmove :: proc(dst : rawptr, src : rawptr, len : uint) -> rawptr ---;
memcmp :: proc(s1 : rawptr, s2 : rawptr, len : uint) -> _c.int ---;
wcslen :: proc(wstr : ^_c.wchar_t) -> uint ---;
wcslcpy :: proc(dst : ^_c.wchar_t, src : ^_c.wchar_t, maxlen : uint) -> uint ---;
wcslcat :: proc(dst : ^_c.wchar_t, src : ^_c.wchar_t, maxlen : uint) -> uint ---;
wcsdup :: proc(wstr : ^_c.wchar_t) -> ^_c.wchar_t ---;
wcsstr :: proc(haystack : ^_c.wchar_t, needle : ^_c.wchar_t) -> ^_c.wchar_t ---;
wcscmp :: proc(str1 : ^_c.wchar_t, str2 : ^_c.wchar_t) -> _c.int ---;
wcsncmp :: proc(str1 : ^_c.wchar_t, str2 : ^_c.wchar_t, maxlen : uint) -> _c.int ---;
wcscasecmp :: proc(str1 : ^_c.wchar_t, str2 : ^_c.wchar_t) -> _c.int ---;
wcsncasecmp :: proc(str1 : ^_c.wchar_t, str2 : ^_c.wchar_t, len : uint) -> _c.int ---;
strlen :: proc(str : cstring) -> uint ---;
strlcpy :: proc(dst : cstring, src : cstring, maxlen : uint) -> uint ---;
utf8strlcpy :: proc(dst : cstring, src : cstring, dst_bytes : uint) -> uint ---;
strlcat :: proc(dst : cstring, src : cstring, maxlen : uint) -> uint ---;
strdup :: proc(str : cstring) -> cstring ---;
strrev :: proc(str : cstring) -> cstring ---;
strupr :: proc(str : cstring) -> cstring ---;
strlwr :: proc(str : cstring) -> cstring ---;
strchr :: proc(str : cstring, c : _c.int) -> cstring ---;
strrchr :: proc(str : cstring, c : _c.int) -> cstring ---;
strstr :: proc(haystack : cstring, needle : cstring) -> cstring ---;
strtokr :: proc(s1 : cstring, s2 : cstring, saveptr : ^cstring) -> cstring ---;
utf8strlen :: proc(str : cstring) -> uint ---;
itoa :: proc(value : _c.int, str : cstring, radix : _c.int) -> cstring ---;
uitoa :: proc(value : _c.uint, str : cstring, radix : _c.int) -> cstring ---;
ltoa :: proc(value : _c.long, str : cstring, radix : _c.int) -> cstring ---;
ultoa :: proc(value : _c.ulong, str : cstring, radix : _c.int) -> cstring ---;
lltoa :: proc(value : Sint64, str : cstring, radix : _c.int) -> cstring ---;
ulltoa :: proc(value : Uint64, str : cstring, radix : _c.int) -> cstring ---;
atoi :: proc(str : cstring) -> _c.int ---;
atof :: proc(str : cstring) -> _c.double ---;
strtol :: proc(str : cstring, endp : ^cstring, base : _c.int) -> _c.long ---;
strtoul :: proc(str : cstring, endp : ^cstring, base : _c.int) -> _c.ulong ---;
strtoll :: proc(str : cstring, endp : ^cstring, base : _c.int) -> Sint64 ---;
strtoull :: proc(str : cstring, endp : ^cstring, base : _c.int) -> Uint64 ---;
strtod :: proc(str : cstring, endp : ^cstring) -> _c.double ---;
strcmp :: proc(str1 : cstring, str2 : cstring) -> _c.int ---;
strncmp :: proc(str1 : cstring, str2 : cstring, maxlen : uint) -> _c.int ---;
strcasecmp :: proc(str1 : cstring, str2 : cstring) -> _c.int ---;
strncasecmp :: proc(str1 : cstring, str2 : cstring, len : uint) -> _c.int ---;
sscanf :: proc(text : cstring, fmt : cstring, #c_vararg __args : ..any) -> _c.int ---;
snprintf :: proc(text : cstring, maxlen : uint, fmt : cstring, #c_vararg __args : ..any) -> _c.int ---;
acos :: proc(x : _c.double) -> _c.double ---;
acosf :: proc(x : _c.float) -> _c.float ---;
asin :: proc(x : _c.double) -> _c.double ---;
asinf :: proc(x : _c.float) -> _c.float ---;
atan :: proc(x : _c.double) -> _c.double ---;
atanf :: proc(x : _c.float) -> _c.float ---;
atan2 :: proc(x : _c.double, y : _c.double) -> _c.double ---;
atan2f :: proc(x : _c.float, y : _c.float) -> _c.float ---;
ceil :: proc(x : _c.double) -> _c.double ---;
ceilf :: proc(x : _c.float) -> _c.float ---;
copysign :: proc(x : _c.double, y : _c.double) -> _c.double ---;
copysignf :: proc(x : _c.float, y : _c.float) -> _c.float ---;
cos :: proc(x : _c.double) -> _c.double ---;
cosf :: proc(x : _c.float) -> _c.float ---;
exp :: proc(x : _c.double) -> _c.double ---;
expf :: proc(x : _c.float) -> _c.float ---;
fabs :: proc(x : _c.double) -> _c.double ---;
fabsf :: proc(x : _c.float) -> _c.float ---;
floor :: proc(x : _c.double) -> _c.double ---;
floorf :: proc(x : _c.float) -> _c.float ---;
trunc :: proc(x : _c.double) -> _c.double ---;
truncf :: proc(x : _c.float) -> _c.float ---;
fmod :: proc(x : _c.double, y : _c.double) -> _c.double ---;
fmodf :: proc(x : _c.float, y : _c.float) -> _c.float ---;
log :: proc(x : _c.double) -> _c.double ---;
logf :: proc(x : _c.float) -> _c.float ---;
log10 :: proc(x : _c.double) -> _c.double ---;
log10f :: proc(x : _c.float) -> _c.float ---;
pow :: proc(x : _c.double, y : _c.double) -> _c.double ---;
powf :: proc(x : _c.float, y : _c.float) -> _c.float ---;
scalbn :: proc(x : _c.double, n : _c.int) -> _c.double ---;
scalbnf :: proc(x : _c.float, n : _c.int) -> _c.float ---;
sin :: proc(x : _c.double) -> _c.double ---;
sinf :: proc(x : _c.float) -> _c.float ---;
sqrt :: proc(x : _c.double) -> _c.double ---;
sqrtf :: proc(x : _c.float) -> _c.float ---;
tan :: proc(x : _c.double) -> _c.double ---;
tanf :: proc(x : _c.float) -> _c.float ---;
iconv_open :: proc(tocode : cstring, fromcode : cstring) -> iconv_t ---;
iconv_close :: proc(cd : iconv_t) -> _c.int ---;
iconv :: proc(cd : iconv_t, inbuf : ^cstring, inbytesleft : ^uint, outbuf : ^cstring, outbytesleft : ^uint) -> uint ---;
iconv_string :: proc(tocode : cstring, fromcode : cstring, inbuf : cstring, inbytesleft : uint) -> cstring ---;
SensorGetDeviceName :: proc(device_index : _c.int) -> cstring ---;
SensorOpen :: proc(device_index : _c.int) -> ^Sensor ---;
SensorFromInstanceID :: proc(instance_id : SensorID) -> ^Sensor ---;
SensorGetName :: proc(sensor : ^Sensor) -> cstring ---;
LinuxSetThreadPriority :: proc(threadID : Sint64, priority : _c.int) -> _c.int ---;
CreateRGBSurface :: proc(flags : Uint32, width : _c.int, height : _c.int, depth : _c.int, Rmask : Uint32, Gmask : Uint32, Bmask : Uint32, Amask : Uint32) -> ^Surface ---;
CreateRGBSurfaceWithFormat :: proc(flags : Uint32, width : _c.int, height : _c.int, depth : _c.int, format : Uint32) -> ^Surface ---;
CreateRGBSurfaceFrom :: proc(pixels : rawptr, width : _c.int, height : _c.int, depth : _c.int, pitch : _c.int, Rmask : Uint32, Gmask : Uint32, Bmask : Uint32, Amask : Uint32) -> ^Surface ---;
CreateRGBSurfaceWithFormatFrom :: proc(pixels : rawptr, width : _c.int, height : _c.int, depth : _c.int, pitch : _c.int, format : Uint32) -> ^Surface ---;
FreeSurface :: proc(surface : ^Surface) ---;
SetSurfacePalette :: proc(surface : ^Surface, palette : ^Palette) -> _c.int ---;
GetPerformanceFrequency :: proc() -> Uint64 ---;
Delay :: proc(ms : Uint32) ---;
AddTimer :: proc(interval : Uint32, callback : TimerCallback, param : rawptr) -> TimerID ---;
RemoveTimer :: proc(id : TimerID) -> bool ---;
GetNumTouchDevices :: proc() -> _c.int ---;
GetTouchDevice :: proc(index : _c.int) -> TouchID ---;
GetTouchDeviceType :: proc(touchID : TouchID) -> TouchDeviceType ---;
GetNumTouchFingers :: proc(touchID : TouchID) -> _c.int ---;
GetVersion :: proc(ver : ^version) ---;
GetRevisionNumber :: proc() -> _c.int ---;
GetTouchFinger :: proc(touchID : TouchID, index : _c.int) -> ^Finger ---;
GetRevision :: proc() -> cstring ---;
LockSurface :: proc(surface : ^Surface) -> _c.int ---;
UnlockSurface :: proc(surface : ^Surface) ---;
CreateThread :: proc(fn : ThreadFunction, name : cstring, data : rawptr) -> ^Thread ---;
LoadBMP_RW :: proc(src : ^RWops, freesrc : _c.int) -> ^Surface ---;
SaveBMP_RW :: proc(surface : ^Surface, dst : ^RWops, freedst : _c.int) -> _c.int ---;
CreateThreadWithStackSize :: proc(fn : ThreadFunction, name : cstring, stacksize : uint, data : rawptr) -> ^Thread ---;
GetThreadName :: proc(thread : ^Thread) -> cstring ---;
SetSurfaceRLE :: proc(surface : ^Surface, flag : _c.int) -> _c.int ---;
ThreadID :: proc() -> threadID ---;
GetThreadID :: proc(thread : ^Thread) -> threadID ---;
HasSurfaceRLE :: proc(surface : ^Surface) -> bool ---;
SetThreadPriority :: proc(priority : ThreadPriority) -> _c.int ---;
SetColorKey :: proc(surface : ^Surface, flag : _c.int, key : Uint32) -> _c.int ---;
GetNumVideoDrivers :: proc() -> _c.int ---;
HasColorKey :: proc(surface : ^Surface) -> bool ---;
WaitThread :: proc(thread : ^Thread, status : ^_c.int) ---;
GetVideoDriver :: proc(index : _c.int) -> cstring ---;
GetColorKey :: proc(surface : ^Surface, key : ^Uint32) -> _c.int ---;
VideoInit :: proc(driver_name : cstring) -> _c.int ---;
SetSurfaceColorMod :: proc(surface : ^Surface, r : Uint8, g : Uint8, b : Uint8) -> _c.int ---;
DetachThread :: proc(thread : ^Thread) ---;
IsTablet :: proc() -> bool ---;
OnApplicationWillTerminate :: proc() ---;
OnApplicationDidReceiveMemoryWarning :: proc() ---;
VideoQuit :: proc() ---;
GetSurfaceColorMod :: proc(surface : ^Surface, r : ^Uint8, g : ^Uint8, b : ^Uint8) -> _c.int ---;
OnApplicationWillResignActive :: proc() ---;
OnApplicationDidEnterBackground :: proc() ---;
OnApplicationWillEnterForeground :: proc() ---;
OnApplicationDidBecomeActive :: proc() ---;
GetNumVideoDisplays :: proc() -> _c.int ---;
GetCurrentVideoDriver :: proc() -> cstring ---;
SetSurfaceAlphaMod :: proc(surface : ^Surface, alpha : Uint8) -> _c.int ---;
TLSCreate :: proc() -> TLSID ---;
GetDisplayName :: proc(displayIndex : _c.int) -> cstring ---;
GetSurfaceAlphaMod :: proc(surface : ^Surface, alpha : ^Uint8) -> _c.int ---;
TLSGet :: proc(id : TLSID) -> rawptr ---;
GetDisplayBounds :: proc(displayIndex : _c.int, rect : ^Rect) -> _c.int ---;
SetSurfaceBlendMode :: proc(surface : ^Surface, blendMode : BlendMode) -> _c.int ---;
TLSSet :: proc(id : TLSID, value : rawptr, destructor : proc(rawptr)) -> _c.int ---;
GetDisplayUsableBounds :: proc(displayIndex : _c.int, rect : ^Rect) -> _c.int ---;
GetSurfaceBlendMode :: proc(surface : ^Surface, blendMode : ^BlendMode) -> _c.int ---;
GetDisplayDPI :: proc(displayIndex : _c.int, ddpi : ^_c.float, hdpi : ^_c.float, vdpi : ^_c.float) -> _c.int ---;
GetDisplayOrientation :: proc(displayIndex : _c.int) -> DisplayOrientation ---;
SetClipRect :: proc(surface : ^Surface, rect : ^Rect) -> bool ---;
GetNumDisplayModes :: proc(displayIndex : _c.int) -> _c.int ---;
GetClipRect :: proc(surface : ^Surface, rect : ^Rect) ---;
DuplicateSurface :: proc(surface : ^Surface) -> ^Surface ---;
ConvertSurface :: proc(src : ^Surface, fmt : ^PixelFormat, flags : Uint32) -> ^Surface ---;
ConvertSurfaceFormat :: proc(src : ^Surface, pixel_format : Uint32, flags : Uint32) -> ^Surface ---;
GetDisplayMode :: proc(displayIndex : _c.int, modeIndex : _c.int, mode : ^DisplayMode) -> _c.int ---;
GetDesktopDisplayMode :: proc(displayIndex : _c.int, mode : ^DisplayMode) -> _c.int ---;
GetCurrentDisplayMode :: proc(displayIndex : _c.int, mode : ^DisplayMode) -> _c.int ---;
ConvertPixels :: proc(width : _c.int, height : _c.int, src_format : Uint32, src : rawptr, src_pitch : _c.int, dst_format : Uint32, dst : rawptr, dst_pitch : _c.int) -> _c.int ---;
FillRect :: proc(dst : ^Surface, rect : ^Rect, color : Uint32) -> _c.int ---;
GetClosestDisplayMode :: proc(displayIndex : _c.int, mode : ^DisplayMode, closest : ^DisplayMode) -> ^DisplayMode ---;
FillRects :: proc(dst : ^Surface, rects : ^Rect, count : _c.int, color : Uint32) -> _c.int ---;
GetWindowDisplayIndex :: proc(window : ^Window) -> _c.int ---;
SetWindowDisplayMode :: proc(window : ^Window, mode : ^DisplayMode) -> _c.int ---;
GetWindowDisplayMode :: proc(window : ^Window, mode : ^DisplayMode) -> _c.int ---;
GetWindowPixelFormat :: proc(window : ^Window) -> Uint32 ---;
UpperBlit :: proc(src : ^Surface, srcrect : ^Rect, dst : ^Surface, dstrect : ^Rect) -> _c.int ---;
LowerBlit :: proc(src : ^Surface, srcrect : ^Rect, dst : ^Surface, dstrect : ^Rect) -> _c.int ---;
SoftStretch :: proc(src : ^Surface, srcrect : ^Rect, dst : ^Surface, dstrect : ^Rect) -> _c.int ---;
CreateWindow :: proc(title : cstring, x : _c.int, y : _c.int, w : _c.int, h : _c.int, flags : Uint32) -> ^Window ---;
UpperBlitScaled :: proc(src : ^Surface, srcrect : ^Rect, dst : ^Surface, dstrect : ^Rect) -> _c.int ---;
LowerBlitScaled :: proc(src : ^Surface, srcrect : ^Rect, dst : ^Surface, dstrect : ^Rect) -> _c.int ---;
SetYUVConversionMode :: proc(mode : YUV_CONVERSION_MODE) ---;
GetYUVConversionMode :: proc() -> YUV_CONVERSION_MODE ---;
GetWindowID :: proc(window : ^Window) -> Uint32 ---;
GetWindowFlags :: proc(window : ^Window) -> Uint32 ---;
CreateWindowFrom :: proc(data : rawptr) -> ^Window ---;
GetWindowFromID :: proc(id : Uint32) -> ^Window ---;
GetYUVConversionModeForResolution :: proc(width : _c.int, height : _c.int) -> YUV_CONVERSION_MODE ---;
SetWindowTitle :: proc(window : ^Window, title : cstring) ---;
GetWindowTitle :: proc(window : ^Window) -> cstring ---;
SetWindowIcon :: proc(window : ^Window, icon : ^Surface) ---;
SetWindowPosition :: proc(window : ^Window, x : _c.int, y : _c.int) ---;
GetWindowPosition :: proc(window : ^Window, x : ^_c.int, y : ^_c.int) ---;
SetWindowSize :: proc(window : ^Window, w : _c.int, h : _c.int) ---;
GetWindowSize :: proc(window : ^Window, w : ^_c.int, h : ^_c.int) ---;
GetWindowBordersSize :: proc(window : ^Window, top : ^_c.int, left : ^_c.int, bottom : ^_c.int, right : ^_c.int) -> _c.int ---;
SetWindowMinimumSize :: proc(window : ^Window, min_w : _c.int, min_h : _c.int) ---;
GetWindowMinimumSize :: proc(window : ^Window, w : ^_c.int, h : ^_c.int) ---;
SetWindowMaximumSize :: proc(window : ^Window, max_w : _c.int, max_h : _c.int) ---;
GetWindowMaximumSize :: proc(window : ^Window, w : ^_c.int, h : ^_c.int) ---;
SetWindowBordered :: proc(window : ^Window, bordered : bool) ---;
SetWindowResizable :: proc(window : ^Window, resizable : bool) ---;
ShowWindow :: proc(window : ^Window) ---;
HideWindow :: proc(window : ^Window) ---;
RaiseWindow :: proc(window : ^Window) ---;
MaximizeWindow :: proc(window : ^Window) ---;
MinimizeWindow :: proc(window : ^Window) ---;
RestoreWindow :: proc(window : ^Window) ---;
SetWindowFullscreen :: proc(window : ^Window, flags : Uint32) -> _c.int ---;
UpdateWindowSurface :: proc(window : ^Window) -> _c.int ---;
UpdateWindowSurfaceRects :: proc(window : ^Window, rects : ^Rect, numrects : _c.int) -> _c.int ---;
SetWindowGrab :: proc(window : ^Window, grabbed : bool) ---;
GetWindowGrab :: proc(window : ^Window) -> bool ---;
SetWindowBrightness :: proc(window : ^Window, brightness : _c.float) -> _c.int ---;
GetWindowBrightness :: proc(window : ^Window) -> _c.float ---;
SetWindowOpacity :: proc(window : ^Window, opacity : _c.float) -> _c.int ---;
GetWindowOpacity :: proc(window : ^Window, out_opacity : ^_c.float) -> _c.int ---;
SetWindowModalFor :: proc(modal_window : ^Window, parent_window : ^Window) -> _c.int ---;
SetWindowInputFocus :: proc(window : ^Window) -> _c.int ---;
SetWindowGammaRamp :: proc(window : ^Window, red : ^Uint16, green : ^Uint16, blue : ^Uint16) -> _c.int ---;
GetWindowGammaRamp :: proc(window : ^Window, red : ^Uint16, green : ^Uint16, blue : ^Uint16) -> _c.int ---;
SetWindowHitTest :: proc(window : ^Window, callback : HitTest, callback_data : rawptr) -> _c.int ---;
DestroyWindow :: proc(window : ^Window) ---;
IsScreenSaverEnabled :: proc() -> bool ---;
EnableScreenSaver :: proc() ---;
DisableScreenSaver :: proc() ---;
GL_LoadLibrary :: proc(path : cstring) -> _c.int ---;
GL_UnloadLibrary :: proc() ---;
GL_ExtensionSupported :: proc(extension : cstring) -> bool ---;
GL_ResetAttributes :: proc() ---;
GL_SetAttribute :: proc(attr : GLattr, value : _c.int) -> _c.int ---;
GL_GetAttribute :: proc(attr : GLattr, value : ^_c.int) -> _c.int ---;
GL_CreateContext :: proc(window : ^Window) -> GLContext ---;
GL_MakeCurrent :: proc(window : ^Window, context_ : GLContext) -> _c.int ---;
GL_GetCurrentContext :: proc() -> GLContext ---;
GL_GetDrawableSize :: proc(window : ^Window, w : ^_c.int, h : ^_c.int) ---;
GL_SetSwapInterval :: proc(interval : _c.int) -> _c.int ---;
GL_GetSwapInterval :: proc() -> _c.int ---;
GL_SwapWindow :: proc(window : ^Window) ---;
GL_DeleteContext :: proc(context_ : GLContext) ---;
SetWindowData :: proc(window : ^Window, name : cstring, userdata : rawptr) -> rawptr ---;
GetWindowData :: proc(window : ^Window, name : cstring) -> rawptr ---;
GetWindowSurface :: proc(window : ^Window) -> ^Surface ---;
GL_GetProcAddress :: proc(proc_ : cstring) -> rawptr ---;
GL_GetCurrentWindow :: proc() -> ^Window ---;
GetGrabbedWindow :: proc() -> ^Window ---;
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment