From 53b6d8553e6387e7397274c9ca7b2d627faa139e Mon Sep 17 00:00:00 2001 From: Scott Percival Date: Sun, 6 Mar 2022 21:33:26 +0800 Subject: [PATCH 01/13] Update bindings to SDL 2.0.20 --- sdl2-sys/SDL | 2 +- sdl2-sys/sdl_bindings.rs | 13863 ++++++++++++++++++++++++++++--------- 2 files changed, 10430 insertions(+), 3435 deletions(-) diff --git a/sdl2-sys/SDL b/sdl2-sys/SDL index a1e992b110..b424665e08 160000 --- a/sdl2-sys/SDL +++ b/sdl2-sys/SDL @@ -1 +1 @@ -Subproject commit a1e992b110b9adf3305a5ebb5514f0e970f7911e +Subproject commit b424665e0899769b200231ba943353a5fee1b6b6 diff --git a/sdl2-sys/sdl_bindings.rs b/sdl2-sys/sdl_bindings.rs index b98fc8ee05..bc75efca53 100644 --- a/sdl2-sys/sdl_bindings.rs +++ b/sdl2-sys/sdl_bindings.rs @@ -8,6 +8,7 @@ pub const HAVE_GCC_SYNC_LOCK_TEST_AND_SET: u32 = 1; pub const SDL_AUDIO_DRIVER_DUMMY: u32 = 1; pub const SDL_JOYSTICK_DISABLED: u32 = 1; pub const SDL_HAPTIC_DISABLED: u32 = 1; +pub const SDL_HIDAPI_DISABLED: u32 = 1; pub const SDL_SENSOR_DISABLED: u32 = 1; pub const SDL_LOADSO_DISABLED: u32 = 1; pub const SDL_THREADS_DISABLED: u32 = 1; @@ -32,6 +33,10 @@ pub const __USE_POSIX199506: u32 = 1; pub const __USE_XOPEN2K: u32 = 1; pub const __USE_XOPEN2K8: u32 = 1; pub const _ATFILE_SOURCE: u32 = 1; +pub const __WORDSIZE: u32 = 64; +pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1; +pub const __SYSCALL_WORDSIZE: u32 = 64; +pub const __TIMESIZE: u32 = 64; pub const __USE_MISC: u32 = 1; pub const __USE_ATFILE: u32 = 1; pub const __USE_FORTIFY_LEVEL: u32 = 0; @@ -39,26 +44,25 @@ pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0; pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0; pub const _STDC_PREDEF_H: u32 = 1; pub const __STDC_IEC_559__: u32 = 1; +pub const __STDC_IEC_60559_BFP__: u32 = 201404; pub const __STDC_IEC_559_COMPLEX__: u32 = 1; +pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404; pub const __STDC_ISO_10646__: u32 = 201706; pub const __GNU_LIBRARY__: u32 = 6; pub const __GLIBC__: u32 = 2; -pub const __GLIBC_MINOR__: u32 = 33; +pub const __GLIBC_MINOR__: u32 = 35; pub const _SYS_CDEFS_H: u32 = 1; pub const __glibc_c99_flexarr_available: u32 = 1; -pub const __WORDSIZE: u32 = 64; -pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1; -pub const __SYSCALL_WORDSIZE: u32 = 64; pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0; pub const __HAVE_GENERIC_SELECTION: u32 = 1; pub const __GLIBC_USE_LIB_EXT2: u32 = 0; pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0; pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 0; +pub const __GLIBC_USE_IEC_60559_EXT: u32 = 0; pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0; pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 0; pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0; pub const _BITS_TYPES_H: u32 = 1; -pub const __TIMESIZE: u32 = 64; pub const _BITS_TYPESIZES_H: u32 = 1; pub const __OFF_T_MATCHES_OFF64_T: u32 = 1; pub const __INO_T_MATCHES_INO64_T: u32 = 1; @@ -111,6 +115,10 @@ pub const SDL_PRIs64: &'static [u8; 3usize] = b"ld\0"; pub const SDL_PRIu64: &'static [u8; 3usize] = b"lu\0"; pub const SDL_PRIx64: &'static [u8; 3usize] = b"lx\0"; pub const SDL_PRIX64: &'static [u8; 3usize] = b"lX\0"; +pub const SDL_PRIs32: &'static [u8; 2usize] = b"d\0"; +pub const SDL_PRIu32: &'static [u8; 2usize] = b"u\0"; +pub const SDL_PRIx32: &'static [u8; 2usize] = b"x\0"; +pub const SDL_PRIX32: &'static [u8; 2usize] = b"X\0"; pub const M_PI: f64 = 3.141592653589793; pub const SDL_ASSERT_LEVEL: u32 = 2; pub const SDL_NULL_WHILE_LOOP_CONDITION: u32 = 0; @@ -319,168 +327,206 @@ pub const SDL_HAPTIC_CARTESIAN: u32 = 1; pub const SDL_HAPTIC_SPHERICAL: u32 = 2; pub const SDL_HAPTIC_STEERING_AXIS: u32 = 3; pub const SDL_HAPTIC_INFINITY: u32 = 4294967295; -pub const SDL_HINT_FRAMEBUFFER_ACCELERATION: &'static [u8; 29usize] = - b"SDL_FRAMEBUFFER_ACCELERATION\0"; -pub const SDL_HINT_RENDER_DRIVER: &'static [u8; 18usize] = b"SDL_RENDER_DRIVER\0"; -pub const SDL_HINT_RENDER_OPENGL_SHADERS: &'static [u8; 26usize] = b"SDL_RENDER_OPENGL_SHADERS\0"; -pub const SDL_HINT_RENDER_DIRECT3D_THREADSAFE: &'static [u8; 31usize] = - b"SDL_RENDER_DIRECT3D_THREADSAFE\0"; -pub const SDL_HINT_RENDER_DIRECT3D11_DEBUG: &'static [u8; 28usize] = - b"SDL_RENDER_DIRECT3D11_DEBUG\0"; -pub const SDL_HINT_RENDER_LOGICAL_SIZE_MODE: &'static [u8; 29usize] = - b"SDL_RENDER_LOGICAL_SIZE_MODE\0"; -pub const SDL_HINT_RENDER_SCALE_QUALITY: &'static [u8; 25usize] = b"SDL_RENDER_SCALE_QUALITY\0"; -pub const SDL_HINT_RENDER_VSYNC: &'static [u8; 17usize] = b"SDL_RENDER_VSYNC\0"; -pub const SDL_HINT_VIDEO_ALLOW_SCREENSAVER: &'static [u8; 28usize] = - b"SDL_VIDEO_ALLOW_SCREENSAVER\0"; -pub const SDL_HINT_VIDEO_EXTERNAL_CONTEXT: &'static [u8; 27usize] = b"SDL_VIDEO_EXTERNAL_CONTEXT\0"; -pub const SDL_HINT_VIDEO_X11_XVIDMODE: &'static [u8; 23usize] = b"SDL_VIDEO_X11_XVIDMODE\0"; -pub const SDL_HINT_VIDEO_X11_XINERAMA: &'static [u8; 23usize] = b"SDL_VIDEO_X11_XINERAMA\0"; -pub const SDL_HINT_VIDEO_X11_XRANDR: &'static [u8; 21usize] = b"SDL_VIDEO_X11_XRANDR\0"; -pub const SDL_HINT_VIDEO_X11_WINDOW_VISUALID: &'static [u8; 30usize] = - b"SDL_VIDEO_X11_WINDOW_VISUALID\0"; -pub const SDL_HINT_VIDEO_X11_NET_WM_PING: &'static [u8; 26usize] = b"SDL_VIDEO_X11_NET_WM_PING\0"; -pub const SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR: &'static [u8; 39usize] = - b"SDL_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR\0"; -pub const SDL_HINT_VIDEO_X11_FORCE_EGL: &'static [u8; 24usize] = b"SDL_VIDEO_X11_FORCE_EGL\0"; -pub const SDL_HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN: &'static [u8; 44usize] = - b"SDL_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN\0"; -pub const SDL_HINT_WINDOWS_INTRESOURCE_ICON: &'static [u8; 29usize] = - b"SDL_WINDOWS_INTRESOURCE_ICON\0"; -pub const SDL_HINT_WINDOWS_INTRESOURCE_ICON_SMALL: &'static [u8; 35usize] = - b"SDL_WINDOWS_INTRESOURCE_ICON_SMALL\0"; -pub const SDL_HINT_WINDOWS_ENABLE_MESSAGELOOP: &'static [u8; 31usize] = - b"SDL_WINDOWS_ENABLE_MESSAGELOOP\0"; -pub const SDL_HINT_GRAB_KEYBOARD: &'static [u8; 18usize] = b"SDL_GRAB_KEYBOARD\0"; -pub const SDL_HINT_MOUSE_DOUBLE_CLICK_TIME: &'static [u8; 28usize] = - b"SDL_MOUSE_DOUBLE_CLICK_TIME\0"; -pub const SDL_HINT_MOUSE_DOUBLE_CLICK_RADIUS: &'static [u8; 30usize] = - b"SDL_MOUSE_DOUBLE_CLICK_RADIUS\0"; -pub const SDL_HINT_MOUSE_NORMAL_SPEED_SCALE: &'static [u8; 29usize] = - b"SDL_MOUSE_NORMAL_SPEED_SCALE\0"; -pub const SDL_HINT_MOUSE_RELATIVE_SPEED_SCALE: &'static [u8; 31usize] = - b"SDL_MOUSE_RELATIVE_SPEED_SCALE\0"; -pub const SDL_HINT_MOUSE_RELATIVE_SCALING: &'static [u8; 27usize] = b"SDL_MOUSE_RELATIVE_SCALING\0"; -pub const SDL_HINT_MOUSE_RELATIVE_MODE_WARP: &'static [u8; 29usize] = - b"SDL_MOUSE_RELATIVE_MODE_WARP\0"; -pub const SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH: &'static [u8; 29usize] = - b"SDL_MOUSE_FOCUS_CLICKTHROUGH\0"; -pub const SDL_HINT_TOUCH_MOUSE_EVENTS: &'static [u8; 23usize] = b"SDL_TOUCH_MOUSE_EVENTS\0"; -pub const SDL_HINT_MOUSE_TOUCH_EVENTS: &'static [u8; 23usize] = b"SDL_MOUSE_TOUCH_EVENTS\0"; -pub const SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS: &'static [u8; 33usize] = - b"SDL_VIDEO_MINIMIZE_ON_FOCUS_LOSS\0"; -pub const SDL_HINT_IDLE_TIMER_DISABLED: &'static [u8; 28usize] = b"SDL_IOS_IDLE_TIMER_DISABLED\0"; -pub const SDL_HINT_ORIENTATIONS: &'static [u8; 21usize] = b"SDL_IOS_ORIENTATIONS\0"; +pub const SDL_HINT_ACCELEROMETER_AS_JOYSTICK: &'static [u8; 30usize] = + b"SDL_ACCELEROMETER_AS_JOYSTICK\0"; +pub const SDL_HINT_ALLOW_ALT_TAB_WHILE_GRABBED: &'static [u8; 32usize] = + b"SDL_ALLOW_ALT_TAB_WHILE_GRABBED\0"; +pub const SDL_HINT_ALLOW_TOPMOST: &'static [u8; 18usize] = b"SDL_ALLOW_TOPMOST\0"; +pub const SDL_HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION: &'static [u8; 44usize] = + b"SDL_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION\0"; +pub const SDL_HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION: &'static [u8; 45usize] = + b"SDL_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION\0"; +pub const SDL_HINT_ANDROID_BLOCK_ON_PAUSE: &'static [u8; 27usize] = b"SDL_ANDROID_BLOCK_ON_PAUSE\0"; +pub const SDL_HINT_ANDROID_BLOCK_ON_PAUSE_PAUSEAUDIO: &'static [u8; 38usize] = + b"SDL_ANDROID_BLOCK_ON_PAUSE_PAUSEAUDIO\0"; +pub const SDL_HINT_ANDROID_TRAP_BACK_BUTTON: &'static [u8; 29usize] = + b"SDL_ANDROID_TRAP_BACK_BUTTON\0"; +pub const SDL_HINT_APP_NAME: &'static [u8; 13usize] = b"SDL_APP_NAME\0"; pub const SDL_HINT_APPLE_TV_CONTROLLER_UI_EVENTS: &'static [u8; 34usize] = b"SDL_APPLE_TV_CONTROLLER_UI_EVENTS\0"; pub const SDL_HINT_APPLE_TV_REMOTE_ALLOW_ROTATION: &'static [u8; 35usize] = b"SDL_APPLE_TV_REMOTE_ALLOW_ROTATION\0"; -pub const SDL_HINT_IOS_HIDE_HOME_INDICATOR: &'static [u8; 28usize] = - b"SDL_IOS_HIDE_HOME_INDICATOR\0"; -pub const SDL_HINT_ACCELEROMETER_AS_JOYSTICK: &'static [u8; 30usize] = - b"SDL_ACCELEROMETER_AS_JOYSTICK\0"; -pub const SDL_HINT_TV_REMOTE_AS_JOYSTICK: &'static [u8; 26usize] = b"SDL_TV_REMOTE_AS_JOYSTICK\0"; -pub const SDL_HINT_XINPUT_ENABLED: &'static [u8; 19usize] = b"SDL_XINPUT_ENABLED\0"; -pub const SDL_HINT_XINPUT_USE_OLD_JOYSTICK_MAPPING: &'static [u8; 36usize] = - b"SDL_XINPUT_USE_OLD_JOYSTICK_MAPPING\0"; -pub const SDL_HINT_GAMECONTROLLERTYPE: &'static [u8; 23usize] = b"SDL_GAMECONTROLLERTYPE\0"; +pub const SDL_HINT_AUDIO_CATEGORY: &'static [u8; 19usize] = b"SDL_AUDIO_CATEGORY\0"; +pub const SDL_HINT_AUDIO_DEVICE_APP_NAME: &'static [u8; 26usize] = b"SDL_AUDIO_DEVICE_APP_NAME\0"; +pub const SDL_HINT_AUDIO_DEVICE_STREAM_NAME: &'static [u8; 29usize] = + b"SDL_AUDIO_DEVICE_STREAM_NAME\0"; +pub const SDL_HINT_AUDIO_DEVICE_STREAM_ROLE: &'static [u8; 29usize] = + b"SDL_AUDIO_DEVICE_STREAM_ROLE\0"; +pub const SDL_HINT_AUDIO_RESAMPLING_MODE: &'static [u8; 26usize] = b"SDL_AUDIO_RESAMPLING_MODE\0"; +pub const SDL_HINT_AUTO_UPDATE_JOYSTICKS: &'static [u8; 26usize] = b"SDL_AUTO_UPDATE_JOYSTICKS\0"; +pub const SDL_HINT_AUTO_UPDATE_SENSORS: &'static [u8; 24usize] = b"SDL_AUTO_UPDATE_SENSORS\0"; +pub const SDL_HINT_BMP_SAVE_LEGACY_FORMAT: &'static [u8; 27usize] = b"SDL_BMP_SAVE_LEGACY_FORMAT\0"; +pub const SDL_HINT_DISPLAY_USABLE_BOUNDS: &'static [u8; 26usize] = b"SDL_DISPLAY_USABLE_BOUNDS\0"; +pub const SDL_HINT_EMSCRIPTEN_ASYNCIFY: &'static [u8; 24usize] = b"SDL_EMSCRIPTEN_ASYNCIFY\0"; +pub const SDL_HINT_EMSCRIPTEN_KEYBOARD_ELEMENT: &'static [u8; 32usize] = + b"SDL_EMSCRIPTEN_KEYBOARD_ELEMENT\0"; +pub const SDL_HINT_ENABLE_STEAM_CONTROLLERS: &'static [u8; 29usize] = + b"SDL_ENABLE_STEAM_CONTROLLERS\0"; +pub const SDL_HINT_EVENT_LOGGING: &'static [u8; 18usize] = b"SDL_EVENT_LOGGING\0"; +pub const SDL_HINT_FRAMEBUFFER_ACCELERATION: &'static [u8; 29usize] = + b"SDL_FRAMEBUFFER_ACCELERATION\0"; pub const SDL_HINT_GAMECONTROLLERCONFIG: &'static [u8; 25usize] = b"SDL_GAMECONTROLLERCONFIG\0"; pub const SDL_HINT_GAMECONTROLLERCONFIG_FILE: &'static [u8; 30usize] = b"SDL_GAMECONTROLLERCONFIG_FILE\0"; +pub const SDL_HINT_GAMECONTROLLERTYPE: &'static [u8; 23usize] = b"SDL_GAMECONTROLLERTYPE\0"; pub const SDL_HINT_GAMECONTROLLER_IGNORE_DEVICES: &'static [u8; 34usize] = b"SDL_GAMECONTROLLER_IGNORE_DEVICES\0"; pub const SDL_HINT_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT: &'static [u8; 41usize] = b"SDL_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT\0"; pub const SDL_HINT_GAMECONTROLLER_USE_BUTTON_LABELS: &'static [u8; 37usize] = b"SDL_GAMECONTROLLER_USE_BUTTON_LABELS\0"; +pub const SDL_HINT_GRAB_KEYBOARD: &'static [u8; 18usize] = b"SDL_GRAB_KEYBOARD\0"; +pub const SDL_HINT_IDLE_TIMER_DISABLED: &'static [u8; 28usize] = b"SDL_IOS_IDLE_TIMER_DISABLED\0"; +pub const SDL_HINT_IME_INTERNAL_EDITING: &'static [u8; 25usize] = b"SDL_IME_INTERNAL_EDITING\0"; +pub const SDL_HINT_IME_SHOW_UI: &'static [u8; 16usize] = b"SDL_IME_SHOW_UI\0"; +pub const SDL_HINT_IOS_HIDE_HOME_INDICATOR: &'static [u8; 28usize] = + b"SDL_IOS_HIDE_HOME_INDICATOR\0"; pub const SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS: &'static [u8; 37usize] = b"SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS\0"; pub const SDL_HINT_JOYSTICK_HIDAPI: &'static [u8; 20usize] = b"SDL_JOYSTICK_HIDAPI\0"; +pub const SDL_HINT_JOYSTICK_HIDAPI_GAMECUBE: &'static [u8; 29usize] = + b"SDL_JOYSTICK_HIDAPI_GAMECUBE\0"; +pub const SDL_HINT_JOYSTICK_HIDAPI_JOY_CONS: &'static [u8; 29usize] = + b"SDL_JOYSTICK_HIDAPI_JOY_CONS\0"; +pub const SDL_HINT_JOYSTICK_HIDAPI_LUNA: &'static [u8; 25usize] = b"SDL_JOYSTICK_HIDAPI_LUNA\0"; pub const SDL_HINT_JOYSTICK_HIDAPI_PS4: &'static [u8; 24usize] = b"SDL_JOYSTICK_HIDAPI_PS4\0"; -pub const SDL_HINT_JOYSTICK_HIDAPI_PS5: &'static [u8; 24usize] = b"SDL_JOYSTICK_HIDAPI_PS5\0"; pub const SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE: &'static [u8; 31usize] = b"SDL_JOYSTICK_HIDAPI_PS4_RUMBLE\0"; +pub const SDL_HINT_JOYSTICK_HIDAPI_PS5: &'static [u8; 24usize] = b"SDL_JOYSTICK_HIDAPI_PS5\0"; +pub const SDL_HINT_JOYSTICK_HIDAPI_PS5_PLAYER_LED: &'static [u8; 35usize] = + b"SDL_JOYSTICK_HIDAPI_PS5_PLAYER_LED\0"; +pub const SDL_HINT_JOYSTICK_HIDAPI_PS5_RUMBLE: &'static [u8; 31usize] = + b"SDL_JOYSTICK_HIDAPI_PS5_RUMBLE\0"; +pub const SDL_HINT_JOYSTICK_HIDAPI_STADIA: &'static [u8; 27usize] = b"SDL_JOYSTICK_HIDAPI_STADIA\0"; pub const SDL_HINT_JOYSTICK_HIDAPI_STEAM: &'static [u8; 26usize] = b"SDL_JOYSTICK_HIDAPI_STEAM\0"; pub const SDL_HINT_JOYSTICK_HIDAPI_SWITCH: &'static [u8; 27usize] = b"SDL_JOYSTICK_HIDAPI_SWITCH\0"; +pub const SDL_HINT_JOYSTICK_HIDAPI_SWITCH_HOME_LED: &'static [u8; 36usize] = + b"SDL_JOYSTICK_HIDAPI_SWITCH_HOME_LED\0"; pub const SDL_HINT_JOYSTICK_HIDAPI_XBOX: &'static [u8; 25usize] = b"SDL_JOYSTICK_HIDAPI_XBOX\0"; -pub const SDL_HINT_JOYSTICK_HIDAPI_CORRELATE_XINPUT: &'static [u8; 37usize] = - b"SDL_JOYSTICK_HIDAPI_CORRELATE_XINPUT\0"; -pub const SDL_HINT_JOYSTICK_HIDAPI_GAMECUBE: &'static [u8; 29usize] = - b"SDL_JOYSTICK_HIDAPI_GAMECUBE\0"; -pub const SDL_HINT_ENABLE_STEAM_CONTROLLERS: &'static [u8; 29usize] = - b"SDL_ENABLE_STEAM_CONTROLLERS\0"; pub const SDL_HINT_JOYSTICK_RAWINPUT: &'static [u8; 22usize] = b"SDL_JOYSTICK_RAWINPUT\0"; +pub const SDL_HINT_JOYSTICK_RAWINPUT_CORRELATE_XINPUT: &'static [u8; 39usize] = + b"SDL_JOYSTICK_RAWINPUT_CORRELATE_XINPUT\0"; pub const SDL_HINT_JOYSTICK_THREAD: &'static [u8; 20usize] = b"SDL_JOYSTICK_THREAD\0"; +pub const SDL_HINT_KMSDRM_REQUIRE_DRM_MASTER: &'static [u8; 30usize] = + b"SDL_KMSDRM_REQUIRE_DRM_MASTER\0"; +pub const SDL_HINT_JOYSTICK_DEVICE: &'static [u8; 20usize] = b"SDL_JOYSTICK_DEVICE\0"; +pub const SDL_HINT_LINUX_JOYSTICK_CLASSIC: &'static [u8; 27usize] = b"SDL_LINUX_JOYSTICK_CLASSIC\0"; pub const SDL_HINT_LINUX_JOYSTICK_DEADZONES: &'static [u8; 29usize] = b"SDL_LINUX_JOYSTICK_DEADZONES\0"; -pub const SDL_HINT_ALLOW_TOPMOST: &'static [u8; 18usize] = b"SDL_ALLOW_TOPMOST\0"; -pub const SDL_HINT_TIMER_RESOLUTION: &'static [u8; 21usize] = b"SDL_TIMER_RESOLUTION\0"; +pub const SDL_HINT_MAC_BACKGROUND_APP: &'static [u8; 23usize] = b"SDL_MAC_BACKGROUND_APP\0"; +pub const SDL_HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK: &'static [u8; 39usize] = + b"SDL_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK\0"; +pub const SDL_HINT_MOUSE_DOUBLE_CLICK_RADIUS: &'static [u8; 30usize] = + b"SDL_MOUSE_DOUBLE_CLICK_RADIUS\0"; +pub const SDL_HINT_MOUSE_DOUBLE_CLICK_TIME: &'static [u8; 28usize] = + b"SDL_MOUSE_DOUBLE_CLICK_TIME\0"; +pub const SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH: &'static [u8; 29usize] = + b"SDL_MOUSE_FOCUS_CLICKTHROUGH\0"; +pub const SDL_HINT_MOUSE_NORMAL_SPEED_SCALE: &'static [u8; 29usize] = + b"SDL_MOUSE_NORMAL_SPEED_SCALE\0"; +pub const SDL_HINT_MOUSE_RELATIVE_MODE_WARP: &'static [u8; 29usize] = + b"SDL_MOUSE_RELATIVE_MODE_WARP\0"; +pub const SDL_HINT_MOUSE_RELATIVE_SCALING: &'static [u8; 27usize] = b"SDL_MOUSE_RELATIVE_SCALING\0"; +pub const SDL_HINT_MOUSE_RELATIVE_SPEED_SCALE: &'static [u8; 31usize] = + b"SDL_MOUSE_RELATIVE_SPEED_SCALE\0"; +pub const SDL_HINT_MOUSE_TOUCH_EVENTS: &'static [u8; 23usize] = b"SDL_MOUSE_TOUCH_EVENTS\0"; +pub const SDL_HINT_NO_SIGNAL_HANDLERS: &'static [u8; 23usize] = b"SDL_NO_SIGNAL_HANDLERS\0"; +pub const SDL_HINT_OPENGL_ES_DRIVER: &'static [u8; 21usize] = b"SDL_OPENGL_ES_DRIVER\0"; +pub const SDL_HINT_ORIENTATIONS: &'static [u8; 21usize] = b"SDL_IOS_ORIENTATIONS\0"; +pub const SDL_HINT_POLL_SENTINEL: &'static [u8; 18usize] = b"SDL_POLL_SENTINEL\0"; +pub const SDL_HINT_PREFERRED_LOCALES: &'static [u8; 22usize] = b"SDL_PREFERRED_LOCALES\0"; pub const SDL_HINT_QTWAYLAND_CONTENT_ORIENTATION: &'static [u8; 34usize] = b"SDL_QTWAYLAND_CONTENT_ORIENTATION\0"; pub const SDL_HINT_QTWAYLAND_WINDOW_FLAGS: &'static [u8; 27usize] = b"SDL_QTWAYLAND_WINDOW_FLAGS\0"; -pub const SDL_HINT_THREAD_STACK_SIZE: &'static [u8; 22usize] = b"SDL_THREAD_STACK_SIZE\0"; -pub const SDL_HINT_THREAD_PRIORITY_POLICY: &'static [u8; 27usize] = b"SDL_THREAD_PRIORITY_POLICY\0"; +pub const SDL_HINT_RENDER_BATCHING: &'static [u8; 20usize] = b"SDL_RENDER_BATCHING\0"; +pub const SDL_HINT_RENDER_LINE_METHOD: &'static [u8; 23usize] = b"SDL_RENDER_LINE_METHOD\0"; +pub const SDL_HINT_RENDER_DIRECT3D11_DEBUG: &'static [u8; 28usize] = + b"SDL_RENDER_DIRECT3D11_DEBUG\0"; +pub const SDL_HINT_RENDER_DIRECT3D_THREADSAFE: &'static [u8; 31usize] = + b"SDL_RENDER_DIRECT3D_THREADSAFE\0"; +pub const SDL_HINT_RENDER_DRIVER: &'static [u8; 18usize] = b"SDL_RENDER_DRIVER\0"; +pub const SDL_HINT_RENDER_LOGICAL_SIZE_MODE: &'static [u8; 29usize] = + b"SDL_RENDER_LOGICAL_SIZE_MODE\0"; +pub const SDL_HINT_RENDER_OPENGL_SHADERS: &'static [u8; 26usize] = b"SDL_RENDER_OPENGL_SHADERS\0"; +pub const SDL_HINT_RENDER_SCALE_QUALITY: &'static [u8; 25usize] = b"SDL_RENDER_SCALE_QUALITY\0"; +pub const SDL_HINT_RENDER_VSYNC: &'static [u8; 17usize] = b"SDL_RENDER_VSYNC\0"; +pub const SDL_HINT_RETURN_KEY_HIDES_IME: &'static [u8; 25usize] = b"SDL_RETURN_KEY_HIDES_IME\0"; +pub const SDL_HINT_RPI_VIDEO_LAYER: &'static [u8; 20usize] = b"SDL_RPI_VIDEO_LAYER\0"; +pub const SDL_HINT_SCREENSAVER_INHIBIT_ACTIVITY_NAME: &'static [u8; 38usize] = + b"SDL_SCREENSAVER_INHIBIT_ACTIVITY_NAME\0"; pub const SDL_HINT_THREAD_FORCE_REALTIME_TIME_CRITICAL: &'static [u8; 40usize] = b"SDL_THREAD_FORCE_REALTIME_TIME_CRITICAL\0"; +pub const SDL_HINT_THREAD_PRIORITY_POLICY: &'static [u8; 27usize] = b"SDL_THREAD_PRIORITY_POLICY\0"; +pub const SDL_HINT_THREAD_STACK_SIZE: &'static [u8; 22usize] = b"SDL_THREAD_STACK_SIZE\0"; +pub const SDL_HINT_TIMER_RESOLUTION: &'static [u8; 21usize] = b"SDL_TIMER_RESOLUTION\0"; +pub const SDL_HINT_TOUCH_MOUSE_EVENTS: &'static [u8; 23usize] = b"SDL_TOUCH_MOUSE_EVENTS\0"; +pub const SDL_HINT_TV_REMOTE_AS_JOYSTICK: &'static [u8; 26usize] = b"SDL_TV_REMOTE_AS_JOYSTICK\0"; +pub const SDL_HINT_VIDEO_ALLOW_SCREENSAVER: &'static [u8; 28usize] = + b"SDL_VIDEO_ALLOW_SCREENSAVER\0"; +pub const SDL_HINT_VIDEO_DOUBLE_BUFFER: &'static [u8; 24usize] = b"SDL_VIDEO_DOUBLE_BUFFER\0"; +pub const SDL_HINT_VIDEO_EGL_ALLOW_TRANSPARENCY: &'static [u8; 33usize] = + b"SDL_VIDEO_EGL_ALLOW_TRANSPARENCY\0"; +pub const SDL_HINT_VIDEO_EXTERNAL_CONTEXT: &'static [u8; 27usize] = b"SDL_VIDEO_EXTERNAL_CONTEXT\0"; pub const SDL_HINT_VIDEO_HIGHDPI_DISABLED: &'static [u8; 27usize] = b"SDL_VIDEO_HIGHDPI_DISABLED\0"; -pub const SDL_HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK: &'static [u8; 39usize] = - b"SDL_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK\0"; -pub const SDL_HINT_VIDEO_WIN_D3DCOMPILER: &'static [u8; 26usize] = b"SDL_VIDEO_WIN_D3DCOMPILER\0"; -pub const SDL_HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT: &'static [u8; 36usize] = - b"SDL_VIDEO_WINDOW_SHARE_PIXEL_FORMAT\0"; -pub const SDL_HINT_WINRT_PRIVACY_POLICY_URL: &'static [u8; 29usize] = - b"SDL_WINRT_PRIVACY_POLICY_URL\0"; -pub const SDL_HINT_WINRT_PRIVACY_POLICY_LABEL: &'static [u8; 31usize] = - b"SDL_WINRT_PRIVACY_POLICY_LABEL\0"; -pub const SDL_HINT_WINRT_HANDLE_BACK_BUTTON: &'static [u8; 29usize] = - b"SDL_WINRT_HANDLE_BACK_BUTTON\0"; pub const SDL_HINT_VIDEO_MAC_FULLSCREEN_SPACES: &'static [u8; 32usize] = b"SDL_VIDEO_MAC_FULLSCREEN_SPACES\0"; -pub const SDL_HINT_MAC_BACKGROUND_APP: &'static [u8; 23usize] = b"SDL_MAC_BACKGROUND_APP\0"; -pub const SDL_HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION: &'static [u8; 44usize] = - b"SDL_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION\0"; -pub const SDL_HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION: &'static [u8; 45usize] = - b"SDL_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION\0"; -pub const SDL_HINT_IME_INTERNAL_EDITING: &'static [u8; 25usize] = b"SDL_IME_INTERNAL_EDITING\0"; -pub const SDL_HINT_ANDROID_TRAP_BACK_BUTTON: &'static [u8; 29usize] = - b"SDL_ANDROID_TRAP_BACK_BUTTON\0"; -pub const SDL_HINT_ANDROID_BLOCK_ON_PAUSE: &'static [u8; 27usize] = b"SDL_ANDROID_BLOCK_ON_PAUSE\0"; -pub const SDL_HINT_ANDROID_BLOCK_ON_PAUSE_PAUSEAUDIO: &'static [u8; 38usize] = - b"SDL_ANDROID_BLOCK_ON_PAUSE_PAUSEAUDIO\0"; -pub const SDL_HINT_RETURN_KEY_HIDES_IME: &'static [u8; 25usize] = b"SDL_RETURN_KEY_HIDES_IME\0"; -pub const SDL_HINT_EMSCRIPTEN_KEYBOARD_ELEMENT: &'static [u8; 32usize] = - b"SDL_EMSCRIPTEN_KEYBOARD_ELEMENT\0"; -pub const SDL_HINT_EMSCRIPTEN_ASYNCIFY: &'static [u8; 24usize] = b"SDL_EMSCRIPTEN_ASYNCIFY\0"; -pub const SDL_HINT_NO_SIGNAL_HANDLERS: &'static [u8; 23usize] = b"SDL_NO_SIGNAL_HANDLERS\0"; -pub const SDL_HINT_WINDOWS_NO_CLOSE_ON_ALT_F4: &'static [u8; 31usize] = - b"SDL_WINDOWS_NO_CLOSE_ON_ALT_F4\0"; -pub const SDL_HINT_BMP_SAVE_LEGACY_FORMAT: &'static [u8; 27usize] = b"SDL_BMP_SAVE_LEGACY_FORMAT\0"; -pub const SDL_HINT_WINDOWS_DISABLE_THREAD_NAMING: &'static [u8; 34usize] = - b"SDL_WINDOWS_DISABLE_THREAD_NAMING\0"; -pub const SDL_HINT_RPI_VIDEO_LAYER: &'static [u8; 20usize] = b"SDL_RPI_VIDEO_LAYER\0"; -pub const SDL_HINT_VIDEO_DOUBLE_BUFFER: &'static [u8; 24usize] = b"SDL_VIDEO_DOUBLE_BUFFER\0"; -pub const SDL_HINT_OPENGL_ES_DRIVER: &'static [u8; 21usize] = b"SDL_OPENGL_ES_DRIVER\0"; -pub const SDL_HINT_AUDIO_RESAMPLING_MODE: &'static [u8; 26usize] = b"SDL_AUDIO_RESAMPLING_MODE\0"; -pub const SDL_HINT_AUDIO_CATEGORY: &'static [u8; 19usize] = b"SDL_AUDIO_CATEGORY\0"; -pub const SDL_HINT_RENDER_BATCHING: &'static [u8; 20usize] = b"SDL_RENDER_BATCHING\0"; -pub const SDL_HINT_AUTO_UPDATE_JOYSTICKS: &'static [u8; 26usize] = b"SDL_AUTO_UPDATE_JOYSTICKS\0"; -pub const SDL_HINT_AUTO_UPDATE_SENSORS: &'static [u8; 24usize] = b"SDL_AUTO_UPDATE_SENSORS\0"; -pub const SDL_HINT_EVENT_LOGGING: &'static [u8; 18usize] = b"SDL_EVENT_LOGGING\0"; +pub const SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS: &'static [u8; 33usize] = + b"SDL_VIDEO_MINIMIZE_ON_FOCUS_LOSS\0"; +pub const SDL_HINT_VIDEO_WAYLAND_ALLOW_LIBDECOR: &'static [u8; 33usize] = + b"SDL_VIDEO_WAYLAND_ALLOW_LIBDECOR\0"; +pub const SDL_HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT: &'static [u8; 36usize] = + b"SDL_VIDEO_WINDOW_SHARE_PIXEL_FORMAT\0"; +pub const SDL_HINT_VIDEO_WIN_D3DCOMPILER: &'static [u8; 26usize] = b"SDL_VIDEO_WIN_D3DCOMPILER\0"; +pub const SDL_HINT_VIDEO_X11_FORCE_EGL: &'static [u8; 24usize] = b"SDL_VIDEO_X11_FORCE_EGL\0"; +pub const SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR: &'static [u8; 39usize] = + b"SDL_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR\0"; +pub const SDL_HINT_VIDEO_X11_NET_WM_PING: &'static [u8; 26usize] = b"SDL_VIDEO_X11_NET_WM_PING\0"; +pub const SDL_HINT_VIDEO_X11_WINDOW_VISUALID: &'static [u8; 30usize] = + b"SDL_VIDEO_X11_WINDOW_VISUALID\0"; +pub const SDL_HINT_VIDEO_X11_XINERAMA: &'static [u8; 23usize] = b"SDL_VIDEO_X11_XINERAMA\0"; +pub const SDL_HINT_VIDEO_X11_XRANDR: &'static [u8; 21usize] = b"SDL_VIDEO_X11_XRANDR\0"; +pub const SDL_HINT_VIDEO_X11_XVIDMODE: &'static [u8; 23usize] = b"SDL_VIDEO_X11_XVIDMODE\0"; +pub const SDL_HINT_WAVE_FACT_CHUNK: &'static [u8; 20usize] = b"SDL_WAVE_FACT_CHUNK\0"; pub const SDL_HINT_WAVE_RIFF_CHUNK_SIZE: &'static [u8; 25usize] = b"SDL_WAVE_RIFF_CHUNK_SIZE\0"; pub const SDL_HINT_WAVE_TRUNCATION: &'static [u8; 20usize] = b"SDL_WAVE_TRUNCATION\0"; -pub const SDL_HINT_WAVE_FACT_CHUNK: &'static [u8; 20usize] = b"SDL_WAVE_FACT_CHUNK\0"; -pub const SDL_HINT_DISPLAY_USABLE_BOUNDS: &'static [u8; 26usize] = b"SDL_DISPLAY_USABLE_BOUNDS\0"; -pub const SDL_HINT_AUDIO_DEVICE_APP_NAME: &'static [u8; 26usize] = b"SDL_AUDIO_DEVICE_APP_NAME\0"; -pub const SDL_HINT_AUDIO_DEVICE_STREAM_NAME: &'static [u8; 29usize] = - b"SDL_AUDIO_DEVICE_STREAM_NAME\0"; -pub const SDL_HINT_PREFERRED_LOCALES: &'static [u8; 22usize] = b"SDL_PREFERRED_LOCALES\0"; +pub const SDL_HINT_WINDOWS_DISABLE_THREAD_NAMING: &'static [u8; 34usize] = + b"SDL_WINDOWS_DISABLE_THREAD_NAMING\0"; +pub const SDL_HINT_WINDOWS_ENABLE_MESSAGELOOP: &'static [u8; 31usize] = + b"SDL_WINDOWS_ENABLE_MESSAGELOOP\0"; +pub const SDL_HINT_WINDOWS_FORCE_MUTEX_CRITICAL_SECTIONS: &'static [u8; 42usize] = + b"SDL_WINDOWS_FORCE_MUTEX_CRITICAL_SECTIONS\0"; +pub const SDL_HINT_WINDOWS_FORCE_SEMAPHORE_KERNEL: &'static [u8; 35usize] = + b"SDL_WINDOWS_FORCE_SEMAPHORE_KERNEL\0"; +pub const SDL_HINT_WINDOWS_INTRESOURCE_ICON: &'static [u8; 29usize] = + b"SDL_WINDOWS_INTRESOURCE_ICON\0"; +pub const SDL_HINT_WINDOWS_INTRESOURCE_ICON_SMALL: &'static [u8; 35usize] = + b"SDL_WINDOWS_INTRESOURCE_ICON_SMALL\0"; +pub const SDL_HINT_WINDOWS_NO_CLOSE_ON_ALT_F4: &'static [u8; 31usize] = + b"SDL_WINDOWS_NO_CLOSE_ON_ALT_F4\0"; +pub const SDL_HINT_WINDOWS_USE_D3D9EX: &'static [u8; 23usize] = b"SDL_WINDOWS_USE_D3D9EX\0"; +pub const SDL_HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN: &'static [u8; 44usize] = + b"SDL_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN\0"; +pub const SDL_HINT_WINDOW_NO_ACTIVATION_WHEN_SHOWN: &'static [u8; 36usize] = + b"SDL_WINDOW_NO_ACTIVATION_WHEN_SHOWN\0"; +pub const SDL_HINT_WINRT_HANDLE_BACK_BUTTON: &'static [u8; 29usize] = + b"SDL_WINRT_HANDLE_BACK_BUTTON\0"; +pub const SDL_HINT_WINRT_PRIVACY_POLICY_LABEL: &'static [u8; 31usize] = + b"SDL_WINRT_PRIVACY_POLICY_LABEL\0"; +pub const SDL_HINT_WINRT_PRIVACY_POLICY_URL: &'static [u8; 29usize] = + b"SDL_WINRT_PRIVACY_POLICY_URL\0"; +pub const SDL_HINT_X11_FORCE_OVERRIDE_REDIRECT: &'static [u8; 32usize] = + b"SDL_X11_FORCE_OVERRIDE_REDIRECT\0"; +pub const SDL_HINT_XINPUT_ENABLED: &'static [u8; 19usize] = b"SDL_XINPUT_ENABLED\0"; +pub const SDL_HINT_XINPUT_USE_OLD_JOYSTICK_MAPPING: &'static [u8; 36usize] = + b"SDL_XINPUT_USE_OLD_JOYSTICK_MAPPING\0"; +pub const SDL_HINT_AUDIO_INCLUDE_MONITORS: &'static [u8; 27usize] = b"SDL_AUDIO_INCLUDE_MONITORS\0"; pub const SDL_MAX_LOG_MESSAGE: u32 = 4096; pub const SDL_NONSHAPEABLE_WINDOW: i32 = -1; pub const SDL_INVALID_SHAPE_ARGUMENT: i32 = -2; pub const SDL_WINDOW_LACKS_SHAPE: i32 = -3; pub const SDL_MAJOR_VERSION: u32 = 2; pub const SDL_MINOR_VERSION: u32 = 0; -pub const SDL_PATCHLEVEL: u32 = 14; +pub const SDL_PATCHLEVEL: u32 = 20; pub const SDL_INIT_TIMER: u32 = 1; pub const SDL_INIT_AUDIO: u32 = 16; pub const SDL_INIT_VIDEO: u32 = 32; @@ -945,7 +991,20 @@ pub const XIMHotKeyStateON: u32 = 1; pub const XIMHotKeyStateOFF: u32 = 2; pub const XATOM_H: u32 = 1; extern "C" { - #[doc = " \\brief Gets the name of the platform."] + #[doc = " Get the name of the platform."] + #[doc = ""] + #[doc = " Here are the names returned for some (but not all) supported platforms:"] + #[doc = ""] + #[doc = " - \"Windows\""] + #[doc = " - \"Mac OS X\""] + #[doc = " - \"Linux\""] + #[doc = " - \"iOS\""] + #[doc = " - \"Android\""] + #[doc = ""] + #[doc = " \\returns the name of the platform. If the correct platform name is not"] + #[doc = " available, returns a string beginning with the text \"Unknown\"."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_GetPlatform() -> *const libc::c_char; } pub type size_t = libc::c_ulong; @@ -1154,7 +1213,9 @@ pub type SDL_realloc_func = ::core::option::Option< >; pub type SDL_free_func = ::core::option::Option; extern "C" { - #[doc = " \\brief Get the current set of SDL memory functions"] + #[doc = " Get the current set of SDL memory functions"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.7."] pub fn SDL_GetMemoryFunctions( malloc_func: *mut SDL_malloc_func, calloc_func: *mut SDL_calloc_func, @@ -1163,12 +1224,9 @@ extern "C" { ); } extern "C" { - #[doc = " \\brief Replace SDL's memory allocation functions with a custom set"] + #[doc = " Replace SDL's memory allocation functions with a custom set"] #[doc = ""] - #[doc = " \\note If you are replacing SDL's memory functions, you should call"] - #[doc = " SDL_GetNumAllocations() and be very careful if it returns non-zero."] - #[doc = " That means that your free function will be called with memory"] - #[doc = " allocated by the previous memory allocation functions."] + #[doc = " \\since This function is available since SDL 2.0.7."] pub fn SDL_SetMemoryFunctions( malloc_func: SDL_malloc_func, calloc_func: SDL_calloc_func, @@ -1177,7 +1235,9 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the number of outstanding (unfreed) allocations"] + #[doc = " Get the number of outstanding (unfreed) allocations"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.7."] pub fn SDL_GetNumAllocations() -> libc::c_int; } extern "C" { @@ -1207,25 +1267,49 @@ extern "C" { pub fn SDL_abs(x: libc::c_int) -> libc::c_int; } extern "C" { - pub fn SDL_isdigit(x: libc::c_int) -> libc::c_int; + pub fn SDL_isalpha(x: libc::c_int) -> libc::c_int; } extern "C" { - pub fn SDL_isspace(x: libc::c_int) -> libc::c_int; + pub fn SDL_isalnum(x: libc::c_int) -> libc::c_int; } extern "C" { - pub fn SDL_isupper(x: libc::c_int) -> libc::c_int; + pub fn SDL_isblank(x: libc::c_int) -> libc::c_int; } extern "C" { - pub fn SDL_islower(x: libc::c_int) -> libc::c_int; + pub fn SDL_iscntrl(x: libc::c_int) -> libc::c_int; } extern "C" { - pub fn SDL_toupper(x: libc::c_int) -> libc::c_int; + pub fn SDL_isdigit(x: libc::c_int) -> libc::c_int; } extern "C" { - pub fn SDL_tolower(x: libc::c_int) -> libc::c_int; + pub fn SDL_isxdigit(x: libc::c_int) -> libc::c_int; } extern "C" { - pub fn SDL_crc32(crc: Uint32, data: *const libc::c_void, len: size_t) -> Uint32; + pub fn SDL_ispunct(x: libc::c_int) -> libc::c_int; +} +extern "C" { + pub fn SDL_isspace(x: libc::c_int) -> libc::c_int; +} +extern "C" { + pub fn SDL_isupper(x: libc::c_int) -> libc::c_int; +} +extern "C" { + pub fn SDL_islower(x: libc::c_int) -> libc::c_int; +} +extern "C" { + pub fn SDL_isprint(x: libc::c_int) -> libc::c_int; +} +extern "C" { + pub fn SDL_isgraph(x: libc::c_int) -> libc::c_int; +} +extern "C" { + pub fn SDL_toupper(x: libc::c_int) -> libc::c_int; +} +extern "C" { + pub fn SDL_tolower(x: libc::c_int) -> libc::c_int; +} +extern "C" { + pub fn SDL_crc32(crc: Uint32, data: *const libc::c_void, len: size_t) -> Uint32; } extern "C" { pub fn SDL_memset(dst: *mut libc::c_void, c: libc::c_int, len: size_t) -> *mut libc::c_void; @@ -1451,6 +1535,29 @@ extern "C" { ) -> libc::c_int; } extern "C" { + pub fn SDL_asprintf(strp: *mut *mut libc::c_char, fmt: *const libc::c_char, ...) + -> libc::c_int; +} +extern "C" { + pub fn SDL_vasprintf( + strp: *mut *mut libc::c_char, + fmt: *const libc::c_char, + ap: *mut __va_list_tag, + ) -> libc::c_int; +} +extern "C" { + #[doc = " Use this function to compute arc cosine of `x`."] + #[doc = ""] + #[doc = " The definition of `y = acos(x)` is `x = cos(y)`."] + #[doc = ""] + #[doc = " Domain: `-1 <= x <= 1`"] + #[doc = ""] + #[doc = " Range: `0 <= y <= Pi`"] + #[doc = ""] + #[doc = " \\param x floating point value, in radians."] + #[doc = " \\returns arc cosine of `x`."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.2."] pub fn SDL_acos(x: f64) -> f64; } extern "C" { @@ -1469,10 +1576,10 @@ extern "C" { pub fn SDL_atanf(x: f32) -> f32; } extern "C" { - pub fn SDL_atan2(x: f64, y: f64) -> f64; + pub fn SDL_atan2(y: f64, x: f64) -> f64; } extern "C" { - pub fn SDL_atan2f(x: f32, y: f32) -> f32; + pub fn SDL_atan2f(y: f32, x: f32) -> f32; } extern "C" { pub fn SDL_ceil(x: f64) -> f64; @@ -1540,6 +1647,18 @@ extern "C" { extern "C" { pub fn SDL_powf(x: f32, y: f32) -> f32; } +extern "C" { + pub fn SDL_round(x: f64) -> f64; +} +extern "C" { + pub fn SDL_roundf(x: f32) -> f32; +} +extern "C" { + pub fn SDL_lround(x: f64) -> libc::c_long; +} +extern "C" { + pub fn SDL_lroundf(x: f32) -> libc::c_long; +} extern "C" { pub fn SDL_scalbn(x: f64, n: libc::c_int) -> f64; } @@ -1589,8 +1708,10 @@ extern "C" { ) -> size_t; } extern "C" { - #[doc = " This function converts a string between encodings in one pass, returning a"] - #[doc = " string that must be freed with SDL_free() or NULL on error."] + #[doc = " This function converts a string between encodings in one pass, returning a"] + #[doc = " string that must be freed with SDL_free() or NULL on error."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_iconv_string( tocode: *const libc::c_char, fromcode: *const libc::c_char, @@ -1606,11 +1727,17 @@ extern "C" { pub fn SDL_main(argc: libc::c_int, argv: *mut *mut libc::c_char) -> libc::c_int; } extern "C" { - #[doc = " This is called by the real SDL main function to let the rest of the"] - #[doc = " library know that initialization was done properly."] + #[doc = " Circumvent failure of SDL_Init() when not using SDL_main() as an entry"] + #[doc = " point."] #[doc = ""] - #[doc = " Calling this yourself without knowing what you're doing can cause"] - #[doc = " crashes and hard to diagnose problems with your application."] + #[doc = " This function is defined in SDL_main.h, along with the preprocessor rule to"] + #[doc = " redefine main() as SDL_main(). Thus to ensure that your main() function"] + #[doc = " will not be changed it is necessary to define SDL_MAIN_HANDLED before"] + #[doc = " including SDL.h."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_Init"] pub fn SDL_SetMainReady(); } #[repr(u32)] @@ -1729,6 +1856,12 @@ extern "C" { arg4: libc::c_int, ) -> SDL_AssertState; } +#[doc = " A callback that fires when an SDL assertion fails."] +#[doc = ""] +#[doc = " \\param data a pointer to the SDL_AssertData structure corresponding to the"] +#[doc = " current assertion"] +#[doc = " \\param userdata what was passed as `userdata` to SDL_SetAssertionHandler()"] +#[doc = " \\returns an SDL_AssertState value indicating how to handle the failure."] pub type SDL_AssertionHandler = ::core::option::Option< unsafe extern "C" fn( data: *const SDL_AssertData, @@ -1736,123 +1869,172 @@ pub type SDL_AssertionHandler = ::core::option::Option< ) -> SDL_AssertState, >; extern "C" { - #[doc = " \\brief Set an application-defined assertion handler."] + #[doc = " Set an application-defined assertion handler."] #[doc = ""] - #[doc = " This allows an app to show its own assertion UI and/or force the"] - #[doc = " response to an assertion failure. If the app doesn't provide this, SDL"] - #[doc = " will try to do the right thing, popping up a system-specific GUI dialog,"] - #[doc = " and probably minimizing any fullscreen windows."] + #[doc = " This function allows an application to show its own assertion UI and/or"] + #[doc = " force the response to an assertion failure. If the application doesn't"] + #[doc = " provide this, SDL will try to do the right thing, popping up a"] + #[doc = " system-specific GUI dialog, and probably minimizing any fullscreen windows."] #[doc = ""] - #[doc = " This callback may fire from any thread, but it runs wrapped in a mutex, so"] - #[doc = " it will only fire from one thread at a time."] + #[doc = " This callback may fire from any thread, but it runs wrapped in a mutex, so"] + #[doc = " it will only fire from one thread at a time."] #[doc = ""] - #[doc = " Setting the callback to NULL restores SDL's original internal handler."] + #[doc = " This callback is NOT reset to SDL's internal handler upon SDL_Quit()!"] #[doc = ""] - #[doc = " This callback is NOT reset to SDL's internal handler upon SDL_Quit()!"] + #[doc = " \\param handler the SDL_AssertionHandler function to call when an assertion"] + #[doc = " fails or NULL for the default handler"] + #[doc = " \\param userdata a pointer that is passed to `handler`"] #[doc = ""] - #[doc = " Return SDL_AssertState value of how to handle the assertion failure."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\param handler Callback function, called when an assertion fails."] - #[doc = " \\param userdata A pointer passed to the callback as-is."] + #[doc = " \\sa SDL_GetAssertionHandler"] pub fn SDL_SetAssertionHandler(handler: SDL_AssertionHandler, userdata: *mut libc::c_void); } extern "C" { - #[doc = " \\brief Get the default assertion handler."] + #[doc = " Get the default assertion handler."] + #[doc = ""] + #[doc = " This returns the function pointer that is called by default when an"] + #[doc = " assertion is triggered. This is an internal function provided by SDL, that"] + #[doc = " is used for assertions when SDL_SetAssertionHandler() hasn't been used to"] + #[doc = " provide a different function."] #[doc = ""] - #[doc = " This returns the function pointer that is called by default when an"] - #[doc = " assertion is triggered. This is an internal function provided by SDL,"] - #[doc = " that is used for assertions when SDL_SetAssertionHandler() hasn't been"] - #[doc = " used to provide a different function."] + #[doc = " \\returns the default SDL_AssertionHandler that is called when an assert"] + #[doc = " triggers."] #[doc = ""] - #[doc = " \\return The default SDL_AssertionHandler that is called when an assert triggers."] + #[doc = " \\since This function is available since SDL 2.0.2."] + #[doc = ""] + #[doc = " \\sa SDL_GetAssertionHandler"] pub fn SDL_GetDefaultAssertionHandler() -> SDL_AssertionHandler; } extern "C" { - #[doc = " \\brief Get the current assertion handler."] + #[doc = " Get the current assertion handler."] + #[doc = ""] + #[doc = " This returns the function pointer that is called when an assertion is"] + #[doc = " triggered. This is either the value last passed to"] + #[doc = " SDL_SetAssertionHandler(), or if no application-specified function is set,"] + #[doc = " is equivalent to calling SDL_GetDefaultAssertionHandler()."] + #[doc = ""] + #[doc = " The parameter `puserdata` is a pointer to a void*, which will store the"] + #[doc = " \"userdata\" pointer that was passed to SDL_SetAssertionHandler(). This value"] + #[doc = " will always be NULL for the default handler. If you don't care about this"] + #[doc = " data, it is safe to pass a NULL pointer to this function to ignore it."] + #[doc = ""] + #[doc = " \\param puserdata pointer which is filled with the \"userdata\" pointer that"] + #[doc = " was passed to SDL_SetAssertionHandler()"] + #[doc = " \\returns the SDL_AssertionHandler that is called when an assert triggers."] #[doc = ""] - #[doc = " This returns the function pointer that is called when an assertion is"] - #[doc = " triggered. This is either the value last passed to"] - #[doc = " SDL_SetAssertionHandler(), or if no application-specified function is"] - #[doc = " set, is equivalent to calling SDL_GetDefaultAssertionHandler()."] + #[doc = " \\since This function is available since SDL 2.0.2."] #[doc = ""] - #[doc = " \\param puserdata Pointer to a void*, which will store the \"userdata\""] - #[doc = " pointer that was passed to SDL_SetAssertionHandler()."] - #[doc = " This value will always be NULL for the default handler."] - #[doc = " If you don't care about this data, it is safe to pass"] - #[doc = " a NULL pointer to this function to ignore it."] - #[doc = " \\return The SDL_AssertionHandler that is called when an assert triggers."] + #[doc = " \\sa SDL_SetAssertionHandler"] pub fn SDL_GetAssertionHandler(puserdata: *mut *mut libc::c_void) -> SDL_AssertionHandler; } extern "C" { - #[doc = " \\brief Get a list of all assertion failures."] + #[doc = " Get a list of all assertion failures."] #[doc = ""] - #[doc = " Get all assertions triggered since last call to SDL_ResetAssertionReport(),"] - #[doc = " or the start of the program."] + #[doc = " This function gets all assertions triggered since the last call to"] + #[doc = " SDL_ResetAssertionReport(), or the start of the program."] #[doc = ""] - #[doc = " The proper way to examine this data looks something like this:"] + #[doc = " The proper way to examine this data looks something like this:"] #[doc = ""] - #[doc = " "] - #[doc = " const SDL_AssertData *item = SDL_GetAssertionReport();"] - #[doc = " while (item) {"] - #[doc = " printf(\"'%s', %s (%s:%d), triggered %u times, always ignore: %s.\\\\n\","] - #[doc = " item->condition, item->function, item->filename,"] - #[doc = " item->linenum, item->trigger_count,"] - #[doc = " item->always_ignore ? \"yes\" : \"no\");"] - #[doc = " item = item->next;"] - #[doc = " }"] - #[doc = " "] + #[doc = " ```c"] + #[doc = " const SDL_AssertData *item = SDL_GetAssertionReport();"] + #[doc = " while (item) {"] + #[doc = " printf(\"'%s', %s (%s:%d), triggered %u times, always ignore: %s.\\\\n\","] + #[doc = " item->condition, item->function, item->filename,"] + #[doc = " item->linenum, item->trigger_count,"] + #[doc = " item->always_ignore ? \"yes\" : \"no\");"] + #[doc = " item = item->next;"] + #[doc = " }"] + #[doc = " ```"] #[doc = ""] - #[doc = " \\return List of all assertions."] - #[doc = " \\sa SDL_ResetAssertionReport"] + #[doc = " \\returns a list of all failed assertions or NULL if the list is empty. This"] + #[doc = " memory should not be modified or freed by the application."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_ResetAssertionReport"] pub fn SDL_GetAssertionReport() -> *const SDL_AssertData; } extern "C" { - #[doc = " \\brief Reset the list of all assertion failures."] + #[doc = " Clear the list of all assertion failures."] #[doc = ""] - #[doc = " Reset list of all assertions triggered."] + #[doc = " This function will clear the list of all assertions triggered up to that"] + #[doc = " point. Immediately following this call, SDL_GetAssertionReport will return"] + #[doc = " no items. In addition, any previously-triggered assertions will be reset to"] + #[doc = " a trigger_count of zero, and their always_ignore state will be false."] #[doc = ""] - #[doc = " \\sa SDL_GetAssertionReport"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetAssertionReport"] pub fn SDL_ResetAssertionReport(); } pub type SDL_SpinLock = libc::c_int; extern "C" { - #[doc = " \\brief Try to lock a spin lock by setting it to a non-zero value."] + #[doc = " Try to lock a spin lock by setting it to a non-zero value."] + #[doc = ""] + #[doc = " ***Please note that spinlocks are dangerous if you don't know what you're"] + #[doc = " doing. Please be careful using any sort of spinlock!***"] #[doc = ""] - #[doc = " \\param lock Points to the lock."] + #[doc = " \\param lock a pointer to a lock variable"] + #[doc = " \\returns SDL_TRUE if the lock succeeded, SDL_FALSE if the lock is already"] + #[doc = " held."] #[doc = ""] - #[doc = " \\return SDL_TRUE if the lock succeeded, SDL_FALSE if the lock is already held."] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_AtomicLock"] + #[doc = " \\sa SDL_AtomicUnlock"] pub fn SDL_AtomicTryLock(lock: *mut SDL_SpinLock) -> SDL_bool; } extern "C" { - #[doc = " \\brief Lock a spin lock by setting it to a non-zero value."] + #[doc = " Lock a spin lock by setting it to a non-zero value."] + #[doc = ""] + #[doc = " ***Please note that spinlocks are dangerous if you don't know what you're"] + #[doc = " doing. Please be careful using any sort of spinlock!***"] + #[doc = ""] + #[doc = " \\param lock a pointer to a lock variable"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\param lock Points to the lock."] + #[doc = " \\sa SDL_AtomicTryLock"] + #[doc = " \\sa SDL_AtomicUnlock"] pub fn SDL_AtomicLock(lock: *mut SDL_SpinLock); } extern "C" { - #[doc = " \\brief Unlock a spin lock by setting it to 0. Always returns immediately"] + #[doc = " Unlock a spin lock by setting it to 0."] + #[doc = ""] + #[doc = " Always returns immediately."] + #[doc = ""] + #[doc = " ***Please note that spinlocks are dangerous if you don't know what you're"] + #[doc = " doing. Please be careful using any sort of spinlock!***"] + #[doc = ""] + #[doc = " \\param lock a pointer to a lock variable"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\param lock Points to the lock."] + #[doc = " \\sa SDL_AtomicLock"] + #[doc = " \\sa SDL_AtomicTryLock"] pub fn SDL_AtomicUnlock(lock: *mut SDL_SpinLock); } extern "C" { #[doc = " Memory barriers are designed to prevent reads and writes from being"] #[doc = " reordered by the compiler and being seen out of order on multi-core CPUs."] #[doc = ""] - #[doc = " A typical pattern would be for thread A to write some data and a flag,"] - #[doc = " and for thread B to read the flag and get the data. In this case you"] - #[doc = " would insert a release barrier between writing the data and the flag,"] + #[doc = " A typical pattern would be for thread A to write some data and a flag, and"] + #[doc = " for thread B to read the flag and get the data. In this case you would"] + #[doc = " insert a release barrier between writing the data and the flag,"] #[doc = " guaranteeing that the data write completes no later than the flag is"] - #[doc = " written, and you would insert an acquire barrier between reading the"] - #[doc = " flag and reading the data, to ensure that all the reads associated"] - #[doc = " with the flag have completed."] + #[doc = " written, and you would insert an acquire barrier between reading the flag"] + #[doc = " and reading the data, to ensure that all the reads associated with the flag"] + #[doc = " have completed."] #[doc = ""] - #[doc = " In this pattern you should always see a release barrier paired with"] - #[doc = " an acquire barrier and you should gate the data reads/writes with a"] - #[doc = " single flag variable."] + #[doc = " In this pattern you should always see a release barrier paired with an"] + #[doc = " acquire barrier and you should gate the data reads/writes with a single"] + #[doc = " flag variable."] #[doc = ""] #[doc = " For more information on these semantics, take a look at the blog post:"] #[doc = " http://preshing.com/20120913/acquire-and-release-semantics"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.6."] pub fn SDL_MemoryBarrierReleaseFunction(); } extern "C" { @@ -1889,11 +2071,21 @@ fn bindgen_test_layout_SDL_atomic_t() { ); } extern "C" { - #[doc = " \\brief Set an atomic variable to a new value if it is currently an old value."] + #[doc = " Set an atomic variable to a new value if it is currently an old value."] + #[doc = ""] + #[doc = " ***Note: If you don't know what this function is for, you shouldn't use"] + #[doc = " it!***"] #[doc = ""] - #[doc = " \\return SDL_TRUE if the atomic variable was set, SDL_FALSE otherwise."] + #[doc = " \\param a a pointer to an SDL_atomic_t variable to be modified"] + #[doc = " \\param oldval the old value"] + #[doc = " \\param newval the new value"] + #[doc = " \\returns SDL_TRUE if the atomic variable was set, SDL_FALSE otherwise."] #[doc = ""] - #[doc = " \\note If you don't know what this function is for, you shouldn't use it!"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_AtomicCASPtr"] + #[doc = " \\sa SDL_AtomicGet"] + #[doc = " \\sa SDL_AtomicSet"] pub fn SDL_AtomicCAS( a: *mut SDL_atomic_t, oldval: libc::c_int, @@ -1901,29 +2093,70 @@ extern "C" { ) -> SDL_bool; } extern "C" { - #[doc = " \\brief Set an atomic variable to a value."] + #[doc = " Set an atomic variable to a value."] + #[doc = ""] + #[doc = " This function also acts as a full memory barrier."] #[doc = ""] - #[doc = " \\return The previous value of the atomic variable."] + #[doc = " ***Note: If you don't know what this function is for, you shouldn't use"] + #[doc = " it!***"] + #[doc = ""] + #[doc = " \\param a a pointer to an SDL_atomic_t variable to be modified"] + #[doc = " \\param v the desired value"] + #[doc = " \\returns the previous value of the atomic variable."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.2."] + #[doc = ""] + #[doc = " \\sa SDL_AtomicGet"] pub fn SDL_AtomicSet(a: *mut SDL_atomic_t, v: libc::c_int) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the value of an atomic variable"] + #[doc = " Get the value of an atomic variable."] + #[doc = ""] + #[doc = " ***Note: If you don't know what this function is for, you shouldn't use"] + #[doc = " it!***"] + #[doc = ""] + #[doc = " \\param a a pointer to an SDL_atomic_t variable"] + #[doc = " \\returns the current value of an atomic variable."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.2."] + #[doc = ""] + #[doc = " \\sa SDL_AtomicSet"] pub fn SDL_AtomicGet(a: *mut SDL_atomic_t) -> libc::c_int; } extern "C" { - #[doc = " \\brief Add to an atomic variable."] + #[doc = " Add to an atomic variable."] + #[doc = ""] + #[doc = " This function also acts as a full memory barrier."] #[doc = ""] - #[doc = " \\return The previous value of the atomic variable."] + #[doc = " ***Note: If you don't know what this function is for, you shouldn't use"] + #[doc = " it!***"] #[doc = ""] - #[doc = " \\note This same style can be used for any number operation"] + #[doc = " \\param a a pointer to an SDL_atomic_t variable to be modified"] + #[doc = " \\param v the desired value to add"] + #[doc = " \\returns the previous value of the atomic variable."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.2."] + #[doc = ""] + #[doc = " \\sa SDL_AtomicDecRef"] + #[doc = " \\sa SDL_AtomicIncRef"] pub fn SDL_AtomicAdd(a: *mut SDL_atomic_t, v: libc::c_int) -> libc::c_int; } extern "C" { - #[doc = " \\brief Set a pointer to a new value if it is currently an old value."] + #[doc = " Set a pointer to a new value if it is currently an old value."] + #[doc = ""] + #[doc = " ***Note: If you don't know what this function is for, you shouldn't use"] + #[doc = " it!***"] + #[doc = ""] + #[doc = " \\param a a pointer to a pointer"] + #[doc = " \\param oldval the old pointer value"] + #[doc = " \\param newval the new pointer value"] + #[doc = " \\returns SDL_TRUE if the pointer was set, SDL_FALSE otherwise."] #[doc = ""] - #[doc = " \\return SDL_TRUE if the pointer was set, SDL_FALSE otherwise."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\note If you don't know what this function is for, you shouldn't use it!"] + #[doc = " \\sa SDL_AtomicCAS"] + #[doc = " \\sa SDL_AtomicGetPtr"] + #[doc = " \\sa SDL_AtomicSetPtr"] pub fn SDL_AtomicCASPtr( a: *mut *mut libc::c_void, oldval: *mut libc::c_void, @@ -1931,48 +2164,120 @@ extern "C" { ) -> SDL_bool; } extern "C" { - #[doc = " \\brief Set a pointer to a value atomically."] + #[doc = " Set a pointer to a value atomically."] #[doc = ""] - #[doc = " \\return The previous value of the pointer."] + #[doc = " ***Note: If you don't know what this function is for, you shouldn't use"] + #[doc = " it!***"] + #[doc = ""] + #[doc = " \\param a a pointer to a pointer"] + #[doc = " \\param v the desired pointer value"] + #[doc = " \\returns the previous value of the pointer."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.2."] + #[doc = ""] + #[doc = " \\sa SDL_AtomicCASPtr"] + #[doc = " \\sa SDL_AtomicGetPtr"] pub fn SDL_AtomicSetPtr(a: *mut *mut libc::c_void, v: *mut libc::c_void) -> *mut libc::c_void; } extern "C" { - #[doc = " \\brief Get the value of a pointer atomically."] + #[doc = " Get the value of a pointer atomically."] + #[doc = ""] + #[doc = " ***Note: If you don't know what this function is for, you shouldn't use"] + #[doc = " it!***"] + #[doc = ""] + #[doc = " \\param a a pointer to a pointer"] + #[doc = " \\returns the current value of a pointer."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.2."] + #[doc = ""] + #[doc = " \\sa SDL_AtomicCASPtr"] + #[doc = " \\sa SDL_AtomicSetPtr"] pub fn SDL_AtomicGetPtr(a: *mut *mut libc::c_void) -> *mut libc::c_void; } extern "C" { - #[doc = " \\brief Set the error message for the current thread"] + #[doc = " Set the SDL error message for the current thread."] + #[doc = ""] + #[doc = " Calling this function will replace any previous error message that was set."] #[doc = ""] - #[doc = " \\return -1, there is no error handling for this function"] + #[doc = " This function always returns -1, since SDL frequently uses -1 to signify an"] + #[doc = " failing result, leading to this idiom:"] + #[doc = ""] + #[doc = " ```c"] + #[doc = " if (error_code) {"] + #[doc = " return SDL_SetError(\"This operation has failed: %d\", error_code);"] + #[doc = " }"] + #[doc = " ```"] + #[doc = ""] + #[doc = " \\param fmt a printf()-style message format string"] + #[doc = " \\param ... additional parameters matching % tokens in the `fmt` string, if"] + #[doc = " any"] + #[doc = " \\returns always -1."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_ClearError"] + #[doc = " \\sa SDL_GetError"] pub fn SDL_SetError(fmt: *const libc::c_char, ...) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the last error message that was set"] + #[doc = " Retrieve a message about the last error that occurred on the current"] + #[doc = " thread."] + #[doc = ""] + #[doc = " It is possible for multiple errors to occur before calling SDL_GetError()."] + #[doc = " Only the last error is returned."] + #[doc = ""] + #[doc = " The message is only applicable when an SDL function has signaled an error."] + #[doc = " You must check the return values of SDL function calls to determine when to"] + #[doc = " appropriately call SDL_GetError(). You should *not* use the results of"] + #[doc = " SDL_GetError() to decide if an error has occurred! Sometimes SDL will set"] + #[doc = " an error string even when reporting success."] + #[doc = ""] + #[doc = " SDL will *not* clear the error string for successful API calls. You *must*"] + #[doc = " check return values for failure cases before you can assume the error"] + #[doc = " string applies."] + #[doc = ""] + #[doc = " Error strings are set per-thread, so an error set in a different thread"] + #[doc = " will not interfere with the current thread's operation."] #[doc = ""] - #[doc = " SDL API functions may set error messages and then succeed, so you should"] - #[doc = " only use the error value if a function fails."] + #[doc = " The returned string is internally allocated and must not be freed by the"] + #[doc = " application."] #[doc = ""] - #[doc = " This returns a pointer to a static buffer for convenience and should not"] - #[doc = " be called by multiple threads simultaneously."] + #[doc = " \\returns a message with information about the specific error that occurred,"] + #[doc = " or an empty string if there hasn't been an error message set since"] + #[doc = " the last call to SDL_ClearError(). The message is only applicable"] + #[doc = " when an SDL function has signaled an error. You must check the"] + #[doc = " return values of SDL function calls to determine when to"] + #[doc = " appropriately call SDL_GetError()."] #[doc = ""] - #[doc = " \\return a pointer to the last error message that was set"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_ClearError"] + #[doc = " \\sa SDL_SetError"] pub fn SDL_GetError() -> *const libc::c_char; } extern "C" { - #[doc = " \\brief Get the last error message that was set for the current thread"] + #[doc = " Get the last error message that was set for the current thread."] + #[doc = ""] + #[doc = " This allows the caller to copy the error string into a provided buffer, but"] + #[doc = " otherwise operates exactly the same as SDL_GetError()."] #[doc = ""] - #[doc = " SDL API functions may set error messages and then succeed, so you should"] - #[doc = " only use the error value if a function fails."] + #[doc = " \\param errstr A buffer to fill with the last error message that was set for"] + #[doc = " the current thread"] + #[doc = " \\param maxlen The size of the buffer pointed to by the errstr parameter"] + #[doc = " \\returns the pointer passed in as the `errstr` parameter."] #[doc = ""] - #[doc = " \\param errstr A buffer to fill with the last error message that was set"] - #[doc = " for the current thread"] - #[doc = " \\param maxlen The size of the buffer pointed to by the errstr parameter"] + #[doc = " \\since This function is available since SDL 2.0.14."] #[doc = ""] - #[doc = " \\return errstr"] + #[doc = " \\sa SDL_GetError"] pub fn SDL_GetErrorMsg(errstr: *mut libc::c_char, maxlen: libc::c_int) -> *mut libc::c_char; } extern "C" { - #[doc = " \\brief Clear the error message for the current thread"] + #[doc = " Clear any previous error message for this thread."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetError"] + #[doc = " \\sa SDL_SetError"] pub fn SDL_ClearError(); } #[repr(u32)] @@ -1994,23 +2299,99 @@ pub struct SDL_mutex { _unused: [u8; 0], } extern "C" { - #[doc = " Create a mutex, initialized unlocked."] + #[doc = " Create a new mutex."] + #[doc = ""] + #[doc = " All newly-created mutexes begin in the _unlocked_ state."] + #[doc = ""] + #[doc = " Calls to SDL_LockMutex() will not return while the mutex is locked by"] + #[doc = " another thread. See SDL_TryLockMutex() to attempt to lock without blocking."] + #[doc = ""] + #[doc = " SDL mutexes are reentrant."] + #[doc = ""] + #[doc = " \\returns the initialized and unlocked mutex or NULL on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_DestroyMutex"] + #[doc = " \\sa SDL_LockMutex"] + #[doc = " \\sa SDL_TryLockMutex"] + #[doc = " \\sa SDL_UnlockMutex"] pub fn SDL_CreateMutex() -> *mut SDL_mutex; } extern "C" { + #[doc = " Lock the mutex."] + #[doc = ""] + #[doc = " This will block until the mutex is available, which is to say it is in the"] + #[doc = " unlocked state and the OS has chosen the caller as the next thread to lock"] + #[doc = " it. Of all threads waiting to lock the mutex, only one may do so at a time."] + #[doc = ""] + #[doc = " It is legal for the owning thread to lock an already-locked mutex. It must"] + #[doc = " unlock it the same number of times before it is actually made available for"] + #[doc = " other threads in the system (this is known as a \"recursive mutex\")."] + #[doc = ""] + #[doc = " \\param mutex the mutex to lock"] + #[doc = " \\return 0, or -1 on error."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_LockMutex(mutex: *mut SDL_mutex) -> libc::c_int; } extern "C" { - #[doc = " Try to lock the mutex"] + #[doc = " Try to lock a mutex without blocking."] + #[doc = ""] + #[doc = " This works just like SDL_LockMutex(), but if the mutex is not available,"] + #[doc = " this function returns `SDL_MUTEX_TIMEOUT` immediately."] + #[doc = ""] + #[doc = " This technique is useful if you need exclusive access to a resource but"] + #[doc = " don't want to wait for it, and will return to it to try again later."] #[doc = ""] - #[doc = " \\return 0, SDL_MUTEX_TIMEDOUT, or -1 on error"] + #[doc = " \\param mutex the mutex to try to lock"] + #[doc = " \\returns 0, `SDL_MUTEX_TIMEDOUT`, or -1 on error; call SDL_GetError() for"] + #[doc = " more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateMutex"] + #[doc = " \\sa SDL_DestroyMutex"] + #[doc = " \\sa SDL_LockMutex"] + #[doc = " \\sa SDL_UnlockMutex"] pub fn SDL_TryLockMutex(mutex: *mut SDL_mutex) -> libc::c_int; } extern "C" { + #[doc = " Unlock the mutex."] + #[doc = ""] + #[doc = " It is legal for the owning thread to lock an already-locked mutex. It must"] + #[doc = " unlock it the same number of times before it is actually made available for"] + #[doc = " other threads in the system (this is known as a \"recursive mutex\")."] + #[doc = ""] + #[doc = " It is an error to unlock a mutex that has not been locked by the current"] + #[doc = " thread, and doing so results in undefined behavior."] + #[doc = ""] + #[doc = " It is also an error to unlock a mutex that isn't locked at all."] + #[doc = ""] + #[doc = " \\param mutex the mutex to unlock."] + #[doc = " \\returns 0, or -1 on error."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_UnlockMutex(mutex: *mut SDL_mutex) -> libc::c_int; } extern "C" { - #[doc = " Destroy a mutex."] + #[doc = " Destroy a mutex created with SDL_CreateMutex()."] + #[doc = ""] + #[doc = " This function must be called on any mutex that is no longer needed. Failure"] + #[doc = " to destroy a mutex will result in a system memory or resource leak. While"] + #[doc = " it is safe to destroy a mutex that is _unlocked_, it is not safe to attempt"] + #[doc = " to destroy a locked mutex, and may result in undefined behavior depending"] + #[doc = " on the platform."] + #[doc = ""] + #[doc = " \\param mutex the mutex to destroy"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateMutex"] + #[doc = " \\sa SDL_LockMutex"] + #[doc = " \\sa SDL_TryLockMutex"] + #[doc = " \\sa SDL_UnlockMutex"] pub fn SDL_DestroyMutex(mutex: *mut SDL_mutex); } #[repr(C)] @@ -2020,44 +2401,145 @@ pub struct SDL_semaphore { } pub type SDL_sem = SDL_semaphore; extern "C" { - #[doc = " Create a semaphore, initialized with value, returns NULL on failure."] + #[doc = " Create a semaphore."] + #[doc = ""] + #[doc = " This function creates a new semaphore and initializes it with the value"] + #[doc = " `initial_value`. Each wait operation on the semaphore will atomically"] + #[doc = " decrement the semaphore value and potentially block if the semaphore value"] + #[doc = " is 0. Each post operation will atomically increment the semaphore value and"] + #[doc = " wake waiting threads and allow them to retry the wait operation."] + #[doc = ""] + #[doc = " \\param initial_value the starting value of the semaphore"] + #[doc = " \\returns a new semaphore or NULL on failure; call SDL_GetError() for more"] + #[doc = " information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_DestroySemaphore"] + #[doc = " \\sa SDL_SemPost"] + #[doc = " \\sa SDL_SemTryWait"] + #[doc = " \\sa SDL_SemValue"] + #[doc = " \\sa SDL_SemWait"] + #[doc = " \\sa SDL_SemWaitTimeout"] pub fn SDL_CreateSemaphore(initial_value: Uint32) -> *mut SDL_sem; } extern "C" { - #[doc = " Destroy a semaphore."] + #[doc = " Destroy a semaphore."] + #[doc = ""] + #[doc = " It is not safe to destroy a semaphore if there are threads currently"] + #[doc = " waiting on it."] + #[doc = ""] + #[doc = " \\param sem the semaphore to destroy"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateSemaphore"] + #[doc = " \\sa SDL_SemPost"] + #[doc = " \\sa SDL_SemTryWait"] + #[doc = " \\sa SDL_SemValue"] + #[doc = " \\sa SDL_SemWait"] + #[doc = " \\sa SDL_SemWaitTimeout"] pub fn SDL_DestroySemaphore(sem: *mut SDL_sem); } extern "C" { - #[doc = " This function suspends the calling thread until the semaphore pointed"] - #[doc = " to by \\c sem has a positive count. It then atomically decreases the"] - #[doc = " semaphore count."] + #[doc = " Wait until a semaphore has a positive value and then decrements it."] + #[doc = ""] + #[doc = " This function suspends the calling thread until either the semaphore"] + #[doc = " pointed to by `sem` has a positive value or the call is interrupted by a"] + #[doc = " signal or error. If the call is successful it will atomically decrement the"] + #[doc = " semaphore value."] + #[doc = ""] + #[doc = " This function is the equivalent of calling SDL_SemWaitTimeout() with a time"] + #[doc = " length of `SDL_MUTEX_MAXWAIT`."] + #[doc = ""] + #[doc = " \\param sem the semaphore wait on"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateSemaphore"] + #[doc = " \\sa SDL_DestroySemaphore"] + #[doc = " \\sa SDL_SemPost"] + #[doc = " \\sa SDL_SemTryWait"] + #[doc = " \\sa SDL_SemValue"] + #[doc = " \\sa SDL_SemWait"] + #[doc = " \\sa SDL_SemWaitTimeout"] pub fn SDL_SemWait(sem: *mut SDL_sem) -> libc::c_int; } extern "C" { - #[doc = " Non-blocking variant of SDL_SemWait()."] + #[doc = " See if a semaphore has a positive value and decrement it if it does."] #[doc = ""] - #[doc = " \\return 0 if the wait succeeds, ::SDL_MUTEX_TIMEDOUT if the wait would"] - #[doc = " block, and -1 on error."] + #[doc = " This function checks to see if the semaphore pointed to by `sem` has a"] + #[doc = " positive value and atomically decrements the semaphore value if it does. If"] + #[doc = " the semaphore doesn't have a positive value, the function immediately"] + #[doc = " returns SDL_MUTEX_TIMEDOUT."] + #[doc = ""] + #[doc = " \\param sem the semaphore to wait on"] + #[doc = " \\returns 0 if the wait succeeds, `SDL_MUTEX_TIMEDOUT` if the wait would"] + #[doc = " block, or a negative error code on failure; call SDL_GetError()"] + #[doc = " for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateSemaphore"] + #[doc = " \\sa SDL_DestroySemaphore"] + #[doc = " \\sa SDL_SemPost"] + #[doc = " \\sa SDL_SemValue"] + #[doc = " \\sa SDL_SemWait"] + #[doc = " \\sa SDL_SemWaitTimeout"] pub fn SDL_SemTryWait(sem: *mut SDL_sem) -> libc::c_int; } extern "C" { - #[doc = " Variant of SDL_SemWait() with a timeout in milliseconds."] + #[doc = " Wait until a semaphore has a positive value and then decrements it."] + #[doc = ""] + #[doc = " This function suspends the calling thread until either the semaphore"] + #[doc = " pointed to by `sem` has a positive value, the call is interrupted by a"] + #[doc = " signal or error, or the specified time has elapsed. If the call is"] + #[doc = " successful it will atomically decrement the semaphore value."] #[doc = ""] - #[doc = " \\return 0 if the wait succeeds, ::SDL_MUTEX_TIMEDOUT if the wait does not"] - #[doc = " succeed in the allotted time, and -1 on error."] + #[doc = " \\param sem the semaphore to wait on"] + #[doc = " \\param ms the length of the timeout, in milliseconds"] + #[doc = " \\returns 0 if the wait succeeds, `SDL_MUTEX_TIMEDOUT` if the wait does not"] + #[doc = " succeed in the allotted time, or a negative error code on failure;"] + #[doc = " call SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\warning On some platforms this function is implemented by looping with a"] - #[doc = " delay of 1 ms, and so should be avoided if possible."] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateSemaphore"] + #[doc = " \\sa SDL_DestroySemaphore"] + #[doc = " \\sa SDL_SemPost"] + #[doc = " \\sa SDL_SemTryWait"] + #[doc = " \\sa SDL_SemValue"] + #[doc = " \\sa SDL_SemWait"] pub fn SDL_SemWaitTimeout(sem: *mut SDL_sem, ms: Uint32) -> libc::c_int; } extern "C" { - #[doc = " Atomically increases the semaphore's count (not blocking)."] + #[doc = " Atomically increment a semaphore's value and wake waiting threads."] + #[doc = ""] + #[doc = " \\param sem the semaphore to increment"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0, or -1 on error."] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateSemaphore"] + #[doc = " \\sa SDL_DestroySemaphore"] + #[doc = " \\sa SDL_SemTryWait"] + #[doc = " \\sa SDL_SemValue"] + #[doc = " \\sa SDL_SemWait"] + #[doc = " \\sa SDL_SemWaitTimeout"] pub fn SDL_SemPost(sem: *mut SDL_sem) -> libc::c_int; } extern "C" { - #[doc = " Returns the current count of the semaphore."] + #[doc = " Get the current value of a semaphore."] + #[doc = ""] + #[doc = " \\param sem the semaphore to query"] + #[doc = " \\returns the current value of the semaphore."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateSemaphore"] pub fn SDL_SemValue(sem: *mut SDL_sem) -> Uint32; } #[repr(C)] @@ -2066,67 +2548,119 @@ pub struct SDL_cond { _unused: [u8; 0], } extern "C" { - #[doc = " Create a condition variable."] - #[doc = ""] - #[doc = " Typical use of condition variables:"] - #[doc = ""] - #[doc = " Thread A:"] - #[doc = " SDL_LockMutex(lock);"] - #[doc = " while ( ! condition ) {"] - #[doc = " SDL_CondWait(cond, lock);"] - #[doc = " }"] - #[doc = " SDL_UnlockMutex(lock);"] + #[doc = " Create a condition variable."] #[doc = ""] - #[doc = " Thread B:"] - #[doc = " SDL_LockMutex(lock);"] - #[doc = " ..."] - #[doc = " condition = true;"] - #[doc = " ..."] - #[doc = " SDL_CondSignal(cond);"] - #[doc = " SDL_UnlockMutex(lock);"] + #[doc = " \\returns a new condition variable or NULL on failure; call SDL_GetError()"] + #[doc = " for more information."] #[doc = ""] - #[doc = " There is some discussion whether to signal the condition variable"] - #[doc = " with the mutex locked or not. There is some potential performance"] - #[doc = " benefit to unlocking first on some platforms, but there are some"] - #[doc = " potential race conditions depending on how your code is structured."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " In general it's safer to signal the condition variable while the"] - #[doc = " mutex is locked."] + #[doc = " \\sa SDL_CondBroadcast"] + #[doc = " \\sa SDL_CondSignal"] + #[doc = " \\sa SDL_CondWait"] + #[doc = " \\sa SDL_CondWaitTimeout"] + #[doc = " \\sa SDL_DestroyCond"] pub fn SDL_CreateCond() -> *mut SDL_cond; } extern "C" { - #[doc = " Destroy a condition variable."] + #[doc = " Destroy a condition variable."] + #[doc = ""] + #[doc = " \\param cond the condition variable to destroy"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CondBroadcast"] + #[doc = " \\sa SDL_CondSignal"] + #[doc = " \\sa SDL_CondWait"] + #[doc = " \\sa SDL_CondWaitTimeout"] + #[doc = " \\sa SDL_CreateCond"] pub fn SDL_DestroyCond(cond: *mut SDL_cond); } extern "C" { - #[doc = " Restart one of the threads that are waiting on the condition variable."] + #[doc = " Restart one of the threads that are waiting on the condition variable."] + #[doc = ""] + #[doc = " \\param cond the condition variable to signal"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 or -1 on error."] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CondBroadcast"] + #[doc = " \\sa SDL_CondWait"] + #[doc = " \\sa SDL_CondWaitTimeout"] + #[doc = " \\sa SDL_CreateCond"] + #[doc = " \\sa SDL_DestroyCond"] pub fn SDL_CondSignal(cond: *mut SDL_cond) -> libc::c_int; } extern "C" { - #[doc = " Restart all threads that are waiting on the condition variable."] + #[doc = " Restart all threads that are waiting on the condition variable."] + #[doc = ""] + #[doc = " \\param cond the condition variable to signal"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 or -1 on error."] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CondSignal"] + #[doc = " \\sa SDL_CondWait"] + #[doc = " \\sa SDL_CondWaitTimeout"] + #[doc = " \\sa SDL_CreateCond"] + #[doc = " \\sa SDL_DestroyCond"] pub fn SDL_CondBroadcast(cond: *mut SDL_cond) -> libc::c_int; } extern "C" { - #[doc = " Wait on the condition variable, unlocking the provided mutex."] + #[doc = " Wait until a condition variable is signaled."] + #[doc = ""] + #[doc = " This function unlocks the specified `mutex` and waits for another thread to"] + #[doc = " call SDL_CondSignal() or SDL_CondBroadcast() on the condition variable"] + #[doc = " `cond`. Once the condition variable is signaled, the mutex is re-locked and"] + #[doc = " the function returns."] #[doc = ""] - #[doc = " \\warning The mutex must be locked before entering this function!"] + #[doc = " The mutex must be locked before calling this function."] #[doc = ""] - #[doc = " The mutex is re-locked once the condition variable is signaled."] + #[doc = " This function is the equivalent of calling SDL_CondWaitTimeout() with a"] + #[doc = " time length of `SDL_MUTEX_MAXWAIT`."] #[doc = ""] - #[doc = " \\return 0 when it is signaled, or -1 on error."] + #[doc = " \\param cond the condition variable to wait on"] + #[doc = " \\param mutex the mutex used to coordinate thread access"] + #[doc = " \\returns 0 when it is signaled or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CondBroadcast"] + #[doc = " \\sa SDL_CondSignal"] + #[doc = " \\sa SDL_CondWaitTimeout"] + #[doc = " \\sa SDL_CreateCond"] + #[doc = " \\sa SDL_DestroyCond"] pub fn SDL_CondWait(cond: *mut SDL_cond, mutex: *mut SDL_mutex) -> libc::c_int; } extern "C" { - #[doc = " Waits for at most \\c ms milliseconds, and returns 0 if the condition"] - #[doc = " variable is signaled, ::SDL_MUTEX_TIMEDOUT if the condition is not"] - #[doc = " signaled in the allotted time, and -1 on error."] + #[doc = " Wait until a condition variable is signaled or a certain time has passed."] + #[doc = ""] + #[doc = " This function unlocks the specified `mutex` and waits for another thread to"] + #[doc = " call SDL_CondSignal() or SDL_CondBroadcast() on the condition variable"] + #[doc = " `cond`, or for the specified time to elapse. Once the condition variable is"] + #[doc = " signaled or the time elapsed, the mutex is re-locked and the function"] + #[doc = " returns."] + #[doc = ""] + #[doc = " The mutex must be locked before calling this function."] #[doc = ""] - #[doc = " \\warning On some platforms this function is implemented by looping with a"] - #[doc = " delay of 1 ms, and so should be avoided if possible."] + #[doc = " \\param cond the condition variable to wait on"] + #[doc = " \\param mutex the mutex used to coordinate thread access"] + #[doc = " \\param ms the maximum time to wait, in milliseconds, or `SDL_MUTEX_MAXWAIT`"] + #[doc = " to wait indefinitely"] + #[doc = " \\returns 0 if the condition variable is signaled, `SDL_MUTEX_TIMEDOUT` if"] + #[doc = " the condition is not signaled in the allotted time, or a negative"] + #[doc = " error code on failure; call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CondBroadcast"] + #[doc = " \\sa SDL_CondSignal"] + #[doc = " \\sa SDL_CondWait"] + #[doc = " \\sa SDL_CreateCond"] + #[doc = " \\sa SDL_DestroyCond"] pub fn SDL_CondWaitTimeout( cond: *mut SDL_cond, mutex: *mut SDL_mutex, @@ -2156,15 +2690,32 @@ pub enum SDL_ThreadPriority { SDL_THREAD_PRIORITY_HIGH = 2, SDL_THREAD_PRIORITY_TIME_CRITICAL = 3, } -#[doc = " The function passed to SDL_CreateThread()."] -#[doc = " It is passed a void* user context parameter and returns an int."] +#[doc = " The function passed to SDL_CreateThread()."] +#[doc = ""] +#[doc = " \\param data what was passed as `data` to SDL_CreateThread()"] +#[doc = " \\returns a value that can be reported through SDL_WaitThread()."] pub type SDL_ThreadFunction = ::core::option::Option libc::c_int>; extern "C" { - #[doc = " Create a thread with a default stack size."] + #[doc = " Create a new thread with a default stack size."] + #[doc = ""] + #[doc = " This is equivalent to calling:"] #[doc = ""] - #[doc = " This is equivalent to calling:"] - #[doc = " SDL_CreateThreadWithStackSize(fn, name, 0, data);"] + #[doc = " ```c"] + #[doc = " SDL_CreateThreadWithStackSize(fn, name, 0, data);"] + #[doc = " ```"] + #[doc = ""] + #[doc = " \\param fn the SDL_ThreadFunction function to call in the new thread"] + #[doc = " \\param name the name of the thread"] + #[doc = " \\param data a pointer that is passed to `fn`"] + #[doc = " \\returns an opaque pointer to the new thread object on success, NULL if the"] + #[doc = " new thread could not be created; call SDL_GetError() for more"] + #[doc = " information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateThreadWithStackSize"] + #[doc = " \\sa SDL_WaitThread"] pub fn SDL_CreateThread( fn_: SDL_ThreadFunction, name: *const libc::c_char, @@ -2172,30 +2723,47 @@ extern "C" { ) -> *mut SDL_Thread; } extern "C" { - #[doc = " Create a thread."] + #[doc = " Create a new thread with a specific stack size."] + #[doc = ""] + #[doc = " SDL makes an attempt to report `name` to the system, so that debuggers can"] + #[doc = " display it. Not all platforms support this."] #[doc = ""] - #[doc = " Thread naming is a little complicated: Most systems have very small"] - #[doc = " limits for the string length (Haiku has 32 bytes, Linux currently has 16,"] - #[doc = " Visual C++ 6.0 has nine!), and possibly other arbitrary rules. You'll"] - #[doc = " have to see what happens with your system's debugger. The name should be"] - #[doc = " UTF-8 (but using the naming limits of C identifiers is a better bet)."] - #[doc = " There are no requirements for thread naming conventions, so long as the"] - #[doc = " string is null-terminated UTF-8, but these guidelines are helpful in"] - #[doc = " choosing a name:"] + #[doc = " Thread naming is a little complicated: Most systems have very small limits"] + #[doc = " for the string length (Haiku has 32 bytes, Linux currently has 16, Visual"] + #[doc = " C++ 6.0 has _nine_!), and possibly other arbitrary rules. You'll have to"] + #[doc = " see what happens with your system's debugger. The name should be UTF-8 (but"] + #[doc = " using the naming limits of C identifiers is a better bet). There are no"] + #[doc = " requirements for thread naming conventions, so long as the string is"] + #[doc = " null-terminated UTF-8, but these guidelines are helpful in choosing a name:"] #[doc = ""] - #[doc = " http://stackoverflow.com/questions/149932/naming-conventions-for-threads"] + #[doc = " https://stackoverflow.com/questions/149932/naming-conventions-for-threads"] #[doc = ""] - #[doc = " If a system imposes requirements, SDL will try to munge the string for"] - #[doc = " it (truncate, etc), but the original string contents will be available"] - #[doc = " from SDL_GetThreadName()."] + #[doc = " If a system imposes requirements, SDL will try to munge the string for it"] + #[doc = " (truncate, etc), but the original string contents will be available from"] + #[doc = " SDL_GetThreadName()."] #[doc = ""] - #[doc = " The size (in bytes) of the new stack can be specified. Zero means \"use"] - #[doc = " the system default\" which might be wildly different between platforms"] - #[doc = " (x86 Linux generally defaults to eight megabytes, an embedded device"] - #[doc = " might be a few kilobytes instead)."] + #[doc = " The size (in bytes) of the new stack can be specified. Zero means \"use the"] + #[doc = " system default\" which might be wildly different between platforms. x86"] + #[doc = " Linux generally defaults to eight megabytes, an embedded device might be a"] + #[doc = " few kilobytes instead. You generally need to specify a stack that is a"] + #[doc = " multiple of the system's page size (in many cases, this is 4 kilobytes, but"] + #[doc = " check your system documentation)."] #[doc = ""] - #[doc = " In SDL 2.1, stacksize will be folded into the original SDL_CreateThread"] - #[doc = " function."] + #[doc = " In SDL 2.1, stack size will be folded into the original SDL_CreateThread"] + #[doc = " function, but for backwards compatibility, this is currently a separate"] + #[doc = " function."] + #[doc = ""] + #[doc = " \\param fn the SDL_ThreadFunction function to call in the new thread"] + #[doc = " \\param name the name of the thread"] + #[doc = " \\param stacksize the size, in bytes, to allocate for the new thread stack."] + #[doc = " \\param data a pointer that is passed to `fn`"] + #[doc = " \\returns an opaque pointer to the new thread object on success, NULL if the"] + #[doc = " new thread could not be created; call SDL_GetError() for more"] + #[doc = " information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.9."] + #[doc = ""] + #[doc = " \\sa SDL_WaitThread"] pub fn SDL_CreateThreadWithStackSize( fn_: SDL_ThreadFunction, name: *const libc::c_char, @@ -2204,132 +2772,197 @@ extern "C" { ) -> *mut SDL_Thread; } extern "C" { - #[doc = " Get the thread name, as it was specified in SDL_CreateThread()."] - #[doc = " This function returns a pointer to a UTF-8 string that names the"] - #[doc = " specified thread, or NULL if it doesn't have a name. This is internal"] - #[doc = " memory, not to be free()'d by the caller, and remains valid until the"] - #[doc = " specified thread is cleaned up by SDL_WaitThread()."] + #[doc = " Get the thread name as it was specified in SDL_CreateThread()."] + #[doc = ""] + #[doc = " This is internal memory, not to be freed by the caller, and remains valid"] + #[doc = " until the specified thread is cleaned up by SDL_WaitThread()."] + #[doc = ""] + #[doc = " \\param thread the thread to query"] + #[doc = " \\returns a pointer to a UTF-8 string that names the specified thread, or"] + #[doc = " NULL if it doesn't have a name."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateThread"] pub fn SDL_GetThreadName(thread: *mut SDL_Thread) -> *const libc::c_char; } extern "C" { - #[doc = " Get the thread identifier for the current thread."] + #[doc = " Get the thread identifier for the current thread."] + #[doc = ""] + #[doc = " This thread identifier is as reported by the underlying operating system."] + #[doc = " If SDL is running on a platform that does not support threads the return"] + #[doc = " value will always be zero."] + #[doc = ""] + #[doc = " This function also returns a valid thread ID when called from the main"] + #[doc = " thread."] + #[doc = ""] + #[doc = " \\returns the ID of the current thread."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetThreadID"] pub fn SDL_ThreadID() -> SDL_threadID; } extern "C" { - #[doc = " Get the thread identifier for the specified thread."] + #[doc = " Get the thread identifier for the specified thread."] #[doc = ""] - #[doc = " Equivalent to SDL_ThreadID() if the specified thread is NULL."] + #[doc = " This thread identifier is as reported by the underlying operating system."] + #[doc = " If SDL is running on a platform that does not support threads the return"] + #[doc = " value will always be zero."] + #[doc = ""] + #[doc = " \\param thread the thread to query"] + #[doc = " \\returns the ID of the specified thread, or the ID of the current thread if"] + #[doc = " `thread` is NULL."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_ThreadID"] pub fn SDL_GetThreadID(thread: *mut SDL_Thread) -> SDL_threadID; } extern "C" { - #[doc = " Set the priority for the current thread"] + #[doc = " Set the priority for the current thread."] + #[doc = ""] + #[doc = " Note that some platforms will not let you alter the priority (or at least,"] + #[doc = " promote the thread to a higher priority) at all, and some require you to be"] + #[doc = " an administrator account. Be prepared for this to fail."] + #[doc = ""] + #[doc = " \\param priority the SDL_ThreadPriority to set"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_SetThreadPriority(priority: SDL_ThreadPriority) -> libc::c_int; } extern "C" { - #[doc = " Wait for a thread to finish. Threads that haven't been detached will"] - #[doc = " remain (as a \"zombie\") until this function cleans them up. Not doing so"] - #[doc = " is a resource leak."] + #[doc = " Wait for a thread to finish."] + #[doc = ""] + #[doc = " Threads that haven't been detached will remain (as a \"zombie\") until this"] + #[doc = " function cleans them up. Not doing so is a resource leak."] + #[doc = ""] + #[doc = " Once a thread has been cleaned up through this function, the SDL_Thread"] + #[doc = " that references it becomes invalid and should not be referenced again. As"] + #[doc = " such, only one thread may call SDL_WaitThread() on another."] #[doc = ""] - #[doc = " Once a thread has been cleaned up through this function, the SDL_Thread"] - #[doc = " that references it becomes invalid and should not be referenced again."] - #[doc = " As such, only one thread may call SDL_WaitThread() on another."] + #[doc = " The return code for the thread function is placed in the area pointed to by"] + #[doc = " `status`, if `status` is not NULL."] #[doc = ""] - #[doc = " The return code for the thread function is placed in the area"] - #[doc = " pointed to by \\c status, if \\c status is not NULL."] + #[doc = " You may not wait on a thread that has been used in a call to"] + #[doc = " SDL_DetachThread(). Use either that function or this one, but not both, or"] + #[doc = " behavior is undefined."] #[doc = ""] - #[doc = " You may not wait on a thread that has been used in a call to"] - #[doc = " SDL_DetachThread(). Use either that function or this one, but not"] - #[doc = " both, or behavior is undefined."] + #[doc = " It is safe to pass a NULL thread to this function; it is a no-op."] #[doc = ""] - #[doc = " It is safe to pass NULL to this function; it is a no-op."] + #[doc = " Note that the thread pointer is freed by this function and is not valid"] + #[doc = " afterward."] + #[doc = ""] + #[doc = " \\param thread the SDL_Thread pointer that was returned from the"] + #[doc = " SDL_CreateThread() call that started this thread"] + #[doc = " \\param status pointer to an integer that will receive the value returned"] + #[doc = " from the thread function by its 'return', or NULL to not"] + #[doc = " receive such value back."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateThread"] + #[doc = " \\sa SDL_DetachThread"] pub fn SDL_WaitThread(thread: *mut SDL_Thread, status: *mut libc::c_int); } extern "C" { - #[doc = " A thread may be \"detached\" to signify that it should not remain until"] - #[doc = " another thread has called SDL_WaitThread() on it. Detaching a thread"] - #[doc = " is useful for long-running threads that nothing needs to synchronize"] - #[doc = " with or further manage. When a detached thread is done, it simply"] - #[doc = " goes away."] + #[doc = " Let a thread clean up on exit without intervention."] + #[doc = ""] + #[doc = " A thread may be \"detached\" to signify that it should not remain until"] + #[doc = " another thread has called SDL_WaitThread() on it. Detaching a thread is"] + #[doc = " useful for long-running threads that nothing needs to synchronize with or"] + #[doc = " further manage. When a detached thread is done, it simply goes away."] #[doc = ""] - #[doc = " There is no way to recover the return code of a detached thread. If you"] - #[doc = " need this, don't detach the thread and instead use SDL_WaitThread()."] + #[doc = " There is no way to recover the return code of a detached thread. If you"] + #[doc = " need this, don't detach the thread and instead use SDL_WaitThread()."] #[doc = ""] - #[doc = " Once a thread is detached, you should usually assume the SDL_Thread isn't"] - #[doc = " safe to reference again, as it will become invalid immediately upon"] - #[doc = " the detached thread's exit, instead of remaining until someone has called"] - #[doc = " SDL_WaitThread() to finally clean it up. As such, don't detach the same"] - #[doc = " thread more than once."] + #[doc = " Once a thread is detached, you should usually assume the SDL_Thread isn't"] + #[doc = " safe to reference again, as it will become invalid immediately upon the"] + #[doc = " detached thread's exit, instead of remaining until someone has called"] + #[doc = " SDL_WaitThread() to finally clean it up. As such, don't detach the same"] + #[doc = " thread more than once."] #[doc = ""] - #[doc = " If a thread has already exited when passed to SDL_DetachThread(), it will"] - #[doc = " stop waiting for a call to SDL_WaitThread() and clean up immediately."] - #[doc = " It is not safe to detach a thread that might be used with SDL_WaitThread()."] + #[doc = " If a thread has already exited when passed to SDL_DetachThread(), it will"] + #[doc = " stop waiting for a call to SDL_WaitThread() and clean up immediately. It is"] + #[doc = " not safe to detach a thread that might be used with SDL_WaitThread()."] #[doc = ""] - #[doc = " You may not call SDL_WaitThread() on a thread that has been detached."] - #[doc = " Use either that function or this one, but not both, or behavior is"] - #[doc = " undefined."] + #[doc = " You may not call SDL_WaitThread() on a thread that has been detached. Use"] + #[doc = " either that function or this one, but not both, or behavior is undefined."] #[doc = ""] - #[doc = " It is safe to pass NULL to this function; it is a no-op."] + #[doc = " It is safe to pass NULL to this function; it is a no-op."] + #[doc = ""] + #[doc = " \\param thread the SDL_Thread pointer that was returned from the"] + #[doc = " SDL_CreateThread() call that started this thread"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.2."] + #[doc = ""] + #[doc = " \\sa SDL_CreateThread"] + #[doc = " \\sa SDL_WaitThread"] pub fn SDL_DetachThread(thread: *mut SDL_Thread); } extern "C" { - #[doc = " \\brief Create an identifier that is globally visible to all threads but refers to data that is thread-specific."] - #[doc = ""] - #[doc = " \\return The newly created thread local storage identifier, or 0 on error"] + #[doc = " Create a piece of thread-local storage."] #[doc = ""] - #[doc = " \\code"] - #[doc = " static SDL_SpinLock tls_lock;"] - #[doc = " static SDL_TLSID thread_local_storage;"] + #[doc = " This creates an identifier that is globally visible to all threads but"] + #[doc = " refers to data that is thread-specific."] #[doc = ""] - #[doc = " void SetMyThreadData(void *value)"] - #[doc = " {"] - #[doc = " if (!thread_local_storage) {"] - #[doc = " SDL_AtomicLock(&tls_lock);"] - #[doc = " if (!thread_local_storage) {"] - #[doc = " thread_local_storage = SDL_TLSCreate();"] - #[doc = " }"] - #[doc = " SDL_AtomicUnlock(&tls_lock);"] - #[doc = " }"] - #[doc = " SDL_TLSSet(thread_local_storage, value, 0);"] - #[doc = " }"] + #[doc = " \\returns the newly created thread local storage identifier or 0 on error."] #[doc = ""] - #[doc = " void *GetMyThreadData(void)"] - #[doc = " {"] - #[doc = " return SDL_TLSGet(thread_local_storage);"] - #[doc = " }"] - #[doc = " \\endcode"] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_TLSGet()"] - #[doc = " \\sa SDL_TLSSet()"] + #[doc = " \\sa SDL_TLSGet"] + #[doc = " \\sa SDL_TLSSet"] pub fn SDL_TLSCreate() -> SDL_TLSID; } extern "C" { - #[doc = " \\brief Get the value associated with a thread local storage ID for the current thread."] + #[doc = " Get the current thread's value associated with a thread local storage ID."] #[doc = ""] - #[doc = " \\param id The thread local storage ID"] + #[doc = " \\param id the thread local storage ID"] + #[doc = " \\returns the value associated with the ID for the current thread or NULL if"] + #[doc = " no value has been set; call SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return The value associated with the ID for the current thread, or NULL if no value has been set."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_TLSCreate()"] - #[doc = " \\sa SDL_TLSSet()"] + #[doc = " \\sa SDL_TLSCreate"] + #[doc = " \\sa SDL_TLSSet"] pub fn SDL_TLSGet(id: SDL_TLSID) -> *mut libc::c_void; } extern "C" { - #[doc = " \\brief Set the value associated with a thread local storage ID for the current thread."] + #[doc = " Set the current thread's value associated with a thread local storage ID."] #[doc = ""] - #[doc = " \\param id The thread local storage ID"] - #[doc = " \\param value The value to associate with the ID for the current thread"] - #[doc = " \\param destructor A function called when the thread exits, to free the value."] + #[doc = " The function prototype for `destructor` is:"] #[doc = ""] - #[doc = " \\return 0 on success, -1 on error"] + #[doc = " ```c"] + #[doc = " void destructor(void *value)"] + #[doc = " ```"] #[doc = ""] - #[doc = " \\sa SDL_TLSCreate()"] - #[doc = " \\sa SDL_TLSGet()"] + #[doc = " where its parameter `value` is what was passed as `value` to SDL_TLSSet()."] + #[doc = ""] + #[doc = " \\param id the thread local storage ID"] + #[doc = " \\param value the value to associate with the ID for the current thread"] + #[doc = " \\param destructor a function called when the thread exits, to free the"] + #[doc = " value"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_TLSCreate"] + #[doc = " \\sa SDL_TLSGet"] pub fn SDL_TLSSet( id: SDL_TLSID, value: *const libc::c_void, destructor: ::core::option::Option, ) -> libc::c_int; } +extern "C" { + #[doc = " Cleanup all TLS data for this thread."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.16."] + pub fn SDL_TLSCleanup(); +} #[doc = " This is the read/write operation structure -- very basic."] #[repr(C)] #[derive(Copy, Clone)] @@ -2620,55 +3253,350 @@ fn bindgen_test_layout_SDL_RWops() { ); } extern "C" { + #[doc = " Use this function to create a new SDL_RWops structure for reading from"] + #[doc = " and/or writing to a named file."] + #[doc = ""] + #[doc = " The `mode` string is treated roughly the same as in a call to the C"] + #[doc = " library's fopen(), even if SDL doesn't happen to use fopen() behind the"] + #[doc = " scenes."] + #[doc = ""] + #[doc = " Available `mode` strings:"] + #[doc = ""] + #[doc = " - \"r\": Open a file for reading. The file must exist."] + #[doc = " - \"w\": Create an empty file for writing. If a file with the same name"] + #[doc = " already exists its content is erased and the file is treated as a new"] + #[doc = " empty file."] + #[doc = " - \"a\": Append to a file. Writing operations append data at the end of the"] + #[doc = " file. The file is created if it does not exist."] + #[doc = " - \"r+\": Open a file for update both reading and writing. The file must"] + #[doc = " exist."] + #[doc = " - \"w+\": Create an empty file for both reading and writing. If a file with"] + #[doc = " the same name already exists its content is erased and the file is"] + #[doc = " treated as a new empty file."] + #[doc = " - \"a+\": Open a file for reading and appending. All writing operations are"] + #[doc = " performed at the end of the file, protecting the previous content to be"] + #[doc = " overwritten. You can reposition (fseek, rewind) the internal pointer to"] + #[doc = " anywhere in the file for reading, but writing operations will move it"] + #[doc = " back to the end of file. The file is created if it does not exist."] + #[doc = ""] + #[doc = " **NOTE**: In order to open a file as a binary file, a \"b\" character has to"] + #[doc = " be included in the `mode` string. This additional \"b\" character can either"] + #[doc = " be appended at the end of the string (thus making the following compound"] + #[doc = " modes: \"rb\", \"wb\", \"ab\", \"r+b\", \"w+b\", \"a+b\") or be inserted between the"] + #[doc = " letter and the \"+\" sign for the mixed modes (\"rb+\", \"wb+\", \"ab+\")."] + #[doc = " Additional characters may follow the sequence, although they should have no"] + #[doc = " effect. For example, \"t\" is sometimes appended to make explicit the file is"] + #[doc = " a text file."] + #[doc = ""] + #[doc = " This function supports Unicode filenames, but they must be encoded in UTF-8"] + #[doc = " format, regardless of the underlying operating system."] + #[doc = ""] + #[doc = " As a fallback, SDL_RWFromFile() will transparently open a matching filename"] + #[doc = " in an Android app's `assets`."] + #[doc = ""] + #[doc = " Closing the SDL_RWops will close the file handle SDL is holding internally."] + #[doc = ""] + #[doc = " \\param file a UTF-8 string representing the filename to open"] + #[doc = " \\param mode an ASCII string representing the mode to be used for opening"] + #[doc = " the file."] + #[doc = " \\returns a pointer to the SDL_RWops structure that is created, or NULL on"] + #[doc = " failure; call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_RWclose"] + #[doc = " \\sa SDL_RWFromConstMem"] + #[doc = " \\sa SDL_RWFromFP"] + #[doc = " \\sa SDL_RWFromMem"] + #[doc = " \\sa SDL_RWread"] + #[doc = " \\sa SDL_RWseek"] + #[doc = " \\sa SDL_RWtell"] + #[doc = " \\sa SDL_RWwrite"] pub fn SDL_RWFromFile(file: *const libc::c_char, mode: *const libc::c_char) -> *mut SDL_RWops; } extern "C" { + #[doc = " Use this function to create an SDL_RWops structure from a standard I/O file"] + #[doc = " pointer (stdio.h's `FILE*`)."] + #[doc = ""] + #[doc = " This function is not available on Windows, since files opened in an"] + #[doc = " application on that platform cannot be used by a dynamically linked"] + #[doc = " library."] + #[doc = ""] + #[doc = " On some platforms, the first parameter is a `void*`, on others, it's a"] + #[doc = " `FILE*`, depending on what system headers are available to SDL. It is"] + #[doc = " always intended to be the `FILE*` type from the C runtime's stdio.h."] + #[doc = ""] + #[doc = " \\param fp the `FILE*` that feeds the SDL_RWops stream"] + #[doc = " \\param autoclose SDL_TRUE to close the `FILE*` when closing the SDL_RWops,"] + #[doc = " SDL_FALSE to leave the `FILE*` open when the RWops is"] + #[doc = " closed"] + #[doc = " \\returns a pointer to the SDL_RWops structure that is created, or NULL on"] + #[doc = " failure; call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_RWclose"] + #[doc = " \\sa SDL_RWFromConstMem"] + #[doc = " \\sa SDL_RWFromFile"] + #[doc = " \\sa SDL_RWFromMem"] + #[doc = " \\sa SDL_RWread"] + #[doc = " \\sa SDL_RWseek"] + #[doc = " \\sa SDL_RWtell"] + #[doc = " \\sa SDL_RWwrite"] pub fn SDL_RWFromFP(fp: *mut libc::c_void, autoclose: SDL_bool) -> *mut SDL_RWops; } extern "C" { + #[doc = " Use this function to prepare a read-write memory buffer for use with"] + #[doc = " SDL_RWops."] + #[doc = ""] + #[doc = " This function sets up an SDL_RWops struct based on a memory area of a"] + #[doc = " certain size, for both read and write access."] + #[doc = ""] + #[doc = " This memory buffer is not copied by the RWops; the pointer you provide must"] + #[doc = " remain valid until you close the stream. Closing the stream will not free"] + #[doc = " the original buffer."] + #[doc = ""] + #[doc = " If you need to make sure the RWops never writes to the memory buffer, you"] + #[doc = " should use SDL_RWFromConstMem() with a read-only buffer of memory instead."] + #[doc = ""] + #[doc = " \\param mem a pointer to a buffer to feed an SDL_RWops stream"] + #[doc = " \\param size the buffer size, in bytes"] + #[doc = " \\returns a pointer to a new SDL_RWops structure, or NULL if it fails; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_RWclose"] + #[doc = " \\sa SDL_RWFromConstMem"] + #[doc = " \\sa SDL_RWFromFile"] + #[doc = " \\sa SDL_RWFromFP"] + #[doc = " \\sa SDL_RWFromMem"] + #[doc = " \\sa SDL_RWread"] + #[doc = " \\sa SDL_RWseek"] + #[doc = " \\sa SDL_RWtell"] + #[doc = " \\sa SDL_RWwrite"] pub fn SDL_RWFromMem(mem: *mut libc::c_void, size: libc::c_int) -> *mut SDL_RWops; } extern "C" { + #[doc = " Use this function to prepare a read-only memory buffer for use with RWops."] + #[doc = ""] + #[doc = " This function sets up an SDL_RWops struct based on a memory area of a"] + #[doc = " certain size. It assumes the memory area is not writable."] + #[doc = ""] + #[doc = " Attempting to write to this RWops stream will report an error without"] + #[doc = " writing to the memory buffer."] + #[doc = ""] + #[doc = " This memory buffer is not copied by the RWops; the pointer you provide must"] + #[doc = " remain valid until you close the stream. Closing the stream will not free"] + #[doc = " the original buffer."] + #[doc = ""] + #[doc = " If you need to write to a memory buffer, you should use SDL_RWFromMem()"] + #[doc = " with a writable buffer of memory instead."] + #[doc = ""] + #[doc = " \\param mem a pointer to a read-only buffer to feed an SDL_RWops stream"] + #[doc = " \\param size the buffer size, in bytes"] + #[doc = " \\returns a pointer to a new SDL_RWops structure, or NULL if it fails; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_RWclose"] + #[doc = " \\sa SDL_RWFromConstMem"] + #[doc = " \\sa SDL_RWFromFile"] + #[doc = " \\sa SDL_RWFromFP"] + #[doc = " \\sa SDL_RWFromMem"] + #[doc = " \\sa SDL_RWread"] + #[doc = " \\sa SDL_RWseek"] + #[doc = " \\sa SDL_RWtell"] pub fn SDL_RWFromConstMem(mem: *const libc::c_void, size: libc::c_int) -> *mut SDL_RWops; } extern "C" { + #[doc = " Use this function to allocate an empty, unpopulated SDL_RWops structure."] + #[doc = ""] + #[doc = " Applications do not need to use this function unless they are providing"] + #[doc = " their own SDL_RWops implementation. If you just need a SDL_RWops to"] + #[doc = " read/write a common data source, you should use the built-in"] + #[doc = " implementations in SDL, like SDL_RWFromFile() or SDL_RWFromMem(), etc."] + #[doc = ""] + #[doc = " You must free the returned pointer with SDL_FreeRW(). Depending on your"] + #[doc = " operating system and compiler, there may be a difference between the"] + #[doc = " malloc() and free() your program uses and the versions SDL calls"] + #[doc = " internally. Trying to mix the two can cause crashing such as segmentation"] + #[doc = " faults. Since all SDL_RWops must free themselves when their **close**"] + #[doc = " method is called, all SDL_RWops must be allocated through this function, so"] + #[doc = " they can all be freed correctly with SDL_FreeRW()."] + #[doc = ""] + #[doc = " \\returns a pointer to the allocated memory on success, or NULL on failure;"] + #[doc = " call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_FreeRW"] pub fn SDL_AllocRW() -> *mut SDL_RWops; } extern "C" { + #[doc = " Use this function to free an SDL_RWops structure allocated by"] + #[doc = " SDL_AllocRW()."] + #[doc = ""] + #[doc = " Applications do not need to use this function unless they are providing"] + #[doc = " their own SDL_RWops implementation. If you just need a SDL_RWops to"] + #[doc = " read/write a common data source, you should use the built-in"] + #[doc = " implementations in SDL, like SDL_RWFromFile() or SDL_RWFromMem(), etc, and"] + #[doc = " call the **close** method on those SDL_RWops pointers when you are done"] + #[doc = " with them."] + #[doc = ""] + #[doc = " Only use SDL_FreeRW() on pointers returned by SDL_AllocRW(). The pointer is"] + #[doc = " invalid as soon as this function returns. Any extra memory allocated during"] + #[doc = " creation of the SDL_RWops is not freed by SDL_FreeRW(); the programmer must"] + #[doc = " be responsible for managing that memory in their **close** method."] + #[doc = ""] + #[doc = " \\param area the SDL_RWops structure to be freed"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_AllocRW"] pub fn SDL_FreeRW(area: *mut SDL_RWops); } extern "C" { - #[doc = " Return the size of the file in this rwops, or -1 if unknown"] + #[doc = " Use this function to get the size of the data stream in an SDL_RWops."] + #[doc = ""] + #[doc = " Prior to SDL 2.0.10, this function was a macro."] + #[doc = ""] + #[doc = " \\param context the SDL_RWops to get the size of the data stream from"] + #[doc = " \\returns the size of the data stream in the SDL_RWops on success, -1 if"] + #[doc = " unknown or a negative error code on failure; call SDL_GetError()"] + #[doc = " for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.10."] pub fn SDL_RWsize(context: *mut SDL_RWops) -> Sint64; } extern "C" { - #[doc = " Seek to \\c offset relative to \\c whence, one of stdio's whence values:"] - #[doc = " RW_SEEK_SET, RW_SEEK_CUR, RW_SEEK_END"] + #[doc = " Seek within an SDL_RWops data stream."] #[doc = ""] - #[doc = " \\return the final offset in the data stream, or -1 on error."] + #[doc = " This function seeks to byte `offset`, relative to `whence`."] + #[doc = ""] + #[doc = " `whence` may be any of the following values:"] + #[doc = ""] + #[doc = " - `RW_SEEK_SET`: seek from the beginning of data"] + #[doc = " - `RW_SEEK_CUR`: seek relative to current read point"] + #[doc = " - `RW_SEEK_END`: seek relative to the end of data"] + #[doc = ""] + #[doc = " If this stream can not seek, it will return -1."] + #[doc = ""] + #[doc = " SDL_RWseek() is actually a wrapper function that calls the SDL_RWops's"] + #[doc = " `seek` method appropriately, to simplify application development."] + #[doc = ""] + #[doc = " Prior to SDL 2.0.10, this function was a macro."] + #[doc = ""] + #[doc = " \\param context a pointer to an SDL_RWops structure"] + #[doc = " \\param offset an offset in bytes, relative to **whence** location; can be"] + #[doc = " negative"] + #[doc = " \\param whence any of `RW_SEEK_SET`, `RW_SEEK_CUR`, `RW_SEEK_END`"] + #[doc = " \\returns the final offset in the data stream after the seek or -1 on error."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.10."] + #[doc = ""] + #[doc = " \\sa SDL_RWclose"] + #[doc = " \\sa SDL_RWFromConstMem"] + #[doc = " \\sa SDL_RWFromFile"] + #[doc = " \\sa SDL_RWFromFP"] + #[doc = " \\sa SDL_RWFromMem"] + #[doc = " \\sa SDL_RWread"] + #[doc = " \\sa SDL_RWtell"] + #[doc = " \\sa SDL_RWwrite"] pub fn SDL_RWseek(context: *mut SDL_RWops, offset: Sint64, whence: libc::c_int) -> Sint64; } extern "C" { - #[doc = " Return the current offset in the data stream, or -1 on error."] + #[doc = " Determine the current read/write offset in an SDL_RWops data stream."] + #[doc = ""] + #[doc = " SDL_RWtell is actually a wrapper function that calls the SDL_RWops's `seek`"] + #[doc = " method, with an offset of 0 bytes from `RW_SEEK_CUR`, to simplify"] + #[doc = " application development."] + #[doc = ""] + #[doc = " Prior to SDL 2.0.10, this function was a macro."] + #[doc = ""] + #[doc = " \\param context a SDL_RWops data stream object from which to get the current"] + #[doc = " offset"] + #[doc = " \\returns the current offset in the stream, or -1 if the information can not"] + #[doc = " be determined."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.10."] + #[doc = ""] + #[doc = " \\sa SDL_RWclose"] + #[doc = " \\sa SDL_RWFromConstMem"] + #[doc = " \\sa SDL_RWFromFile"] + #[doc = " \\sa SDL_RWFromFP"] + #[doc = " \\sa SDL_RWFromMem"] + #[doc = " \\sa SDL_RWread"] + #[doc = " \\sa SDL_RWseek"] + #[doc = " \\sa SDL_RWwrite"] pub fn SDL_RWtell(context: *mut SDL_RWops) -> Sint64; } extern "C" { - #[doc = " Read up to \\c maxnum objects each of size \\c size from the data"] - #[doc = " stream to the area pointed at by \\c ptr."] + #[doc = " Read from a data source."] #[doc = ""] - #[doc = " \\return the number of objects read, or 0 at error or end of file."] - pub fn SDL_RWread( - context: *mut SDL_RWops, - ptr: *mut libc::c_void, + #[doc = " This function reads up to `maxnum` objects each of size `size` from the"] + #[doc = " data source to the area pointed at by `ptr`. This function may read less"] + #[doc = " objects than requested. It will return zero when there has been an error or"] + #[doc = " the data stream is completely read."] + #[doc = ""] + #[doc = " SDL_RWread() is actually a function wrapper that calls the SDL_RWops's"] + #[doc = " `read` method appropriately, to simplify application development."] + #[doc = ""] + #[doc = " Prior to SDL 2.0.10, this function was a macro."] + #[doc = ""] + #[doc = " \\param context a pointer to an SDL_RWops structure"] + #[doc = " \\param ptr a pointer to a buffer to read data into"] + #[doc = " \\param size the size of each object to read, in bytes"] + #[doc = " \\param maxnum the maximum number of objects to be read"] + #[doc = " \\returns the number of objects read, or 0 at error or end of file; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.10."] + #[doc = ""] + #[doc = " \\sa SDL_RWclose"] + #[doc = " \\sa SDL_RWFromConstMem"] + #[doc = " \\sa SDL_RWFromFile"] + #[doc = " \\sa SDL_RWFromFP"] + #[doc = " \\sa SDL_RWFromMem"] + #[doc = " \\sa SDL_RWseek"] + #[doc = " \\sa SDL_RWwrite"] + pub fn SDL_RWread( + context: *mut SDL_RWops, + ptr: *mut libc::c_void, size: size_t, maxnum: size_t, ) -> size_t; } extern "C" { - #[doc = " Write exactly \\c num objects each of size \\c size from the area"] - #[doc = " pointed at by \\c ptr to data stream."] + #[doc = " Write to an SDL_RWops data stream."] #[doc = ""] - #[doc = " \\return the number of objects written, or 0 at error or end of file."] + #[doc = " This function writes exactly `num` objects each of size `size` from the"] + #[doc = " area pointed at by `ptr` to the stream. If this fails for any reason, it'll"] + #[doc = " return less than `num` to demonstrate how far the write progressed. On"] + #[doc = " success, it returns `num`."] + #[doc = ""] + #[doc = " SDL_RWwrite is actually a function wrapper that calls the SDL_RWops's"] + #[doc = " `write` method appropriately, to simplify application development."] + #[doc = ""] + #[doc = " Prior to SDL 2.0.10, this function was a macro."] + #[doc = ""] + #[doc = " \\param context a pointer to an SDL_RWops structure"] + #[doc = " \\param ptr a pointer to a buffer containing data to write"] + #[doc = " \\param size the size of an object to write, in bytes"] + #[doc = " \\param num the number of objects to write"] + #[doc = " \\returns the number of objects written, which will be less than **num** on"] + #[doc = " error; call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.10."] + #[doc = ""] + #[doc = " \\sa SDL_RWclose"] + #[doc = " \\sa SDL_RWFromConstMem"] + #[doc = " \\sa SDL_RWFromFile"] + #[doc = " \\sa SDL_RWFromFP"] + #[doc = " \\sa SDL_RWFromMem"] + #[doc = " \\sa SDL_RWread"] + #[doc = " \\sa SDL_RWseek"] pub fn SDL_RWwrite( context: *mut SDL_RWops, ptr: *const libc::c_void, @@ -2677,23 +3605,48 @@ extern "C" { ) -> size_t; } extern "C" { - #[doc = " Close and free an allocated SDL_RWops structure."] + #[doc = " Close and free an allocated SDL_RWops structure."] #[doc = ""] - #[doc = " \\return 0 if successful or -1 on write error when flushing data."] + #[doc = " SDL_RWclose() closes and cleans up the SDL_RWops stream. It releases any"] + #[doc = " resources used by the stream and frees the SDL_RWops itself with"] + #[doc = " SDL_FreeRW(). This returns 0 on success, or -1 if the stream failed to"] + #[doc = " flush to its output (e.g. to disk)."] + #[doc = ""] + #[doc = " Note that if this fails to flush the stream to disk, this function reports"] + #[doc = " an error, but the SDL_RWops is still invalid once this function returns."] + #[doc = ""] + #[doc = " Prior to SDL 2.0.10, this function was a macro."] + #[doc = ""] + #[doc = " \\param context SDL_RWops structure to close"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.10."] + #[doc = ""] + #[doc = " \\sa SDL_RWFromConstMem"] + #[doc = " \\sa SDL_RWFromFile"] + #[doc = " \\sa SDL_RWFromFP"] + #[doc = " \\sa SDL_RWFromMem"] + #[doc = " \\sa SDL_RWread"] + #[doc = " \\sa SDL_RWseek"] + #[doc = " \\sa SDL_RWwrite"] pub fn SDL_RWclose(context: *mut SDL_RWops) -> libc::c_int; } extern "C" { - #[doc = " Load all the data from an SDL data stream."] - #[doc = ""] - #[doc = " The data is allocated with a zero byte at the end (null terminated)"] + #[doc = " Load all the data from an SDL data stream."] #[doc = ""] - #[doc = " If \\c datasize is not NULL, it is filled with the size of the data read."] + #[doc = " The data is allocated with a zero byte at the end (null terminated) for"] + #[doc = " convenience. This extra byte is not included in the value reported via"] + #[doc = " `datasize`."] #[doc = ""] - #[doc = " If \\c freesrc is non-zero, the stream will be closed after being read."] + #[doc = " The data should be freed with SDL_free()."] #[doc = ""] - #[doc = " The data should be freed with SDL_free()."] + #[doc = " \\param src the SDL_RWops to read all available data from"] + #[doc = " \\param datasize if not NULL, will store the number of bytes read"] + #[doc = " \\param freesrc if non-zero, calls SDL_RWclose() on `src` before returning"] + #[doc = " \\returns the data, or NULL if there was an error."] #[doc = ""] - #[doc = " \\return the data, or NULL if there was an error."] + #[doc = " \\since This function is available since SDL 2.0.6."] pub fn SDL_LoadFile_RW( src: *mut SDL_RWops, datasize: *mut size_t, @@ -2701,59 +3654,236 @@ extern "C" { ) -> *mut libc::c_void; } extern "C" { - #[doc = " Load an entire file."] + #[doc = " Load all the data from a file path."] #[doc = ""] - #[doc = " The data is allocated with a zero byte at the end (null terminated)"] + #[doc = " The data is allocated with a zero byte at the end (null terminated) for"] + #[doc = " convenience. This extra byte is not included in the value reported via"] + #[doc = " `datasize`."] #[doc = ""] - #[doc = " If \\c datasize is not NULL, it is filled with the size of the data read."] + #[doc = " The data should be freed with SDL_free()."] #[doc = ""] - #[doc = " If \\c freesrc is non-zero, the stream will be closed after being read."] + #[doc = " Prior to SDL 2.0.10, this function was a macro wrapping around"] + #[doc = " SDL_LoadFile_RW."] #[doc = ""] - #[doc = " The data should be freed with SDL_free()."] + #[doc = " \\param file the path to read all available data from"] + #[doc = " \\param datasize if not NULL, will store the number of bytes read"] + #[doc = " \\returns the data, or NULL if there was an error."] #[doc = ""] - #[doc = " \\return the data, or NULL if there was an error."] + #[doc = " \\since This function is available since SDL 2.0.10."] pub fn SDL_LoadFile(file: *const libc::c_char, datasize: *mut size_t) -> *mut libc::c_void; } extern "C" { + #[doc = " Use this function to read a byte from an SDL_RWops."] + #[doc = ""] + #[doc = " \\param src the SDL_RWops to read from"] + #[doc = " \\returns the read byte on success or 0 on failure; call SDL_GetError() for"] + #[doc = " more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_WriteU8"] pub fn SDL_ReadU8(src: *mut SDL_RWops) -> Uint8; } extern "C" { + #[doc = " Use this function to read 16 bits of little-endian data from an SDL_RWops"] + #[doc = " and return in native format."] + #[doc = ""] + #[doc = " SDL byteswaps the data only if necessary, so the data returned will be in"] + #[doc = " the native byte order."] + #[doc = ""] + #[doc = " \\param src the stream from which to read data"] + #[doc = " \\returns 16 bits of data in the native byte order of the platform."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_ReadBE16"] pub fn SDL_ReadLE16(src: *mut SDL_RWops) -> Uint16; } extern "C" { + #[doc = " Use this function to read 16 bits of big-endian data from an SDL_RWops and"] + #[doc = " return in native format."] + #[doc = ""] + #[doc = " SDL byteswaps the data only if necessary, so the data returned will be in"] + #[doc = " the native byte order."] + #[doc = ""] + #[doc = " \\param src the stream from which to read data"] + #[doc = " \\returns 16 bits of data in the native byte order of the platform."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_ReadLE16"] pub fn SDL_ReadBE16(src: *mut SDL_RWops) -> Uint16; } extern "C" { + #[doc = " Use this function to read 32 bits of little-endian data from an SDL_RWops"] + #[doc = " and return in native format."] + #[doc = ""] + #[doc = " SDL byteswaps the data only if necessary, so the data returned will be in"] + #[doc = " the native byte order."] + #[doc = ""] + #[doc = " \\param src the stream from which to read data"] + #[doc = " \\returns 32 bits of data in the native byte order of the platform."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_ReadBE32"] pub fn SDL_ReadLE32(src: *mut SDL_RWops) -> Uint32; } extern "C" { + #[doc = " Use this function to read 32 bits of big-endian data from an SDL_RWops and"] + #[doc = " return in native format."] + #[doc = ""] + #[doc = " SDL byteswaps the data only if necessary, so the data returned will be in"] + #[doc = " the native byte order."] + #[doc = ""] + #[doc = " \\param src the stream from which to read data"] + #[doc = " \\returns 32 bits of data in the native byte order of the platform."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_ReadLE32"] pub fn SDL_ReadBE32(src: *mut SDL_RWops) -> Uint32; } extern "C" { + #[doc = " Use this function to read 64 bits of little-endian data from an SDL_RWops"] + #[doc = " and return in native format."] + #[doc = ""] + #[doc = " SDL byteswaps the data only if necessary, so the data returned will be in"] + #[doc = " the native byte order."] + #[doc = ""] + #[doc = " \\param src the stream from which to read data"] + #[doc = " \\returns 64 bits of data in the native byte order of the platform."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_ReadBE64"] pub fn SDL_ReadLE64(src: *mut SDL_RWops) -> Uint64; } extern "C" { + #[doc = " Use this function to read 64 bits of big-endian data from an SDL_RWops and"] + #[doc = " return in native format."] + #[doc = ""] + #[doc = " SDL byteswaps the data only if necessary, so the data returned will be in"] + #[doc = " the native byte order."] + #[doc = ""] + #[doc = " \\param src the stream from which to read data"] + #[doc = " \\returns 64 bits of data in the native byte order of the platform."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_ReadLE64"] pub fn SDL_ReadBE64(src: *mut SDL_RWops) -> Uint64; } extern "C" { + #[doc = " Use this function to write a byte to an SDL_RWops."] + #[doc = ""] + #[doc = " \\param dst the SDL_RWops to write to"] + #[doc = " \\param value the byte value to write"] + #[doc = " \\returns 1 on success or 0 on failure; call SDL_GetError() for more"] + #[doc = " information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_ReadU8"] pub fn SDL_WriteU8(dst: *mut SDL_RWops, value: Uint8) -> size_t; } extern "C" { + #[doc = " Use this function to write 16 bits in native format to a SDL_RWops as"] + #[doc = " little-endian data."] + #[doc = ""] + #[doc = " SDL byteswaps the data only if necessary, so the application always"] + #[doc = " specifies native format, and the data written will be in little-endian"] + #[doc = " format."] + #[doc = ""] + #[doc = " \\param dst the stream to which data will be written"] + #[doc = " \\param value the data to be written, in native format"] + #[doc = " \\returns 1 on successful write, 0 on error."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_WriteBE16"] pub fn SDL_WriteLE16(dst: *mut SDL_RWops, value: Uint16) -> size_t; } extern "C" { + #[doc = " Use this function to write 16 bits in native format to a SDL_RWops as"] + #[doc = " big-endian data."] + #[doc = ""] + #[doc = " SDL byteswaps the data only if necessary, so the application always"] + #[doc = " specifies native format, and the data written will be in big-endian format."] + #[doc = ""] + #[doc = " \\param dst the stream to which data will be written"] + #[doc = " \\param value the data to be written, in native format"] + #[doc = " \\returns 1 on successful write, 0 on error."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_WriteLE16"] pub fn SDL_WriteBE16(dst: *mut SDL_RWops, value: Uint16) -> size_t; } extern "C" { + #[doc = " Use this function to write 32 bits in native format to a SDL_RWops as"] + #[doc = " little-endian data."] + #[doc = ""] + #[doc = " SDL byteswaps the data only if necessary, so the application always"] + #[doc = " specifies native format, and the data written will be in little-endian"] + #[doc = " format."] + #[doc = ""] + #[doc = " \\param dst the stream to which data will be written"] + #[doc = " \\param value the data to be written, in native format"] + #[doc = " \\returns 1 on successful write, 0 on error."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_WriteBE32"] pub fn SDL_WriteLE32(dst: *mut SDL_RWops, value: Uint32) -> size_t; } extern "C" { + #[doc = " Use this function to write 32 bits in native format to a SDL_RWops as"] + #[doc = " big-endian data."] + #[doc = ""] + #[doc = " SDL byteswaps the data only if necessary, so the application always"] + #[doc = " specifies native format, and the data written will be in big-endian format."] + #[doc = ""] + #[doc = " \\param dst the stream to which data will be written"] + #[doc = " \\param value the data to be written, in native format"] + #[doc = " \\returns 1 on successful write, 0 on error."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_WriteLE32"] pub fn SDL_WriteBE32(dst: *mut SDL_RWops, value: Uint32) -> size_t; } extern "C" { + #[doc = " Use this function to write 64 bits in native format to a SDL_RWops as"] + #[doc = " little-endian data."] + #[doc = ""] + #[doc = " SDL byteswaps the data only if necessary, so the application always"] + #[doc = " specifies native format, and the data written will be in little-endian"] + #[doc = " format."] + #[doc = ""] + #[doc = " \\param dst the stream to which data will be written"] + #[doc = " \\param value the data to be written, in native format"] + #[doc = " \\returns 1 on successful write, 0 on error."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_WriteBE64"] pub fn SDL_WriteLE64(dst: *mut SDL_RWops, value: Uint64) -> size_t; } extern "C" { + #[doc = " Use this function to write 64 bits in native format to a SDL_RWops as"] + #[doc = " big-endian data."] + #[doc = ""] + #[doc = " SDL byteswaps the data only if necessary, so the application always"] + #[doc = " specifies native format, and the data written will be in big-endian format."] + #[doc = ""] + #[doc = " \\param dst the stream to which data will be written"] + #[doc = " \\param value the data to be written, in native format"] + #[doc = " \\returns 1 on successful write, 0 on error."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_WriteLE64"] pub fn SDL_WriteBE64(dst: *mut SDL_RWops, value: Uint64) -> size_t; } #[doc = " \\brief Audio format flags."] @@ -3077,66 +4207,138 @@ fn bindgen_test_layout_SDL_AudioCVT() { ); } extern "C" { + #[doc = " Use this function to get the number of built-in audio drivers."] + #[doc = ""] + #[doc = " This function returns a hardcoded number. This never returns a negative"] + #[doc = " value; if there are no drivers compiled into this build of SDL, this"] + #[doc = " function returns zero. The presence of a driver in this list does not mean"] + #[doc = " it will function, it just means SDL is capable of interacting with that"] + #[doc = " interface. For example, a build of SDL might have esound support, but if"] + #[doc = " there's no esound server available, SDL's esound driver would fail if used."] + #[doc = ""] + #[doc = " By default, SDL tries all drivers, in its preferred order, until one is"] + #[doc = " found to be usable."] + #[doc = ""] + #[doc = " \\returns the number of built-in audio drivers."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetAudioDriver"] pub fn SDL_GetNumAudioDrivers() -> libc::c_int; } extern "C" { + #[doc = " Use this function to get the name of a built in audio driver."] + #[doc = ""] + #[doc = " The list of audio drivers is given in the order that they are normally"] + #[doc = " initialized by default; the drivers that seem more reasonable to choose"] + #[doc = " first (as far as the SDL developers believe) are earlier in the list."] + #[doc = ""] + #[doc = " The names of drivers are all simple, low-ASCII identifiers, like \"alsa\","] + #[doc = " \"coreaudio\" or \"xaudio2\". These never have Unicode characters, and are not"] + #[doc = " meant to be proper names."] + #[doc = ""] + #[doc = " \\param index the index of the audio driver; the value ranges from 0 to"] + #[doc = " SDL_GetNumAudioDrivers() - 1"] + #[doc = " \\returns the name of the audio driver at the requested index, or NULL if an"] + #[doc = " invalid index was specified."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetNumAudioDrivers"] pub fn SDL_GetAudioDriver(index: libc::c_int) -> *const libc::c_char; } extern "C" { + #[doc = " Use this function to initialize a particular audio driver."] + #[doc = ""] + #[doc = " This function is used internally, and should not be used unless you have a"] + #[doc = " specific need to designate the audio driver you want to use. You should"] + #[doc = " normally use SDL_Init() or SDL_InitSubSystem()."] + #[doc = ""] + #[doc = " \\param driver_name the name of the desired audio driver"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_AudioQuit"] pub fn SDL_AudioInit(driver_name: *const libc::c_char) -> libc::c_int; } extern "C" { + #[doc = " Use this function to shut down audio if you initialized it with"] + #[doc = " SDL_AudioInit()."] + #[doc = ""] + #[doc = " This function is used internally, and should not be used unless you have a"] + #[doc = " specific need to specify the audio driver you want to use. You should"] + #[doc = " normally use SDL_Quit() or SDL_QuitSubSystem()."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_AudioInit"] pub fn SDL_AudioQuit(); } extern "C" { - #[doc = " This function returns the name of the current audio driver, or NULL"] - #[doc = " if no driver has been initialized."] + #[doc = " Get the name of the current audio driver."] + #[doc = ""] + #[doc = " The returned string points to internal static memory and thus never becomes"] + #[doc = " invalid, even if you quit the audio subsystem and initialize a new driver"] + #[doc = " (although such a case would return a different static string from another"] + #[doc = " call to this function, of course). As such, you should not modify or free"] + #[doc = " the returned string."] + #[doc = ""] + #[doc = " \\returns the name of the current audio driver or NULL if no driver has been"] + #[doc = " initialized."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_AudioInit"] pub fn SDL_GetCurrentAudioDriver() -> *const libc::c_char; } extern "C" { - #[doc = " This function opens the audio device with the desired parameters, and"] - #[doc = " returns 0 if successful, placing the actual hardware parameters in the"] - #[doc = " structure pointed to by \\c obtained. If \\c obtained is NULL, the audio"] - #[doc = " data passed to the callback function will be guaranteed to be in the"] - #[doc = " requested format, and will be automatically converted to the hardware"] - #[doc = " audio format if necessary. This function returns -1 if it failed"] - #[doc = " to open the audio device, or couldn't set up the audio thread."] - #[doc = ""] - #[doc = " When filling in the desired audio spec structure,"] - #[doc = " - \\c desired->freq should be the desired audio frequency in samples-per-"] - #[doc = " second."] - #[doc = " - \\c desired->format should be the desired audio format."] - #[doc = " - \\c desired->samples is the desired size of the audio buffer, in"] - #[doc = " samples. This number should be a power of two, and may be adjusted by"] - #[doc = " the audio driver to a value more suitable for the hardware. Good values"] - #[doc = " seem to range between 512 and 8096 inclusive, depending on the"] - #[doc = " application and CPU speed. Smaller values yield faster response time,"] - #[doc = " but can lead to underflow if the application is doing heavy processing"] - #[doc = " and cannot fill the audio buffer in time. A stereo sample consists of"] - #[doc = " both right and left channels in LR ordering."] - #[doc = " Note that the number of samples is directly related to time by the"] - #[doc = " following formula: \\code ms = (samples*1000)/freq \\endcode"] - #[doc = " - \\c desired->size is the size in bytes of the audio buffer, and is"] - #[doc = " calculated by SDL_OpenAudio()."] - #[doc = " - \\c desired->silence is the value used to set the buffer to silence,"] - #[doc = " and is calculated by SDL_OpenAudio()."] - #[doc = " - \\c desired->callback should be set to a function that will be called"] - #[doc = " when the audio device is ready for more data. It is passed a pointer"] - #[doc = " to the audio buffer, and the length in bytes of the audio buffer."] - #[doc = " This function usually runs in a separate thread, and so you should"] - #[doc = " protect data structures that it accesses by calling SDL_LockAudio()"] - #[doc = " and SDL_UnlockAudio() in your code. Alternately, you may pass a NULL"] - #[doc = " pointer here, and call SDL_QueueAudio() with some frequency, to queue"] - #[doc = " more audio samples to be played (or for capture devices, call"] - #[doc = " SDL_DequeueAudio() with some frequency, to obtain audio samples)."] - #[doc = " - \\c desired->userdata is passed as the first parameter to your callback"] - #[doc = " function. If you passed a NULL callback, this value is ignored."] - #[doc = ""] - #[doc = " The audio device starts out playing silence when it's opened, and should"] - #[doc = " be enabled for playing by calling \\c SDL_PauseAudio(0) when you are ready"] - #[doc = " for your audio callback function to be called. Since the audio driver"] - #[doc = " may modify the requested size of the audio buffer, you should allocate"] - #[doc = " any local mixing buffers after you open the audio device."] + #[doc = " This function is a legacy means of opening the audio device."] + #[doc = ""] + #[doc = " This function remains for compatibility with SDL 1.2, but also because it's"] + #[doc = " slightly easier to use than the new functions in SDL 2.0. The new, more"] + #[doc = " powerful, and preferred way to do this is SDL_OpenAudioDevice()."] + #[doc = ""] + #[doc = " This function is roughly equivalent to:"] + #[doc = ""] + #[doc = " ```c"] + #[doc = " SDL_OpenAudioDevice(NULL, 0, desired, obtained, SDL_AUDIO_ALLOW_ANY_CHANGE);"] + #[doc = " ```"] + #[doc = ""] + #[doc = " With two notable exceptions:"] + #[doc = ""] + #[doc = " - If `obtained` is NULL, we use `desired` (and allow no changes), which"] + #[doc = " means desired will be modified to have the correct values for silence,"] + #[doc = " etc, and SDL will convert any differences between your app's specific"] + #[doc = " request and the hardware behind the scenes."] + #[doc = " - The return value is always success or failure, and not a device ID, which"] + #[doc = " means you can only have one device open at a time with this function."] + #[doc = ""] + #[doc = " \\param desired an SDL_AudioSpec structure representing the desired output"] + #[doc = " format. Please refer to the SDL_OpenAudioDevice"] + #[doc = " documentation for details on how to prepare this structure."] + #[doc = " \\param obtained an SDL_AudioSpec structure filled in with the actual"] + #[doc = " parameters, or NULL."] + #[doc = " \\returns 0 if successful, placing the actual hardware parameters in the"] + #[doc = " structure pointed to by `obtained`."] + #[doc = ""] + #[doc = " If `obtained` is NULL, the audio data passed to the callback"] + #[doc = " function will be guaranteed to be in the requested format, and"] + #[doc = " will be automatically converted to the actual hardware audio"] + #[doc = " format if necessary. If `obtained` is NULL, `desired` will have"] + #[doc = " fields modified."] + #[doc = ""] + #[doc = " This function returns a negative error code on failure to open the"] + #[doc = " audio device or failure to set up the audio thread; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CloseAudio"] + #[doc = " \\sa SDL_LockAudio"] + #[doc = " \\sa SDL_PauseAudio"] + #[doc = " \\sa SDL_UnlockAudio"] pub fn SDL_OpenAudio(desired: *mut SDL_AudioSpec, obtained: *mut SDL_AudioSpec) -> libc::c_int; } #[doc = " SDL Audio Device IDs."] @@ -3148,47 +4350,216 @@ extern "C" { #[doc = " specific, or capture devices."] pub type SDL_AudioDeviceID = Uint32; extern "C" { - #[doc = " Get the number of available devices exposed by the current driver."] - #[doc = " Only valid after a successfully initializing the audio subsystem."] - #[doc = " Returns -1 if an explicit list of devices can't be determined; this is"] - #[doc = " not an error. For example, if SDL is set up to talk to a remote audio"] - #[doc = " server, it can't list every one available on the Internet, but it will"] - #[doc = " still allow a specific host to be specified to SDL_OpenAudioDevice()."] + #[doc = " Get the number of built-in audio devices."] + #[doc = ""] + #[doc = " This function is only valid after successfully initializing the audio"] + #[doc = " subsystem."] + #[doc = ""] + #[doc = " Note that audio capture support is not implemented as of SDL 2.0.4, so the"] + #[doc = " `iscapture` parameter is for future expansion and should always be zero for"] + #[doc = " now."] + #[doc = ""] + #[doc = " This function will return -1 if an explicit list of devices can't be"] + #[doc = " determined. Returning -1 is not an error. For example, if SDL is set up to"] + #[doc = " talk to a remote audio server, it can't list every one available on the"] + #[doc = " Internet, but it will still allow a specific host to be specified in"] + #[doc = " SDL_OpenAudioDevice()."] #[doc = ""] - #[doc = " In many common cases, when this function returns a value <= 0, it can still"] - #[doc = " successfully open the default device (NULL for first argument of"] - #[doc = " SDL_OpenAudioDevice())."] + #[doc = " In many common cases, when this function returns a value <= 0, it can still"] + #[doc = " successfully open the default device (NULL for first argument of"] + #[doc = " SDL_OpenAudioDevice())."] + #[doc = ""] + #[doc = " This function may trigger a complete redetect of available hardware. It"] + #[doc = " should not be called for each iteration of a loop, but rather once at the"] + #[doc = " start of a loop:"] + #[doc = ""] + #[doc = " ```c"] + #[doc = " // Don't do this:"] + #[doc = " for (int i = 0; i < SDL_GetNumAudioDevices(0); i++)"] + #[doc = ""] + #[doc = " // do this instead:"] + #[doc = " const int count = SDL_GetNumAudioDevices(0);"] + #[doc = " for (int i = 0; i < count; ++i) { do_something_here(); }"] + #[doc = " ```"] + #[doc = ""] + #[doc = " \\param iscapture zero to request playback devices, non-zero to request"] + #[doc = " recording devices"] + #[doc = " \\returns the number of available devices exposed by the current driver or"] + #[doc = " -1 if an explicit list of devices can't be determined. A return"] + #[doc = " value of -1 does not necessarily mean an error condition."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetAudioDeviceName"] + #[doc = " \\sa SDL_OpenAudioDevice"] pub fn SDL_GetNumAudioDevices(iscapture: libc::c_int) -> libc::c_int; } extern "C" { - #[doc = " Get the human-readable name of a specific audio device."] - #[doc = " Must be a value between 0 and (number of audio devices-1)."] - #[doc = " Only valid after a successfully initializing the audio subsystem."] - #[doc = " The values returned by this function reflect the latest call to"] - #[doc = " SDL_GetNumAudioDevices(); recall that function to redetect available"] - #[doc = " hardware."] + #[doc = " Get the human-readable name of a specific audio device."] + #[doc = ""] + #[doc = " This function is only valid after successfully initializing the audio"] + #[doc = " subsystem. The values returned by this function reflect the latest call to"] + #[doc = " SDL_GetNumAudioDevices(); re-call that function to redetect available"] + #[doc = " hardware."] + #[doc = ""] + #[doc = " The string returned by this function is UTF-8 encoded, read-only, and"] + #[doc = " managed internally. You are not to free it. If you need to keep the string"] + #[doc = " for any length of time, you should make your own copy of it, as it will be"] + #[doc = " invalid next time any of several other SDL functions are called."] #[doc = ""] - #[doc = " The string returned by this function is UTF-8 encoded, read-only, and"] - #[doc = " managed internally. You are not to free it. If you need to keep the"] - #[doc = " string for any length of time, you should make your own copy of it, as it"] - #[doc = " will be invalid next time any of several other SDL functions is called."] + #[doc = " \\param index the index of the audio device; valid values range from 0 to"] + #[doc = " SDL_GetNumAudioDevices() - 1"] + #[doc = " \\param iscapture non-zero to query the list of recording devices, zero to"] + #[doc = " query the list of output devices."] + #[doc = " \\returns the name of the audio device at the requested index, or NULL on"] + #[doc = " error."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetNumAudioDevices"] pub fn SDL_GetAudioDeviceName( index: libc::c_int, iscapture: libc::c_int, ) -> *const libc::c_char; } extern "C" { - #[doc = " Open a specific audio device. Passing in a device name of NULL requests"] - #[doc = " the most reasonable default (and is equivalent to calling SDL_OpenAudio())."] + #[doc = " Get the preferred audio format of a specific audio device."] + #[doc = ""] + #[doc = " This function is only valid after a successfully initializing the audio"] + #[doc = " subsystem. The values returned by this function reflect the latest call to"] + #[doc = " SDL_GetNumAudioDevices(); re-call that function to redetect available"] + #[doc = " hardware."] + #[doc = ""] + #[doc = " `spec` will be filled with the sample rate, sample format, and channel"] + #[doc = " count. All other values in the structure are filled with 0. When the"] + #[doc = " supported struct members are 0, SDL was unable to get the property from the"] + #[doc = " backend."] #[doc = ""] - #[doc = " The device name is a UTF-8 string reported by SDL_GetAudioDeviceName(), but"] - #[doc = " some drivers allow arbitrary and driver-specific strings, such as a"] - #[doc = " hostname/IP address for a remote audio server, or a filename in the"] - #[doc = " diskaudio driver."] + #[doc = " \\param index the index of the audio device; valid values range from 0 to"] + #[doc = " SDL_GetNumAudioDevices() - 1"] + #[doc = " \\param iscapture non-zero to query the list of recording devices, zero to"] + #[doc = " query the list of output devices."] + #[doc = " \\param spec The SDL_AudioSpec to be initialized by this function."] + #[doc = " \\returns 0 on success, nonzero on error"] #[doc = ""] - #[doc = " \\return 0 on error, a valid device ID that is >= 2 on success."] + #[doc = " \\since This function is available since SDL 2.0.16."] #[doc = ""] - #[doc = " SDL_OpenAudio(), unlike this function, always acts on device ID 1."] + #[doc = " \\sa SDL_GetNumAudioDevices"] + pub fn SDL_GetAudioDeviceSpec( + index: libc::c_int, + iscapture: libc::c_int, + spec: *mut SDL_AudioSpec, + ) -> libc::c_int; +} +extern "C" { + #[doc = " Open a specific audio device."] + #[doc = ""] + #[doc = " SDL_OpenAudio(), unlike this function, always acts on device ID 1. As such,"] + #[doc = " this function will never return a 1 so as not to conflict with the legacy"] + #[doc = " function."] + #[doc = ""] + #[doc = " Please note that SDL 2.0 before 2.0.5 did not support recording; as such,"] + #[doc = " this function would fail if `iscapture` was not zero. Starting with SDL"] + #[doc = " 2.0.5, recording is implemented and this value can be non-zero."] + #[doc = ""] + #[doc = " Passing in a `device` name of NULL requests the most reasonable default"] + #[doc = " (and is equivalent to what SDL_OpenAudio() does to choose a device). The"] + #[doc = " `device` name is a UTF-8 string reported by SDL_GetAudioDeviceName(), but"] + #[doc = " some drivers allow arbitrary and driver-specific strings, such as a"] + #[doc = " hostname/IP address for a remote audio server, or a filename in the"] + #[doc = " diskaudio driver."] + #[doc = ""] + #[doc = " An opened audio device starts out paused, and should be enabled for playing"] + #[doc = " by calling SDL_PauseAudioDevice(devid, 0) when you are ready for your audio"] + #[doc = " callback function to be called. Since the audio driver may modify the"] + #[doc = " requested size of the audio buffer, you should allocate any local mixing"] + #[doc = " buffers after you open the audio device."] + #[doc = ""] + #[doc = " The audio callback runs in a separate thread in most cases; you can prevent"] + #[doc = " race conditions between your callback and other threads without fully"] + #[doc = " pausing playback with SDL_LockAudioDevice(). For more information about the"] + #[doc = " callback, see SDL_AudioSpec."] + #[doc = ""] + #[doc = " Managing the audio spec via 'desired' and 'obtained':"] + #[doc = ""] + #[doc = " When filling in the desired audio spec structure:"] + #[doc = ""] + #[doc = " - `desired->freq` should be the frequency in sample-frames-per-second (Hz)."] + #[doc = " - `desired->format` should be the audio format (`AUDIO_S16SYS`, etc)."] + #[doc = " - `desired->samples` is the desired size of the audio buffer, in _sample"] + #[doc = " frames_ (with stereo output, two samples--left and right--would make a"] + #[doc = " single sample frame). This number should be a power of two, and may be"] + #[doc = " adjusted by the audio driver to a value more suitable for the hardware."] + #[doc = " Good values seem to range between 512 and 8096 inclusive, depending on"] + #[doc = " the application and CPU speed. Smaller values reduce latency, but can"] + #[doc = " lead to underflow if the application is doing heavy processing and cannot"] + #[doc = " fill the audio buffer in time. Note that the number of sample frames is"] + #[doc = " directly related to time by the following formula: `ms ="] + #[doc = " (sampleframes*1000)/freq`"] + #[doc = " - `desired->size` is the size in _bytes_ of the audio buffer, and is"] + #[doc = " calculated by SDL_OpenAudioDevice(). You don't initialize this."] + #[doc = " - `desired->silence` is the value used to set the buffer to silence, and is"] + #[doc = " calculated by SDL_OpenAudioDevice(). You don't initialize this."] + #[doc = " - `desired->callback` should be set to a function that will be called when"] + #[doc = " the audio device is ready for more data. It is passed a pointer to the"] + #[doc = " audio buffer, and the length in bytes of the audio buffer. This function"] + #[doc = " usually runs in a separate thread, and so you should protect data"] + #[doc = " structures that it accesses by calling SDL_LockAudioDevice() and"] + #[doc = " SDL_UnlockAudioDevice() in your code. Alternately, you may pass a NULL"] + #[doc = " pointer here, and call SDL_QueueAudio() with some frequency, to queue"] + #[doc = " more audio samples to be played (or for capture devices, call"] + #[doc = " SDL_DequeueAudio() with some frequency, to obtain audio samples)."] + #[doc = " - `desired->userdata` is passed as the first parameter to your callback"] + #[doc = " function. If you passed a NULL callback, this value is ignored."] + #[doc = ""] + #[doc = " `allowed_changes` can have the following flags OR'd together:"] + #[doc = ""] + #[doc = " - `SDL_AUDIO_ALLOW_FREQUENCY_CHANGE`"] + #[doc = " - `SDL_AUDIO_ALLOW_FORMAT_CHANGE`"] + #[doc = " - `SDL_AUDIO_ALLOW_CHANNELS_CHANGE`"] + #[doc = " - `SDL_AUDIO_ALLOW_ANY_CHANGE`"] + #[doc = ""] + #[doc = " These flags specify how SDL should behave when a device cannot offer a"] + #[doc = " specific feature. If the application requests a feature that the hardware"] + #[doc = " doesn't offer, SDL will always try to get the closest equivalent."] + #[doc = ""] + #[doc = " For example, if you ask for float32 audio format, but the sound card only"] + #[doc = " supports int16, SDL will set the hardware to int16. If you had set"] + #[doc = " SDL_AUDIO_ALLOW_FORMAT_CHANGE, SDL will change the format in the `obtained`"] + #[doc = " structure. If that flag was *not* set, SDL will prepare to convert your"] + #[doc = " callback's float32 audio to int16 before feeding it to the hardware and"] + #[doc = " will keep the originally requested format in the `obtained` structure."] + #[doc = ""] + #[doc = " The resulting audio specs, varying depending on hardware and on what"] + #[doc = " changes were allowed, will then be written back to `obtained`."] + #[doc = ""] + #[doc = " If your application can only handle one specific data format, pass a zero"] + #[doc = " for `allowed_changes` and let SDL transparently handle any differences."] + #[doc = ""] + #[doc = " \\param device a UTF-8 string reported by SDL_GetAudioDeviceName() or a"] + #[doc = " driver-specific name as appropriate. NULL requests the most"] + #[doc = " reasonable default device."] + #[doc = " \\param iscapture non-zero to specify a device should be opened for"] + #[doc = " recording, not playback"] + #[doc = " \\param desired an SDL_AudioSpec structure representing the desired output"] + #[doc = " format; see SDL_OpenAudio() for more information"] + #[doc = " \\param obtained an SDL_AudioSpec structure filled in with the actual output"] + #[doc = " format; see SDL_OpenAudio() for more information"] + #[doc = " \\param allowed_changes 0, or one or more flags OR'd together"] + #[doc = " \\returns a valid device ID that is > 0 on success or 0 on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " For compatibility with SDL 1.2, this will never return 1, since"] + #[doc = " SDL reserves that ID for the legacy SDL_OpenAudio() function."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CloseAudioDevice"] + #[doc = " \\sa SDL_GetAudioDeviceName"] + #[doc = " \\sa SDL_LockAudioDevice"] + #[doc = " \\sa SDL_OpenAudio"] + #[doc = " \\sa SDL_PauseAudioDevice"] + #[doc = " \\sa SDL_UnlockAudioDevice"] pub fn SDL_OpenAudioDevice( device: *const libc::c_char, iscapture: libc::c_int, @@ -3205,68 +4576,165 @@ pub enum SDL_AudioStatus { SDL_AUDIO_PAUSED = 2, } extern "C" { + #[doc = " This function is a legacy means of querying the audio device."] + #[doc = ""] + #[doc = " New programs might want to use SDL_GetAudioDeviceStatus() instead. This"] + #[doc = " function is equivalent to calling..."] + #[doc = ""] + #[doc = " ```c"] + #[doc = " SDL_GetAudioDeviceStatus(1);"] + #[doc = " ```"] + #[doc = ""] + #[doc = " ...and is only useful if you used the legacy SDL_OpenAudio() function."] + #[doc = ""] + #[doc = " \\returns the SDL_AudioStatus of the audio device opened by SDL_OpenAudio()."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetAudioDeviceStatus"] pub fn SDL_GetAudioStatus() -> SDL_AudioStatus; } extern "C" { + #[doc = " Use this function to get the current audio state of an audio device."] + #[doc = ""] + #[doc = " \\param dev the ID of an audio device previously opened with"] + #[doc = " SDL_OpenAudioDevice()"] + #[doc = " \\returns the SDL_AudioStatus of the specified audio device."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_PauseAudioDevice"] pub fn SDL_GetAudioDeviceStatus(dev: SDL_AudioDeviceID) -> SDL_AudioStatus; } extern "C" { + #[doc = " This function is a legacy means of pausing the audio device."] + #[doc = ""] + #[doc = " New programs might want to use SDL_PauseAudioDevice() instead. This"] + #[doc = " function is equivalent to calling..."] + #[doc = ""] + #[doc = " ```c"] + #[doc = " SDL_PauseAudioDevice(1, pause_on);"] + #[doc = " ```"] + #[doc = ""] + #[doc = " ...and is only useful if you used the legacy SDL_OpenAudio() function."] + #[doc = ""] + #[doc = " \\param pause_on non-zero to pause, 0 to unpause"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetAudioStatus"] + #[doc = " \\sa SDL_PauseAudioDevice"] pub fn SDL_PauseAudio(pause_on: libc::c_int); } extern "C" { + #[doc = " Use this function to pause and unpause audio playback on a specified"] + #[doc = " device."] + #[doc = ""] + #[doc = " This function pauses and unpauses the audio callback processing for a given"] + #[doc = " device. Newly-opened audio devices start in the paused state, so you must"] + #[doc = " call this function with **pause_on**=0 after opening the specified audio"] + #[doc = " device to start playing sound. This allows you to safely initialize data"] + #[doc = " for your callback function after opening the audio device. Silence will be"] + #[doc = " written to the audio device while paused, and the audio callback is"] + #[doc = " guaranteed to not be called. Pausing one device does not prevent other"] + #[doc = " unpaused devices from running their callbacks."] + #[doc = ""] + #[doc = " Pausing state does not stack; even if you pause a device several times, a"] + #[doc = " single unpause will start the device playing again, and vice versa. This is"] + #[doc = " different from how SDL_LockAudioDevice() works."] + #[doc = ""] + #[doc = " If you just need to protect a few variables from race conditions vs your"] + #[doc = " callback, you shouldn't pause the audio device, as it will lead to dropouts"] + #[doc = " in the audio playback. Instead, you should use SDL_LockAudioDevice()."] + #[doc = ""] + #[doc = " \\param dev a device opened by SDL_OpenAudioDevice()"] + #[doc = " \\param pause_on non-zero to pause, 0 to unpause"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_LockAudioDevice"] pub fn SDL_PauseAudioDevice(dev: SDL_AudioDeviceID, pause_on: libc::c_int); } extern "C" { - #[doc = " \\brief Load the audio data of a WAVE file into memory"] - #[doc = ""] - #[doc = " Loading a WAVE file requires \\c src, \\c spec, \\c audio_buf and \\c audio_len"] - #[doc = " to be valid pointers. The entire data portion of the file is then loaded"] - #[doc = " into memory and decoded if necessary."] - #[doc = ""] - #[doc = " If \\c freesrc is non-zero, the data source gets automatically closed and"] - #[doc = " freed before the function returns."] - #[doc = ""] - #[doc = " Supported are RIFF WAVE files with the formats PCM (8, 16, 24, and 32 bits),"] - #[doc = " IEEE Float (32 bits), Microsoft ADPCM and IMA ADPCM (4 bits), and A-law and"] - #[doc = " µ-law (8 bits). Other formats are currently unsupported and cause an error."] - #[doc = ""] - #[doc = " If this function succeeds, the pointer returned by it is equal to \\c spec"] - #[doc = " and the pointer to the audio data allocated by the function is written to"] - #[doc = " \\c audio_buf and its length in bytes to \\c audio_len. The \\ref SDL_AudioSpec"] - #[doc = " members \\c freq, \\c channels, and \\c format are set to the values of the"] - #[doc = " audio data in the buffer. The \\c samples member is set to a sane default and"] - #[doc = " all others are set to zero."] - #[doc = ""] - #[doc = " It's necessary to use SDL_FreeWAV() to free the audio data returned in"] - #[doc = " \\c audio_buf when it is no longer used."] - #[doc = ""] - #[doc = " Because of the underspecification of the Waveform format, there are many"] - #[doc = " problematic files in the wild that cause issues with strict decoders. To"] - #[doc = " provide compatibility with these files, this decoder is lenient in regards"] - #[doc = " to the truncation of the file, the fact chunk, and the size of the RIFF"] - #[doc = " chunk. The hints SDL_HINT_WAVE_RIFF_CHUNK_SIZE, SDL_HINT_WAVE_TRUNCATION,"] - #[doc = " and SDL_HINT_WAVE_FACT_CHUNK can be used to tune the behavior of the"] - #[doc = " loading process."] - #[doc = ""] - #[doc = " Any file that is invalid (due to truncation, corruption, or wrong values in"] - #[doc = " the headers), too big, or unsupported causes an error. Additionally, any"] - #[doc = " critical I/O error from the data source will terminate the loading process"] - #[doc = " with an error. The function returns NULL on error and in all cases (with the"] - #[doc = " exception of \\c src being NULL), an appropriate error message will be set."] - #[doc = ""] - #[doc = " It is required that the data source supports seeking."] - #[doc = ""] - #[doc = " Example:"] - #[doc = " \\code"] - #[doc = " SDL_LoadWAV_RW(SDL_RWFromFile(\"sample.wav\", \"rb\"), 1, ...);"] - #[doc = " \\endcode"] - #[doc = ""] - #[doc = " \\param src The data source with the WAVE data"] - #[doc = " \\param freesrc A integer value that makes the function close the data source if non-zero"] - #[doc = " \\param spec A pointer filled with the audio format of the audio data"] - #[doc = " \\param audio_buf A pointer filled with the audio data allocated by the function"] - #[doc = " \\param audio_len A pointer filled with the length of the audio data buffer in bytes"] - #[doc = " \\return NULL on error, or non-NULL on success."] + #[doc = " Load the audio data of a WAVE file into memory."] + #[doc = ""] + #[doc = " Loading a WAVE file requires `src`, `spec`, `audio_buf` and `audio_len` to"] + #[doc = " be valid pointers. The entire data portion of the file is then loaded into"] + #[doc = " memory and decoded if necessary."] + #[doc = ""] + #[doc = " If `freesrc` is non-zero, the data source gets automatically closed and"] + #[doc = " freed before the function returns."] + #[doc = ""] + #[doc = " Supported formats are RIFF WAVE files with the formats PCM (8, 16, 24, and"] + #[doc = " 32 bits), IEEE Float (32 bits), Microsoft ADPCM and IMA ADPCM (4 bits), and"] + #[doc = " A-law and mu-law (8 bits). Other formats are currently unsupported and"] + #[doc = " cause an error."] + #[doc = ""] + #[doc = " If this function succeeds, the pointer returned by it is equal to `spec`"] + #[doc = " and the pointer to the audio data allocated by the function is written to"] + #[doc = " `audio_buf` and its length in bytes to `audio_len`. The SDL_AudioSpec"] + #[doc = " members `freq`, `channels`, and `format` are set to the values of the audio"] + #[doc = " data in the buffer. The `samples` member is set to a sane default and all"] + #[doc = " others are set to zero."] + #[doc = ""] + #[doc = " It's necessary to use SDL_FreeWAV() to free the audio data returned in"] + #[doc = " `audio_buf` when it is no longer used."] + #[doc = ""] + #[doc = " Because of the underspecification of the .WAV format, there are many"] + #[doc = " problematic files in the wild that cause issues with strict decoders. To"] + #[doc = " provide compatibility with these files, this decoder is lenient in regards"] + #[doc = " to the truncation of the file, the fact chunk, and the size of the RIFF"] + #[doc = " chunk. The hints `SDL_HINT_WAVE_RIFF_CHUNK_SIZE`,"] + #[doc = " `SDL_HINT_WAVE_TRUNCATION`, and `SDL_HINT_WAVE_FACT_CHUNK` can be used to"] + #[doc = " tune the behavior of the loading process."] + #[doc = ""] + #[doc = " Any file that is invalid (due to truncation, corruption, or wrong values in"] + #[doc = " the headers), too big, or unsupported causes an error. Additionally, any"] + #[doc = " critical I/O error from the data source will terminate the loading process"] + #[doc = " with an error. The function returns NULL on error and in all cases (with"] + #[doc = " the exception of `src` being NULL), an appropriate error message will be"] + #[doc = " set."] + #[doc = ""] + #[doc = " It is required that the data source supports seeking."] + #[doc = ""] + #[doc = " Example:"] + #[doc = ""] + #[doc = " ```c"] + #[doc = " SDL_LoadWAV_RW(SDL_RWFromFile(\"sample.wav\", \"rb\"), 1, &spec, &buf, &len);"] + #[doc = " ```"] + #[doc = ""] + #[doc = " Note that the SDL_LoadWAV macro does this same thing for you, but in a less"] + #[doc = " messy way:"] + #[doc = ""] + #[doc = " ```c"] + #[doc = " SDL_LoadWAV(\"sample.wav\", &spec, &buf, &len);"] + #[doc = " ```"] + #[doc = ""] + #[doc = " \\param src The data source for the WAVE data"] + #[doc = " \\param freesrc If non-zero, SDL will _always_ free the data source"] + #[doc = " \\param spec An SDL_AudioSpec that will be filled in with the wave file's"] + #[doc = " format details"] + #[doc = " \\param audio_buf A pointer filled with the audio data, allocated by the"] + #[doc = " function."] + #[doc = " \\param audio_len A pointer filled with the length of the audio data buffer"] + #[doc = " in bytes"] + #[doc = " \\returns This function, if successfully called, returns `spec`, which will"] + #[doc = " be filled with the audio data format of the wave source data."] + #[doc = " `audio_buf` will be filled with a pointer to an allocated buffer"] + #[doc = " containing the audio data, and `audio_len` is filled with the"] + #[doc = " length of that audio buffer in bytes."] + #[doc = ""] + #[doc = " This function returns NULL if the .WAV file cannot be opened, uses"] + #[doc = " an unknown data format, or is corrupt; call SDL_GetError() for"] + #[doc = " more information."] + #[doc = ""] + #[doc = " When the application is done with the data returned in"] + #[doc = " `audio_buf`, it should call SDL_FreeWAV() to dispose of it."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_FreeWAV"] + #[doc = " \\sa SDL_LoadWAV"] pub fn SDL_LoadWAV_RW( src: *mut SDL_RWops, freesrc: libc::c_int, @@ -3276,17 +4744,52 @@ extern "C" { ) -> *mut SDL_AudioSpec; } extern "C" { - #[doc = " This function frees data previously allocated with SDL_LoadWAV_RW()"] + #[doc = " Free data previously allocated with SDL_LoadWAV() or SDL_LoadWAV_RW()."] + #[doc = ""] + #[doc = " After a WAVE file has been opened with SDL_LoadWAV() or SDL_LoadWAV_RW()"] + #[doc = " its data can eventually be freed with SDL_FreeWAV(). It is safe to call"] + #[doc = " this function with a NULL pointer."] + #[doc = ""] + #[doc = " \\param audio_buf a pointer to the buffer created by SDL_LoadWAV() or"] + #[doc = " SDL_LoadWAV_RW()"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_LoadWAV"] + #[doc = " \\sa SDL_LoadWAV_RW"] pub fn SDL_FreeWAV(audio_buf: *mut Uint8); } extern "C" { - #[doc = " This function takes a source format and rate and a destination format"] - #[doc = " and rate, and initializes the \\c cvt structure with information needed"] - #[doc = " by SDL_ConvertAudio() to convert a buffer of audio data from one format"] - #[doc = " to the other. An unsupported format causes an error and -1 will be returned."] + #[doc = " Initialize an SDL_AudioCVT structure for conversion."] + #[doc = ""] + #[doc = " Before an SDL_AudioCVT structure can be used to convert audio data it must"] + #[doc = " be initialized with source and destination information."] + #[doc = ""] + #[doc = " This function will zero out every field of the SDL_AudioCVT, so it must be"] + #[doc = " called before the application fills in the final buffer information."] + #[doc = ""] + #[doc = " Once this function has returned successfully, and reported that a"] + #[doc = " conversion is necessary, the application fills in the rest of the fields in"] + #[doc = " SDL_AudioCVT, now that it knows how large a buffer it needs to allocate,"] + #[doc = " and then can call SDL_ConvertAudio() to complete the conversion."] + #[doc = ""] + #[doc = " \\param cvt an SDL_AudioCVT structure filled in with audio conversion"] + #[doc = " information"] + #[doc = " \\param src_format the source format of the audio data; for more info see"] + #[doc = " SDL_AudioFormat"] + #[doc = " \\param src_channels the number of channels in the source"] + #[doc = " \\param src_rate the frequency (sample-frames-per-second) of the source"] + #[doc = " \\param dst_format the destination format of the audio data; for more info"] + #[doc = " see SDL_AudioFormat"] + #[doc = " \\param dst_channels the number of channels in the destination"] + #[doc = " \\param dst_rate the frequency (sample-frames-per-second) of the destination"] + #[doc = " \\returns 1 if the audio filter is prepared, 0 if no conversion is needed,"] + #[doc = " or a negative error code on failure; call SDL_GetError() for more"] + #[doc = " information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\return 0 if no conversion is needed, 1 if the audio filter is set up,"] - #[doc = " or -1 on error."] + #[doc = " \\sa SDL_ConvertAudio"] pub fn SDL_BuildAudioCVT( cvt: *mut SDL_AudioCVT, src_format: SDL_AudioFormat, @@ -3298,16 +4801,42 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " Once you have initialized the \\c cvt structure using SDL_BuildAudioCVT(),"] - #[doc = " created an audio buffer \\c cvt->buf, and filled it with \\c cvt->len bytes of"] - #[doc = " audio data in the source format, this function will convert it in-place"] - #[doc = " to the desired format."] + #[doc = " Convert audio data to a desired audio format."] #[doc = ""] - #[doc = " The data conversion may expand the size of the audio data, so the buffer"] - #[doc = " \\c cvt->buf should be allocated after the \\c cvt structure is initialized by"] - #[doc = " SDL_BuildAudioCVT(), and should be \\c cvt->len*cvt->len_mult bytes long."] + #[doc = " This function does the actual audio data conversion, after the application"] + #[doc = " has called SDL_BuildAudioCVT() to prepare the conversion information and"] + #[doc = " then filled in the buffer details."] #[doc = ""] - #[doc = " \\return 0 on success or -1 if \\c cvt->buf is NULL."] + #[doc = " Once the application has initialized the `cvt` structure using"] + #[doc = " SDL_BuildAudioCVT(), allocated an audio buffer and filled it with audio"] + #[doc = " data in the source format, this function will convert the buffer, in-place,"] + #[doc = " to the desired format."] + #[doc = ""] + #[doc = " The data conversion may go through several passes; any given pass may"] + #[doc = " possibly temporarily increase the size of the data. For example, SDL might"] + #[doc = " expand 16-bit data to 32 bits before resampling to a lower frequency,"] + #[doc = " shrinking the data size after having grown it briefly. Since the supplied"] + #[doc = " buffer will be both the source and destination, converting as necessary"] + #[doc = " in-place, the application must allocate a buffer that will fully contain"] + #[doc = " the data during its largest conversion pass. After SDL_BuildAudioCVT()"] + #[doc = " returns, the application should set the `cvt->len` field to the size, in"] + #[doc = " bytes, of the source data, and allocate a buffer that is `cvt->len *"] + #[doc = " cvt->len_mult` bytes long for the `buf` field."] + #[doc = ""] + #[doc = " The source data should be copied into this buffer before the call to"] + #[doc = " SDL_ConvertAudio(). Upon successful return, this buffer will contain the"] + #[doc = " converted audio, and `cvt->len_cvt` will be the size of the converted data,"] + #[doc = " in bytes. Any bytes in the buffer past `cvt->len_cvt` are undefined once"] + #[doc = " this function returns."] + #[doc = ""] + #[doc = " \\param cvt an SDL_AudioCVT structure that was previously set up by"] + #[doc = " SDL_BuildAudioCVT()."] + #[doc = " \\returns 0 if the conversion was completed successfully or a negative error"] + #[doc = " code on failure; call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_BuildAudioCVT"] pub fn SDL_ConvertAudio(cvt: *mut SDL_AudioCVT) -> libc::c_int; } #[repr(C)] @@ -3317,22 +4846,24 @@ pub struct _SDL_AudioStream { } pub type SDL_AudioStream = _SDL_AudioStream; extern "C" { - #[doc = " Create a new audio stream"] - #[doc = ""] - #[doc = " \\param src_format The format of the source audio"] - #[doc = " \\param src_channels The number of channels of the source audio"] - #[doc = " \\param src_rate The sampling rate of the source audio"] - #[doc = " \\param dst_format The format of the desired audio output"] - #[doc = " \\param dst_channels The number of channels of the desired audio output"] - #[doc = " \\param dst_rate The sampling rate of the desired audio output"] - #[doc = " \\return 0 on success, or -1 on error."] - #[doc = ""] - #[doc = " \\sa SDL_AudioStreamPut"] - #[doc = " \\sa SDL_AudioStreamGet"] - #[doc = " \\sa SDL_AudioStreamAvailable"] - #[doc = " \\sa SDL_AudioStreamFlush"] - #[doc = " \\sa SDL_AudioStreamClear"] - #[doc = " \\sa SDL_FreeAudioStream"] + #[doc = " Create a new audio stream."] + #[doc = ""] + #[doc = " \\param src_format The format of the source audio"] + #[doc = " \\param src_channels The number of channels of the source audio"] + #[doc = " \\param src_rate The sampling rate of the source audio"] + #[doc = " \\param dst_format The format of the desired audio output"] + #[doc = " \\param dst_channels The number of channels of the desired audio output"] + #[doc = " \\param dst_rate The sampling rate of the desired audio output"] + #[doc = " \\returns 0 on success, or -1 on error."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.7."] + #[doc = ""] + #[doc = " \\sa SDL_AudioStreamPut"] + #[doc = " \\sa SDL_AudioStreamGet"] + #[doc = " \\sa SDL_AudioStreamAvailable"] + #[doc = " \\sa SDL_AudioStreamFlush"] + #[doc = " \\sa SDL_AudioStreamClear"] + #[doc = " \\sa SDL_FreeAudioStream"] pub fn SDL_NewAudioStream( src_format: SDL_AudioFormat, src_channels: Uint8, @@ -3343,19 +4874,21 @@ extern "C" { ) -> *mut SDL_AudioStream; } extern "C" { - #[doc = " Add data to be converted/resampled to the stream"] + #[doc = " Add data to be converted/resampled to the stream."] #[doc = ""] - #[doc = " \\param stream The stream the audio data is being added to"] - #[doc = " \\param buf A pointer to the audio data to add"] - #[doc = " \\param len The number of bytes to write to the stream"] - #[doc = " \\return 0 on success, or -1 on error."] + #[doc = " \\param stream The stream the audio data is being added to"] + #[doc = " \\param buf A pointer to the audio data to add"] + #[doc = " \\param len The number of bytes to write to the stream"] + #[doc = " \\returns 0 on success, or -1 on error."] #[doc = ""] - #[doc = " \\sa SDL_NewAudioStream"] - #[doc = " \\sa SDL_AudioStreamGet"] - #[doc = " \\sa SDL_AudioStreamAvailable"] - #[doc = " \\sa SDL_AudioStreamFlush"] - #[doc = " \\sa SDL_AudioStreamClear"] - #[doc = " \\sa SDL_FreeAudioStream"] + #[doc = " \\since This function is available since SDL 2.0.7."] + #[doc = ""] + #[doc = " \\sa SDL_NewAudioStream"] + #[doc = " \\sa SDL_AudioStreamGet"] + #[doc = " \\sa SDL_AudioStreamAvailable"] + #[doc = " \\sa SDL_AudioStreamFlush"] + #[doc = " \\sa SDL_AudioStreamClear"] + #[doc = " \\sa SDL_FreeAudioStream"] pub fn SDL_AudioStreamPut( stream: *mut SDL_AudioStream, buf: *const libc::c_void, @@ -3363,19 +4896,21 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " Get converted/resampled data from the stream"] + #[doc = " Get converted/resampled data from the stream"] + #[doc = ""] + #[doc = " \\param stream The stream the audio is being requested from"] + #[doc = " \\param buf A buffer to fill with audio data"] + #[doc = " \\param len The maximum number of bytes to fill"] + #[doc = " \\returns the number of bytes read from the stream, or -1 on error"] #[doc = ""] - #[doc = " \\param stream The stream the audio is being requested from"] - #[doc = " \\param buf A buffer to fill with audio data"] - #[doc = " \\param len The maximum number of bytes to fill"] - #[doc = " \\return The number of bytes read from the stream, or -1 on error"] + #[doc = " \\since This function is available since SDL 2.0.7."] #[doc = ""] - #[doc = " \\sa SDL_NewAudioStream"] - #[doc = " \\sa SDL_AudioStreamPut"] - #[doc = " \\sa SDL_AudioStreamAvailable"] - #[doc = " \\sa SDL_AudioStreamFlush"] - #[doc = " \\sa SDL_AudioStreamClear"] - #[doc = " \\sa SDL_FreeAudioStream"] + #[doc = " \\sa SDL_NewAudioStream"] + #[doc = " \\sa SDL_AudioStreamPut"] + #[doc = " \\sa SDL_AudioStreamAvailable"] + #[doc = " \\sa SDL_AudioStreamFlush"] + #[doc = " \\sa SDL_AudioStreamClear"] + #[doc = " \\sa SDL_FreeAudioStream"] pub fn SDL_AudioStreamGet( stream: *mut SDL_AudioStream, buf: *mut libc::c_void, @@ -3383,69 +4918,118 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " Get the number of converted/resampled bytes available. The stream may be"] - #[doc = " buffering data behind the scenes until it has enough to resample"] - #[doc = " correctly, so this number might be lower than what you expect, or even"] - #[doc = " be zero. Add more data or flush the stream if you need the data now."] + #[doc = " Get the number of converted/resampled bytes available."] + #[doc = ""] + #[doc = " The stream may be buffering data behind the scenes until it has enough to"] + #[doc = " resample correctly, so this number might be lower than what you expect, or"] + #[doc = " even be zero. Add more data or flush the stream if you need the data now."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.7."] #[doc = ""] - #[doc = " \\sa SDL_NewAudioStream"] - #[doc = " \\sa SDL_AudioStreamPut"] - #[doc = " \\sa SDL_AudioStreamGet"] - #[doc = " \\sa SDL_AudioStreamFlush"] - #[doc = " \\sa SDL_AudioStreamClear"] - #[doc = " \\sa SDL_FreeAudioStream"] + #[doc = " \\sa SDL_NewAudioStream"] + #[doc = " \\sa SDL_AudioStreamPut"] + #[doc = " \\sa SDL_AudioStreamGet"] + #[doc = " \\sa SDL_AudioStreamFlush"] + #[doc = " \\sa SDL_AudioStreamClear"] + #[doc = " \\sa SDL_FreeAudioStream"] pub fn SDL_AudioStreamAvailable(stream: *mut SDL_AudioStream) -> libc::c_int; } extern "C" { #[doc = " Tell the stream that you're done sending data, and anything being buffered"] - #[doc = " should be converted/resampled and made available immediately."] - #[doc = ""] - #[doc = " It is legal to add more data to a stream after flushing, but there will"] - #[doc = " be audio gaps in the output. Generally this is intended to signal the"] - #[doc = " end of input, so the complete output becomes available."] - #[doc = ""] - #[doc = " \\sa SDL_NewAudioStream"] - #[doc = " \\sa SDL_AudioStreamPut"] - #[doc = " \\sa SDL_AudioStreamGet"] - #[doc = " \\sa SDL_AudioStreamAvailable"] - #[doc = " \\sa SDL_AudioStreamClear"] - #[doc = " \\sa SDL_FreeAudioStream"] + #[doc = " should be converted/resampled and made available immediately."] + #[doc = ""] + #[doc = " It is legal to add more data to a stream after flushing, but there will be"] + #[doc = " audio gaps in the output. Generally this is intended to signal the end of"] + #[doc = " input, so the complete output becomes available."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.7."] + #[doc = ""] + #[doc = " \\sa SDL_NewAudioStream"] + #[doc = " \\sa SDL_AudioStreamPut"] + #[doc = " \\sa SDL_AudioStreamGet"] + #[doc = " \\sa SDL_AudioStreamAvailable"] + #[doc = " \\sa SDL_AudioStreamClear"] + #[doc = " \\sa SDL_FreeAudioStream"] pub fn SDL_AudioStreamFlush(stream: *mut SDL_AudioStream) -> libc::c_int; } extern "C" { - #[doc = " Clear any pending data in the stream without converting it"] + #[doc = " Clear any pending data in the stream without converting it"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.7."] #[doc = ""] - #[doc = " \\sa SDL_NewAudioStream"] - #[doc = " \\sa SDL_AudioStreamPut"] - #[doc = " \\sa SDL_AudioStreamGet"] - #[doc = " \\sa SDL_AudioStreamAvailable"] - #[doc = " \\sa SDL_AudioStreamFlush"] - #[doc = " \\sa SDL_FreeAudioStream"] + #[doc = " \\sa SDL_NewAudioStream"] + #[doc = " \\sa SDL_AudioStreamPut"] + #[doc = " \\sa SDL_AudioStreamGet"] + #[doc = " \\sa SDL_AudioStreamAvailable"] + #[doc = " \\sa SDL_AudioStreamFlush"] + #[doc = " \\sa SDL_FreeAudioStream"] pub fn SDL_AudioStreamClear(stream: *mut SDL_AudioStream); } extern "C" { #[doc = " Free an audio stream"] #[doc = ""] - #[doc = " \\sa SDL_NewAudioStream"] - #[doc = " \\sa SDL_AudioStreamPut"] - #[doc = " \\sa SDL_AudioStreamGet"] - #[doc = " \\sa SDL_AudioStreamAvailable"] - #[doc = " \\sa SDL_AudioStreamFlush"] - #[doc = " \\sa SDL_AudioStreamClear"] + #[doc = " \\since This function is available since SDL 2.0.7."] + #[doc = ""] + #[doc = " \\sa SDL_NewAudioStream"] + #[doc = " \\sa SDL_AudioStreamPut"] + #[doc = " \\sa SDL_AudioStreamGet"] + #[doc = " \\sa SDL_AudioStreamAvailable"] + #[doc = " \\sa SDL_AudioStreamFlush"] + #[doc = " \\sa SDL_AudioStreamClear"] pub fn SDL_FreeAudioStream(stream: *mut SDL_AudioStream); } extern "C" { - #[doc = " This takes two audio buffers of the playing audio format and mixes"] - #[doc = " them, performing addition, volume adjustment, and overflow clipping."] - #[doc = " The volume ranges from 0 - 128, and should be set to ::SDL_MIX_MAXVOLUME"] - #[doc = " for full audio volume. Note this does not change hardware volume."] - #[doc = " This is provided for convenience -- you can mix your own audio data."] + #[doc = " This function is a legacy means of mixing audio."] + #[doc = ""] + #[doc = " This function is equivalent to calling..."] + #[doc = ""] + #[doc = " ```c"] + #[doc = " SDL_MixAudioFormat(dst, src, format, len, volume);"] + #[doc = " ```"] + #[doc = ""] + #[doc = " ...where `format` is the obtained format of the audio device from the"] + #[doc = " legacy SDL_OpenAudio() function."] + #[doc = ""] + #[doc = " \\param dst the destination for the mixed audio"] + #[doc = " \\param src the source audio buffer to be mixed"] + #[doc = " \\param len the length of the audio buffer in bytes"] + #[doc = " \\param volume ranges from 0 - 128, and should be set to SDL_MIX_MAXVOLUME"] + #[doc = " for full audio volume"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_MixAudioFormat"] pub fn SDL_MixAudio(dst: *mut Uint8, src: *const Uint8, len: Uint32, volume: libc::c_int); } extern "C" { - #[doc = " This works like SDL_MixAudio(), but you specify the audio format instead of"] - #[doc = " using the format of audio device 1. Thus it can be used when no audio"] - #[doc = " device is open at all."] + #[doc = " Mix audio data in a specified format."] + #[doc = ""] + #[doc = " This takes an audio buffer `src` of `len` bytes of `format` data and mixes"] + #[doc = " it into `dst`, performing addition, volume adjustment, and overflow"] + #[doc = " clipping. The buffer pointed to by `dst` must also be `len` bytes of"] + #[doc = " `format` data."] + #[doc = ""] + #[doc = " This is provided for convenience -- you can mix your own audio data."] + #[doc = ""] + #[doc = " Do not use this function for mixing together more than two streams of"] + #[doc = " sample data. The output from repeated application of this function may be"] + #[doc = " distorted by clipping, because there is no accumulator with greater range"] + #[doc = " than the input (not to mention this being an inefficient way of doing it)."] + #[doc = ""] + #[doc = " It is a common misconception that this function is required to write audio"] + #[doc = " data to an output stream in an audio callback. While you can do that,"] + #[doc = " SDL_MixAudioFormat() is really only needed when you're mixing a single"] + #[doc = " audio stream with a volume adjustment."] + #[doc = ""] + #[doc = " \\param dst the destination for the mixed audio"] + #[doc = " \\param src the source audio buffer to be mixed"] + #[doc = " \\param format the SDL_AudioFormat structure representing the desired audio"] + #[doc = " format"] + #[doc = " \\param len the length of the audio buffer in bytes"] + #[doc = " \\param volume ranges from 0 - 128, and should be set to SDL_MIX_MAXVOLUME"] + #[doc = " for full audio volume"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_MixAudioFormat( dst: *mut Uint8, src: *const Uint8, @@ -3455,43 +5039,50 @@ extern "C" { ); } extern "C" { - #[doc = " Queue more audio on non-callback devices."] + #[doc = " Queue more audio on non-callback devices."] + #[doc = ""] + #[doc = " If you are looking to retrieve queued audio from a non-callback capture"] + #[doc = " device, you want SDL_DequeueAudio() instead. SDL_QueueAudio() will return"] + #[doc = " -1 to signify an error if you use it with capture devices."] #[doc = ""] - #[doc = " (If you are looking to retrieve queued audio from a non-callback capture"] - #[doc = " device, you want SDL_DequeueAudio() instead. This will return -1 to"] - #[doc = " signify an error if you use it with capture devices.)"] + #[doc = " SDL offers two ways to feed audio to the device: you can either supply a"] + #[doc = " callback that SDL triggers with some frequency to obtain more audio (pull"] + #[doc = " method), or you can supply no callback, and then SDL will expect you to"] + #[doc = " supply data at regular intervals (push method) with this function."] #[doc = ""] - #[doc = " SDL offers two ways to feed audio to the device: you can either supply a"] - #[doc = " callback that SDL triggers with some frequency to obtain more audio"] - #[doc = " (pull method), or you can supply no callback, and then SDL will expect"] - #[doc = " you to supply data at regular intervals (push method) with this function."] + #[doc = " There are no limits on the amount of data you can queue, short of"] + #[doc = " exhaustion of address space. Queued data will drain to the device as"] + #[doc = " necessary without further intervention from you. If the device needs audio"] + #[doc = " but there is not enough queued, it will play silence to make up the"] + #[doc = " difference. This means you will have skips in your audio playback if you"] + #[doc = " aren't routinely queueing sufficient data."] #[doc = ""] - #[doc = " There are no limits on the amount of data you can queue, short of"] - #[doc = " exhaustion of address space. Queued data will drain to the device as"] - #[doc = " necessary without further intervention from you. If the device needs"] - #[doc = " audio but there is not enough queued, it will play silence to make up"] - #[doc = " the difference. This means you will have skips in your audio playback"] - #[doc = " if you aren't routinely queueing sufficient data."] + #[doc = " This function copies the supplied data, so you are safe to free it when the"] + #[doc = " function returns. This function is thread-safe, but queueing to the same"] + #[doc = " device from two threads at once does not promise which buffer will be"] + #[doc = " queued first."] #[doc = ""] - #[doc = " This function copies the supplied data, so you are safe to free it when"] - #[doc = " the function returns. This function is thread-safe, but queueing to the"] - #[doc = " same device from two threads at once does not promise which buffer will"] - #[doc = " be queued first."] + #[doc = " You may not queue audio on a device that is using an application-supplied"] + #[doc = " callback; doing so returns an error. You have to use the audio callback or"] + #[doc = " queue audio with this function, but not both."] #[doc = ""] - #[doc = " You may not queue audio on a device that is using an application-supplied"] - #[doc = " callback; doing so returns an error. You have to use the audio callback"] - #[doc = " or queue audio with this function, but not both."] + #[doc = " You should not call SDL_LockAudio() on the device before queueing; SDL"] + #[doc = " handles locking internally for this function."] #[doc = ""] - #[doc = " You should not call SDL_LockAudio() on the device before queueing; SDL"] - #[doc = " handles locking internally for this function."] + #[doc = " Note that SDL2 does not support planar audio. You will need to resample"] + #[doc = " from planar audio formats into a non-planar one (see SDL_AudioFormat)"] + #[doc = " before queuing audio."] #[doc = ""] - #[doc = " \\param dev The device ID to which we will queue audio."] - #[doc = " \\param data The data to queue to the device for later playback."] - #[doc = " \\param len The number of bytes (not samples!) to which (data) points."] - #[doc = " \\return 0 on success, or -1 on error."] + #[doc = " \\param dev the device ID to which we will queue audio"] + #[doc = " \\param data the data to queue to the device for later playback"] + #[doc = " \\param len the number of bytes (not samples!) to which `data` points"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\sa SDL_GetQueuedAudioSize"] - #[doc = " \\sa SDL_ClearQueuedAudio"] + #[doc = " \\since This function is available since SDL 2.0.4."] + #[doc = ""] + #[doc = " \\sa SDL_ClearQueuedAudio"] + #[doc = " \\sa SDL_GetQueuedAudioSize"] pub fn SDL_QueueAudio( dev: SDL_AudioDeviceID, data: *const libc::c_void, @@ -3499,156 +5090,285 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " Dequeue more audio on non-callback devices."] + #[doc = " Dequeue more audio on non-callback devices."] + #[doc = ""] + #[doc = " If you are looking to queue audio for output on a non-callback playback"] + #[doc = " device, you want SDL_QueueAudio() instead. SDL_DequeueAudio() will always"] + #[doc = " return 0 if you use it with playback devices."] #[doc = ""] - #[doc = " (If you are looking to queue audio for output on a non-callback playback"] - #[doc = " device, you want SDL_QueueAudio() instead. This will always return 0"] - #[doc = " if you use it with playback devices.)"] + #[doc = " SDL offers two ways to retrieve audio from a capture device: you can either"] + #[doc = " supply a callback that SDL triggers with some frequency as the device"] + #[doc = " records more audio data, (push method), or you can supply no callback, and"] + #[doc = " then SDL will expect you to retrieve data at regular intervals (pull"] + #[doc = " method) with this function."] #[doc = ""] - #[doc = " SDL offers two ways to retrieve audio from a capture device: you can"] - #[doc = " either supply a callback that SDL triggers with some frequency as the"] - #[doc = " device records more audio data, (push method), or you can supply no"] - #[doc = " callback, and then SDL will expect you to retrieve data at regular"] - #[doc = " intervals (pull method) with this function."] + #[doc = " There are no limits on the amount of data you can queue, short of"] + #[doc = " exhaustion of address space. Data from the device will keep queuing as"] + #[doc = " necessary without further intervention from you. This means you will"] + #[doc = " eventually run out of memory if you aren't routinely dequeueing data."] #[doc = ""] - #[doc = " There are no limits on the amount of data you can queue, short of"] - #[doc = " exhaustion of address space. Data from the device will keep queuing as"] - #[doc = " necessary without further intervention from you. This means you will"] - #[doc = " eventually run out of memory if you aren't routinely dequeueing data."] + #[doc = " Capture devices will not queue data when paused; if you are expecting to"] + #[doc = " not need captured audio for some length of time, use SDL_PauseAudioDevice()"] + #[doc = " to stop the capture device from queueing more data. This can be useful"] + #[doc = " during, say, level loading times. When unpaused, capture devices will start"] + #[doc = " queueing data from that point, having flushed any capturable data available"] + #[doc = " while paused."] #[doc = ""] - #[doc = " Capture devices will not queue data when paused; if you are expecting"] - #[doc = " to not need captured audio for some length of time, use"] - #[doc = " SDL_PauseAudioDevice() to stop the capture device from queueing more"] - #[doc = " data. This can be useful during, say, level loading times. When"] - #[doc = " unpaused, capture devices will start queueing data from that point,"] - #[doc = " having flushed any capturable data available while paused."] + #[doc = " This function is thread-safe, but dequeueing from the same device from two"] + #[doc = " threads at once does not promise which thread will dequeue data first."] #[doc = ""] - #[doc = " This function is thread-safe, but dequeueing from the same device from"] - #[doc = " two threads at once does not promise which thread will dequeued data"] - #[doc = " first."] + #[doc = " You may not dequeue audio from a device that is using an"] + #[doc = " application-supplied callback; doing so returns an error. You have to use"] + #[doc = " the audio callback, or dequeue audio with this function, but not both."] #[doc = ""] - #[doc = " You may not dequeue audio from a device that is using an"] - #[doc = " application-supplied callback; doing so returns an error. You have to use"] - #[doc = " the audio callback, or dequeue audio with this function, but not both."] + #[doc = " You should not call SDL_LockAudio() on the device before dequeueing; SDL"] + #[doc = " handles locking internally for this function."] #[doc = ""] - #[doc = " You should not call SDL_LockAudio() on the device before queueing; SDL"] - #[doc = " handles locking internally for this function."] + #[doc = " \\param dev the device ID from which we will dequeue audio"] + #[doc = " \\param data a pointer into where audio data should be copied"] + #[doc = " \\param len the number of bytes (not samples!) to which (data) points"] + #[doc = " \\returns the number of bytes dequeued, which could be less than requested;"] + #[doc = " call SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\param dev The device ID from which we will dequeue audio."] - #[doc = " \\param data A pointer into where audio data should be copied."] - #[doc = " \\param len The number of bytes (not samples!) to which (data) points."] - #[doc = " \\return number of bytes dequeued, which could be less than requested."] + #[doc = " \\since This function is available since SDL 2.0.5."] #[doc = ""] - #[doc = " \\sa SDL_GetQueuedAudioSize"] - #[doc = " \\sa SDL_ClearQueuedAudio"] + #[doc = " \\sa SDL_ClearQueuedAudio"] + #[doc = " \\sa SDL_GetQueuedAudioSize"] pub fn SDL_DequeueAudio(dev: SDL_AudioDeviceID, data: *mut libc::c_void, len: Uint32) -> Uint32; } extern "C" { - #[doc = " Get the number of bytes of still-queued audio."] + #[doc = " Get the number of bytes of still-queued audio."] #[doc = ""] - #[doc = " For playback device:"] + #[doc = " For playback devices: this is the number of bytes that have been queued for"] + #[doc = " playback with SDL_QueueAudio(), but have not yet been sent to the hardware."] #[doc = ""] - #[doc = " This is the number of bytes that have been queued for playback with"] - #[doc = " SDL_QueueAudio(), but have not yet been sent to the hardware. This"] - #[doc = " number may shrink at any time, so this only informs of pending data."] + #[doc = " Once we've sent it to the hardware, this function can not decide the exact"] + #[doc = " byte boundary of what has been played. It's possible that we just gave the"] + #[doc = " hardware several kilobytes right before you called this function, but it"] + #[doc = " hasn't played any of it yet, or maybe half of it, etc."] #[doc = ""] - #[doc = " Once we've sent it to the hardware, this function can not decide the"] - #[doc = " exact byte boundary of what has been played. It's possible that we just"] - #[doc = " gave the hardware several kilobytes right before you called this"] - #[doc = " function, but it hasn't played any of it yet, or maybe half of it, etc."] + #[doc = " For capture devices, this is the number of bytes that have been captured by"] + #[doc = " the device and are waiting for you to dequeue. This number may grow at any"] + #[doc = " time, so this only informs of the lower-bound of available data."] #[doc = ""] - #[doc = " For capture devices:"] + #[doc = " You may not queue or dequeue audio on a device that is using an"] + #[doc = " application-supplied callback; calling this function on such a device"] + #[doc = " always returns 0. You have to use the audio callback or queue audio, but"] + #[doc = " not both."] #[doc = ""] - #[doc = " This is the number of bytes that have been captured by the device and"] - #[doc = " are waiting for you to dequeue. This number may grow at any time, so"] - #[doc = " this only informs of the lower-bound of available data."] + #[doc = " You should not call SDL_LockAudio() on the device before querying; SDL"] + #[doc = " handles locking internally for this function."] #[doc = ""] - #[doc = " You may not queue audio on a device that is using an application-supplied"] - #[doc = " callback; calling this function on such a device always returns 0."] - #[doc = " You have to queue audio with SDL_QueueAudio()/SDL_DequeueAudio(), or use"] - #[doc = " the audio callback, but not both."] + #[doc = " \\param dev the device ID of which we will query queued audio size"] + #[doc = " \\returns the number of bytes (not samples!) of queued audio."] #[doc = ""] - #[doc = " You should not call SDL_LockAudio() on the device before querying; SDL"] - #[doc = " handles locking internally for this function."] + #[doc = " \\since This function is available since SDL 2.0.4."] #[doc = ""] - #[doc = " \\param dev The device ID of which we will query queued audio size."] - #[doc = " \\return Number of bytes (not samples!) of queued audio."] - #[doc = ""] - #[doc = " \\sa SDL_QueueAudio"] - #[doc = " \\sa SDL_ClearQueuedAudio"] + #[doc = " \\sa SDL_ClearQueuedAudio"] + #[doc = " \\sa SDL_QueueAudio"] + #[doc = " \\sa SDL_DequeueAudio"] pub fn SDL_GetQueuedAudioSize(dev: SDL_AudioDeviceID) -> Uint32; } extern "C" { - #[doc = " Drop any queued audio data. For playback devices, this is any queued data"] - #[doc = " still waiting to be submitted to the hardware. For capture devices, this"] - #[doc = " is any data that was queued by the device that hasn't yet been dequeued by"] - #[doc = " the application."] + #[doc = " Drop any queued audio data waiting to be sent to the hardware."] + #[doc = ""] + #[doc = " Immediately after this call, SDL_GetQueuedAudioSize() will return 0. For"] + #[doc = " output devices, the hardware will start playing silence if more audio isn't"] + #[doc = " queued. For capture devices, the hardware will start filling the empty"] + #[doc = " queue with new data if the capture device isn't paused."] #[doc = ""] - #[doc = " Immediately after this call, SDL_GetQueuedAudioSize() will return 0. For"] - #[doc = " playback devices, the hardware will start playing silence if more audio"] - #[doc = " isn't queued. Unpaused capture devices will start filling the queue again"] - #[doc = " as soon as they have more data available (which, depending on the state"] - #[doc = " of the hardware and the thread, could be before this function call"] - #[doc = " returns!)."] + #[doc = " This will not prevent playback of queued audio that's already been sent to"] + #[doc = " the hardware, as we can not undo that, so expect there to be some fraction"] + #[doc = " of a second of audio that might still be heard. This can be useful if you"] + #[doc = " want to, say, drop any pending music or any unprocessed microphone input"] + #[doc = " during a level change in your game."] #[doc = ""] - #[doc = " This will not prevent playback of queued audio that's already been sent"] - #[doc = " to the hardware, as we can not undo that, so expect there to be some"] - #[doc = " fraction of a second of audio that might still be heard. This can be"] - #[doc = " useful if you want to, say, drop any pending music during a level change"] - #[doc = " in your game."] + #[doc = " You may not queue or dequeue audio on a device that is using an"] + #[doc = " application-supplied callback; calling this function on such a device"] + #[doc = " always returns 0. You have to use the audio callback or queue audio, but"] + #[doc = " not both."] #[doc = ""] - #[doc = " You may not queue audio on a device that is using an application-supplied"] - #[doc = " callback; calling this function on such a device is always a no-op."] - #[doc = " You have to queue audio with SDL_QueueAudio()/SDL_DequeueAudio(), or use"] - #[doc = " the audio callback, but not both."] + #[doc = " You should not call SDL_LockAudio() on the device before clearing the"] + #[doc = " queue; SDL handles locking internally for this function."] #[doc = ""] - #[doc = " You should not call SDL_LockAudio() on the device before clearing the"] - #[doc = " queue; SDL handles locking internally for this function."] + #[doc = " This function always succeeds and thus returns void."] #[doc = ""] - #[doc = " This function always succeeds and thus returns void."] + #[doc = " \\param dev the device ID of which to clear the audio queue"] #[doc = ""] - #[doc = " \\param dev The device ID of which to clear the audio queue."] + #[doc = " \\since This function is available since SDL 2.0.4."] #[doc = ""] - #[doc = " \\sa SDL_QueueAudio"] - #[doc = " \\sa SDL_GetQueuedAudioSize"] + #[doc = " \\sa SDL_GetQueuedAudioSize"] + #[doc = " \\sa SDL_QueueAudio"] + #[doc = " \\sa SDL_DequeueAudio"] pub fn SDL_ClearQueuedAudio(dev: SDL_AudioDeviceID); } extern "C" { + #[doc = " This function is a legacy means of locking the audio device."] + #[doc = ""] + #[doc = " New programs might want to use SDL_LockAudioDevice() instead. This function"] + #[doc = " is equivalent to calling..."] + #[doc = ""] + #[doc = " ```c"] + #[doc = " SDL_LockAudioDevice(1);"] + #[doc = " ```"] + #[doc = ""] + #[doc = " ...and is only useful if you used the legacy SDL_OpenAudio() function."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_LockAudioDevice"] + #[doc = " \\sa SDL_UnlockAudio"] + #[doc = " \\sa SDL_UnlockAudioDevice"] pub fn SDL_LockAudio(); } extern "C" { + #[doc = " Use this function to lock out the audio callback function for a specified"] + #[doc = " device."] + #[doc = ""] + #[doc = " The lock manipulated by these functions protects the audio callback"] + #[doc = " function specified in SDL_OpenAudioDevice(). During a"] + #[doc = " SDL_LockAudioDevice()/SDL_UnlockAudioDevice() pair, you can be guaranteed"] + #[doc = " that the callback function for that device is not running, even if the"] + #[doc = " device is not paused. While a device is locked, any other unpaused,"] + #[doc = " unlocked devices may still run their callbacks."] + #[doc = ""] + #[doc = " Calling this function from inside your audio callback is unnecessary. SDL"] + #[doc = " obtains this lock before calling your function, and releases it when the"] + #[doc = " function returns."] + #[doc = ""] + #[doc = " You should not hold the lock longer than absolutely necessary. If you hold"] + #[doc = " it too long, you'll experience dropouts in your audio playback. Ideally,"] + #[doc = " your application locks the device, sets a few variables and unlocks again."] + #[doc = " Do not do heavy work while holding the lock for a device."] + #[doc = ""] + #[doc = " It is safe to lock the audio device multiple times, as long as you unlock"] + #[doc = " it an equivalent number of times. The callback will not run until the"] + #[doc = " device has been unlocked completely in this way. If your application fails"] + #[doc = " to unlock the device appropriately, your callback will never run, you might"] + #[doc = " hear repeating bursts of audio, and SDL_CloseAudioDevice() will probably"] + #[doc = " deadlock."] + #[doc = ""] + #[doc = " Internally, the audio device lock is a mutex; if you lock from two threads"] + #[doc = " at once, not only will you block the audio callback, you'll block the other"] + #[doc = " thread."] + #[doc = ""] + #[doc = " \\param dev the ID of the device to be locked"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_UnlockAudioDevice"] pub fn SDL_LockAudioDevice(dev: SDL_AudioDeviceID); } extern "C" { + #[doc = " This function is a legacy means of unlocking the audio device."] + #[doc = ""] + #[doc = " New programs might want to use SDL_UnlockAudioDevice() instead. This"] + #[doc = " function is equivalent to calling..."] + #[doc = ""] + #[doc = " ```c"] + #[doc = " SDL_UnlockAudioDevice(1);"] + #[doc = " ```"] + #[doc = ""] + #[doc = " ...and is only useful if you used the legacy SDL_OpenAudio() function."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_LockAudio"] + #[doc = " \\sa SDL_UnlockAudioDevice"] pub fn SDL_UnlockAudio(); } extern "C" { + #[doc = " Use this function to unlock the audio callback function for a specified"] + #[doc = " device."] + #[doc = ""] + #[doc = " This function should be paired with a previous SDL_LockAudioDevice() call."] + #[doc = ""] + #[doc = " \\param dev the ID of the device to be unlocked"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_LockAudioDevice"] pub fn SDL_UnlockAudioDevice(dev: SDL_AudioDeviceID); } extern "C" { - #[doc = " This function shuts down audio processing and closes the audio device."] + #[doc = " This function is a legacy means of closing the audio device."] + #[doc = ""] + #[doc = " This function is equivalent to calling..."] + #[doc = ""] + #[doc = " ```c"] + #[doc = " SDL_CloseAudioDevice(1);"] + #[doc = " ```"] + #[doc = ""] + #[doc = " ...and is only useful if you used the legacy SDL_OpenAudio() function."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_OpenAudio"] pub fn SDL_CloseAudio(); } extern "C" { + #[doc = " Use this function to shut down audio processing and close the audio device."] + #[doc = ""] + #[doc = " The application should close open audio devices once they are no longer"] + #[doc = " needed. Calling this function will wait until the device's audio callback"] + #[doc = " is not running, release the audio hardware and then clean up internal"] + #[doc = " state. No further audio will play from this device once this function"] + #[doc = " returns."] + #[doc = ""] + #[doc = " This function may block briefly while pending audio data is played by the"] + #[doc = " hardware, so that applications don't drop the last buffer of data they"] + #[doc = " supplied."] + #[doc = ""] + #[doc = " The device ID is invalid as soon as the device is closed, and is eligible"] + #[doc = " for reuse in a new SDL_OpenAudioDevice() call immediately."] + #[doc = ""] + #[doc = " \\param dev an audio device previously opened with SDL_OpenAudioDevice()"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_OpenAudioDevice"] pub fn SDL_CloseAudioDevice(dev: SDL_AudioDeviceID); } extern "C" { - #[doc = " \\brief Put UTF-8 text into the clipboard"] + #[doc = " Put UTF-8 text into the clipboard."] + #[doc = ""] + #[doc = " \\param text the text to store in the clipboard"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\sa SDL_GetClipboardText()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetClipboardText"] + #[doc = " \\sa SDL_HasClipboardText"] pub fn SDL_SetClipboardText(text: *const libc::c_char) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get UTF-8 text from the clipboard, which must be freed with SDL_free()"] + #[doc = " Get UTF-8 text from the clipboard, which must be freed with SDL_free()."] + #[doc = ""] + #[doc = " This functions returns empty string if there was not enough memory left for"] + #[doc = " a copy of the clipboard's content."] + #[doc = ""] + #[doc = " \\returns the clipboard text on success or an empty string on failure; call"] + #[doc = " SDL_GetError() for more information. Caller must call SDL_free()"] + #[doc = " on the returned pointer when done with it (even if there was an"] + #[doc = " error)."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_SetClipboardText()"] + #[doc = " \\sa SDL_HasClipboardText"] + #[doc = " \\sa SDL_SetClipboardText"] pub fn SDL_GetClipboardText() -> *mut libc::c_char; } extern "C" { - #[doc = " \\brief Returns a flag indicating whether the clipboard exists and contains a text string that is non-empty"] + #[doc = " Query whether the clipboard exists and contains a non-empty text string."] #[doc = ""] - #[doc = " \\sa SDL_GetClipboardText()"] + #[doc = " \\returns SDL_TRUE if the clipboard has text, or SDL_FALSE if it does not."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetClipboardText"] + #[doc = " \\sa SDL_SetClipboardText"] pub fn SDL_HasClipboardText() -> SDL_bool; } pub type __m64 = [libc::c_longlong; 1usize]; @@ -4050,28 +5770,120 @@ pub type fsblkcnt_t = __fsblkcnt_t; pub type fsfilcnt_t = __fsfilcnt_t; #[repr(C)] #[derive(Copy, Clone)] -pub struct __pthread_internal_list { - pub __prev: *mut __pthread_internal_list, - pub __next: *mut __pthread_internal_list, +pub union __atomic_wide_counter { + pub __value64: libc::c_ulonglong, + pub __value32: __atomic_wide_counter__bindgen_ty_1, + _bindgen_union_align: u64, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct __atomic_wide_counter__bindgen_ty_1 { + pub __low: libc::c_uint, + pub __high: libc::c_uint, } #[test] -fn bindgen_test_layout___pthread_internal_list() { - assert_eq!( - ::core::mem::size_of::<__pthread_internal_list>(), - 16usize, - concat!("Size of: ", stringify!(__pthread_internal_list)) - ); +fn bindgen_test_layout___atomic_wide_counter__bindgen_ty_1() { assert_eq!( - ::core::mem::align_of::<__pthread_internal_list>(), + ::core::mem::size_of::<__atomic_wide_counter__bindgen_ty_1>(), 8usize, - concat!("Alignment of ", stringify!(__pthread_internal_list)) + concat!("Size of: ", stringify!(__atomic_wide_counter__bindgen_ty_1)) ); assert_eq!( - unsafe { &(*(::core::ptr::null::<__pthread_internal_list>())).__prev as *const _ as usize }, - 0usize, + ::core::mem::align_of::<__atomic_wide_counter__bindgen_ty_1>(), + 4usize, concat!( - "Offset of field: ", - stringify!(__pthread_internal_list), + "Alignment of ", + stringify!(__atomic_wide_counter__bindgen_ty_1) + ) + ); + assert_eq!( + unsafe { + &(*(::core::ptr::null::<__atomic_wide_counter__bindgen_ty_1>())).__low as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__atomic_wide_counter__bindgen_ty_1), + "::", + stringify!(__low) + ) + ); + assert_eq!( + unsafe { + &(*(::core::ptr::null::<__atomic_wide_counter__bindgen_ty_1>())).__high as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__atomic_wide_counter__bindgen_ty_1), + "::", + stringify!(__high) + ) + ); +} +#[test] +fn bindgen_test_layout___atomic_wide_counter() { + assert_eq!( + ::core::mem::size_of::<__atomic_wide_counter>(), + 8usize, + concat!("Size of: ", stringify!(__atomic_wide_counter)) + ); + assert_eq!( + ::core::mem::align_of::<__atomic_wide_counter>(), + 8usize, + concat!("Alignment of ", stringify!(__atomic_wide_counter)) + ); + assert_eq!( + unsafe { + &(*(::core::ptr::null::<__atomic_wide_counter>())).__value64 as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__atomic_wide_counter), + "::", + stringify!(__value64) + ) + ); + assert_eq!( + unsafe { + &(*(::core::ptr::null::<__atomic_wide_counter>())).__value32 as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__atomic_wide_counter), + "::", + stringify!(__value32) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct __pthread_internal_list { + pub __prev: *mut __pthread_internal_list, + pub __next: *mut __pthread_internal_list, +} +#[test] +fn bindgen_test_layout___pthread_internal_list() { + assert_eq!( + ::core::mem::size_of::<__pthread_internal_list>(), + 16usize, + concat!("Size of: ", stringify!(__pthread_internal_list)) + ); + assert_eq!( + ::core::mem::align_of::<__pthread_internal_list>(), + 8usize, + concat!("Alignment of ", stringify!(__pthread_internal_list)) + ); + assert_eq!( + unsafe { &(*(::core::ptr::null::<__pthread_internal_list>())).__prev as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__pthread_internal_list), "::", stringify!(__prev) ) @@ -4394,219 +6206,46 @@ fn bindgen_test_layout___pthread_rwlock_arch_t() { #[repr(C)] #[derive(Copy, Clone)] pub struct __pthread_cond_s { - pub __bindgen_anon_1: __pthread_cond_s__bindgen_ty_1, - pub __bindgen_anon_2: __pthread_cond_s__bindgen_ty_2, + pub __wseq: __atomic_wide_counter, + pub __g1_start: __atomic_wide_counter, pub __g_refs: [libc::c_uint; 2usize], pub __g_size: [libc::c_uint; 2usize], pub __g1_orig_size: libc::c_uint, pub __wrefs: libc::c_uint, pub __g_signals: [libc::c_uint; 2usize], } -#[repr(C)] -#[derive(Copy, Clone)] -pub union __pthread_cond_s__bindgen_ty_1 { - pub __wseq: libc::c_ulonglong, - pub __wseq32: __pthread_cond_s__bindgen_ty_1__bindgen_ty_1, - _bindgen_union_align: u64, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct __pthread_cond_s__bindgen_ty_1__bindgen_ty_1 { - pub __low: libc::c_uint, - pub __high: libc::c_uint, -} -#[test] -fn bindgen_test_layout___pthread_cond_s__bindgen_ty_1__bindgen_ty_1() { - assert_eq!( - ::core::mem::size_of::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - concat!( - "Size of: ", - stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1) - ) - ); - assert_eq!( - ::core::mem::align_of::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>(), - 4usize, - concat!( - "Alignment of ", - stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1) - ) - ); - assert_eq!( - unsafe { - &(*(::core::ptr::null::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>())).__low - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1), - "::", - stringify!(__low) - ) - ); - assert_eq!( - unsafe { - &(*(::core::ptr::null::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>())).__high - as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1), - "::", - stringify!(__high) - ) - ); -} #[test] -fn bindgen_test_layout___pthread_cond_s__bindgen_ty_1() { +fn bindgen_test_layout___pthread_cond_s() { assert_eq!( - ::core::mem::size_of::<__pthread_cond_s__bindgen_ty_1>(), - 8usize, - concat!("Size of: ", stringify!(__pthread_cond_s__bindgen_ty_1)) + ::core::mem::size_of::<__pthread_cond_s>(), + 48usize, + concat!("Size of: ", stringify!(__pthread_cond_s)) ); assert_eq!( - ::core::mem::align_of::<__pthread_cond_s__bindgen_ty_1>(), + ::core::mem::align_of::<__pthread_cond_s>(), 8usize, - concat!("Alignment of ", stringify!(__pthread_cond_s__bindgen_ty_1)) + concat!("Alignment of ", stringify!(__pthread_cond_s)) ); assert_eq!( - unsafe { - &(*(::core::ptr::null::<__pthread_cond_s__bindgen_ty_1>())).__wseq as *const _ as usize - }, + unsafe { &(*(::core::ptr::null::<__pthread_cond_s>())).__wseq as *const _ as usize }, 0usize, concat!( "Offset of field: ", - stringify!(__pthread_cond_s__bindgen_ty_1), + stringify!(__pthread_cond_s), "::", stringify!(__wseq) ) ); assert_eq!( - unsafe { - &(*(::core::ptr::null::<__pthread_cond_s__bindgen_ty_1>())).__wseq32 as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__pthread_cond_s__bindgen_ty_1), - "::", - stringify!(__wseq32) - ) - ); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union __pthread_cond_s__bindgen_ty_2 { - pub __g1_start: libc::c_ulonglong, - pub __g1_start32: __pthread_cond_s__bindgen_ty_2__bindgen_ty_1, - _bindgen_union_align: u64, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct __pthread_cond_s__bindgen_ty_2__bindgen_ty_1 { - pub __low: libc::c_uint, - pub __high: libc::c_uint, -} -#[test] -fn bindgen_test_layout___pthread_cond_s__bindgen_ty_2__bindgen_ty_1() { - assert_eq!( - ::core::mem::size_of::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>(), - 8usize, - concat!( - "Size of: ", - stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1) - ) - ); - assert_eq!( - ::core::mem::align_of::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>(), - 4usize, - concat!( - "Alignment of ", - stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1) - ) - ); - assert_eq!( - unsafe { - &(*(::core::ptr::null::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>())).__low - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1), - "::", - stringify!(__low) - ) - ); - assert_eq!( - unsafe { - &(*(::core::ptr::null::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>())).__high - as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1), - "::", - stringify!(__high) - ) - ); -} -#[test] -fn bindgen_test_layout___pthread_cond_s__bindgen_ty_2() { - assert_eq!( - ::core::mem::size_of::<__pthread_cond_s__bindgen_ty_2>(), - 8usize, - concat!("Size of: ", stringify!(__pthread_cond_s__bindgen_ty_2)) - ); - assert_eq!( - ::core::mem::align_of::<__pthread_cond_s__bindgen_ty_2>(), + unsafe { &(*(::core::ptr::null::<__pthread_cond_s>())).__g1_start as *const _ as usize }, 8usize, - concat!("Alignment of ", stringify!(__pthread_cond_s__bindgen_ty_2)) - ); - assert_eq!( - unsafe { - &(*(::core::ptr::null::<__pthread_cond_s__bindgen_ty_2>())).__g1_start as *const _ - as usize - }, - 0usize, concat!( "Offset of field: ", - stringify!(__pthread_cond_s__bindgen_ty_2), + stringify!(__pthread_cond_s), "::", stringify!(__g1_start) ) ); - assert_eq!( - unsafe { - &(*(::core::ptr::null::<__pthread_cond_s__bindgen_ty_2>())).__g1_start32 as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__pthread_cond_s__bindgen_ty_2), - "::", - stringify!(__g1_start32) - ) - ); -} -#[test] -fn bindgen_test_layout___pthread_cond_s() { - assert_eq!( - ::core::mem::size_of::<__pthread_cond_s>(), - 48usize, - concat!("Size of: ", stringify!(__pthread_cond_s)) - ); - assert_eq!( - ::core::mem::align_of::<__pthread_cond_s>(), - 8usize, - concat!("Alignment of ", stringify!(__pthread_cond_s)) - ); assert_eq!( unsafe { &(*(::core::ptr::null::<__pthread_cond_s>())).__g_refs as *const _ as usize }, 16usize, @@ -5370,6 +7009,9 @@ extern "C" { extern "C" { pub fn realloc(__ptr: *mut libc::c_void, __size: libc::c_ulong) -> *mut libc::c_void; } +extern "C" { + pub fn free(__ptr: *mut libc::c_void); +} extern "C" { pub fn reallocarray( __ptr: *mut libc::c_void, @@ -5377,9 +7019,6 @@ extern "C" { __size: size_t, ) -> *mut libc::c_void; } -extern "C" { - pub fn free(__ptr: *mut libc::c_void); -} extern "C" { pub fn alloca(__size: libc::c_ulong) -> *mut libc::c_void; } @@ -5394,7 +7033,7 @@ extern "C" { ) -> libc::c_int; } extern "C" { - pub fn aligned_alloc(__alignment: size_t, __size: size_t) -> *mut libc::c_void; + pub fn aligned_alloc(__alignment: libc::c_ulong, __size: libc::c_ulong) -> *mut libc::c_void; } extern "C" { pub fn abort(); @@ -5645,118 +7284,352 @@ extern "C" { pub fn _mm_pause(); } extern "C" { - #[doc = " This function returns the number of CPU cores available."] + #[doc = " Get the number of CPU cores available."] + #[doc = ""] + #[doc = " \\returns the total number of logical CPU cores. On CPUs that include"] + #[doc = " technologies such as hyperthreading, the number of logical cores"] + #[doc = " may be more than the number of physical cores."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_GetCPUCount() -> libc::c_int; } extern "C" { - #[doc = " This function returns the L1 cache line size of the CPU"] + #[doc = " Determine the L1 cache line size of the CPU."] + #[doc = ""] + #[doc = " This is useful for determining multi-threaded structure padding or SIMD"] + #[doc = " prefetch sizes."] #[doc = ""] - #[doc = " This is useful for determining multi-threaded structure padding"] - #[doc = " or SIMD prefetch sizes."] + #[doc = " \\returns the L1 cache line size of the CPU, in bytes."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_GetCPUCacheLineSize() -> libc::c_int; } extern "C" { - #[doc = " This function returns true if the CPU has the RDTSC instruction."] + #[doc = " Determine whether the CPU has the RDTSC instruction."] + #[doc = ""] + #[doc = " This always returns false on CPUs that aren't using Intel instruction sets."] + #[doc = ""] + #[doc = " \\returns SDL_TRUE if the CPU has the RDTSC instruction or SDL_FALSE if not."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_Has3DNow"] + #[doc = " \\sa SDL_HasAltiVec"] + #[doc = " \\sa SDL_HasAVX"] + #[doc = " \\sa SDL_HasAVX2"] + #[doc = " \\sa SDL_HasMMX"] + #[doc = " \\sa SDL_HasSSE"] + #[doc = " \\sa SDL_HasSSE2"] + #[doc = " \\sa SDL_HasSSE3"] + #[doc = " \\sa SDL_HasSSE41"] + #[doc = " \\sa SDL_HasSSE42"] pub fn SDL_HasRDTSC() -> SDL_bool; } extern "C" { - #[doc = " This function returns true if the CPU has AltiVec features."] + #[doc = " Determine whether the CPU has AltiVec features."] + #[doc = ""] + #[doc = " This always returns false on CPUs that aren't using PowerPC instruction"] + #[doc = " sets."] + #[doc = ""] + #[doc = " \\returns SDL_TRUE if the CPU has AltiVec features or SDL_FALSE if not."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_Has3DNow"] + #[doc = " \\sa SDL_HasAVX"] + #[doc = " \\sa SDL_HasAVX2"] + #[doc = " \\sa SDL_HasMMX"] + #[doc = " \\sa SDL_HasRDTSC"] + #[doc = " \\sa SDL_HasSSE"] + #[doc = " \\sa SDL_HasSSE2"] + #[doc = " \\sa SDL_HasSSE3"] + #[doc = " \\sa SDL_HasSSE41"] + #[doc = " \\sa SDL_HasSSE42"] pub fn SDL_HasAltiVec() -> SDL_bool; } extern "C" { - #[doc = " This function returns true if the CPU has MMX features."] + #[doc = " Determine whether the CPU has MMX features."] + #[doc = ""] + #[doc = " This always returns false on CPUs that aren't using Intel instruction sets."] + #[doc = ""] + #[doc = " \\returns SDL_TRUE if the CPU has MMX features or SDL_FALSE if not."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_Has3DNow"] + #[doc = " \\sa SDL_HasAltiVec"] + #[doc = " \\sa SDL_HasAVX"] + #[doc = " \\sa SDL_HasAVX2"] + #[doc = " \\sa SDL_HasRDTSC"] + #[doc = " \\sa SDL_HasSSE"] + #[doc = " \\sa SDL_HasSSE2"] + #[doc = " \\sa SDL_HasSSE3"] + #[doc = " \\sa SDL_HasSSE41"] + #[doc = " \\sa SDL_HasSSE42"] pub fn SDL_HasMMX() -> SDL_bool; } extern "C" { - #[doc = " This function returns true if the CPU has 3DNow! features."] + #[doc = " Determine whether the CPU has 3DNow! features."] + #[doc = ""] + #[doc = " This always returns false on CPUs that aren't using AMD instruction sets."] + #[doc = ""] + #[doc = " \\returns SDL_TRUE if the CPU has 3DNow! features or SDL_FALSE if not."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HasAltiVec"] + #[doc = " \\sa SDL_HasAVX"] + #[doc = " \\sa SDL_HasAVX2"] + #[doc = " \\sa SDL_HasMMX"] + #[doc = " \\sa SDL_HasRDTSC"] + #[doc = " \\sa SDL_HasSSE"] + #[doc = " \\sa SDL_HasSSE2"] + #[doc = " \\sa SDL_HasSSE3"] + #[doc = " \\sa SDL_HasSSE41"] + #[doc = " \\sa SDL_HasSSE42"] pub fn SDL_Has3DNow() -> SDL_bool; } extern "C" { - #[doc = " This function returns true if the CPU has SSE features."] + #[doc = " Determine whether the CPU has SSE features."] + #[doc = ""] + #[doc = " This always returns false on CPUs that aren't using Intel instruction sets."] + #[doc = ""] + #[doc = " \\returns SDL_TRUE if the CPU has SSE features or SDL_FALSE if not."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_Has3DNow"] + #[doc = " \\sa SDL_HasAltiVec"] + #[doc = " \\sa SDL_HasAVX"] + #[doc = " \\sa SDL_HasAVX2"] + #[doc = " \\sa SDL_HasMMX"] + #[doc = " \\sa SDL_HasRDTSC"] + #[doc = " \\sa SDL_HasSSE2"] + #[doc = " \\sa SDL_HasSSE3"] + #[doc = " \\sa SDL_HasSSE41"] + #[doc = " \\sa SDL_HasSSE42"] pub fn SDL_HasSSE() -> SDL_bool; } extern "C" { - #[doc = " This function returns true if the CPU has SSE2 features."] + #[doc = " Determine whether the CPU has SSE2 features."] + #[doc = ""] + #[doc = " This always returns false on CPUs that aren't using Intel instruction sets."] + #[doc = ""] + #[doc = " \\returns SDL_TRUE if the CPU has SSE2 features or SDL_FALSE if not."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_Has3DNow"] + #[doc = " \\sa SDL_HasAltiVec"] + #[doc = " \\sa SDL_HasAVX"] + #[doc = " \\sa SDL_HasAVX2"] + #[doc = " \\sa SDL_HasMMX"] + #[doc = " \\sa SDL_HasRDTSC"] + #[doc = " \\sa SDL_HasSSE"] + #[doc = " \\sa SDL_HasSSE3"] + #[doc = " \\sa SDL_HasSSE41"] + #[doc = " \\sa SDL_HasSSE42"] pub fn SDL_HasSSE2() -> SDL_bool; } extern "C" { - #[doc = " This function returns true if the CPU has SSE3 features."] - pub fn SDL_HasSSE3() -> SDL_bool; + #[doc = " Determine whether the CPU has SSE3 features."] + #[doc = ""] + #[doc = " This always returns false on CPUs that aren't using Intel instruction sets."] + #[doc = ""] + #[doc = " \\returns SDL_TRUE if the CPU has SSE3 features or SDL_FALSE if not."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_Has3DNow"] + #[doc = " \\sa SDL_HasAltiVec"] + #[doc = " \\sa SDL_HasAVX"] + #[doc = " \\sa SDL_HasAVX2"] + #[doc = " \\sa SDL_HasMMX"] + #[doc = " \\sa SDL_HasRDTSC"] + #[doc = " \\sa SDL_HasSSE"] + #[doc = " \\sa SDL_HasSSE2"] + #[doc = " \\sa SDL_HasSSE41"] + #[doc = " \\sa SDL_HasSSE42"] + pub fn SDL_HasSSE3() -> SDL_bool; } extern "C" { - #[doc = " This function returns true if the CPU has SSE4.1 features."] + #[doc = " Determine whether the CPU has SSE4.1 features."] + #[doc = ""] + #[doc = " This always returns false on CPUs that aren't using Intel instruction sets."] + #[doc = ""] + #[doc = " \\returns SDL_TRUE if the CPU has SSE4.1 features or SDL_FALSE if not."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_Has3DNow"] + #[doc = " \\sa SDL_HasAltiVec"] + #[doc = " \\sa SDL_HasAVX"] + #[doc = " \\sa SDL_HasAVX2"] + #[doc = " \\sa SDL_HasMMX"] + #[doc = " \\sa SDL_HasRDTSC"] + #[doc = " \\sa SDL_HasSSE"] + #[doc = " \\sa SDL_HasSSE2"] + #[doc = " \\sa SDL_HasSSE3"] + #[doc = " \\sa SDL_HasSSE42"] pub fn SDL_HasSSE41() -> SDL_bool; } extern "C" { - #[doc = " This function returns true if the CPU has SSE4.2 features."] + #[doc = " Determine whether the CPU has SSE4.2 features."] + #[doc = ""] + #[doc = " This always returns false on CPUs that aren't using Intel instruction sets."] + #[doc = ""] + #[doc = " \\returns SDL_TRUE if the CPU has SSE4.2 features or SDL_FALSE if not."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_Has3DNow"] + #[doc = " \\sa SDL_HasAltiVec"] + #[doc = " \\sa SDL_HasAVX"] + #[doc = " \\sa SDL_HasAVX2"] + #[doc = " \\sa SDL_HasMMX"] + #[doc = " \\sa SDL_HasRDTSC"] + #[doc = " \\sa SDL_HasSSE"] + #[doc = " \\sa SDL_HasSSE2"] + #[doc = " \\sa SDL_HasSSE3"] + #[doc = " \\sa SDL_HasSSE41"] pub fn SDL_HasSSE42() -> SDL_bool; } extern "C" { - #[doc = " This function returns true if the CPU has AVX features."] + #[doc = " Determine whether the CPU has AVX features."] + #[doc = ""] + #[doc = " This always returns false on CPUs that aren't using Intel instruction sets."] + #[doc = ""] + #[doc = " \\returns SDL_TRUE if the CPU has AVX features or SDL_FALSE if not."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.2."] + #[doc = ""] + #[doc = " \\sa SDL_Has3DNow"] + #[doc = " \\sa SDL_HasAltiVec"] + #[doc = " \\sa SDL_HasAVX2"] + #[doc = " \\sa SDL_HasMMX"] + #[doc = " \\sa SDL_HasRDTSC"] + #[doc = " \\sa SDL_HasSSE"] + #[doc = " \\sa SDL_HasSSE2"] + #[doc = " \\sa SDL_HasSSE3"] + #[doc = " \\sa SDL_HasSSE41"] + #[doc = " \\sa SDL_HasSSE42"] pub fn SDL_HasAVX() -> SDL_bool; } extern "C" { - #[doc = " This function returns true if the CPU has AVX2 features."] + #[doc = " Determine whether the CPU has AVX2 features."] + #[doc = ""] + #[doc = " This always returns false on CPUs that aren't using Intel instruction sets."] + #[doc = ""] + #[doc = " \\returns SDL_TRUE if the CPU has AVX2 features or SDL_FALSE if not."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.4."] + #[doc = ""] + #[doc = " \\sa SDL_Has3DNow"] + #[doc = " \\sa SDL_HasAltiVec"] + #[doc = " \\sa SDL_HasAVX"] + #[doc = " \\sa SDL_HasMMX"] + #[doc = " \\sa SDL_HasRDTSC"] + #[doc = " \\sa SDL_HasSSE"] + #[doc = " \\sa SDL_HasSSE2"] + #[doc = " \\sa SDL_HasSSE3"] + #[doc = " \\sa SDL_HasSSE41"] + #[doc = " \\sa SDL_HasSSE42"] pub fn SDL_HasAVX2() -> SDL_bool; } extern "C" { - #[doc = " This function returns true if the CPU has AVX-512F (foundation) features."] + #[doc = " Determine whether the CPU has AVX-512F (foundation) features."] + #[doc = ""] + #[doc = " This always returns false on CPUs that aren't using Intel instruction sets."] + #[doc = ""] + #[doc = " \\returns SDL_TRUE if the CPU has AVX-512F features or SDL_FALSE if not."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.9."] + #[doc = ""] + #[doc = " \\sa SDL_HasAVX"] pub fn SDL_HasAVX512F() -> SDL_bool; } extern "C" { - #[doc = " This function returns true if the CPU has ARM SIMD (ARMv6) features."] + #[doc = " Determine whether the CPU has ARM SIMD (ARMv6) features."] + #[doc = ""] + #[doc = " This is different from ARM NEON, which is a different instruction set."] + #[doc = ""] + #[doc = " This always returns false on CPUs that aren't using ARM instruction sets."] + #[doc = ""] + #[doc = " \\returns SDL_TRUE if the CPU has ARM SIMD features or SDL_FALSE if not."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.12."] + #[doc = ""] + #[doc = " \\sa SDL_HasNEON"] pub fn SDL_HasARMSIMD() -> SDL_bool; } extern "C" { - #[doc = " This function returns true if the CPU has NEON (ARM SIMD) features."] + #[doc = " Determine whether the CPU has NEON (ARM SIMD) features."] + #[doc = ""] + #[doc = " This always returns false on CPUs that aren't using ARM instruction sets."] + #[doc = ""] + #[doc = " \\returns SDL_TRUE if the CPU has ARM NEON features or SDL_FALSE if not."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.6."] pub fn SDL_HasNEON() -> SDL_bool; } extern "C" { - #[doc = " This function returns the amount of RAM configured in the system, in MB."] + #[doc = " Get the amount of RAM configured in the system."] + #[doc = ""] + #[doc = " \\returns the amount of RAM configured in the system in MB."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.1."] pub fn SDL_GetSystemRAM() -> libc::c_int; } extern "C" { - #[doc = " \\brief Report the alignment this system needs for SIMD allocations."] + #[doc = " Report the alignment this system needs for SIMD allocations."] #[doc = ""] #[doc = " This will return the minimum number of bytes to which a pointer must be"] - #[doc = " aligned to be compatible with SIMD instructions on the current machine."] - #[doc = " For example, if the machine supports SSE only, it will return 16, but if"] - #[doc = " it supports AVX-512F, it'll return 64 (etc). This only reports values for"] - #[doc = " instruction sets SDL knows about, so if your SDL build doesn't have"] - #[doc = " SDL_HasAVX512F(), then it might return 16 for the SSE support it sees and"] - #[doc = " not 64 for the AVX-512 instructions that exist but SDL doesn't know about."] - #[doc = " Plan accordingly."] + #[doc = " aligned to be compatible with SIMD instructions on the current machine. For"] + #[doc = " example, if the machine supports SSE only, it will return 16, but if it"] + #[doc = " supports AVX-512F, it'll return 64 (etc). This only reports values for"] + #[doc = " instruction sets SDL knows about, so if your SDL build doesn't have"] + #[doc = " SDL_HasAVX512F(), then it might return 16 for the SSE support it sees and"] + #[doc = " not 64 for the AVX-512 instructions that exist but SDL doesn't know about."] + #[doc = " Plan accordingly."] + #[doc = ""] + #[doc = " \\returns the alignment in bytes needed for available, known SIMD"] + #[doc = " instructions."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.10."] pub fn SDL_SIMDGetAlignment() -> size_t; } extern "C" { - #[doc = " \\brief Allocate memory in a SIMD-friendly way."] + #[doc = " Allocate memory in a SIMD-friendly way."] #[doc = ""] #[doc = " This will allocate a block of memory that is suitable for use with SIMD"] - #[doc = " instructions. Specifically, it will be properly aligned and padded for"] - #[doc = " the system's supported vector instructions."] + #[doc = " instructions. Specifically, it will be properly aligned and padded for the"] + #[doc = " system's supported vector instructions."] #[doc = ""] - #[doc = " The memory returned will be padded such that it is safe to read or write"] - #[doc = " an incomplete vector at the end of the memory block. This can be useful"] - #[doc = " so you don't have to drop back to a scalar fallback at the end of your"] - #[doc = " SIMD processing loop to deal with the final elements without overflowing"] - #[doc = " the allocated buffer."] + #[doc = " The memory returned will be padded such that it is safe to read or write an"] + #[doc = " incomplete vector at the end of the memory block. This can be useful so you"] + #[doc = " don't have to drop back to a scalar fallback at the end of your SIMD"] + #[doc = " processing loop to deal with the final elements without overflowing the"] + #[doc = " allocated buffer."] #[doc = ""] - #[doc = " You must free this memory with SDL_FreeSIMD(), not free() or SDL_free()"] - #[doc = " or delete[], etc."] + #[doc = " You must free this memory with SDL_FreeSIMD(), not free() or SDL_free() or"] + #[doc = " delete[], etc."] #[doc = ""] - #[doc = " Note that SDL will only deal with SIMD instruction sets it is aware of;"] - #[doc = " for example, SDL 2.0.8 knows that SSE wants 16-byte vectors"] - #[doc = " (SDL_HasSSE()), and AVX2 wants 32 bytes (SDL_HasAVX2()), but doesn't"] - #[doc = " know that AVX-512 wants 64. To be clear: if you can't decide to use an"] - #[doc = " instruction set with an SDL_Has*() function, don't use that instruction"] - #[doc = " set with memory allocated through here."] + #[doc = " Note that SDL will only deal with SIMD instruction sets it is aware of; for"] + #[doc = " example, SDL 2.0.8 knows that SSE wants 16-byte vectors (SDL_HasSSE()), and"] + #[doc = " AVX2 wants 32 bytes (SDL_HasAVX2()), but doesn't know that AVX-512 wants"] + #[doc = " 64. To be clear: if you can't decide to use an instruction set with an"] + #[doc = " SDL_Has*() function, don't use that instruction set with memory allocated"] + #[doc = " through here."] #[doc = ""] #[doc = " SDL_AllocSIMD(0) will return a non-NULL pointer, assuming the system isn't"] - #[doc = " out of memory."] + #[doc = " out of memory, but you are not allowed to dereference it (because you only"] + #[doc = " own zero bytes of that buffer)."] + #[doc = ""] + #[doc = " \\param len The length, in bytes, of the block to allocate. The actual"] + #[doc = " allocated block might be larger due to padding, etc."] + #[doc = " \\returns a pointer to the newly-allocated block, NULL if out of memory."] #[doc = ""] - #[doc = " \\param len The length, in bytes, of the block to allocated. The actual"] - #[doc = " allocated block might be larger due to padding, etc."] - #[doc = " \\return Pointer to newly-allocated block, NULL if out of memory."] + #[doc = " \\since This function is available since SDL 2.0.10."] #[doc = ""] #[doc = " \\sa SDL_SIMDAlignment"] #[doc = " \\sa SDL_SIMDRealloc"] @@ -5764,20 +7637,22 @@ extern "C" { pub fn SDL_SIMDAlloc(len: size_t) -> *mut libc::c_void; } extern "C" { - #[doc = " \\brief Reallocate memory obtained from SDL_SIMDAlloc"] + #[doc = " Reallocate memory obtained from SDL_SIMDAlloc"] #[doc = ""] #[doc = " It is not valid to use this function on a pointer from anything but"] - #[doc = " SDL_SIMDAlloc(). It can't be used on pointers from malloc, realloc,"] - #[doc = " SDL_malloc, memalign, new[], etc."] - #[doc = ""] - #[doc = " \\param mem The pointer obtained from SDL_SIMDAlloc. This function also"] - #[doc = " accepts NULL, at which point this function is the same as"] - #[doc = " calling SDL_realloc with a NULL pointer."] - #[doc = " \\param len The length, in bytes, of the block to allocated. The actual"] - #[doc = " allocated block might be larger due to padding, etc. Passing 0"] - #[doc = " will return a non-NULL pointer, assuming the system isn't out of"] - #[doc = " memory."] - #[doc = " \\return Pointer to newly-reallocated block, NULL if out of memory."] + #[doc = " SDL_SIMDAlloc(). It can't be used on pointers from malloc, realloc,"] + #[doc = " SDL_malloc, memalign, new[], etc."] + #[doc = ""] + #[doc = " \\param mem The pointer obtained from SDL_SIMDAlloc. This function also"] + #[doc = " accepts NULL, at which point this function is the same as"] + #[doc = " calling SDL_SIMDAlloc with a NULL pointer."] + #[doc = " \\param len The length, in bytes, of the block to allocated. The actual"] + #[doc = " allocated block might be larger due to padding, etc. Passing 0"] + #[doc = " will return a non-NULL pointer, assuming the system isn't out of"] + #[doc = " memory."] + #[doc = " \\returns a pointer to the newly-reallocated block, NULL if out of memory."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.14."] #[doc = ""] #[doc = " \\sa SDL_SIMDAlignment"] #[doc = " \\sa SDL_SIMDAlloc"] @@ -5785,14 +7660,24 @@ extern "C" { pub fn SDL_SIMDRealloc(mem: *mut libc::c_void, len: size_t) -> *mut libc::c_void; } extern "C" { - #[doc = " \\brief Deallocate memory obtained from SDL_SIMDAlloc"] + #[doc = " Deallocate memory obtained from SDL_SIMDAlloc"] #[doc = ""] #[doc = " It is not valid to use this function on a pointer from anything but"] - #[doc = " SDL_SIMDAlloc(). It can't be used on pointers from malloc, realloc,"] - #[doc = " SDL_malloc, memalign, new[], etc."] + #[doc = " SDL_SIMDAlloc() or SDL_SIMDRealloc(). It can't be used on pointers from"] + #[doc = " malloc, realloc, SDL_malloc, memalign, new[], etc."] #[doc = ""] #[doc = " However, SDL_SIMDFree(NULL) is a legal no-op."] #[doc = ""] + #[doc = " The memory pointed to by `ptr` is no longer valid for access upon return,"] + #[doc = " and may be returned to the system or reused by a future allocation. The"] + #[doc = " pointer passed to this function is no longer safe to dereference once this"] + #[doc = " function returns, and should be discarded."] + #[doc = ""] + #[doc = " \\param ptr The pointer, returned from SDL_SIMDAlloc or SDL_SIMDRealloc, to"] + #[doc = " deallocate. NULL is a legal no-op."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.10."] + #[doc = ""] #[doc = " \\sa SDL_SIMDAlloc"] #[doc = " \\sa SDL_SIMDRealloc"] pub fn SDL_SIMDFree(ptr: *mut libc::c_void); @@ -5954,6 +7839,9 @@ pub enum SDL_PixelFormatEnum { #[doc = "< Android video texture format"] SDL_PIXELFORMAT_EXTERNAL_OES = 542328143, } +#[doc = " The bits of this structure can be directly reinterpreted as an integer-packed"] +#[doc = " color which uses the SDL_PIXELFORMAT_RGBA32 format (SDL_PIXELFORMAT_ABGR8888"] +#[doc = " on little-endian systems and SDL_PIXELFORMAT_RGBA8888 on big-endian systems)."] #[repr(C)] #[derive(Copy, Clone)] pub struct SDL_Color { @@ -6304,15 +8192,30 @@ fn bindgen_test_layout_SDL_PixelFormat() { ); } extern "C" { - #[doc = " \\brief Get the human readable name of a pixel format"] + #[doc = " Get the human readable name of a pixel format."] + #[doc = ""] + #[doc = " \\param format the pixel format to query"] + #[doc = " \\returns the human readable name of the specified pixel format or"] + #[doc = " `SDL_PIXELFORMAT_UNKNOWN` if the format isn't recognized."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_GetPixelFormatName(format: Uint32) -> *const libc::c_char; } extern "C" { - #[doc = " \\brief Convert one of the enumerated pixel formats to a bpp and RGBA masks."] + #[doc = " Convert one of the enumerated pixel formats to a bpp value and RGBA masks."] + #[doc = ""] + #[doc = " \\param format one of the SDL_PixelFormatEnum values"] + #[doc = " \\param bpp a bits per pixel value; usually 15, 16, or 32"] + #[doc = " \\param Rmask a pointer filled in with the red mask for the format"] + #[doc = " \\param Gmask a pointer filled in with the green mask for the format"] + #[doc = " \\param Bmask a pointer filled in with the blue mask for the format"] + #[doc = " \\param Amask a pointer filled in with the alpha mask for the format"] + #[doc = " \\returns SDL_TRUE on success or SDL_FALSE if the conversion wasn't"] + #[doc = " possible; call SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return SDL_TRUE, or SDL_FALSE if the conversion wasn't possible."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_MasksToPixelFormatEnum()"] + #[doc = " \\sa SDL_MasksToPixelFormatEnum"] pub fn SDL_PixelFormatEnumToMasks( format: Uint32, bpp: *mut libc::c_int, @@ -6323,12 +8226,21 @@ extern "C" { ) -> SDL_bool; } extern "C" { - #[doc = " \\brief Convert a bpp and RGBA masks to an enumerated pixel format."] + #[doc = " Convert a bpp value and RGBA masks to an enumerated pixel format."] #[doc = ""] - #[doc = " \\return The pixel format, or ::SDL_PIXELFORMAT_UNKNOWN if the conversion"] - #[doc = " wasn't possible."] + #[doc = " This will return `SDL_PIXELFORMAT_UNKNOWN` if the conversion wasn't"] + #[doc = " possible."] #[doc = ""] - #[doc = " \\sa SDL_PixelFormatEnumToMasks()"] + #[doc = " \\param bpp a bits per pixel value; usually 15, 16, or 32"] + #[doc = " \\param Rmask the red mask for the format"] + #[doc = " \\param Gmask the green mask for the format"] + #[doc = " \\param Bmask the blue mask for the format"] + #[doc = " \\param Amask the alpha mask for the format"] + #[doc = " \\returns one of the SDL_PixelFormatEnum values"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_PixelFormatEnumToMasks"] pub fn SDL_MasksToPixelFormatEnum( bpp: libc::c_int, Rmask: Uint32, @@ -6338,40 +8250,77 @@ extern "C" { ) -> Uint32; } extern "C" { - #[doc = " \\brief Create an SDL_PixelFormat structure from a pixel format enum."] + #[doc = " Create an SDL_PixelFormat structure corresponding to a pixel format."] + #[doc = ""] + #[doc = " Returned structure may come from a shared global cache (i.e. not newly"] + #[doc = " allocated), and hence should not be modified, especially the palette. Weird"] + #[doc = " errors such as `Blit combination not supported` may occur."] + #[doc = ""] + #[doc = " \\param pixel_format one of the SDL_PixelFormatEnum values"] + #[doc = " \\returns the new SDL_PixelFormat structure or NULL on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_FreeFormat"] pub fn SDL_AllocFormat(pixel_format: Uint32) -> *mut SDL_PixelFormat; } extern "C" { - #[doc = " \\brief Free an SDL_PixelFormat structure."] + #[doc = " Free an SDL_PixelFormat structure allocated by SDL_AllocFormat()."] + #[doc = ""] + #[doc = " \\param format the SDL_PixelFormat structure to free"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_AllocFormat"] pub fn SDL_FreeFormat(format: *mut SDL_PixelFormat); } extern "C" { - #[doc = " \\brief Create a palette structure with the specified number of color"] - #[doc = " entries."] + #[doc = " Create a palette structure with the specified number of color entries."] + #[doc = ""] + #[doc = " The palette entries are initialized to white."] #[doc = ""] - #[doc = " \\return A new palette, or NULL if there wasn't enough memory."] + #[doc = " \\param ncolors represents the number of color entries in the color palette"] + #[doc = " \\returns a new SDL_Palette structure on success or NULL on failure (e.g. if"] + #[doc = " there wasn't enough memory); call SDL_GetError() for more"] + #[doc = " information."] #[doc = ""] - #[doc = " \\note The palette entries are initialized to white."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_FreePalette()"] + #[doc = " \\sa SDL_FreePalette"] pub fn SDL_AllocPalette(ncolors: libc::c_int) -> *mut SDL_Palette; } extern "C" { - #[doc = " \\brief Set the palette for a pixel format structure."] + #[doc = " Set the palette for a pixel format structure."] + #[doc = ""] + #[doc = " \\param format the SDL_PixelFormat structure that will use the palette"] + #[doc = " \\param palette the SDL_Palette structure that will be used"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_AllocPalette"] + #[doc = " \\sa SDL_FreePalette"] pub fn SDL_SetPixelFormatPalette( format: *mut SDL_PixelFormat, palette: *mut SDL_Palette, ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Set a range of colors in a palette."] + #[doc = " Set a range of colors in a palette."] + #[doc = ""] + #[doc = " \\param palette the SDL_Palette structure to modify"] + #[doc = " \\param colors an array of SDL_Color structures to copy into the palette"] + #[doc = " \\param firstcolor the index of the first palette entry to modify"] + #[doc = " \\param ncolors the number of entries to modify"] + #[doc = " \\returns 0 on success or a negative error code if not all of the colors"] + #[doc = " could be set; call SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\param palette The palette to modify."] - #[doc = " \\param colors An array of colors to copy into the palette."] - #[doc = " \\param firstcolor The index of the first palette entry to modify."] - #[doc = " \\param ncolors The number of entries to modify."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if not all of the colors could be set."] + #[doc = " \\sa SDL_AllocPalette"] + #[doc = " \\sa SDL_CreateRGBSurface"] pub fn SDL_SetPaletteColors( palette: *mut SDL_Palette, colors: *const SDL_Color, @@ -6380,21 +8329,77 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Free a palette created with SDL_AllocPalette()."] + #[doc = " Free a palette created with SDL_AllocPalette()."] + #[doc = ""] + #[doc = " \\param palette the SDL_Palette structure to be freed"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_AllocPalette()"] + #[doc = " \\sa SDL_AllocPalette"] pub fn SDL_FreePalette(palette: *mut SDL_Palette); } extern "C" { - #[doc = " \\brief Maps an RGB triple to an opaque pixel value for a given pixel format."] + #[doc = " Map an RGB triple to an opaque pixel value for a given pixel format."] + #[doc = ""] + #[doc = " This function maps the RGB color value to the specified pixel format and"] + #[doc = " returns the pixel value best approximating the given RGB color value for"] + #[doc = " the given pixel format."] + #[doc = ""] + #[doc = " If the format has a palette (8-bit) the index of the closest matching color"] + #[doc = " in the palette will be returned."] + #[doc = ""] + #[doc = " If the specified pixel format has an alpha component it will be returned as"] + #[doc = " all 1 bits (fully opaque)."] + #[doc = ""] + #[doc = " If the pixel format bpp (color depth) is less than 32-bpp then the unused"] + #[doc = " upper bits of the return value can safely be ignored (e.g., with a 16-bpp"] + #[doc = " format the return value can be assigned to a Uint16, and similarly a Uint8"] + #[doc = " for an 8-bpp format)."] #[doc = ""] - #[doc = " \\sa SDL_MapRGBA"] + #[doc = " \\param format an SDL_PixelFormat structure describing the pixel format"] + #[doc = " \\param r the red component of the pixel in the range 0-255"] + #[doc = " \\param g the green component of the pixel in the range 0-255"] + #[doc = " \\param b the blue component of the pixel in the range 0-255"] + #[doc = " \\returns a pixel value"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetRGB"] + #[doc = " \\sa SDL_GetRGBA"] + #[doc = " \\sa SDL_MapRGBA"] pub fn SDL_MapRGB(format: *const SDL_PixelFormat, r: Uint8, g: Uint8, b: Uint8) -> Uint32; } extern "C" { - #[doc = " \\brief Maps an RGBA quadruple to a pixel value for a given pixel format."] + #[doc = " Map an RGBA quadruple to a pixel value for a given pixel format."] + #[doc = ""] + #[doc = " This function maps the RGBA color value to the specified pixel format and"] + #[doc = " returns the pixel value best approximating the given RGBA color value for"] + #[doc = " the given pixel format."] + #[doc = ""] + #[doc = " If the specified pixel format has no alpha component the alpha value will"] + #[doc = " be ignored (as it will be in formats with a palette)."] + #[doc = ""] + #[doc = " If the format has a palette (8-bit) the index of the closest matching color"] + #[doc = " in the palette will be returned."] + #[doc = ""] + #[doc = " If the pixel format bpp (color depth) is less than 32-bpp then the unused"] + #[doc = " upper bits of the return value can safely be ignored (e.g., with a 16-bpp"] + #[doc = " format the return value can be assigned to a Uint16, and similarly a Uint8"] + #[doc = " for an 8-bpp format)."] + #[doc = ""] + #[doc = " \\param format an SDL_PixelFormat structure describing the format of the"] + #[doc = " pixel"] + #[doc = " \\param r the red component of the pixel in the range 0-255"] + #[doc = " \\param g the green component of the pixel in the range 0-255"] + #[doc = " \\param b the blue component of the pixel in the range 0-255"] + #[doc = " \\param a the alpha component of the pixel in the range 0-255"] + #[doc = " \\returns a pixel value"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_MapRGB"] + #[doc = " \\sa SDL_GetRGB"] + #[doc = " \\sa SDL_GetRGBA"] + #[doc = " \\sa SDL_MapRGB"] pub fn SDL_MapRGBA( format: *const SDL_PixelFormat, r: Uint8, @@ -6404,9 +8409,25 @@ extern "C" { ) -> Uint32; } extern "C" { - #[doc = " \\brief Get the RGB components from a pixel of the specified format."] + #[doc = " Get RGB values from a pixel in the specified format."] #[doc = ""] - #[doc = " \\sa SDL_GetRGBA"] + #[doc = " This function uses the entire 8-bit [0..255] range when converting color"] + #[doc = " components from pixel formats with less than 8-bits per RGB component"] + #[doc = " (e.g., a completely white pixel in 16-bit RGB565 format would return [0xff,"] + #[doc = " 0xff, 0xff] not [0xf8, 0xfc, 0xf8])."] + #[doc = ""] + #[doc = " \\param pixel a pixel value"] + #[doc = " \\param format an SDL_PixelFormat structure describing the format of the"] + #[doc = " pixel"] + #[doc = " \\param r a pointer filled in with the red component"] + #[doc = " \\param g a pointer filled in with the green component"] + #[doc = " \\param b a pointer filled in with the blue component"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetRGBA"] + #[doc = " \\sa SDL_MapRGB"] + #[doc = " \\sa SDL_MapRGBA"] pub fn SDL_GetRGB( pixel: Uint32, format: *const SDL_PixelFormat, @@ -6416,9 +8437,29 @@ extern "C" { ); } extern "C" { - #[doc = " \\brief Get the RGBA components from a pixel of the specified format."] + #[doc = " Get RGBA values from a pixel in the specified format."] + #[doc = ""] + #[doc = " This function uses the entire 8-bit [0..255] range when converting color"] + #[doc = " components from pixel formats with less than 8-bits per RGB component"] + #[doc = " (e.g., a completely white pixel in 16-bit RGB565 format would return [0xff,"] + #[doc = " 0xff, 0xff] not [0xf8, 0xfc, 0xf8])."] #[doc = ""] - #[doc = " \\sa SDL_GetRGB"] + #[doc = " If the surface has no alpha component, the alpha will be returned as 0xff"] + #[doc = " (100% opaque)."] + #[doc = ""] + #[doc = " \\param pixel a pixel value"] + #[doc = " \\param format an SDL_PixelFormat structure describing the format of the"] + #[doc = " pixel"] + #[doc = " \\param r a pointer filled in with the red component"] + #[doc = " \\param g a pointer filled in with the green component"] + #[doc = " \\param b a pointer filled in with the blue component"] + #[doc = " \\param a a pointer filled in with the alpha component"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetRGB"] + #[doc = " \\sa SDL_MapRGB"] + #[doc = " \\sa SDL_MapRGBA"] pub fn SDL_GetRGBA( pixel: Uint32, format: *const SDL_PixelFormat, @@ -6429,13 +8470,20 @@ extern "C" { ); } extern "C" { - #[doc = " \\brief Calculate a 256 entry gamma ramp for a gamma value."] + #[doc = " Calculate a 256 entry gamma ramp for a gamma value."] + #[doc = ""] + #[doc = " \\param gamma a gamma value where 0.0 is black and 1.0 is identity"] + #[doc = " \\param ramp an array of 256 values filled in with the gamma ramp"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_SetWindowGammaRamp"] pub fn SDL_CalculateGammaRamp(gamma: f32, ramp: *mut Uint16); } -#[doc = " \\brief The structure that defines a point (integer)"] +#[doc = " The structure that defines a point (integer)"] #[doc = ""] -#[doc = " \\sa SDL_EnclosePoints"] -#[doc = " \\sa SDL_PointInRect"] +#[doc = " \\sa SDL_EnclosePoints"] +#[doc = " \\sa SDL_PointInRect"] #[repr(C)] #[derive(Copy, Clone)] pub struct SDL_Point { @@ -6475,10 +8523,10 @@ fn bindgen_test_layout_SDL_Point() { ) ); } -#[doc = " \\brief The structure that defines a point (floating point)"] +#[doc = " The structure that defines a point (floating point)"] #[doc = ""] -#[doc = " \\sa SDL_EnclosePoints"] -#[doc = " \\sa SDL_PointInRect"] +#[doc = " \\sa SDL_EnclosePoints"] +#[doc = " \\sa SDL_PointInRect"] #[repr(C)] #[derive(Copy, Clone)] pub struct SDL_FPoint { @@ -6518,14 +8566,14 @@ fn bindgen_test_layout_SDL_FPoint() { ) ); } -#[doc = " \\brief A rectangle, with the origin at the upper left (integer)."] +#[doc = " A rectangle, with the origin at the upper left (integer)."] #[doc = ""] -#[doc = " \\sa SDL_RectEmpty"] -#[doc = " \\sa SDL_RectEquals"] -#[doc = " \\sa SDL_HasIntersection"] -#[doc = " \\sa SDL_IntersectRect"] -#[doc = " \\sa SDL_UnionRect"] -#[doc = " \\sa SDL_EnclosePoints"] +#[doc = " \\sa SDL_RectEmpty"] +#[doc = " \\sa SDL_RectEquals"] +#[doc = " \\sa SDL_HasIntersection"] +#[doc = " \\sa SDL_IntersectRect"] +#[doc = " \\sa SDL_UnionRect"] +#[doc = " \\sa SDL_EnclosePoints"] #[repr(C)] #[derive(Copy, Clone)] pub struct SDL_Rect { @@ -6587,7 +8635,7 @@ fn bindgen_test_layout_SDL_Rect() { ) ); } -#[doc = " \\brief A rectangle, with the origin at the upper left (floating point)."] +#[doc = " A rectangle, with the origin at the upper left (floating point)."] #[repr(C)] #[derive(Copy, Clone)] pub struct SDL_FRect { @@ -6650,15 +8698,33 @@ fn bindgen_test_layout_SDL_FRect() { ); } extern "C" { - #[doc = " \\brief Determine whether two rectangles intersect."] + #[doc = " Determine whether two rectangles intersect."] + #[doc = ""] + #[doc = " If either pointer is NULL the function will return SDL_FALSE."] + #[doc = ""] + #[doc = " \\param A an SDL_Rect structure representing the first rectangle"] + #[doc = " \\param B an SDL_Rect structure representing the second rectangle"] + #[doc = " \\returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise."] #[doc = ""] - #[doc = " \\return SDL_TRUE if there is an intersection, SDL_FALSE otherwise."] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_IntersectRect"] pub fn SDL_HasIntersection(A: *const SDL_Rect, B: *const SDL_Rect) -> SDL_bool; } extern "C" { - #[doc = " \\brief Calculate the intersection of two rectangles."] + #[doc = " Calculate the intersection of two rectangles."] + #[doc = ""] + #[doc = " If `result` is NULL then this function will return SDL_FALSE."] + #[doc = ""] + #[doc = " \\param A an SDL_Rect structure representing the first rectangle"] + #[doc = " \\param B an SDL_Rect structure representing the second rectangle"] + #[doc = " \\param result an SDL_Rect structure filled in with the intersection of"] + #[doc = " rectangles `A` and `B`"] + #[doc = " \\returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\return SDL_TRUE if there is an intersection, SDL_FALSE otherwise."] + #[doc = " \\sa SDL_HasIntersection"] pub fn SDL_IntersectRect( A: *const SDL_Rect, B: *const SDL_Rect, @@ -6666,13 +8732,32 @@ extern "C" { ) -> SDL_bool; } extern "C" { - #[doc = " \\brief Calculate the union of two rectangles."] + #[doc = " Calculate the union of two rectangles."] + #[doc = ""] + #[doc = " \\param A an SDL_Rect structure representing the first rectangle"] + #[doc = " \\param B an SDL_Rect structure representing the second rectangle"] + #[doc = " \\param result an SDL_Rect structure filled in with the union of rectangles"] + #[doc = " `A` and `B`"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_UnionRect(A: *const SDL_Rect, B: *const SDL_Rect, result: *mut SDL_Rect); } extern "C" { - #[doc = " \\brief Calculate a minimal rectangle enclosing a set of points"] + #[doc = " Calculate a minimal rectangle enclosing a set of points."] + #[doc = ""] + #[doc = " If `clip` is not NULL then only points inside of the clipping rectangle are"] + #[doc = " considered."] + #[doc = ""] + #[doc = " \\param points an array of SDL_Point structures representing points to be"] + #[doc = " enclosed"] + #[doc = " \\param count the number of structures in the `points` array"] + #[doc = " \\param clip an SDL_Rect used for clipping or NULL to enclose all points"] + #[doc = " \\param result an SDL_Rect structure filled in with the minimal enclosing"] + #[doc = " rectangle"] + #[doc = " \\returns SDL_TRUE if any points were enclosed or SDL_FALSE if all the"] + #[doc = " points were outside of the clipping rectangle."] #[doc = ""] - #[doc = " \\return SDL_TRUE if any points were within the clipping rect"] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_EnclosePoints( points: *const SDL_Point, count: libc::c_int, @@ -6681,9 +8766,22 @@ extern "C" { ) -> SDL_bool; } extern "C" { - #[doc = " \\brief Calculate the intersection of a rectangle and line segment."] + #[doc = " Calculate the intersection of a rectangle and line segment."] #[doc = ""] - #[doc = " \\return SDL_TRUE if there is an intersection, SDL_FALSE otherwise."] + #[doc = " This function is used to clip a line segment to a rectangle. A line segment"] + #[doc = " contained entirely within the rectangle or that does not intersect will"] + #[doc = " remain unchanged. A line segment that crosses the rectangle at either or"] + #[doc = " both ends will be clipped to the boundary of the rectangle and the new"] + #[doc = " coordinates saved in `X1`, `Y1`, `X2`, and/or `Y2` as necessary."] + #[doc = ""] + #[doc = " \\param rect an SDL_Rect structure representing the rectangle to intersect"] + #[doc = " \\param X1 a pointer to the starting X-coordinate of the line"] + #[doc = " \\param Y1 a pointer to the starting Y-coordinate of the line"] + #[doc = " \\param X2 a pointer to the ending X-coordinate of the line"] + #[doc = " \\param Y2 a pointer to the ending Y-coordinate of the line"] + #[doc = " \\returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_IntersectRectAndLine( rect: *const SDL_Rect, X1: *mut libc::c_int, @@ -6758,19 +8856,96 @@ pub enum SDL_BlendFactor { SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA = 10, } extern "C" { - #[doc = " \\brief Create a custom blend mode, which may or may not be supported by a given renderer"] - #[doc = ""] - #[doc = " \\param srcColorFactor source color factor"] - #[doc = " \\param dstColorFactor destination color factor"] - #[doc = " \\param colorOperation color operation"] - #[doc = " \\param srcAlphaFactor source alpha factor"] - #[doc = " \\param dstAlphaFactor destination alpha factor"] - #[doc = " \\param alphaOperation alpha operation"] - #[doc = ""] - #[doc = " The result of the blend mode operation will be:"] - #[doc = " dstRGB = dstRGB * dstColorFactor colorOperation srcRGB * srcColorFactor"] - #[doc = " and"] - #[doc = " dstA = dstA * dstAlphaFactor alphaOperation srcA * srcAlphaFactor"] + #[doc = " Compose a custom blend mode for renderers."] + #[doc = ""] + #[doc = " The functions SDL_SetRenderDrawBlendMode and SDL_SetTextureBlendMode accept"] + #[doc = " the SDL_BlendMode returned by this function if the renderer supports it."] + #[doc = ""] + #[doc = " A blend mode controls how the pixels from a drawing operation (source) get"] + #[doc = " combined with the pixels from the render target (destination). First, the"] + #[doc = " components of the source and destination pixels get multiplied with their"] + #[doc = " blend factors. Then, the blend operation takes the two products and"] + #[doc = " calculates the result that will get stored in the render target."] + #[doc = ""] + #[doc = " Expressed in pseudocode, it would look like this:"] + #[doc = ""] + #[doc = " ```c"] + #[doc = " dstRGB = colorOperation(srcRGB * srcColorFactor, dstRGB * dstColorFactor);"] + #[doc = " dstA = alphaOperation(srcA * srcAlphaFactor, dstA * dstAlphaFactor);"] + #[doc = " ```"] + #[doc = ""] + #[doc = " Where the functions `colorOperation(src, dst)` and `alphaOperation(src,"] + #[doc = " dst)` can return one of the following:"] + #[doc = ""] + #[doc = " - `src + dst`"] + #[doc = " - `src - dst`"] + #[doc = " - `dst - src`"] + #[doc = " - `min(src, dst)`"] + #[doc = " - `max(src, dst)`"] + #[doc = ""] + #[doc = " The red, green, and blue components are always multiplied with the first,"] + #[doc = " second, and third components of the SDL_BlendFactor, respectively. The"] + #[doc = " fourth component is not used."] + #[doc = ""] + #[doc = " The alpha component is always multiplied with the fourth component of the"] + #[doc = " SDL_BlendFactor. The other components are not used in the alpha"] + #[doc = " calculation."] + #[doc = ""] + #[doc = " Support for these blend modes varies for each renderer. To check if a"] + #[doc = " specific SDL_BlendMode is supported, create a renderer and pass it to"] + #[doc = " either SDL_SetRenderDrawBlendMode or SDL_SetTextureBlendMode. They will"] + #[doc = " return with an error if the blend mode is not supported."] + #[doc = ""] + #[doc = " This list describes the support of custom blend modes for each renderer in"] + #[doc = " SDL 2.0.6. All renderers support the four blend modes listed in the"] + #[doc = " SDL_BlendMode enumeration."] + #[doc = ""] + #[doc = " - **direct3d**: Supports `SDL_BLENDOPERATION_ADD` with all factors."] + #[doc = " - **direct3d11**: Supports all operations with all factors. However, some"] + #[doc = " factors produce unexpected results with `SDL_BLENDOPERATION_MINIMUM` and"] + #[doc = " `SDL_BLENDOPERATION_MAXIMUM`."] + #[doc = " - **opengl**: Supports the `SDL_BLENDOPERATION_ADD` operation with all"] + #[doc = " factors. OpenGL versions 1.1, 1.2, and 1.3 do not work correctly with SDL"] + #[doc = " 2.0.6."] + #[doc = " - **opengles**: Supports the `SDL_BLENDOPERATION_ADD` operation with all"] + #[doc = " factors. Color and alpha factors need to be the same. OpenGL ES 1"] + #[doc = " implementation specific: May also support `SDL_BLENDOPERATION_SUBTRACT`"] + #[doc = " and `SDL_BLENDOPERATION_REV_SUBTRACT`. May support color and alpha"] + #[doc = " operations being different from each other. May support color and alpha"] + #[doc = " factors being different from each other."] + #[doc = " - **opengles2**: Supports the `SDL_BLENDOPERATION_ADD`,"] + #[doc = " `SDL_BLENDOPERATION_SUBTRACT`, `SDL_BLENDOPERATION_REV_SUBTRACT`"] + #[doc = " operations with all factors."] + #[doc = " - **psp**: No custom blend mode support."] + #[doc = " - **software**: No custom blend mode support."] + #[doc = ""] + #[doc = " Some renderers do not provide an alpha component for the default render"] + #[doc = " target. The `SDL_BLENDFACTOR_DST_ALPHA` and"] + #[doc = " `SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA` factors do not have an effect in this"] + #[doc = " case."] + #[doc = ""] + #[doc = " \\param srcColorFactor the SDL_BlendFactor applied to the red, green, and"] + #[doc = " blue components of the source pixels"] + #[doc = " \\param dstColorFactor the SDL_BlendFactor applied to the red, green, and"] + #[doc = " blue components of the destination pixels"] + #[doc = " \\param colorOperation the SDL_BlendOperation used to combine the red,"] + #[doc = " green, and blue components of the source and"] + #[doc = " destination pixels"] + #[doc = " \\param srcAlphaFactor the SDL_BlendFactor applied to the alpha component of"] + #[doc = " the source pixels"] + #[doc = " \\param dstAlphaFactor the SDL_BlendFactor applied to the alpha component of"] + #[doc = " the destination pixels"] + #[doc = " \\param alphaOperation the SDL_BlendOperation used to combine the alpha"] + #[doc = " component of the source and destination pixels"] + #[doc = " \\returns an SDL_BlendMode that represents the chosen factors and"] + #[doc = " operations."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.6."] + #[doc = ""] + #[doc = " \\sa SDL_SetRenderDrawBlendMode"] + #[doc = " \\sa SDL_GetRenderDrawBlendMode"] + #[doc = " \\sa SDL_SetTextureBlendMode"] + #[doc = " \\sa SDL_GetTextureBlendMode"] pub fn SDL_ComposeCustomBlendMode( srcColorFactor: SDL_BlendFactor, dstColorFactor: SDL_BlendFactor, @@ -6968,22 +9143,48 @@ pub enum SDL_YUV_CONVERSION_MODE { SDL_YUV_CONVERSION_AUTOMATIC = 3, } extern "C" { - #[doc = " Allocate and free an RGB surface."] + #[doc = " Allocate a new RGB surface."] #[doc = ""] - #[doc = " If the depth is 4 or 8 bits, an empty palette is allocated for the surface."] - #[doc = " If the depth is greater than 8 bits, the pixel format is set using the"] - #[doc = " flags '[RGB]mask'."] + #[doc = " If `depth` is 4 or 8 bits, an empty palette is allocated for the surface."] + #[doc = " If `depth` is greater than 8 bits, the pixel format is set using the"] + #[doc = " [RGBA]mask parameters."] #[doc = ""] - #[doc = " If the function runs out of memory, it will return NULL."] + #[doc = " The [RGBA]mask parameters are the bitmasks used to extract that color from"] + #[doc = " a pixel. For instance, `Rmask` being 0xFF000000 means the red data is"] + #[doc = " stored in the most significant byte. Using zeros for the RGB masks sets a"] + #[doc = " default value, based on the depth. For example:"] #[doc = ""] - #[doc = " \\param flags The \\c flags are obsolete and should be set to 0."] - #[doc = " \\param width The width in pixels of the surface to create."] - #[doc = " \\param height The height in pixels of the surface to create."] - #[doc = " \\param depth The depth in bits of the surface to create."] - #[doc = " \\param Rmask The red mask of the surface to create."] - #[doc = " \\param Gmask The green mask of the surface to create."] - #[doc = " \\param Bmask The blue mask of the surface to create."] - #[doc = " \\param Amask The alpha mask of the surface to create."] + #[doc = " ```c++"] + #[doc = " SDL_CreateRGBSurface(0,w,h,32,0,0,0,0);"] + #[doc = " ```"] + #[doc = ""] + #[doc = " However, using zero for the Amask results in an Amask of 0."] + #[doc = ""] + #[doc = " By default surfaces with an alpha mask are set up for blending as with:"] + #[doc = ""] + #[doc = " ```c++"] + #[doc = " SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_BLEND)"] + #[doc = " ```"] + #[doc = ""] + #[doc = " You can change this by calling SDL_SetSurfaceBlendMode() and selecting a"] + #[doc = " different `blendMode`."] + #[doc = ""] + #[doc = " \\param flags the flags are unused and should be set to 0"] + #[doc = " \\param width the width of the surface"] + #[doc = " \\param height the height of the surface"] + #[doc = " \\param depth the depth of the surface in bits"] + #[doc = " \\param Rmask the red mask for the pixels"] + #[doc = " \\param Gmask the green mask for the pixels"] + #[doc = " \\param Bmask the blue mask for the pixels"] + #[doc = " \\param Amask the alpha mask for the pixels"] + #[doc = " \\returns the new SDL_Surface structure that is created or NULL if it fails;"] + #[doc = " call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateRGBSurfaceFrom"] + #[doc = " \\sa SDL_CreateRGBSurfaceWithFormat"] + #[doc = " \\sa SDL_FreeSurface"] pub fn SDL_CreateRGBSurface( flags: Uint32, width: libc::c_int, @@ -6996,6 +9197,25 @@ extern "C" { ) -> *mut SDL_Surface; } extern "C" { + #[doc = " Allocate a new RGB surface with a specific pixel format."] + #[doc = ""] + #[doc = " This function operates mostly like SDL_CreateRGBSurface(), except instead"] + #[doc = " of providing pixel color masks, you provide it with a predefined format"] + #[doc = " from SDL_PixelFormatEnum."] + #[doc = ""] + #[doc = " \\param flags the flags are unused and should be set to 0"] + #[doc = " \\param width the width of the surface"] + #[doc = " \\param height the height of the surface"] + #[doc = " \\param depth the depth of the surface in bits"] + #[doc = " \\param format the SDL_PixelFormatEnum for the new surface's pixel format."] + #[doc = " \\returns the new SDL_Surface structure that is created or NULL if it fails;"] + #[doc = " call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.5."] + #[doc = ""] + #[doc = " \\sa SDL_CreateRGBSurface"] + #[doc = " \\sa SDL_CreateRGBSurfaceFrom"] + #[doc = " \\sa SDL_FreeSurface"] pub fn SDL_CreateRGBSurfaceWithFormat( flags: Uint32, width: libc::c_int, @@ -7005,6 +9225,32 @@ extern "C" { ) -> *mut SDL_Surface; } extern "C" { + #[doc = " Allocate a new RGB surface with existing pixel data."] + #[doc = ""] + #[doc = " This function operates mostly like SDL_CreateRGBSurface(), except it does"] + #[doc = " not allocate memory for the pixel data, instead the caller provides an"] + #[doc = " existing buffer of data for the surface to use."] + #[doc = ""] + #[doc = " No copy is made of the pixel data. Pixel data is not managed automatically;"] + #[doc = " you must free the surface before you free the pixel data."] + #[doc = ""] + #[doc = " \\param pixels a pointer to existing pixel data"] + #[doc = " \\param width the width of the surface"] + #[doc = " \\param height the height of the surface"] + #[doc = " \\param depth the depth of the surface in bits"] + #[doc = " \\param pitch the pitch of the surface in bytes"] + #[doc = " \\param Rmask the red mask for the pixels"] + #[doc = " \\param Gmask the green mask for the pixels"] + #[doc = " \\param Bmask the blue mask for the pixels"] + #[doc = " \\param Amask the alpha mask for the pixels"] + #[doc = " \\returns the new SDL_Surface structure that is created or NULL if it fails;"] + #[doc = " call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateRGBSurface"] + #[doc = " \\sa SDL_CreateRGBSurfaceWithFormat"] + #[doc = " \\sa SDL_FreeSurface"] pub fn SDL_CreateRGBSurfaceFrom( pixels: *mut libc::c_void, width: libc::c_int, @@ -7018,6 +9264,30 @@ extern "C" { ) -> *mut SDL_Surface; } extern "C" { + #[doc = " Allocate a new RGB surface with with a specific pixel format and existing"] + #[doc = " pixel data."] + #[doc = ""] + #[doc = " This function operates mostly like SDL_CreateRGBSurfaceFrom(), except"] + #[doc = " instead of providing pixel color masks, you provide it with a predefined"] + #[doc = " format from SDL_PixelFormatEnum."] + #[doc = ""] + #[doc = " No copy is made of the pixel data. Pixel data is not managed automatically;"] + #[doc = " you must free the surface before you free the pixel data."] + #[doc = ""] + #[doc = " \\param pixels a pointer to existing pixel data"] + #[doc = " \\param width the width of the surface"] + #[doc = " \\param height the height of the surface"] + #[doc = " \\param depth the depth of the surface in bits"] + #[doc = " \\param pitch the pitch of the surface in bytes"] + #[doc = " \\param format the SDL_PixelFormatEnum for the new surface's pixel format."] + #[doc = " \\returns the new SDL_Surface structure that is created or NULL if it fails;"] + #[doc = " call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.5."] + #[doc = ""] + #[doc = " \\sa SDL_CreateRGBSurfaceFrom"] + #[doc = " \\sa SDL_CreateRGBSurfaceWithFormat"] + #[doc = " \\sa SDL_FreeSurface"] pub fn SDL_CreateRGBSurfaceWithFormatFrom( pixels: *mut libc::c_void, width: libc::c_int, @@ -7028,65 +9298,110 @@ extern "C" { ) -> *mut SDL_Surface; } extern "C" { + #[doc = " Free an RGB surface."] + #[doc = ""] + #[doc = " It is safe to pass NULL to this function."] + #[doc = ""] + #[doc = " \\param surface the SDL_Surface to free."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateRGBSurface"] + #[doc = " \\sa SDL_CreateRGBSurfaceFrom"] + #[doc = " \\sa SDL_LoadBMP"] + #[doc = " \\sa SDL_LoadBMP_RW"] pub fn SDL_FreeSurface(surface: *mut SDL_Surface); } extern "C" { - #[doc = " \\brief Set the palette used by a surface."] + #[doc = " Set the palette used by a surface."] + #[doc = ""] + #[doc = " A single palette can be shared with many surfaces."] #[doc = ""] - #[doc = " \\return 0, or -1 if the surface format doesn't use a palette."] + #[doc = " \\param surface the SDL_Surface structure to update"] + #[doc = " \\param palette the SDL_Palette structure to use"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\note A single palette can be shared with many surfaces."] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_SetSurfacePalette( surface: *mut SDL_Surface, palette: *mut SDL_Palette, ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Sets up a surface for directly accessing the pixels."] + #[doc = " Set up a surface for directly accessing the pixels."] #[doc = ""] - #[doc = " Between calls to SDL_LockSurface() / SDL_UnlockSurface(), you can write"] - #[doc = " to and read from \\c surface->pixels, using the pixel format stored in"] - #[doc = " \\c surface->format. Once you are done accessing the surface, you should"] - #[doc = " use SDL_UnlockSurface() to release it."] + #[doc = " Between calls to SDL_LockSurface() / SDL_UnlockSurface(), you can write to"] + #[doc = " and read from `surface->pixels`, using the pixel format stored in"] + #[doc = " `surface->format`. Once you are done accessing the surface, you should use"] + #[doc = " SDL_UnlockSurface() to release it."] #[doc = ""] - #[doc = " Not all surfaces require locking. If SDL_MUSTLOCK(surface) evaluates"] - #[doc = " to 0, then you can read and write to the surface at any time, and the"] - #[doc = " pixel format of the surface will not change."] + #[doc = " Not all surfaces require locking. If `SDL_MUSTLOCK(surface)` evaluates to"] + #[doc = " 0, then you can read and write to the surface at any time, and the pixel"] + #[doc = " format of the surface will not change."] #[doc = ""] - #[doc = " No operating system or library calls should be made between lock/unlock"] - #[doc = " pairs, as critical system locks may be held during this time."] + #[doc = " \\param surface the SDL_Surface structure to be locked"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " SDL_LockSurface() returns 0, or -1 if the surface couldn't be locked."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_UnlockSurface()"] + #[doc = " \\sa SDL_MUSTLOCK"] + #[doc = " \\sa SDL_UnlockSurface"] pub fn SDL_LockSurface(surface: *mut SDL_Surface) -> libc::c_int; } extern "C" { - #[doc = " \\sa SDL_LockSurface()"] + #[doc = " Release a surface after directly accessing the pixels."] + #[doc = ""] + #[doc = " \\param surface the SDL_Surface structure to be unlocked"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_LockSurface"] pub fn SDL_UnlockSurface(surface: *mut SDL_Surface); } extern "C" { - #[doc = " Load a surface from a seekable SDL data stream (memory or file)."] + #[doc = " Load a BMP image from a seekable SDL data stream."] + #[doc = ""] + #[doc = " The new surface should be freed with SDL_FreeSurface(). Not doing so will"] + #[doc = " result in a memory leak."] #[doc = ""] - #[doc = " If \\c freesrc is non-zero, the stream will be closed after being read."] + #[doc = " src is an open SDL_RWops buffer, typically loaded with SDL_RWFromFile."] + #[doc = " Alternitavely, you might also use the macro SDL_LoadBMP to load a bitmap"] + #[doc = " from a file, convert it to an SDL_Surface and then close the file."] #[doc = ""] - #[doc = " The new surface should be freed with SDL_FreeSurface()."] + #[doc = " \\param src the data stream for the surface"] + #[doc = " \\param freesrc non-zero to close the stream after being read"] + #[doc = " \\returns a pointer to a new SDL_Surface structure or NULL if there was an"] + #[doc = " error; call SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return the new surface, or NULL if there was an error."] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_FreeSurface"] + #[doc = " \\sa SDL_RWFromFile"] + #[doc = " \\sa SDL_LoadBMP"] + #[doc = " \\sa SDL_SaveBMP_RW"] pub fn SDL_LoadBMP_RW(src: *mut SDL_RWops, freesrc: libc::c_int) -> *mut SDL_Surface; } extern "C" { - #[doc = " Save a surface to a seekable SDL data stream (memory or file)."] + #[doc = " Save a surface to a seekable SDL data stream in BMP format."] + #[doc = ""] + #[doc = " Surfaces with a 24-bit, 32-bit and paletted 8-bit format get saved in the"] + #[doc = " BMP directly. Other RGB formats with 8-bit or higher get converted to a"] + #[doc = " 24-bit surface or, if they have an alpha mask or a colorkey, to a 32-bit"] + #[doc = " surface before they are saved. YUV and paletted 1-bit and 4-bit formats are"] + #[doc = " not supported."] #[doc = ""] - #[doc = " Surfaces with a 24-bit, 32-bit and paletted 8-bit format get saved in the"] - #[doc = " BMP directly. Other RGB formats with 8-bit or higher get converted to a"] - #[doc = " 24-bit surface or, if they have an alpha mask or a colorkey, to a 32-bit"] - #[doc = " surface before they are saved. YUV and paletted 1-bit and 4-bit formats are"] - #[doc = " not supported."] + #[doc = " \\param surface the SDL_Surface structure containing the image to be saved"] + #[doc = " \\param dst a data stream to save to"] + #[doc = " \\param freedst non-zero to close the stream after being written"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " If \\c freedst is non-zero, the stream will be closed after being written."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\return 0 if successful or -1 if there was an error."] + #[doc = " \\sa SDL_LoadBMP_RW"] + #[doc = " \\sa SDL_SaveBMP"] pub fn SDL_SaveBMP_RW( surface: *mut SDL_Surface, dst: *mut SDL_RWops, @@ -7094,30 +9409,59 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Sets the RLE acceleration hint for a surface."] + #[doc = " Set the RLE acceleration hint for a surface."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the surface is not valid"] + #[doc = " If RLE is enabled, color key and alpha blending blits are much faster, but"] + #[doc = " the surface must be locked before directly accessing the pixels."] #[doc = ""] - #[doc = " \\note If RLE is enabled, colorkey and alpha blending blits are much faster,"] - #[doc = " but the surface must be locked before directly accessing the pixels."] + #[doc = " \\param surface the SDL_Surface structure to optimize"] + #[doc = " \\param flag 0 to disable, non-zero to enable RLE acceleration"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_BlitSurface"] + #[doc = " \\sa SDL_LockSurface"] + #[doc = " \\sa SDL_UnlockSurface"] pub fn SDL_SetSurfaceRLE(surface: *mut SDL_Surface, flag: libc::c_int) -> libc::c_int; } extern "C" { - #[doc = " \\brief Returns whether the surface is RLE enabled"] + #[doc = " Returns whether the surface is RLE enabled"] + #[doc = ""] + #[doc = " It is safe to pass a NULL `surface` here; it will return SDL_FALSE."] + #[doc = ""] + #[doc = " \\param surface the SDL_Surface structure to query"] + #[doc = " \\returns SDL_TRUE if the surface is RLE enabled, SDL_FALSE otherwise."] #[doc = ""] - #[doc = " \\return SDL_TRUE if the surface is RLE enabled, or SDL_FALSE if the surface is NULL or not RLE enabled"] + #[doc = " \\since This function is available since SDL 2.0.14."] + #[doc = ""] + #[doc = " \\sa SDL_SetSurfaceRLE"] pub fn SDL_HasSurfaceRLE(surface: *mut SDL_Surface) -> SDL_bool; } extern "C" { - #[doc = " \\brief Sets the color key (transparent pixel) in a blittable surface."] + #[doc = " Set the color key (transparent pixel) in a surface."] + #[doc = ""] + #[doc = " The color key defines a pixel value that will be treated as transparent in"] + #[doc = " a blit. For example, one can use this to specify that cyan pixels should be"] + #[doc = " considered transparent, and therefore not rendered."] + #[doc = ""] + #[doc = " It is a pixel of the format used by the surface, as generated by"] + #[doc = " SDL_MapRGB()."] + #[doc = ""] + #[doc = " RLE acceleration can substantially speed up blitting of images with large"] + #[doc = " horizontal runs of transparent pixels. See SDL_SetSurfaceRLE() for details."] #[doc = ""] - #[doc = " \\param surface The surface to update"] - #[doc = " \\param flag Non-zero to enable colorkey and 0 to disable colorkey"] - #[doc = " \\param key The transparent pixel in the native surface format"] + #[doc = " \\param surface the SDL_Surface structure to update"] + #[doc = " \\param flag SDL_TRUE to enable color key, SDL_FALSE to disable color key"] + #[doc = " \\param key the transparent pixel"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the surface is not valid"] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " You can pass SDL_RLEACCEL to enable RLE accelerated blits."] + #[doc = " \\sa SDL_BlitSurface"] + #[doc = " \\sa SDL_GetColorKey"] pub fn SDL_SetColorKey( surface: *mut SDL_Surface, flag: libc::c_int, @@ -7125,33 +9469,58 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Returns whether the surface has a color key"] + #[doc = " Returns whether the surface has a color key"] #[doc = ""] - #[doc = " \\return SDL_TRUE if the surface has a color key, or SDL_FALSE if the surface is NULL or has no color key"] + #[doc = " It is safe to pass a NULL `surface` here; it will return SDL_FALSE."] + #[doc = ""] + #[doc = " \\param surface the SDL_Surface structure to query"] + #[doc = " \\return SDL_TRUE if the surface has a color key, SDL_FALSE otherwise."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.9."] + #[doc = ""] + #[doc = " \\sa SDL_SetColorKey"] + #[doc = " \\sa SDL_GetColorKey"] pub fn SDL_HasColorKey(surface: *mut SDL_Surface) -> SDL_bool; } extern "C" { - #[doc = " \\brief Gets the color key (transparent pixel) in a blittable surface."] + #[doc = " Get the color key (transparent pixel) for a surface."] + #[doc = ""] + #[doc = " The color key is a pixel of the format used by the surface, as generated by"] + #[doc = " SDL_MapRGB()."] #[doc = ""] - #[doc = " \\param surface The surface to update"] - #[doc = " \\param key A pointer filled in with the transparent pixel in the native"] - #[doc = " surface format"] + #[doc = " If the surface doesn't have color key enabled this function returns -1."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the surface is not valid or colorkey is not"] - #[doc = " enabled."] + #[doc = " \\param surface the SDL_Surface structure to query"] + #[doc = " \\param key a pointer filled in with the transparent pixel"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_BlitSurface"] + #[doc = " \\sa SDL_SetColorKey"] pub fn SDL_GetColorKey(surface: *mut SDL_Surface, key: *mut Uint32) -> libc::c_int; } extern "C" { - #[doc = " \\brief Set an additional color value used in blit operations."] + #[doc = " Set an additional color value multiplied into blit operations."] + #[doc = ""] + #[doc = " When this surface is blitted, during the blit operation each source color"] + #[doc = " channel is modulated by the appropriate color value according to the"] + #[doc = " following formula:"] + #[doc = ""] + #[doc = " `srcC = srcC * (color / 255)`"] #[doc = ""] - #[doc = " \\param surface The surface to update."] - #[doc = " \\param r The red color value multiplied into blit operations."] - #[doc = " \\param g The green color value multiplied into blit operations."] - #[doc = " \\param b The blue color value multiplied into blit operations."] + #[doc = " \\param surface the SDL_Surface structure to update"] + #[doc = " \\param r the red color value multiplied into blit operations"] + #[doc = " \\param g the green color value multiplied into blit operations"] + #[doc = " \\param b the blue color value multiplied into blit operations"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the surface is not valid."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_GetSurfaceColorMod()"] + #[doc = " \\sa SDL_GetSurfaceColorMod"] + #[doc = " \\sa SDL_SetSurfaceAlphaMod"] pub fn SDL_SetSurfaceColorMod( surface: *mut SDL_Surface, r: Uint8, @@ -7160,16 +9529,19 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the additional color value used in blit operations."] + #[doc = " Get the additional color value multiplied into blit operations."] #[doc = ""] - #[doc = " \\param surface The surface to query."] - #[doc = " \\param r A pointer filled in with the current red color value."] - #[doc = " \\param g A pointer filled in with the current green color value."] - #[doc = " \\param b A pointer filled in with the current blue color value."] + #[doc = " \\param surface the SDL_Surface structure to query"] + #[doc = " \\param r a pointer filled in with the current red color value"] + #[doc = " \\param g a pointer filled in with the current green color value"] + #[doc = " \\param b a pointer filled in with the current blue color value"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the surface is not valid."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_SetSurfaceColorMod()"] + #[doc = " \\sa SDL_GetSurfaceAlphaMod"] + #[doc = " \\sa SDL_SetSurfaceColorMod"] pub fn SDL_GetSurfaceColorMod( surface: *mut SDL_Surface, r: *mut Uint8, @@ -7178,88 +9550,136 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Set an additional alpha value used in blit operations."] + #[doc = " Set an additional alpha value used in blit operations."] #[doc = ""] - #[doc = " \\param surface The surface to update."] - #[doc = " \\param alpha The alpha value multiplied into blit operations."] + #[doc = " When this surface is blitted, during the blit operation the source alpha"] + #[doc = " value is modulated by this alpha value according to the following formula:"] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the surface is not valid."] + #[doc = " `srcA = srcA * (alpha / 255)`"] #[doc = ""] - #[doc = " \\sa SDL_GetSurfaceAlphaMod()"] + #[doc = " \\param surface the SDL_Surface structure to update"] + #[doc = " \\param alpha the alpha value multiplied into blit operations"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetSurfaceAlphaMod"] + #[doc = " \\sa SDL_SetSurfaceColorMod"] pub fn SDL_SetSurfaceAlphaMod(surface: *mut SDL_Surface, alpha: Uint8) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the additional alpha value used in blit operations."] + #[doc = " Get the additional alpha value used in blit operations."] #[doc = ""] - #[doc = " \\param surface The surface to query."] - #[doc = " \\param alpha A pointer filled in with the current alpha value."] + #[doc = " \\param surface the SDL_Surface structure to query"] + #[doc = " \\param alpha a pointer filled in with the current alpha value"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the surface is not valid."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_SetSurfaceAlphaMod()"] + #[doc = " \\sa SDL_GetSurfaceColorMod"] + #[doc = " \\sa SDL_SetSurfaceAlphaMod"] pub fn SDL_GetSurfaceAlphaMod(surface: *mut SDL_Surface, alpha: *mut Uint8) -> libc::c_int; } extern "C" { - #[doc = " \\brief Set the blend mode used for blit operations."] + #[doc = " Set the blend mode used for blit operations."] #[doc = ""] - #[doc = " \\param surface The surface to update."] - #[doc = " \\param blendMode ::SDL_BlendMode to use for blit blending."] + #[doc = " To copy a surface to another surface (or texture) without blending with the"] + #[doc = " existing data, the blendmode of the SOURCE surface should be set to"] + #[doc = " `SDL_BLENDMODE_NONE`."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the parameters are not valid."] + #[doc = " \\param surface the SDL_Surface structure to update"] + #[doc = " \\param blendMode the SDL_BlendMode to use for blit blending"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\sa SDL_GetSurfaceBlendMode()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetSurfaceBlendMode"] pub fn SDL_SetSurfaceBlendMode( surface: *mut SDL_Surface, blendMode: SDL_BlendMode, ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the blend mode used for blit operations."] + #[doc = " Get the blend mode used for blit operations."] #[doc = ""] - #[doc = " \\param surface The surface to query."] - #[doc = " \\param blendMode A pointer filled in with the current blend mode."] + #[doc = " \\param surface the SDL_Surface structure to query"] + #[doc = " \\param blendMode a pointer filled in with the current SDL_BlendMode"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the surface is not valid."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_SetSurfaceBlendMode()"] + #[doc = " \\sa SDL_SetSurfaceBlendMode"] pub fn SDL_GetSurfaceBlendMode( surface: *mut SDL_Surface, blendMode: *mut SDL_BlendMode, ) -> libc::c_int; } extern "C" { - #[doc = " Sets the clipping rectangle for the destination surface in a blit."] + #[doc = " Set the clipping rectangle for a surface."] + #[doc = ""] + #[doc = " When `surface` is the destination of a blit, only the area within the clip"] + #[doc = " rectangle is drawn into."] #[doc = ""] - #[doc = " If the clip rectangle is NULL, clipping will be disabled."] + #[doc = " Note that blits are automatically clipped to the edges of the source and"] + #[doc = " destination surfaces."] #[doc = ""] - #[doc = " If the clip rectangle doesn't intersect the surface, the function will"] - #[doc = " return SDL_FALSE and blits will be completely clipped. Otherwise the"] - #[doc = " function returns SDL_TRUE and blits to the surface will be clipped to"] - #[doc = " the intersection of the surface area and the clipping rectangle."] + #[doc = " \\param surface the SDL_Surface structure to be clipped"] + #[doc = " \\param rect the SDL_Rect structure representing the clipping rectangle, or"] + #[doc = " NULL to disable clipping"] + #[doc = " \\returns SDL_TRUE if the rectangle intersects the surface, otherwise"] + #[doc = " SDL_FALSE and blits will be completely clipped."] #[doc = ""] - #[doc = " Note that blits are automatically clipped to the edges of the source"] - #[doc = " and destination surfaces."] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_BlitSurface"] + #[doc = " \\sa SDL_GetClipRect"] pub fn SDL_SetClipRect(surface: *mut SDL_Surface, rect: *const SDL_Rect) -> SDL_bool; } extern "C" { - #[doc = " Gets the clipping rectangle for the destination surface in a blit."] + #[doc = " Get the clipping rectangle for a surface."] + #[doc = ""] + #[doc = " When `surface` is the destination of a blit, only the area within the clip"] + #[doc = " rectangle is drawn into."] + #[doc = ""] + #[doc = " \\param surface the SDL_Surface structure representing the surface to be"] + #[doc = " clipped"] + #[doc = " \\param rect an SDL_Rect structure filled in with the clipping rectangle for"] + #[doc = " the surface"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\c rect must be a pointer to a valid rectangle which will be filled"] - #[doc = " with the correct values."] + #[doc = " \\sa SDL_BlitSurface"] + #[doc = " \\sa SDL_SetClipRect"] pub fn SDL_GetClipRect(surface: *mut SDL_Surface, rect: *mut SDL_Rect); } extern "C" { pub fn SDL_DuplicateSurface(surface: *mut SDL_Surface) -> *mut SDL_Surface; } extern "C" { - #[doc = " Creates a new surface of the specified format, and then copies and maps"] - #[doc = " the given surface to it so the blit of the converted surface will be as"] - #[doc = " fast as possible. If this function fails, it returns NULL."] + #[doc = " Copy an existing surface to a new surface of the specified format."] #[doc = ""] - #[doc = " The \\c flags parameter is passed to SDL_CreateRGBSurface() and has those"] - #[doc = " semantics. You can also pass ::SDL_RLEACCEL in the flags parameter and"] - #[doc = " SDL will try to RLE accelerate colorkey and alpha blits in the resulting"] - #[doc = " surface."] + #[doc = " This function is used to optimize images for faster *repeat* blitting. This"] + #[doc = " is accomplished by converting the original and storing the result as a new"] + #[doc = " surface. The new, optimized surface can then be used as the source for"] + #[doc = " future blits, making them faster."] + #[doc = ""] + #[doc = " \\param src the existing SDL_Surface structure to convert"] + #[doc = " \\param fmt the SDL_PixelFormat structure that the new surface is optimized"] + #[doc = " for"] + #[doc = " \\param flags the flags are unused and should be set to 0; this is a"] + #[doc = " leftover from SDL 1.2's API"] + #[doc = " \\returns the new SDL_Surface structure that is created or NULL if it fails;"] + #[doc = " call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_AllocFormat"] + #[doc = " \\sa SDL_ConvertSurfaceFormat"] + #[doc = " \\sa SDL_CreateRGBSurface"] pub fn SDL_ConvertSurface( src: *mut SDL_Surface, fmt: *const SDL_PixelFormat, @@ -7267,6 +9687,26 @@ extern "C" { ) -> *mut SDL_Surface; } extern "C" { + #[doc = " Copy an existing surface to a new surface of the specified format enum."] + #[doc = ""] + #[doc = " This function operates just like SDL_ConvertSurface(), but accepts an"] + #[doc = " SDL_PixelFormatEnum value instead of an SDL_PixelFormat structure. As such,"] + #[doc = " it might be easier to call but it doesn't have access to palette"] + #[doc = " information for the destination surface, in case that would be important."] + #[doc = ""] + #[doc = " \\param src the existing SDL_Surface structure to convert"] + #[doc = " \\param pixel_format the SDL_PixelFormatEnum that the new surface is"] + #[doc = " optimized for"] + #[doc = " \\param flags the flags are unused and should be set to 0; this is a"] + #[doc = " leftover from SDL 1.2's API"] + #[doc = " \\returns the new SDL_Surface structure that is created or NULL if it fails;"] + #[doc = " call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_AllocFormat"] + #[doc = " \\sa SDL_ConvertSurface"] + #[doc = " \\sa SDL_CreateRGBSurface"] pub fn SDL_ConvertSurfaceFormat( src: *mut SDL_Surface, pixel_format: Uint32, @@ -7274,9 +9714,20 @@ extern "C" { ) -> *mut SDL_Surface; } extern "C" { - #[doc = " \\brief Copy a block of pixels of one format to another format"] + #[doc = " Copy a block of pixels of one format to another format."] + #[doc = ""] + #[doc = " \\param width the width of the block to copy, in pixels"] + #[doc = " \\param height the height of the block to copy, in pixels"] + #[doc = " \\param src_format an SDL_PixelFormatEnum value of the `src` pixels format"] + #[doc = " \\param src a pointer to the source pixels"] + #[doc = " \\param src_pitch the pitch of the source pixels, in bytes"] + #[doc = " \\param dst_format an SDL_PixelFormatEnum value of the `dst` pixels format"] + #[doc = " \\param dst a pointer to be filled in with new pixel data"] + #[doc = " \\param dst_pitch the pitch of the destination pixels, in bytes"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if there was an error"] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_ConvertPixels( width: libc::c_int, height: libc::c_int, @@ -7289,18 +9740,82 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " Performs a fast fill of the given rectangle with \\c color."] + #[doc = " Premultiply the alpha on a block of pixels."] #[doc = ""] - #[doc = " If \\c rect is NULL, the whole surface will be filled with \\c color."] + #[doc = " This is safe to use with src == dst, but not for other overlapping areas."] #[doc = ""] - #[doc = " The color should be a pixel of the format used by the surface, and"] - #[doc = " can be generated by the SDL_MapRGB() function."] + #[doc = " This function is currently only implemented for SDL_PIXELFORMAT_ARGB8888."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error."] + #[doc = " \\param width the width of the block to convert, in pixels"] + #[doc = " \\param height the height of the block to convert, in pixels"] + #[doc = " \\param src_format an SDL_PixelFormatEnum value of the `src` pixels format"] + #[doc = " \\param src a pointer to the source pixels"] + #[doc = " \\param src_pitch the pitch of the source pixels, in bytes"] + #[doc = " \\param dst_format an SDL_PixelFormatEnum value of the `dst` pixels format"] + #[doc = " \\param dst a pointer to be filled in with premultiplied pixel data"] + #[doc = " \\param dst_pitch the pitch of the destination pixels, in bytes"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.18."] + pub fn SDL_PremultiplyAlpha( + width: libc::c_int, + height: libc::c_int, + src_format: Uint32, + src: *const libc::c_void, + src_pitch: libc::c_int, + dst_format: Uint32, + dst: *mut libc::c_void, + dst_pitch: libc::c_int, + ) -> libc::c_int; +} +extern "C" { + #[doc = " Perform a fast fill of a rectangle with a specific color."] + #[doc = ""] + #[doc = " `color` should be a pixel of the format used by the surface, and can be"] + #[doc = " generated by SDL_MapRGB() or SDL_MapRGBA(). If the color value contains an"] + #[doc = " alpha component then the destination is simply filled with that alpha"] + #[doc = " information, no blending takes place."] + #[doc = ""] + #[doc = " If there is a clip rectangle set on the destination (set via"] + #[doc = " SDL_SetClipRect()), then this function will fill based on the intersection"] + #[doc = " of the clip rectangle and `rect`."] + #[doc = ""] + #[doc = " \\param dst the SDL_Surface structure that is the drawing target"] + #[doc = " \\param rect the SDL_Rect structure representing the rectangle to fill, or"] + #[doc = " NULL to fill the entire surface"] + #[doc = " \\param color the color to fill with"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_FillRects"] pub fn SDL_FillRect(dst: *mut SDL_Surface, rect: *const SDL_Rect, color: Uint32) -> libc::c_int; } extern "C" { + #[doc = " Perform a fast fill of a set of rectangles with a specific color."] + #[doc = ""] + #[doc = " `color` should be a pixel of the format used by the surface, and can be"] + #[doc = " generated by SDL_MapRGB() or SDL_MapRGBA(). If the color value contains an"] + #[doc = " alpha component then the destination is simply filled with that alpha"] + #[doc = " information, no blending takes place."] + #[doc = ""] + #[doc = " If there is a clip rectangle set on the destination (set via"] + #[doc = " SDL_SetClipRect()), then this function will fill based on the intersection"] + #[doc = " of the clip rectangle and `rect`."] + #[doc = ""] + #[doc = " \\param dst the SDL_Surface structure that is the drawing target"] + #[doc = " \\param rects an array of SDL_Rects representing the rectangles to fill."] + #[doc = " \\param count the number of rectangles in the array"] + #[doc = " \\param color the color to fill with"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_FillRect"] pub fn SDL_FillRects( dst: *mut SDL_Surface, rects: *const SDL_Rect, @@ -7309,8 +9824,14 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " This is the public blit function, SDL_BlitSurface(), and it performs"] - #[doc = " rectangle validation and clipping before passing it to SDL_LowerBlit()"] + #[doc = " Perform a fast blit from the source surface to the destination surface."] + #[doc = ""] + #[doc = " SDL_UpperBlit() has been replaced by SDL_BlitSurface(), which is merely a"] + #[doc = " macro for this function with a less confusing name."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_BlitSurface"] pub fn SDL_UpperBlit( src: *mut SDL_Surface, srcrect: *const SDL_Rect, @@ -7319,8 +9840,26 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " This is a semi-private blit function and it performs low-level surface"] - #[doc = " blitting only."] + #[doc = " Perform low-level surface blitting only."] + #[doc = ""] + #[doc = " This is a semi-private blit function and it performs low-level surface"] + #[doc = " blitting, assuming the input rectangles have already been clipped."] + #[doc = ""] + #[doc = " Unless you know what you're doing, you should be using SDL_BlitSurface()"] + #[doc = " instead."] + #[doc = ""] + #[doc = " \\param src the SDL_Surface structure to be copied from"] + #[doc = " \\param srcrect the SDL_Rect structure representing the rectangle to be"] + #[doc = " copied, or NULL to copy the entire surface"] + #[doc = " \\param dst the SDL_Surface structure that is the blit target"] + #[doc = " \\param dstrect the SDL_Rect structure representing the rectangle that is"] + #[doc = " copied into"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_BlitSurface"] pub fn SDL_LowerBlit( src: *mut SDL_Surface, srcrect: *mut SDL_Rect, @@ -7329,10 +9868,12 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Perform a fast, low quality, stretch blit between two surfaces of the"] - #[doc = " same pixel format."] + #[doc = " Perform a fast, low quality, stretch blit between two surfaces of the same"] + #[doc = " format."] #[doc = ""] - #[doc = " \\note This function uses a static buffer, and is not thread-safe."] + #[doc = " Please use SDL_BlitScaled() instead."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_SoftStretch( src: *mut SDL_Surface, srcrect: *const SDL_Rect, @@ -7341,8 +9882,25 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " This is the public scaled blit function, SDL_BlitScaled(), and it performs"] - #[doc = " rectangle validation and clipping before passing it to SDL_LowerBlitScaled()"] + #[doc = " Perform bilinear scaling between two surfaces of the same format, 32BPP."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.16."] + pub fn SDL_SoftStretchLinear( + src: *mut SDL_Surface, + srcrect: *const SDL_Rect, + dst: *mut SDL_Surface, + dstrect: *const SDL_Rect, + ) -> libc::c_int; +} +extern "C" { + #[doc = " Perform a scaled surface copy to a destination surface."] + #[doc = ""] + #[doc = " SDL_UpperBlitScaled() has been replaced by SDL_BlitScaled(), which is"] + #[doc = " merely a macro for this function with a less confusing name."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_BlitScaled"] pub fn SDL_UpperBlitScaled( src: *mut SDL_Surface, srcrect: *const SDL_Rect, @@ -7351,8 +9909,23 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " This is a semi-private blit function and it performs low-level surface"] - #[doc = " scaled blitting only."] + #[doc = " Perform low-level surface scaled blitting only."] + #[doc = ""] + #[doc = " This is a semi-private function and it performs low-level surface blitting,"] + #[doc = " assuming the input rectangles have already been clipped."] + #[doc = ""] + #[doc = " \\param src the SDL_Surface structure to be copied from"] + #[doc = " \\param srcrect the SDL_Rect structure representing the rectangle to be"] + #[doc = " copied"] + #[doc = " \\param dst the SDL_Surface structure that is the blit target"] + #[doc = " \\param dstrect the SDL_Rect structure representing the rectangle that is"] + #[doc = " copied into"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_BlitScaled"] pub fn SDL_LowerBlitScaled( src: *mut SDL_Surface, srcrect: *mut SDL_Rect, @@ -7361,15 +9934,22 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Set the YUV conversion mode"] + #[doc = " Set the YUV conversion mode"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.8."] pub fn SDL_SetYUVConversionMode(mode: SDL_YUV_CONVERSION_MODE); } extern "C" { - #[doc = " \\brief Get the YUV conversion mode"] + #[doc = " Get the YUV conversion mode"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.8."] pub fn SDL_GetYUVConversionMode() -> SDL_YUV_CONVERSION_MODE; } extern "C" { - #[doc = " \\brief Get the YUV conversion mode, returning the correct mode for the resolution when the current conversion mode is SDL_YUV_CONVERSION_AUTOMATIC"] + #[doc = " Get the YUV conversion mode, returning the correct mode for the resolution"] + #[doc = " when the current conversion mode is SDL_YUV_CONVERSION_AUTOMATIC"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.8."] pub fn SDL_GetYUVConversionModeForResolution( width: libc::c_int, height: libc::c_int, @@ -7466,6 +10046,9 @@ fn bindgen_test_layout_SDL_DisplayMode() { pub struct SDL_Window { _unused: [u8; 0], } +impl SDL_WindowFlags { + pub const SDL_WINDOW_INPUT_GRABBED: SDL_WindowFlags = SDL_WindowFlags::SDL_WINDOW_MOUSE_GRABBED; +} #[repr(u32)] #[doc = " \\brief The flags on a window"] #[doc = ""] @@ -7488,8 +10071,8 @@ pub enum SDL_WindowFlags { SDL_WINDOW_MINIMIZED = 64, #[doc = "< window is maximized"] SDL_WINDOW_MAXIMIZED = 128, - #[doc = "< window has grabbed input focus"] - SDL_WINDOW_INPUT_GRABBED = 256, + #[doc = "< window has grabbed mouse input"] + SDL_WINDOW_MOUSE_GRABBED = 256, #[doc = "< window has input focus"] SDL_WINDOW_INPUT_FOCUS = 512, #[doc = "< window has mouse focus"] @@ -7501,7 +10084,7 @@ pub enum SDL_WindowFlags { #[doc = "On macOS NSHighResolutionCapable must be set true in the"] #[doc = "application's Info.plist for this to have any effect."] SDL_WINDOW_ALLOW_HIGHDPI = 8192, - #[doc = "< window has mouse captured (unrelated to INPUT_GRABBED)"] + #[doc = "< window has mouse captured (unrelated to MOUSE_GRABBED)"] SDL_WINDOW_MOUSE_CAPTURE = 16384, #[doc = "< window should always be above others"] SDL_WINDOW_ALWAYS_ON_TOP = 32768, @@ -7513,6 +10096,8 @@ pub enum SDL_WindowFlags { SDL_WINDOW_TOOLTIP = 262144, #[doc = "< window should be treated as a popup menu"] SDL_WINDOW_POPUP_MENU = 524288, + #[doc = "< window has grabbed keyboard input"] + SDL_WINDOW_KEYBOARD_GRABBED = 1048576, #[doc = "< window usable for Vulkan surface"] SDL_WINDOW_VULKAN = 268435456, #[doc = "< window usable for Metal view"] @@ -7560,6 +10145,10 @@ pub enum SDL_WindowEventID { SDL_WINDOWEVENT_TAKE_FOCUS = 15, #[doc = "< Window had a hit test that wasn't SDL_HITTEST_NORMAL."] SDL_WINDOWEVENT_HIT_TEST = 16, + #[doc = "< The ICC profile of the window's display has changed."] + SDL_WINDOWEVENT_ICCPROF_CHANGED = 17, + #[doc = "< Window has been moved to display data1."] + SDL_WINDOWEVENT_DISPLAY_CHANGED = 18, } #[repr(u32)] #[doc = " \\brief Event subtype for display events"] @@ -7575,6 +10164,7 @@ pub enum SDL_DisplayEventID { SDL_DISPLAYEVENT_DISCONNECTED = 3, } #[repr(u32)] +#[doc = " \\brief Display orientation"] #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub enum SDL_DisplayOrientation { #[doc = "< The display orientation can't be determined"] @@ -7588,6 +10178,17 @@ pub enum SDL_DisplayOrientation { #[doc = "< The display is in portrait mode, upside down"] SDL_ORIENTATION_PORTRAIT_FLIPPED = 4, } +#[repr(u32)] +#[doc = " \\brief Window flash operation"] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum SDL_FlashOperation { + #[doc = "< Cancel any window flash state"] + SDL_FLASH_CANCEL = 0, + #[doc = "< Flash the window briefly to get attention"] + SDL_FLASH_BRIEFLY = 1, + #[doc = "< Flash the window until it gets focus"] + SDL_FLASH_UNTIL_FOCUSED = 2, +} #[doc = " \\brief An opaque handle to an OpenGL context."] pub type SDL_GLContext = *mut libc::c_void; #[repr(u32)] @@ -7651,106 +10252,177 @@ pub enum SDL_GLContextResetNotification { SDL_GL_CONTEXT_RESET_LOSE_CONTEXT = 1, } extern "C" { - #[doc = " \\brief Get the number of video drivers compiled into SDL"] + #[doc = " Get the number of video drivers compiled into SDL."] + #[doc = ""] + #[doc = " \\returns a number >= 1 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\sa SDL_GetVideoDriver()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetVideoDriver"] pub fn SDL_GetNumVideoDrivers() -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the name of a built in video driver."] + #[doc = " Get the name of a built in video driver."] + #[doc = ""] + #[doc = " The video drivers are presented in the order in which they are normally"] + #[doc = " checked during initialization."] #[doc = ""] - #[doc = " \\note The video drivers are presented in the order in which they are"] - #[doc = " normally checked during initialization."] + #[doc = " \\param index the index of a video driver"] + #[doc = " \\returns the name of the video driver with the given **index**."] #[doc = ""] - #[doc = " \\sa SDL_GetNumVideoDrivers()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetNumVideoDrivers"] pub fn SDL_GetVideoDriver(index: libc::c_int) -> *const libc::c_char; } extern "C" { - #[doc = " \\brief Initialize the video subsystem, optionally specifying a video driver."] + #[doc = " Initialize the video subsystem, optionally specifying a video driver."] + #[doc = ""] + #[doc = " This function initializes the video subsystem, setting up a connection to"] + #[doc = " the window manager, etc, and determines the available display modes and"] + #[doc = " pixel formats, but does not initialize a window or graphics mode."] + #[doc = ""] + #[doc = " If you use this function and you haven't used the SDL_INIT_VIDEO flag with"] + #[doc = " either SDL_Init() or SDL_InitSubSystem(), you should call SDL_VideoQuit()"] + #[doc = " before calling SDL_Quit()."] + #[doc = ""] + #[doc = " It is safe to call this function multiple times. SDL_VideoInit() will call"] + #[doc = " SDL_VideoQuit() itself if the video subsystem has already been initialized."] #[doc = ""] - #[doc = " \\param driver_name Initialize a specific driver by name, or NULL for the"] - #[doc = " default video driver."] + #[doc = " You can use SDL_GetNumVideoDrivers() and SDL_GetVideoDriver() to find a"] + #[doc = " specific `driver_name`."] #[doc = ""] - #[doc = " \\return 0 on success, -1 on error"] + #[doc = " \\param driver_name the name of a video driver to initialize, or NULL for"] + #[doc = " the default driver"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " This function initializes the video subsystem; setting up a connection"] - #[doc = " to the window manager, etc, and determines the available display modes"] - #[doc = " and pixel formats, but does not initialize a window or graphics mode."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_VideoQuit()"] + #[doc = " \\sa SDL_GetNumVideoDrivers"] + #[doc = " \\sa SDL_GetVideoDriver"] + #[doc = " \\sa SDL_InitSubSystem"] + #[doc = " \\sa SDL_VideoQuit"] pub fn SDL_VideoInit(driver_name: *const libc::c_char) -> libc::c_int; } extern "C" { - #[doc = " \\brief Shuts down the video subsystem."] + #[doc = " Shut down the video subsystem, if initialized with SDL_VideoInit()."] #[doc = ""] - #[doc = " This function closes all windows, and restores the original video mode."] + #[doc = " This function closes all windows, and restores the original video mode."] #[doc = ""] - #[doc = " \\sa SDL_VideoInit()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_VideoInit"] pub fn SDL_VideoQuit(); } extern "C" { - #[doc = " \\brief Returns the name of the currently initialized video driver."] + #[doc = " Get the name of the currently initialized video driver."] + #[doc = ""] + #[doc = " \\returns the name of the current video driver or NULL if no driver has been"] + #[doc = " initialized."] #[doc = ""] - #[doc = " \\return The name of the current video driver or NULL if no driver"] - #[doc = " has been initialized"] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_GetNumVideoDrivers()"] - #[doc = " \\sa SDL_GetVideoDriver()"] + #[doc = " \\sa SDL_GetNumVideoDrivers"] + #[doc = " \\sa SDL_GetVideoDriver"] pub fn SDL_GetCurrentVideoDriver() -> *const libc::c_char; } extern "C" { - #[doc = " \\brief Returns the number of available video displays."] + #[doc = " Get the number of available video displays."] + #[doc = ""] + #[doc = " \\returns a number >= 1 or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_GetDisplayBounds()"] + #[doc = " \\sa SDL_GetDisplayBounds"] pub fn SDL_GetNumVideoDisplays() -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the name of a display in UTF-8 encoding"] + #[doc = " Get the name of a display in UTF-8 encoding."] #[doc = ""] - #[doc = " \\return The name of a display, or NULL for an invalid display index."] + #[doc = " \\param displayIndex the index of display from which the name should be"] + #[doc = " queried"] + #[doc = " \\returns the name of a display or NULL for an invalid display index or"] + #[doc = " failure; call SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\sa SDL_GetNumVideoDisplays()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetNumVideoDisplays"] pub fn SDL_GetDisplayName(displayIndex: libc::c_int) -> *const libc::c_char; } extern "C" { - #[doc = " \\brief Get the desktop area represented by a display, with the primary"] - #[doc = " display located at 0,0"] + #[doc = " Get the desktop area represented by a display."] + #[doc = ""] + #[doc = " The primary display (`displayIndex` zero) is always located at 0,0."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the index is out of range."] + #[doc = " \\param displayIndex the index of the display to query"] + #[doc = " \\param rect the SDL_Rect structure filled in with the display bounds"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\sa SDL_GetNumVideoDisplays()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetNumVideoDisplays"] pub fn SDL_GetDisplayBounds(displayIndex: libc::c_int, rect: *mut SDL_Rect) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the usable desktop area represented by a display, with the"] - #[doc = " primary display located at 0,0"] + #[doc = " Get the usable desktop area represented by a display."] + #[doc = ""] + #[doc = " The primary display (`displayIndex` zero) is always located at 0,0."] #[doc = ""] - #[doc = " This is the same area as SDL_GetDisplayBounds() reports, but with portions"] - #[doc = " reserved by the system removed. For example, on Mac OS X, this subtracts"] - #[doc = " the area occupied by the menu bar and dock."] + #[doc = " This is the same area as SDL_GetDisplayBounds() reports, but with portions"] + #[doc = " reserved by the system removed. For example, on Apple's macOS, this"] + #[doc = " subtracts the area occupied by the menu bar and dock."] #[doc = ""] - #[doc = " Setting a window to be fullscreen generally bypasses these unusable areas,"] - #[doc = " so these are good guidelines for the maximum space available to a"] - #[doc = " non-fullscreen window."] + #[doc = " Setting a window to be fullscreen generally bypasses these unusable areas,"] + #[doc = " so these are good guidelines for the maximum space available to a"] + #[doc = " non-fullscreen window."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the index is out of range."] + #[doc = " The parameter `rect` is ignored if it is NULL."] #[doc = ""] - #[doc = " \\sa SDL_GetDisplayBounds()"] - #[doc = " \\sa SDL_GetNumVideoDisplays()"] + #[doc = " This function also returns -1 if the parameter `displayIndex` is out of"] + #[doc = " range."] + #[doc = ""] + #[doc = " \\param displayIndex the index of the display to query the usable bounds"] + #[doc = " from"] + #[doc = " \\param rect the SDL_Rect structure filled in with the display bounds"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.5."] + #[doc = ""] + #[doc = " \\sa SDL_GetDisplayBounds"] + #[doc = " \\sa SDL_GetNumVideoDisplays"] pub fn SDL_GetDisplayUsableBounds( displayIndex: libc::c_int, rect: *mut SDL_Rect, ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the dots/pixels-per-inch for a display"] + #[doc = " Get the dots/pixels-per-inch for a display."] + #[doc = ""] + #[doc = " Diagonal, horizontal and vertical DPI can all be optionally returned if the"] + #[doc = " appropriate parameter is non-NULL."] #[doc = ""] - #[doc = " \\note Diagonal, horizontal and vertical DPI can all be optionally"] - #[doc = " returned if the parameter is non-NULL."] + #[doc = " A failure of this function usually means that either no DPI information is"] + #[doc = " available or the `displayIndex` is out of range."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if no DPI information is available or the index is out of range."] + #[doc = " \\param displayIndex the index of the display from which DPI information"] + #[doc = " should be queried"] + #[doc = " \\param ddpi a pointer filled in with the diagonal DPI of the display; may"] + #[doc = " be NULL"] + #[doc = " \\param hdpi a pointer filled in with the horizontal DPI of the display; may"] + #[doc = " be NULL"] + #[doc = " \\param vdpi a pointer filled in with the vertical DPI of the display; may"] + #[doc = " be NULL"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\sa SDL_GetNumVideoDisplays()"] + #[doc = " \\since This function is available since SDL 2.0.4."] + #[doc = ""] + #[doc = " \\sa SDL_GetNumVideoDisplays"] pub fn SDL_GetDisplayDPI( displayIndex: libc::c_int, ddpi: *mut f32, @@ -7759,29 +10431,54 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the orientation of a display"] + #[doc = " Get the orientation of a display."] + #[doc = ""] + #[doc = " \\param displayIndex the index of the display to query"] + #[doc = " \\returns The SDL_DisplayOrientation enum value of the display, or"] + #[doc = " `SDL_ORIENTATION_UNKNOWN` if it isn't available."] #[doc = ""] - #[doc = " \\return The orientation of the display, or SDL_ORIENTATION_UNKNOWN if it isn't available."] + #[doc = " \\since This function is available since SDL 2.0.9."] #[doc = ""] - #[doc = " \\sa SDL_GetNumVideoDisplays()"] + #[doc = " \\sa SDL_GetNumVideoDisplays"] pub fn SDL_GetDisplayOrientation(displayIndex: libc::c_int) -> SDL_DisplayOrientation; } extern "C" { - #[doc = " \\brief Returns the number of available display modes."] + #[doc = " Get the number of available display modes."] + #[doc = ""] + #[doc = " The `displayIndex` needs to be in the range from 0 to"] + #[doc = " SDL_GetNumVideoDisplays() - 1."] + #[doc = ""] + #[doc = " \\param displayIndex the index of the display to query"] + #[doc = " \\returns a number >= 1 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\sa SDL_GetDisplayMode()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetDisplayMode"] + #[doc = " \\sa SDL_GetNumVideoDisplays"] pub fn SDL_GetNumDisplayModes(displayIndex: libc::c_int) -> libc::c_int; } extern "C" { - #[doc = " \\brief Fill in information about a specific display mode."] + #[doc = " Get information about a specific display mode."] + #[doc = ""] + #[doc = " The display modes are sorted in this priority:"] + #[doc = ""] + #[doc = " - width -> largest to smallest"] + #[doc = " - height -> largest to smallest"] + #[doc = " - bits per pixel -> more colors to fewer colors"] + #[doc = " - packed pixel layout -> largest to smallest"] + #[doc = " - refresh rate -> highest to lowest"] + #[doc = ""] + #[doc = " \\param displayIndex the index of the display to query"] + #[doc = " \\param modeIndex the index of the display mode to query"] + #[doc = " \\param mode an SDL_DisplayMode structure filled in with the mode at"] + #[doc = " `modeIndex`"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\note The display modes are sorted in this priority:"] - #[doc = " \\li bits per pixel -> more colors to fewer colors"] - #[doc = " \\li width -> largest to smallest"] - #[doc = " \\li height -> largest to smallest"] - #[doc = " \\li refresh rate -> highest to lowest"] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_GetNumDisplayModes()"] + #[doc = " \\sa SDL_GetNumDisplayModes"] pub fn SDL_GetDisplayMode( displayIndex: libc::c_int, modeIndex: libc::c_int, @@ -7789,39 +10486,76 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Fill in information about the desktop display mode."] + #[doc = " Get information about the desktop's display mode."] + #[doc = ""] + #[doc = " There's a difference between this function and SDL_GetCurrentDisplayMode()"] + #[doc = " when SDL runs fullscreen and has changed the resolution. In that case this"] + #[doc = " function will return the previous native display mode, and not the current"] + #[doc = " display mode."] + #[doc = ""] + #[doc = " \\param displayIndex the index of the display to query"] + #[doc = " \\param mode an SDL_DisplayMode structure filled in with the current display"] + #[doc = " mode"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetCurrentDisplayMode"] + #[doc = " \\sa SDL_GetDisplayMode"] + #[doc = " \\sa SDL_SetWindowDisplayMode"] pub fn SDL_GetDesktopDisplayMode( displayIndex: libc::c_int, mode: *mut SDL_DisplayMode, ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Fill in information about the current display mode."] + #[doc = " Get information about the current display mode."] + #[doc = ""] + #[doc = " There's a difference between this function and SDL_GetDesktopDisplayMode()"] + #[doc = " when SDL runs fullscreen and has changed the resolution. In that case this"] + #[doc = " function will return the current display mode, and not the previous native"] + #[doc = " display mode."] + #[doc = ""] + #[doc = " \\param displayIndex the index of the display to query"] + #[doc = " \\param mode an SDL_DisplayMode structure filled in with the current display"] + #[doc = " mode"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetDesktopDisplayMode"] + #[doc = " \\sa SDL_GetDisplayMode"] + #[doc = " \\sa SDL_GetNumVideoDisplays"] + #[doc = " \\sa SDL_SetWindowDisplayMode"] pub fn SDL_GetCurrentDisplayMode( displayIndex: libc::c_int, mode: *mut SDL_DisplayMode, ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the closest match to the requested display mode."] + #[doc = " Get the closest match to the requested display mode."] #[doc = ""] - #[doc = " \\param displayIndex The index of display from which mode should be queried."] - #[doc = " \\param mode The desired display mode"] - #[doc = " \\param closest A pointer to a display mode to be filled in with the closest"] - #[doc = " match of the available display modes."] + #[doc = " The available display modes are scanned and `closest` is filled in with the"] + #[doc = " closest mode matching the requested mode and returned. The mode format and"] + #[doc = " refresh rate default to the desktop mode if they are set to 0. The modes"] + #[doc = " are scanned with size being first priority, format being second priority,"] + #[doc = " and finally checking the refresh rate. If all the available modes are too"] + #[doc = " small, then NULL is returned."] #[doc = ""] - #[doc = " \\return The passed in value \\c closest, or NULL if no matching video mode"] - #[doc = " was available."] + #[doc = " \\param displayIndex the index of the display to query"] + #[doc = " \\param mode an SDL_DisplayMode structure containing the desired display"] + #[doc = " mode"] + #[doc = " \\param closest an SDL_DisplayMode structure filled in with the closest"] + #[doc = " match of the available display modes"] + #[doc = " \\returns the passed in value `closest` or NULL if no matching video mode"] + #[doc = " was available; call SDL_GetError() for more information."] #[doc = ""] - #[doc = " The available display modes are scanned, and \\c closest is filled in with the"] - #[doc = " closest mode matching the requested mode and returned. The mode format and"] - #[doc = " refresh_rate default to the desktop mode if they are 0. The modes are"] - #[doc = " scanned with size being first priority, format being second priority, and"] - #[doc = " finally checking the refresh_rate. If all the available modes are too"] - #[doc = " small, then NULL is returned."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_GetNumDisplayModes()"] - #[doc = " \\sa SDL_GetDisplayMode()"] + #[doc = " \\sa SDL_GetDisplayMode"] + #[doc = " \\sa SDL_GetNumDisplayModes"] pub fn SDL_GetClosestDisplayMode( displayIndex: libc::c_int, mode: *const SDL_DisplayMode, @@ -7829,90 +10563,152 @@ extern "C" { ) -> *mut SDL_DisplayMode; } extern "C" { - #[doc = " \\brief Get the display index associated with a window."] + #[doc = " Get the index of the display associated with a window."] #[doc = ""] - #[doc = " \\return the display index of the display containing the center of the"] - #[doc = " window, or -1 on error."] + #[doc = " \\param window the window to query"] + #[doc = " \\returns the index of the display containing the center of the window on"] + #[doc = " success or a negative error code on failure; call SDL_GetError()"] + #[doc = " for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetDisplayBounds"] + #[doc = " \\sa SDL_GetNumVideoDisplays"] pub fn SDL_GetWindowDisplayIndex(window: *mut SDL_Window) -> libc::c_int; } extern "C" { - #[doc = " \\brief Set the display mode used when a fullscreen window is visible."] + #[doc = " Set the display mode to use when a window is visible at fullscreen."] #[doc = ""] - #[doc = " By default the window's dimensions and the desktop format and refresh rate"] - #[doc = " are used."] + #[doc = " This only affects the display mode used when the window is fullscreen. To"] + #[doc = " change the window size when the window is not fullscreen, use"] + #[doc = " SDL_SetWindowSize()."] #[doc = ""] - #[doc = " \\param window The window for which the display mode should be set."] - #[doc = " \\param mode The mode to use, or NULL for the default mode."] + #[doc = " \\param window the window to affect"] + #[doc = " \\param mode the SDL_DisplayMode structure representing the mode to use, or"] + #[doc = " NULL to use the window's dimensions and the desktop's format"] + #[doc = " and refresh rate"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if setting the display mode failed."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_GetWindowDisplayMode()"] - #[doc = " \\sa SDL_SetWindowFullscreen()"] + #[doc = " \\sa SDL_GetWindowDisplayMode"] + #[doc = " \\sa SDL_SetWindowFullscreen"] pub fn SDL_SetWindowDisplayMode( window: *mut SDL_Window, mode: *const SDL_DisplayMode, ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Fill in information about the display mode used when a fullscreen"] - #[doc = " window is visible."] + #[doc = " Query the display mode to use when a window is visible at fullscreen."] + #[doc = ""] + #[doc = " \\param window the window to query"] + #[doc = " \\param mode an SDL_DisplayMode structure filled in with the fullscreen"] + #[doc = " display mode"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_SetWindowDisplayMode()"] - #[doc = " \\sa SDL_SetWindowFullscreen()"] + #[doc = " \\sa SDL_SetWindowDisplayMode"] + #[doc = " \\sa SDL_SetWindowFullscreen"] pub fn SDL_GetWindowDisplayMode( window: *mut SDL_Window, mode: *mut SDL_DisplayMode, ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the pixel format associated with the window."] - pub fn SDL_GetWindowPixelFormat(window: *mut SDL_Window) -> Uint32; + #[doc = " Get the raw ICC profile data for the screen the window is currently on."] + #[doc = ""] + #[doc = " Data returned should be freed with SDL_free."] + #[doc = ""] + #[doc = " \\param window the window to query"] + #[doc = " \\param size the size of the ICC profile"] + #[doc = " \\returns the raw ICC profile data on success or NULL on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.18."] + pub fn SDL_GetWindowICCProfile(window: *mut SDL_Window, size: *mut size_t) + -> *mut libc::c_void; } extern "C" { - #[doc = " \\brief Create a window with the specified position, dimensions, and flags."] - #[doc = ""] - #[doc = " \\param title The title of the window, in UTF-8 encoding."] - #[doc = " \\param x The x position of the window, ::SDL_WINDOWPOS_CENTERED, or"] - #[doc = " ::SDL_WINDOWPOS_UNDEFINED."] - #[doc = " \\param y The y position of the window, ::SDL_WINDOWPOS_CENTERED, or"] - #[doc = " ::SDL_WINDOWPOS_UNDEFINED."] - #[doc = " \\param w The width of the window, in screen coordinates."] - #[doc = " \\param h The height of the window, in screen coordinates."] - #[doc = " \\param flags The flags for the window, a mask of any of the following:"] - #[doc = " ::SDL_WINDOW_FULLSCREEN, ::SDL_WINDOW_OPENGL,"] - #[doc = " ::SDL_WINDOW_HIDDEN, ::SDL_WINDOW_BORDERLESS,"] - #[doc = " ::SDL_WINDOW_RESIZABLE, ::SDL_WINDOW_MAXIMIZED,"] - #[doc = " ::SDL_WINDOW_MINIMIZED, ::SDL_WINDOW_INPUT_GRABBED,"] - #[doc = " ::SDL_WINDOW_ALLOW_HIGHDPI, ::SDL_WINDOW_VULKAN"] - #[doc = " ::SDL_WINDOW_METAL."] - #[doc = ""] - #[doc = " \\return The created window, or NULL if window creation failed."] - #[doc = ""] - #[doc = " If the window is created with the SDL_WINDOW_ALLOW_HIGHDPI flag, its size"] - #[doc = " in pixels may differ from its size in screen coordinates on platforms with"] - #[doc = " high-DPI support (e.g. iOS and Mac OS X). Use SDL_GetWindowSize() to query"] - #[doc = " the client area's size in screen coordinates, and SDL_GL_GetDrawableSize(),"] - #[doc = " SDL_Vulkan_GetDrawableSize(), or SDL_GetRendererOutputSize() to query the"] - #[doc = " drawable size in pixels."] - #[doc = ""] - #[doc = " If the window is created with any of the SDL_WINDOW_OPENGL or"] - #[doc = " SDL_WINDOW_VULKAN flags, then the corresponding LoadLibrary function"] - #[doc = " (SDL_GL_LoadLibrary or SDL_Vulkan_LoadLibrary) is called and the"] - #[doc = " corresponding UnloadLibrary function is called by SDL_DestroyWindow()."] - #[doc = ""] - #[doc = " If SDL_WINDOW_VULKAN is specified and there isn't a working Vulkan driver,"] - #[doc = " SDL_CreateWindow() will fail because SDL_Vulkan_LoadLibrary() will fail."] - #[doc = ""] - #[doc = " If SDL_WINDOW_METAL is specified on an OS that does not support Metal,"] - #[doc = " SDL_CreateWindow() will fail."] - #[doc = ""] - #[doc = " \\note On non-Apple devices, SDL requires you to either not link to the"] - #[doc = " Vulkan loader or link to a dynamic library version. This limitation"] - #[doc = " may be removed in a future version of SDL."] - #[doc = ""] - #[doc = " \\sa SDL_DestroyWindow()"] - #[doc = " \\sa SDL_GL_LoadLibrary()"] - #[doc = " \\sa SDL_Vulkan_LoadLibrary()"] + #[doc = " Get the pixel format associated with the window."] + #[doc = ""] + #[doc = " \\param window the window to query"] + #[doc = " \\returns the pixel format of the window on success or"] + #[doc = " SDL_PIXELFORMAT_UNKNOWN on failure; call SDL_GetError() for more"] + #[doc = " information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + pub fn SDL_GetWindowPixelFormat(window: *mut SDL_Window) -> Uint32; +} +extern "C" { + #[doc = " Create a window with the specified position, dimensions, and flags."] + #[doc = ""] + #[doc = " `flags` may be any of the following OR'd together:"] + #[doc = ""] + #[doc = " - `SDL_WINDOW_FULLSCREEN`: fullscreen window"] + #[doc = " - `SDL_WINDOW_FULLSCREEN_DESKTOP`: fullscreen window at desktop resolution"] + #[doc = " - `SDL_WINDOW_OPENGL`: window usable with an OpenGL context"] + #[doc = " - `SDL_WINDOW_VULKAN`: window usable with a Vulkan instance"] + #[doc = " - `SDL_WINDOW_METAL`: window usable with a Metal instance"] + #[doc = " - `SDL_WINDOW_HIDDEN`: window is not visible"] + #[doc = " - `SDL_WINDOW_BORDERLESS`: no window decoration"] + #[doc = " - `SDL_WINDOW_RESIZABLE`: window can be resized"] + #[doc = " - `SDL_WINDOW_MINIMIZED`: window is minimized"] + #[doc = " - `SDL_WINDOW_MAXIMIZED`: window is maximized"] + #[doc = " - `SDL_WINDOW_INPUT_GRABBED`: window has grabbed input focus"] + #[doc = " - `SDL_WINDOW_ALLOW_HIGHDPI`: window should be created in high-DPI mode if"] + #[doc = " supported (>= SDL 2.0.1)"] + #[doc = ""] + #[doc = " `SDL_WINDOW_SHOWN` is ignored by SDL_CreateWindow(). The SDL_Window is"] + #[doc = " implicitly shown if SDL_WINDOW_HIDDEN is not set. `SDL_WINDOW_SHOWN` may be"] + #[doc = " queried later using SDL_GetWindowFlags()."] + #[doc = ""] + #[doc = " On Apple's macOS, you **must** set the NSHighResolutionCapable Info.plist"] + #[doc = " property to YES, otherwise you will not receive a High-DPI OpenGL canvas."] + #[doc = ""] + #[doc = " If the window is created with the `SDL_WINDOW_ALLOW_HIGHDPI` flag, its size"] + #[doc = " in pixels may differ from its size in screen coordinates on platforms with"] + #[doc = " high-DPI support (e.g. iOS and macOS). Use SDL_GetWindowSize() to query the"] + #[doc = " client area's size in screen coordinates, and SDL_GL_GetDrawableSize() or"] + #[doc = " SDL_GetRendererOutputSize() to query the drawable size in pixels."] + #[doc = ""] + #[doc = " If the window is set fullscreen, the width and height parameters `w` and"] + #[doc = " `h` will not be used. However, invalid size parameters (e.g. too large) may"] + #[doc = " still fail. Window size is actually limited to 16384 x 16384 for all"] + #[doc = " platforms at window creation."] + #[doc = ""] + #[doc = " If the window is created with any of the SDL_WINDOW_OPENGL or"] + #[doc = " SDL_WINDOW_VULKAN flags, then the corresponding LoadLibrary function"] + #[doc = " (SDL_GL_LoadLibrary or SDL_Vulkan_LoadLibrary) is called and the"] + #[doc = " corresponding UnloadLibrary function is called by SDL_DestroyWindow()."] + #[doc = ""] + #[doc = " If SDL_WINDOW_VULKAN is specified and there isn't a working Vulkan driver,"] + #[doc = " SDL_CreateWindow() will fail because SDL_Vulkan_LoadLibrary() will fail."] + #[doc = ""] + #[doc = " If SDL_WINDOW_METAL is specified on an OS that does not support Metal,"] + #[doc = " SDL_CreateWindow() will fail."] + #[doc = ""] + #[doc = " On non-Apple devices, SDL requires you to either not link to the Vulkan"] + #[doc = " loader or link to a dynamic library version. This limitation may be removed"] + #[doc = " in a future version of SDL."] + #[doc = ""] + #[doc = " \\param title the title of the window, in UTF-8 encoding"] + #[doc = " \\param x the x position of the window, `SDL_WINDOWPOS_CENTERED`, or"] + #[doc = " `SDL_WINDOWPOS_UNDEFINED`"] + #[doc = " \\param y the y position of the window, `SDL_WINDOWPOS_CENTERED`, or"] + #[doc = " `SDL_WINDOWPOS_UNDEFINED`"] + #[doc = " \\param w the width of the window, in screen coordinates"] + #[doc = " \\param h the height of the window, in screen coordinates"] + #[doc = " \\param flags 0, or one or more SDL_WindowFlags OR'd together"] + #[doc = " \\returns the window that was created or NULL on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateWindowFrom"] + #[doc = " \\sa SDL_DestroyWindow"] pub fn SDL_CreateWindow( title: *const libc::c_char, x: libc::c_int, @@ -7923,58 +10719,117 @@ extern "C" { ) -> *mut SDL_Window; } extern "C" { - #[doc = " \\brief Create an SDL window from an existing native window."] + #[doc = " Create an SDL window from an existing native window."] + #[doc = ""] + #[doc = " In some cases (e.g. OpenGL) and on some platforms (e.g. Microsoft Windows)"] + #[doc = " the hint `SDL_HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT` needs to be configured"] + #[doc = " before using SDL_CreateWindowFrom()."] #[doc = ""] - #[doc = " \\param data A pointer to driver-dependent window creation data"] + #[doc = " \\param data a pointer to driver-dependent window creation data, typically"] + #[doc = " your native window cast to a void*"] + #[doc = " \\returns the window that was created or NULL on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return The created window, or NULL if window creation failed."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_DestroyWindow()"] + #[doc = " \\sa SDL_CreateWindow"] + #[doc = " \\sa SDL_DestroyWindow"] pub fn SDL_CreateWindowFrom(data: *const libc::c_void) -> *mut SDL_Window; } extern "C" { - #[doc = " \\brief Get the numeric ID of a window, for logging purposes."] + #[doc = " Get the numeric ID of a window."] + #[doc = ""] + #[doc = " The numeric ID is what SDL_WindowEvent references, and is necessary to map"] + #[doc = " these events to specific SDL_Window objects."] + #[doc = ""] + #[doc = " \\param window the window to query"] + #[doc = " \\returns the ID of the window on success or 0 on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetWindowFromID"] pub fn SDL_GetWindowID(window: *mut SDL_Window) -> Uint32; } extern "C" { - #[doc = " \\brief Get a window from a stored ID, or NULL if it doesn't exist."] + #[doc = " Get a window from a stored ID."] + #[doc = ""] + #[doc = " The numeric ID is what SDL_WindowEvent references, and is necessary to map"] + #[doc = " these events to specific SDL_Window objects."] + #[doc = ""] + #[doc = " \\param id the ID of the window"] + #[doc = " \\returns the window associated with `id` or NULL if it doesn't exist; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetWindowID"] pub fn SDL_GetWindowFromID(id: Uint32) -> *mut SDL_Window; } extern "C" { - #[doc = " \\brief Get the window flags."] + #[doc = " Get the window flags."] + #[doc = ""] + #[doc = " \\param window the window to query"] + #[doc = " \\returns a mask of the SDL_WindowFlags associated with `window`"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateWindow"] + #[doc = " \\sa SDL_HideWindow"] + #[doc = " \\sa SDL_MaximizeWindow"] + #[doc = " \\sa SDL_MinimizeWindow"] + #[doc = " \\sa SDL_SetWindowFullscreen"] + #[doc = " \\sa SDL_SetWindowGrab"] + #[doc = " \\sa SDL_ShowWindow"] pub fn SDL_GetWindowFlags(window: *mut SDL_Window) -> Uint32; } extern "C" { - #[doc = " \\brief Set the title of a window, in UTF-8 format."] + #[doc = " Set the title of a window."] + #[doc = ""] + #[doc = " This string is expected to be in UTF-8 encoding."] + #[doc = ""] + #[doc = " \\param window the window to change"] + #[doc = " \\param title the desired window title in UTF-8 format"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_GetWindowTitle()"] + #[doc = " \\sa SDL_GetWindowTitle"] pub fn SDL_SetWindowTitle(window: *mut SDL_Window, title: *const libc::c_char); } extern "C" { - #[doc = " \\brief Get the title of a window, in UTF-8 format."] + #[doc = " Get the title of a window."] #[doc = ""] - #[doc = " \\sa SDL_SetWindowTitle()"] + #[doc = " \\param window the window to query"] + #[doc = " \\returns the title of the window in UTF-8 format or \"\" if there is no"] + #[doc = " title."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_SetWindowTitle"] pub fn SDL_GetWindowTitle(window: *mut SDL_Window) -> *const libc::c_char; } extern "C" { - #[doc = " \\brief Set the icon for a window."] + #[doc = " Set the icon for a window."] #[doc = ""] - #[doc = " \\param window The window for which the icon should be set."] - #[doc = " \\param icon The icon for the window."] + #[doc = " \\param window the window to change"] + #[doc = " \\param icon an SDL_Surface structure containing the icon for the window"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_SetWindowIcon(window: *mut SDL_Window, icon: *mut SDL_Surface); } extern "C" { - #[doc = " \\brief Associate an arbitrary named pointer with a window."] + #[doc = " Associate an arbitrary named pointer with a window."] #[doc = ""] - #[doc = " \\param window The window to associate with the pointer."] - #[doc = " \\param name The name of the pointer."] - #[doc = " \\param userdata The associated pointer."] + #[doc = " `name` is case-sensitive."] #[doc = ""] - #[doc = " \\return The previous value associated with 'name'"] + #[doc = " \\param window the window to associate with the pointer"] + #[doc = " \\param name the name of the pointer"] + #[doc = " \\param userdata the associated pointer"] + #[doc = " \\returns the previous value associated with `name`."] #[doc = ""] - #[doc = " \\note The name is case-sensitive."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_GetWindowData()"] + #[doc = " \\sa SDL_GetWindowData"] pub fn SDL_SetWindowData( window: *mut SDL_Window, name: *const libc::c_char, @@ -7982,95 +10837,132 @@ extern "C" { ) -> *mut libc::c_void; } extern "C" { - #[doc = " \\brief Retrieve the data pointer associated with a window."] + #[doc = " Retrieve the data pointer associated with a window."] #[doc = ""] - #[doc = " \\param window The window to query."] - #[doc = " \\param name The name of the pointer."] + #[doc = " \\param window the window to query"] + #[doc = " \\param name the name of the pointer"] + #[doc = " \\returns the value associated with `name`."] #[doc = ""] - #[doc = " \\return The value associated with 'name'"] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_SetWindowData()"] + #[doc = " \\sa SDL_SetWindowData"] pub fn SDL_GetWindowData( window: *mut SDL_Window, name: *const libc::c_char, ) -> *mut libc::c_void; } extern "C" { - #[doc = " \\brief Set the position of a window."] + #[doc = " Set the position of a window."] + #[doc = ""] + #[doc = " The window coordinate origin is the upper left of the display."] #[doc = ""] - #[doc = " \\param window The window to reposition."] - #[doc = " \\param x The x coordinate of the window in screen coordinates, or"] - #[doc = " ::SDL_WINDOWPOS_CENTERED or ::SDL_WINDOWPOS_UNDEFINED."] - #[doc = " \\param y The y coordinate of the window in screen coordinates, or"] - #[doc = " ::SDL_WINDOWPOS_CENTERED or ::SDL_WINDOWPOS_UNDEFINED."] + #[doc = " \\param window the window to reposition"] + #[doc = " \\param x the x coordinate of the window in screen coordinates, or"] + #[doc = " `SDL_WINDOWPOS_CENTERED` or `SDL_WINDOWPOS_UNDEFINED`"] + #[doc = " \\param y the y coordinate of the window in screen coordinates, or"] + #[doc = " `SDL_WINDOWPOS_CENTERED` or `SDL_WINDOWPOS_UNDEFINED`"] #[doc = ""] - #[doc = " \\note The window coordinate origin is the upper left of the display."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_GetWindowPosition()"] + #[doc = " \\sa SDL_GetWindowPosition"] pub fn SDL_SetWindowPosition(window: *mut SDL_Window, x: libc::c_int, y: libc::c_int); } extern "C" { - #[doc = " \\brief Get the position of a window."] + #[doc = " Get the position of a window."] #[doc = ""] - #[doc = " \\param window The window to query."] - #[doc = " \\param x Pointer to variable for storing the x position, in screen"] - #[doc = " coordinates. May be NULL."] - #[doc = " \\param y Pointer to variable for storing the y position, in screen"] - #[doc = " coordinates. May be NULL."] + #[doc = " If you do not need the value for one of the positions a NULL may be passed"] + #[doc = " in the `x` or `y` parameter."] #[doc = ""] - #[doc = " \\sa SDL_SetWindowPosition()"] + #[doc = " \\param window the window to query"] + #[doc = " \\param x a pointer filled in with the x position of the window, in screen"] + #[doc = " coordinates, may be NULL"] + #[doc = " \\param y a pointer filled in with the y position of the window, in screen"] + #[doc = " coordinates, may be NULL"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_SetWindowPosition"] pub fn SDL_GetWindowPosition(window: *mut SDL_Window, x: *mut libc::c_int, y: *mut libc::c_int); } extern "C" { - #[doc = " \\brief Set the size of a window's client area."] + #[doc = " Set the size of a window's client area."] #[doc = ""] - #[doc = " \\param window The window to resize."] - #[doc = " \\param w The width of the window, in screen coordinates. Must be >0."] - #[doc = " \\param h The height of the window, in screen coordinates. Must be >0."] + #[doc = " The window size in screen coordinates may differ from the size in pixels,"] + #[doc = " if the window was created with `SDL_WINDOW_ALLOW_HIGHDPI` on a platform"] + #[doc = " with high-dpi support (e.g. iOS or macOS). Use SDL_GL_GetDrawableSize() or"] + #[doc = " SDL_GetRendererOutputSize() to get the real client area size in pixels."] #[doc = ""] - #[doc = " \\note Fullscreen windows automatically match the size of the display mode,"] - #[doc = " and you should use SDL_SetWindowDisplayMode() to change their size."] + #[doc = " Fullscreen windows automatically match the size of the display mode, and"] + #[doc = " you should use SDL_SetWindowDisplayMode() to change their size."] #[doc = ""] - #[doc = " The window size in screen coordinates may differ from the size in pixels, if"] - #[doc = " the window was created with SDL_WINDOW_ALLOW_HIGHDPI on a platform with"] - #[doc = " high-dpi support (e.g. iOS or OS X). Use SDL_GL_GetDrawableSize() or"] - #[doc = " SDL_GetRendererOutputSize() to get the real client area size in pixels."] + #[doc = " \\param window the window to change"] + #[doc = " \\param w the width of the window in pixels, in screen coordinates, must be"] + #[doc = " > 0"] + #[doc = " \\param h the height of the window in pixels, in screen coordinates, must be"] + #[doc = " > 0"] #[doc = ""] - #[doc = " \\sa SDL_GetWindowSize()"] - #[doc = " \\sa SDL_SetWindowDisplayMode()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetWindowSize"] + #[doc = " \\sa SDL_SetWindowDisplayMode"] pub fn SDL_SetWindowSize(window: *mut SDL_Window, w: libc::c_int, h: libc::c_int); } extern "C" { - #[doc = " \\brief Get the size of a window's client area."] + #[doc = " Get the size of a window's client area."] + #[doc = ""] + #[doc = " NULL can safely be passed as the `w` or `h` parameter if the width or"] + #[doc = " height value is not desired."] #[doc = ""] - #[doc = " \\param window The window to query."] - #[doc = " \\param w Pointer to variable for storing the width, in screen"] - #[doc = " coordinates. May be NULL."] - #[doc = " \\param h Pointer to variable for storing the height, in screen"] - #[doc = " coordinates. May be NULL."] + #[doc = " The window size in screen coordinates may differ from the size in pixels,"] + #[doc = " if the window was created with `SDL_WINDOW_ALLOW_HIGHDPI` on a platform"] + #[doc = " with high-dpi support (e.g. iOS or macOS). Use SDL_GL_GetDrawableSize(),"] + #[doc = " SDL_Vulkan_GetDrawableSize(), or SDL_GetRendererOutputSize() to get the"] + #[doc = " real client area size in pixels."] #[doc = ""] - #[doc = " The window size in screen coordinates may differ from the size in pixels, if"] - #[doc = " the window was created with SDL_WINDOW_ALLOW_HIGHDPI on a platform with"] - #[doc = " high-dpi support (e.g. iOS or OS X). Use SDL_GL_GetDrawableSize() or"] - #[doc = " SDL_GetRendererOutputSize() to get the real client area size in pixels."] + #[doc = " \\param window the window to query the width and height from"] + #[doc = " \\param w a pointer filled in with the width of the window, in screen"] + #[doc = " coordinates, may be NULL"] + #[doc = " \\param h a pointer filled in with the height of the window, in screen"] + #[doc = " coordinates, may be NULL"] #[doc = ""] - #[doc = " \\sa SDL_SetWindowSize()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GL_GetDrawableSize"] + #[doc = " \\sa SDL_Vulkan_GetDrawableSize"] + #[doc = " \\sa SDL_SetWindowSize"] pub fn SDL_GetWindowSize(window: *mut SDL_Window, w: *mut libc::c_int, h: *mut libc::c_int); } extern "C" { - #[doc = " \\brief Get the size of a window's borders (decorations) around the client area."] + #[doc = " Get the size of a window's borders (decorations) around the client area."] + #[doc = ""] + #[doc = " Note: If this function fails (returns -1), the size values will be"] + #[doc = " initialized to 0, 0, 0, 0 (if a non-NULL pointer is provided), as if the"] + #[doc = " window in question was borderless."] + #[doc = ""] + #[doc = " Note: This function may fail on systems where the window has not yet been"] + #[doc = " decorated by the display server (for example, immediately after calling"] + #[doc = " SDL_CreateWindow). It is recommended that you wait at least until the"] + #[doc = " window has been presented and composited, so that the window system has a"] + #[doc = " chance to decorate the window and provide the border dimensions to SDL."] + #[doc = ""] + #[doc = " This function also returns -1 if getting the information is not supported."] #[doc = ""] - #[doc = " \\param window The window to query."] - #[doc = " \\param top Pointer to variable for storing the size of the top border. NULL is permitted."] - #[doc = " \\param left Pointer to variable for storing the size of the left border. NULL is permitted."] - #[doc = " \\param bottom Pointer to variable for storing the size of the bottom border. NULL is permitted."] - #[doc = " \\param right Pointer to variable for storing the size of the right border. NULL is permitted."] + #[doc = " \\param window the window to query the size values of the border"] + #[doc = " (decorations) from"] + #[doc = " \\param top pointer to variable for storing the size of the top border; NULL"] + #[doc = " is permitted"] + #[doc = " \\param left pointer to variable for storing the size of the left border;"] + #[doc = " NULL is permitted"] + #[doc = " \\param bottom pointer to variable for storing the size of the bottom"] + #[doc = " border; NULL is permitted"] + #[doc = " \\param right pointer to variable for storing the size of the right border;"] + #[doc = " NULL is permitted"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if getting this information is not supported."] + #[doc = " \\since This function is available since SDL 2.0.5."] #[doc = ""] - #[doc = " \\note if this function fails (returns -1), the size values will be"] - #[doc = " initialized to 0, 0, 0, 0 (if a non-NULL pointer is provided), as"] - #[doc = " if the window in question was borderless."] + #[doc = " \\sa SDL_GetWindowSize"] pub fn SDL_GetWindowBordersSize( window: *mut SDL_Window, top: *mut libc::c_int, @@ -8080,17 +10972,16 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Set the minimum size of a window's client area."] + #[doc = " Set the minimum size of a window's client area."] #[doc = ""] - #[doc = " \\param window The window to set a new minimum size."] - #[doc = " \\param min_w The minimum width of the window, must be >0"] - #[doc = " \\param min_h The minimum height of the window, must be >0"] + #[doc = " \\param window the window to change"] + #[doc = " \\param min_w the minimum width of the window in pixels"] + #[doc = " \\param min_h the minimum height of the window in pixels"] #[doc = ""] - #[doc = " \\note You can't change the minimum size of a fullscreen window, it"] - #[doc = " automatically matches the size of the display mode."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_GetWindowMinimumSize()"] - #[doc = " \\sa SDL_SetWindowMaximumSize()"] + #[doc = " \\sa SDL_GetWindowMinimumSize"] + #[doc = " \\sa SDL_SetWindowMaximumSize"] pub fn SDL_SetWindowMinimumSize( window: *mut SDL_Window, min_w: libc::c_int, @@ -8098,14 +10989,18 @@ extern "C" { ); } extern "C" { - #[doc = " \\brief Get the minimum size of a window's client area."] + #[doc = " Get the minimum size of a window's client area."] #[doc = ""] - #[doc = " \\param window The window to query."] - #[doc = " \\param w Pointer to variable for storing the minimum width, may be NULL"] - #[doc = " \\param h Pointer to variable for storing the minimum height, may be NULL"] + #[doc = " \\param window the window to query"] + #[doc = " \\param w a pointer filled in with the minimum width of the window, may be"] + #[doc = " NULL"] + #[doc = " \\param h a pointer filled in with the minimum height of the window, may be"] + #[doc = " NULL"] #[doc = ""] - #[doc = " \\sa SDL_GetWindowMaximumSize()"] - #[doc = " \\sa SDL_SetWindowMinimumSize()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetWindowMaximumSize"] + #[doc = " \\sa SDL_SetWindowMinimumSize"] pub fn SDL_GetWindowMinimumSize( window: *mut SDL_Window, w: *mut libc::c_int, @@ -8113,17 +11008,16 @@ extern "C" { ); } extern "C" { - #[doc = " \\brief Set the maximum size of a window's client area."] + #[doc = " Set the maximum size of a window's client area."] #[doc = ""] - #[doc = " \\param window The window to set a new maximum size."] - #[doc = " \\param max_w The maximum width of the window, must be >0"] - #[doc = " \\param max_h The maximum height of the window, must be >0"] + #[doc = " \\param window the window to change"] + #[doc = " \\param max_w the maximum width of the window in pixels"] + #[doc = " \\param max_h the maximum height of the window in pixels"] #[doc = ""] - #[doc = " \\note You can't change the maximum size of a fullscreen window, it"] - #[doc = " automatically matches the size of the display mode."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_GetWindowMaximumSize()"] - #[doc = " \\sa SDL_SetWindowMinimumSize()"] + #[doc = " \\sa SDL_GetWindowMaximumSize"] + #[doc = " \\sa SDL_SetWindowMinimumSize"] pub fn SDL_SetWindowMaximumSize( window: *mut SDL_Window, max_w: libc::c_int, @@ -8131,14 +11025,18 @@ extern "C" { ); } extern "C" { - #[doc = " \\brief Get the maximum size of a window's client area."] + #[doc = " Get the maximum size of a window's client area."] + #[doc = ""] + #[doc = " \\param window the window to query"] + #[doc = " \\param w a pointer filled in with the maximum width of the window, may be"] + #[doc = " NULL"] + #[doc = " \\param h a pointer filled in with the maximum height of the window, may be"] + #[doc = " NULL"] #[doc = ""] - #[doc = " \\param window The window to query."] - #[doc = " \\param w Pointer to variable for storing the maximum width, may be NULL"] - #[doc = " \\param h Pointer to variable for storing the maximum height, may be NULL"] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_GetWindowMinimumSize()"] - #[doc = " \\sa SDL_SetWindowMaximumSize()"] + #[doc = " \\sa SDL_GetWindowMinimumSize"] + #[doc = " \\sa SDL_SetWindowMaximumSize"] pub fn SDL_GetWindowMaximumSize( window: *mut SDL_Window, w: *mut libc::c_int, @@ -8146,109 +11044,195 @@ extern "C" { ); } extern "C" { - #[doc = " \\brief Set the border state of a window."] + #[doc = " Set the border state of a window."] #[doc = ""] - #[doc = " This will add or remove the window's SDL_WINDOW_BORDERLESS flag and"] - #[doc = " add or remove the border from the actual window. This is a no-op if the"] - #[doc = " window's border already matches the requested state."] + #[doc = " This will add or remove the window's `SDL_WINDOW_BORDERLESS` flag and add"] + #[doc = " or remove the border from the actual window. This is a no-op if the"] + #[doc = " window's border already matches the requested state."] #[doc = ""] - #[doc = " \\param window The window of which to change the border state."] - #[doc = " \\param bordered SDL_FALSE to remove border, SDL_TRUE to add border."] + #[doc = " You can't change the border state of a fullscreen window."] #[doc = ""] - #[doc = " \\note You can't change the border state of a fullscreen window."] + #[doc = " \\param window the window of which to change the border state"] + #[doc = " \\param bordered SDL_FALSE to remove border, SDL_TRUE to add border"] #[doc = ""] - #[doc = " \\sa SDL_GetWindowFlags()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetWindowFlags"] pub fn SDL_SetWindowBordered(window: *mut SDL_Window, bordered: SDL_bool); } extern "C" { - #[doc = " \\brief Set the user-resizable state of a window."] + #[doc = " Set the user-resizable state of a window."] + #[doc = ""] + #[doc = " This will add or remove the window's `SDL_WINDOW_RESIZABLE` flag and"] + #[doc = " allow/disallow user resizing of the window. This is a no-op if the window's"] + #[doc = " resizable state already matches the requested state."] #[doc = ""] - #[doc = " This will add or remove the window's SDL_WINDOW_RESIZABLE flag and"] - #[doc = " allow/disallow user resizing of the window. This is a no-op if the"] - #[doc = " window's resizable state already matches the requested state."] + #[doc = " You can't change the resizable state of a fullscreen window."] #[doc = ""] - #[doc = " \\param window The window of which to change the resizable state."] - #[doc = " \\param resizable SDL_TRUE to allow resizing, SDL_FALSE to disallow."] + #[doc = " \\param window the window of which to change the resizable state"] + #[doc = " \\param resizable SDL_TRUE to allow resizing, SDL_FALSE to disallow"] #[doc = ""] - #[doc = " \\note You can't change the resizable state of a fullscreen window."] + #[doc = " \\since This function is available since SDL 2.0.5."] #[doc = ""] - #[doc = " \\sa SDL_GetWindowFlags()"] + #[doc = " \\sa SDL_GetWindowFlags"] pub fn SDL_SetWindowResizable(window: *mut SDL_Window, resizable: SDL_bool); } extern "C" { - #[doc = " \\brief Show a window."] + #[doc = " Set the window to always be above the others."] + #[doc = ""] + #[doc = " This will add or remove the window's `SDL_WINDOW_ALWAYS_ON_TOP` flag. This"] + #[doc = " will bring the window to the front and keep the window above the rest."] + #[doc = ""] + #[doc = " \\param window The window of which to change the always on top state"] + #[doc = " \\param on_top SDL_TRUE to set the window always on top, SDL_FALSE to"] + #[doc = " disable"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.16."] + #[doc = ""] + #[doc = " \\sa SDL_GetWindowFlags"] + pub fn SDL_SetWindowAlwaysOnTop(window: *mut SDL_Window, on_top: SDL_bool); +} +extern "C" { + #[doc = " Show a window."] + #[doc = ""] + #[doc = " \\param window the window to show"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_HideWindow()"] + #[doc = " \\sa SDL_HideWindow"] + #[doc = " \\sa SDL_RaiseWindow"] pub fn SDL_ShowWindow(window: *mut SDL_Window); } extern "C" { - #[doc = " \\brief Hide a window."] + #[doc = " Hide a window."] #[doc = ""] - #[doc = " \\sa SDL_ShowWindow()"] + #[doc = " \\param window the window to hide"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_ShowWindow"] pub fn SDL_HideWindow(window: *mut SDL_Window); } extern "C" { - #[doc = " \\brief Raise a window above other windows and set the input focus."] + #[doc = " Raise a window above other windows and set the input focus."] + #[doc = ""] + #[doc = " \\param window the window to raise"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_RaiseWindow(window: *mut SDL_Window); } extern "C" { - #[doc = " \\brief Make a window as large as possible."] + #[doc = " Make a window as large as possible."] #[doc = ""] - #[doc = " \\sa SDL_RestoreWindow()"] + #[doc = " \\param window the window to maximize"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_MinimizeWindow"] + #[doc = " \\sa SDL_RestoreWindow"] pub fn SDL_MaximizeWindow(window: *mut SDL_Window); } extern "C" { - #[doc = " \\brief Minimize a window to an iconic representation."] + #[doc = " Minimize a window to an iconic representation."] + #[doc = ""] + #[doc = " \\param window the window to minimize"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_RestoreWindow()"] + #[doc = " \\sa SDL_MaximizeWindow"] + #[doc = " \\sa SDL_RestoreWindow"] pub fn SDL_MinimizeWindow(window: *mut SDL_Window); } extern "C" { - #[doc = " \\brief Restore the size and position of a minimized or maximized window."] + #[doc = " Restore the size and position of a minimized or maximized window."] #[doc = ""] - #[doc = " \\sa SDL_MaximizeWindow()"] - #[doc = " \\sa SDL_MinimizeWindow()"] + #[doc = " \\param window the window to restore"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_MaximizeWindow"] + #[doc = " \\sa SDL_MinimizeWindow"] pub fn SDL_RestoreWindow(window: *mut SDL_Window); } extern "C" { - #[doc = " \\brief Set a window's fullscreen state."] + #[doc = " Set a window's fullscreen state."] + #[doc = ""] + #[doc = " `flags` may be `SDL_WINDOW_FULLSCREEN`, for \"real\" fullscreen with a"] + #[doc = " videomode change; `SDL_WINDOW_FULLSCREEN_DESKTOP` for \"fake\" fullscreen"] + #[doc = " that takes the size of the desktop; and 0 for windowed mode."] + #[doc = ""] + #[doc = " \\param window the window to change"] + #[doc = " \\param flags `SDL_WINDOW_FULLSCREEN`, `SDL_WINDOW_FULLSCREEN_DESKTOP` or 0"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if setting the display mode failed."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_SetWindowDisplayMode()"] - #[doc = " \\sa SDL_GetWindowDisplayMode()"] + #[doc = " \\sa SDL_GetWindowDisplayMode"] + #[doc = " \\sa SDL_SetWindowDisplayMode"] pub fn SDL_SetWindowFullscreen(window: *mut SDL_Window, flags: Uint32) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the SDL surface associated with the window."] + #[doc = " Get the SDL surface associated with the window."] #[doc = ""] - #[doc = " \\return The window's framebuffer surface, or NULL on error."] + #[doc = " A new surface will be created with the optimal format for the window, if"] + #[doc = " necessary. This surface will be freed when the window is destroyed. Do not"] + #[doc = " free this surface."] #[doc = ""] - #[doc = " A new surface will be created with the optimal format for the window,"] - #[doc = " if necessary. This surface will be freed when the window is destroyed."] + #[doc = " This surface will be invalidated if the window is resized. After resizing a"] + #[doc = " window this function must be called again to return a valid surface."] #[doc = ""] - #[doc = " \\note You may not combine this with 3D or the rendering API on this window."] + #[doc = " You may not combine this with 3D or the rendering API on this window."] #[doc = ""] - #[doc = " \\sa SDL_UpdateWindowSurface()"] - #[doc = " \\sa SDL_UpdateWindowSurfaceRects()"] + #[doc = " This function is affected by `SDL_HINT_FRAMEBUFFER_ACCELERATION`."] + #[doc = ""] + #[doc = " \\param window the window to query"] + #[doc = " \\returns the surface associated with the window, or NULL on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_UpdateWindowSurface"] + #[doc = " \\sa SDL_UpdateWindowSurfaceRects"] pub fn SDL_GetWindowSurface(window: *mut SDL_Window) -> *mut SDL_Surface; } extern "C" { - #[doc = " \\brief Copy the window surface to the screen."] + #[doc = " Copy the window surface to the screen."] + #[doc = ""] + #[doc = " This is the function you use to reflect any changes to the surface on the"] + #[doc = " screen."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error."] + #[doc = " This function is equivalent to the SDL 1.2 API SDL_Flip()."] #[doc = ""] - #[doc = " \\sa SDL_GetWindowSurface()"] - #[doc = " \\sa SDL_UpdateWindowSurfaceRects()"] + #[doc = " \\param window the window to update"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetWindowSurface"] + #[doc = " \\sa SDL_UpdateWindowSurfaceRects"] pub fn SDL_UpdateWindowSurface(window: *mut SDL_Window) -> libc::c_int; } extern "C" { - #[doc = " \\brief Copy a number of rectangles on the window surface to the screen."] + #[doc = " Copy areas of the window surface to the screen."] + #[doc = ""] + #[doc = " This is the function you use to reflect changes to portions of the surface"] + #[doc = " on the screen."] + #[doc = ""] + #[doc = " This function is equivalent to the SDL 1.2 API SDL_UpdateRects()."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error."] + #[doc = " \\param window the window to update"] + #[doc = " \\param rects an array of SDL_Rect structures representing areas of the"] + #[doc = " surface to copy"] + #[doc = " \\param numrects the number of rectangles"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\sa SDL_GetWindowSurface()"] - #[doc = " \\sa SDL_UpdateWindowSurface()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetWindowSurface"] + #[doc = " \\sa SDL_UpdateWindowSurface"] pub fn SDL_UpdateWindowSurfaceRects( window: *mut SDL_Window, rects: *const SDL_Rect, @@ -8256,118 +11240,285 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Set a window's input grab mode."] + #[doc = " Set a window's input grab mode."] + #[doc = ""] + #[doc = " When input is grabbed, the mouse is confined to the window. This function"] + #[doc = " will also grab the keyboard if `SDL_HINT_GRAB_KEYBOARD` is set. To grab the"] + #[doc = " keyboard without also grabbing the mouse, use SDL_SetWindowKeyboardGrab()."] #[doc = ""] - #[doc = " \\param window The window for which the input grab mode should be set."] - #[doc = " \\param grabbed This is SDL_TRUE to grab input, and SDL_FALSE to release input."] + #[doc = " If the caller enables a grab while another window is currently grabbed, the"] + #[doc = " other window loses its grab in favor of the caller's window."] #[doc = ""] - #[doc = " If the caller enables a grab while another window is currently grabbed,"] - #[doc = " the other window loses its grab in favor of the caller's window."] + #[doc = " \\param window the window for which the input grab mode should be set"] + #[doc = " \\param grabbed SDL_TRUE to grab input or SDL_FALSE to release input"] #[doc = ""] - #[doc = " \\sa SDL_GetWindowGrab()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetGrabbedWindow"] + #[doc = " \\sa SDL_GetWindowGrab"] pub fn SDL_SetWindowGrab(window: *mut SDL_Window, grabbed: SDL_bool); } extern "C" { - #[doc = " \\brief Get a window's input grab mode."] + #[doc = " Set a window's keyboard grab mode."] + #[doc = ""] + #[doc = " Keyboard grab enables capture of system keyboard shortcuts like Alt+Tab or"] + #[doc = " the Meta/Super key. Note that not all system keyboard shortcuts can be"] + #[doc = " captured by applications (one example is Ctrl+Alt+Del on Windows)."] + #[doc = ""] + #[doc = " This is primarily intended for specialized applications such as VNC clients"] + #[doc = " or VM frontends. Normal games should not use keyboard grab."] + #[doc = ""] + #[doc = " When keyboard grab is enabled, SDL will continue to handle Alt+Tab when the"] + #[doc = " window is full-screen to ensure the user is not trapped in your"] + #[doc = " application. If you have a custom keyboard shortcut to exit fullscreen"] + #[doc = " mode, you may suppress this behavior with"] + #[doc = " `SDL_HINT_ALLOW_ALT_TAB_WHILE_GRABBED`."] + #[doc = ""] + #[doc = " If the caller enables a grab while another window is currently grabbed, the"] + #[doc = " other window loses its grab in favor of the caller's window."] + #[doc = ""] + #[doc = " \\param window The window for which the keyboard grab mode should be set."] + #[doc = " \\param grabbed This is SDL_TRUE to grab keyboard, and SDL_FALSE to release."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.16."] + #[doc = ""] + #[doc = " \\sa SDL_GetWindowKeyboardGrab"] + #[doc = " \\sa SDL_SetWindowMouseGrab"] + #[doc = " \\sa SDL_SetWindowGrab"] + pub fn SDL_SetWindowKeyboardGrab(window: *mut SDL_Window, grabbed: SDL_bool); +} +extern "C" { + #[doc = " Set a window's mouse grab mode."] + #[doc = ""] + #[doc = " Mouse grab confines the mouse cursor to the window."] + #[doc = ""] + #[doc = " \\param window The window for which the mouse grab mode should be set."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.16."] + #[doc = ""] + #[doc = " \\sa SDL_GetWindowMouseGrab"] + #[doc = " \\sa SDL_SetWindowKeyboardGrab"] + #[doc = " \\sa SDL_SetWindowGrab"] + pub fn SDL_SetWindowMouseGrab(window: *mut SDL_Window, grabbed: SDL_bool); +} +extern "C" { + #[doc = " Get a window's input grab mode."] #[doc = ""] - #[doc = " \\return This returns SDL_TRUE if input is grabbed, and SDL_FALSE otherwise."] + #[doc = " \\param window the window to query"] + #[doc = " \\returns SDL_TRUE if input is grabbed, SDL_FALSE otherwise."] #[doc = ""] - #[doc = " \\sa SDL_SetWindowGrab()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_SetWindowGrab"] pub fn SDL_GetWindowGrab(window: *mut SDL_Window) -> SDL_bool; } extern "C" { - #[doc = " \\brief Get the window that currently has an input grab enabled."] + #[doc = " Get a window's keyboard grab mode."] + #[doc = ""] + #[doc = " \\param window the window to query"] + #[doc = " \\returns SDL_TRUE if keyboard is grabbed, and SDL_FALSE otherwise."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.16."] + #[doc = ""] + #[doc = " \\sa SDL_SetWindowKeyboardGrab"] + #[doc = " \\sa SDL_GetWindowGrab"] + pub fn SDL_GetWindowKeyboardGrab(window: *mut SDL_Window) -> SDL_bool; +} +extern "C" { + #[doc = " Get a window's mouse grab mode."] #[doc = ""] - #[doc = " \\return This returns the window if input is grabbed, and NULL otherwise."] + #[doc = " \\param window the window to query"] + #[doc = " \\returns SDL_TRUE if mouse is grabbed, and SDL_FALSE otherwise."] #[doc = ""] - #[doc = " \\sa SDL_SetWindowGrab()"] + #[doc = " \\since This function is available since SDL 2.0.16."] + #[doc = ""] + #[doc = " \\sa SDL_SetWindowKeyboardGrab"] + #[doc = " \\sa SDL_GetWindowGrab"] + pub fn SDL_GetWindowMouseGrab(window: *mut SDL_Window) -> SDL_bool; +} +extern "C" { + #[doc = " Get the window that currently has an input grab enabled."] + #[doc = ""] + #[doc = " \\returns the window if input is grabbed or NULL otherwise."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.4."] + #[doc = ""] + #[doc = " \\sa SDL_GetWindowGrab"] + #[doc = " \\sa SDL_SetWindowGrab"] pub fn SDL_GetGrabbedWindow() -> *mut SDL_Window; } extern "C" { - #[doc = " \\brief Set the brightness (gamma correction) for a window."] + #[doc = " Confines the cursor to the specified area of a window."] + #[doc = ""] + #[doc = " Note that this does NOT grab the cursor, it only defines the area a cursor"] + #[doc = " is restricted to when the window has mouse focus."] + #[doc = ""] + #[doc = " \\param window The window that will be associated with the barrier."] + #[doc = " \\param rect A rectangle area in window-relative coordinates. If NULL the"] + #[doc = " barrier for the specified window will be destroyed."] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.18."] + #[doc = ""] + #[doc = " \\sa SDL_GetWindowMouseRect"] + #[doc = " \\sa SDL_SetWindowMouseGrab"] + pub fn SDL_SetWindowMouseRect(window: *mut SDL_Window, rect: *const SDL_Rect) -> libc::c_int; +} +extern "C" { + #[doc = " Get the mouse confinement rectangle of a window."] + #[doc = ""] + #[doc = " \\param window The window to query"] + #[doc = " \\returns A pointer to the mouse confinement rectangle of a window, or NULL"] + #[doc = " if there isn't one."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.18."] + #[doc = ""] + #[doc = " \\sa SDL_SetWindowMouseRect"] + pub fn SDL_GetWindowMouseRect(window: *mut SDL_Window) -> *const SDL_Rect; +} +extern "C" { + #[doc = " Set the brightness (gamma multiplier) for a given window's display."] + #[doc = ""] + #[doc = " Despite the name and signature, this method sets the brightness of the"] + #[doc = " entire display, not an individual window. A window is considered to be"] + #[doc = " owned by the display that contains the window's center pixel. (The index of"] + #[doc = " this display can be retrieved using SDL_GetWindowDisplayIndex().) The"] + #[doc = " brightness set will not follow the window if it is moved to another"] + #[doc = " display."] + #[doc = ""] + #[doc = " Many platforms will refuse to set the display brightness in modern times."] + #[doc = " You are better off using a shader to adjust gamma during rendering, or"] + #[doc = " something similar."] + #[doc = ""] + #[doc = " \\param window the window used to select the display whose brightness will"] + #[doc = " be changed"] + #[doc = " \\param brightness the brightness (gamma multiplier) value to set where 0.0"] + #[doc = " is completely dark and 1.0 is normal brightness"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if setting the brightness isn't supported."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_GetWindowBrightness()"] - #[doc = " \\sa SDL_SetWindowGammaRamp()"] + #[doc = " \\sa SDL_GetWindowBrightness"] + #[doc = " \\sa SDL_SetWindowGammaRamp"] pub fn SDL_SetWindowBrightness(window: *mut SDL_Window, brightness: f32) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the brightness (gamma correction) for a window."] + #[doc = " Get the brightness (gamma multiplier) for a given window's display."] #[doc = ""] - #[doc = " \\return The last brightness value passed to SDL_SetWindowBrightness()"] + #[doc = " Despite the name and signature, this method retrieves the brightness of the"] + #[doc = " entire display, not an individual window. A window is considered to be"] + #[doc = " owned by the display that contains the window's center pixel. (The index of"] + #[doc = " this display can be retrieved using SDL_GetWindowDisplayIndex().)"] #[doc = ""] - #[doc = " \\sa SDL_SetWindowBrightness()"] + #[doc = " \\param window the window used to select the display whose brightness will"] + #[doc = " be queried"] + #[doc = " \\returns the brightness for the display where 0.0 is completely dark and"] + #[doc = " 1.0 is normal brightness."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_SetWindowBrightness"] pub fn SDL_GetWindowBrightness(window: *mut SDL_Window) -> f32; } extern "C" { - #[doc = " \\brief Set the opacity for a window"] + #[doc = " Set the opacity for a window."] + #[doc = ""] + #[doc = " The parameter `opacity` will be clamped internally between 0.0f"] + #[doc = " (transparent) and 1.0f (opaque)."] + #[doc = ""] + #[doc = " This function also returns -1 if setting the opacity isn't supported."] #[doc = ""] - #[doc = " \\param window The window which will be made transparent or opaque"] - #[doc = " \\param opacity Opacity (0.0f - transparent, 1.0f - opaque) This will be"] - #[doc = " clamped internally between 0.0f and 1.0f."] + #[doc = " \\param window the window which will be made transparent or opaque"] + #[doc = " \\param opacity the opacity value (0.0f - transparent, 1.0f - opaque)"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if setting the opacity isn't supported."] + #[doc = " \\since This function is available since SDL 2.0.5."] #[doc = ""] - #[doc = " \\sa SDL_GetWindowOpacity()"] + #[doc = " \\sa SDL_GetWindowOpacity"] pub fn SDL_SetWindowOpacity(window: *mut SDL_Window, opacity: f32) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the opacity of a window."] + #[doc = " Get the opacity of a window."] #[doc = ""] - #[doc = " If transparency isn't supported on this platform, opacity will be reported"] - #[doc = " as 1.0f without error."] + #[doc = " If transparency isn't supported on this platform, opacity will be reported"] + #[doc = " as 1.0f without error."] #[doc = ""] - #[doc = " \\param window The window in question."] - #[doc = " \\param out_opacity Opacity (0.0f - transparent, 1.0f - opaque)"] + #[doc = " The parameter `opacity` is ignored if it is NULL."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error (invalid window, etc)."] + #[doc = " This function also returns -1 if an invalid window was provided."] #[doc = ""] - #[doc = " \\sa SDL_SetWindowOpacity()"] + #[doc = " \\param window the window to get the current opacity value from"] + #[doc = " \\param out_opacity the float filled in (0.0f - transparent, 1.0f - opaque)"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.5."] + #[doc = ""] + #[doc = " \\sa SDL_SetWindowOpacity"] pub fn SDL_GetWindowOpacity(window: *mut SDL_Window, out_opacity: *mut f32) -> libc::c_int; } extern "C" { - #[doc = " \\brief Sets the window as a modal for another window (TODO: reconsider this function and/or its name)"] + #[doc = " Set the window as a modal for another window."] #[doc = ""] - #[doc = " \\param modal_window The window that should be modal"] - #[doc = " \\param parent_window The parent window"] + #[doc = " \\param modal_window the window that should be set modal"] + #[doc = " \\param parent_window the parent window for the modal window"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 otherwise."] + #[doc = " \\since This function is available since SDL 2.0.5."] pub fn SDL_SetWindowModalFor( modal_window: *mut SDL_Window, parent_window: *mut SDL_Window, ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Explicitly sets input focus to the window."] + #[doc = " Explicitly set input focus to the window."] #[doc = ""] - #[doc = " You almost certainly want SDL_RaiseWindow() instead of this function. Use"] - #[doc = " this with caution, as you might give focus to a window that's completely"] - #[doc = " obscured by other windows."] + #[doc = " You almost certainly want SDL_RaiseWindow() instead of this function. Use"] + #[doc = " this with caution, as you might give focus to a window that is completely"] + #[doc = " obscured by other windows."] #[doc = ""] - #[doc = " \\param window The window that should get the input focus"] + #[doc = " \\param window the window that should get the input focus"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 otherwise."] - #[doc = " \\sa SDL_RaiseWindow()"] + #[doc = " \\since This function is available since SDL 2.0.5."] + #[doc = ""] + #[doc = " \\sa SDL_RaiseWindow"] pub fn SDL_SetWindowInputFocus(window: *mut SDL_Window) -> libc::c_int; } extern "C" { - #[doc = " \\brief Set the gamma ramp for a window."] + #[doc = " Set the gamma ramp for the display that owns a given window."] + #[doc = ""] + #[doc = " Set the gamma translation table for the red, green, and blue channels of"] + #[doc = " the video hardware. Each table is an array of 256 16-bit quantities,"] + #[doc = " representing a mapping between the input and output for that channel. The"] + #[doc = " input is the index into the array, and the output is the 16-bit gamma value"] + #[doc = " at that index, scaled to the output color precision."] #[doc = ""] - #[doc = " \\param window The window for which the gamma ramp should be set."] - #[doc = " \\param red The translation table for the red channel, or NULL."] - #[doc = " \\param green The translation table for the green channel, or NULL."] - #[doc = " \\param blue The translation table for the blue channel, or NULL."] + #[doc = " Despite the name and signature, this method sets the gamma ramp of the"] + #[doc = " entire display, not an individual window. A window is considered to be"] + #[doc = " owned by the display that contains the window's center pixel. (The index of"] + #[doc = " this display can be retrieved using SDL_GetWindowDisplayIndex().) The gamma"] + #[doc = " ramp set will not follow the window if it is moved to another display."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if gamma ramps are unsupported."] + #[doc = " \\param window the window used to select the display whose gamma ramp will"] + #[doc = " be changed"] + #[doc = " \\param red a 256 element array of 16-bit quantities representing the"] + #[doc = " translation table for the red channel, or NULL"] + #[doc = " \\param green a 256 element array of 16-bit quantities representing the"] + #[doc = " translation table for the green channel, or NULL"] + #[doc = " \\param blue a 256 element array of 16-bit quantities representing the"] + #[doc = " translation table for the blue channel, or NULL"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " Set the gamma translation table for the red, green, and blue channels"] - #[doc = " of the video hardware. Each table is an array of 256 16-bit quantities,"] - #[doc = " representing a mapping between the input and output for that channel."] - #[doc = " The input is the index into the array, and the output is the 16-bit"] - #[doc = " gamma value at that index, scaled to the output color precision."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_GetWindowGammaRamp()"] + #[doc = " \\sa SDL_GetWindowGammaRamp"] pub fn SDL_SetWindowGammaRamp( window: *mut SDL_Window, red: *const Uint16, @@ -8376,19 +11527,27 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the gamma ramp for a window."] + #[doc = " Get the gamma ramp for a given window's display."] #[doc = ""] - #[doc = " \\param window The window from which the gamma ramp should be queried."] - #[doc = " \\param red A pointer to a 256 element array of 16-bit quantities to hold"] - #[doc = " the translation table for the red channel, or NULL."] - #[doc = " \\param green A pointer to a 256 element array of 16-bit quantities to hold"] - #[doc = " the translation table for the green channel, or NULL."] - #[doc = " \\param blue A pointer to a 256 element array of 16-bit quantities to hold"] - #[doc = " the translation table for the blue channel, or NULL."] + #[doc = " Despite the name and signature, this method retrieves the gamma ramp of the"] + #[doc = " entire display, not an individual window. A window is considered to be"] + #[doc = " owned by the display that contains the window's center pixel. (The index of"] + #[doc = " this display can be retrieved using SDL_GetWindowDisplayIndex().)"] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if gamma ramps are unsupported."] + #[doc = " \\param window the window used to select the display whose gamma ramp will"] + #[doc = " be queried"] + #[doc = " \\param red a 256 element array of 16-bit quantities filled in with the"] + #[doc = " translation table for the red channel, or NULL"] + #[doc = " \\param green a 256 element array of 16-bit quantities filled in with the"] + #[doc = " translation table for the green channel, or NULL"] + #[doc = " \\param blue a 256 element array of 16-bit quantities filled in with the"] + #[doc = " translation table for the blue channel, or NULL"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\sa SDL_SetWindowGammaRamp()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_SetWindowGammaRamp"] pub fn SDL_GetWindowGammaRamp( window: *mut SDL_Window, red: *mut Uint16, @@ -8397,9 +11556,9 @@ extern "C" { ) -> libc::c_int; } #[repr(u32)] -#[doc = " \\brief Possible return values from the SDL_HitTest callback."] +#[doc = " Possible return values from the SDL_HitTest callback."] #[doc = ""] -#[doc = " \\sa SDL_HitTest"] +#[doc = " \\sa SDL_HitTest"] #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub enum SDL_HitTestResult { #[doc = "< Region is normal. No special properties."] @@ -8415,9 +11574,14 @@ pub enum SDL_HitTestResult { SDL_HITTEST_RESIZE_BOTTOMLEFT = 8, SDL_HITTEST_RESIZE_LEFT = 9, } -#[doc = " \\brief Callback used for hit-testing."] +#[doc = " Callback used for hit-testing."] +#[doc = ""] +#[doc = " \\param win the SDL_Window where hit-testing was set on"] +#[doc = " \\param area an SDL_Point which should be hit-tested"] +#[doc = " \\param data what was passed as `callback_data` to SDL_SetWindowHitTest()"] +#[doc = " \\return an SDL_HitTestResult value."] #[doc = ""] -#[doc = " \\sa SDL_SetWindowHitTest"] +#[doc = " \\sa SDL_SetWindowHitTest"] pub type SDL_HitTest = ::core::option::Option< unsafe extern "C" fn( win: *mut SDL_Window, @@ -8426,41 +11590,44 @@ pub type SDL_HitTest = ::core::option::Option< ) -> SDL_HitTestResult, >; extern "C" { - #[doc = " \\brief Provide a callback that decides if a window region has special properties."] - #[doc = ""] - #[doc = " Normally windows are dragged and resized by decorations provided by the"] - #[doc = " system window manager (a title bar, borders, etc), but for some apps, it"] - #[doc = " makes sense to drag them from somewhere else inside the window itself; for"] - #[doc = " example, one might have a borderless window that wants to be draggable"] - #[doc = " from any part, or simulate its own title bar, etc."] - #[doc = ""] - #[doc = " This function lets the app provide a callback that designates pieces of"] - #[doc = " a given window as special. This callback is run during event processing"] - #[doc = " if we need to tell the OS to treat a region of the window specially; the"] - #[doc = " use of this callback is known as \"hit testing.\""] - #[doc = ""] - #[doc = " Mouse input may not be delivered to your application if it is within"] - #[doc = " a special area; the OS will often apply that input to moving the window or"] - #[doc = " resizing the window and not deliver it to the application."] - #[doc = ""] - #[doc = " Specifying NULL for a callback disables hit-testing. Hit-testing is"] - #[doc = " disabled by default."] - #[doc = ""] - #[doc = " Platforms that don't support this functionality will return -1"] - #[doc = " unconditionally, even if you're attempting to disable hit-testing."] - #[doc = ""] - #[doc = " Your callback may fire at any time, and its firing does not indicate any"] - #[doc = " specific behavior (for example, on Windows, this certainly might fire"] - #[doc = " when the OS is deciding whether to drag your window, but it fires for lots"] - #[doc = " of other reasons, too, some unrelated to anything you probably care about"] - #[doc = " _and when the mouse isn't actually at the location it is testing_)."] - #[doc = " Since this can fire at any time, you should try to keep your callback"] - #[doc = " efficient, devoid of allocations, etc."] - #[doc = ""] - #[doc = " \\param window The window to set hit-testing on."] - #[doc = " \\param callback The callback to call when doing a hit-test."] - #[doc = " \\param callback_data An app-defined void pointer passed to the callback."] - #[doc = " \\return 0 on success, -1 on error (including unsupported)."] + #[doc = " Provide a callback that decides if a window region has special properties."] + #[doc = ""] + #[doc = " Normally windows are dragged and resized by decorations provided by the"] + #[doc = " system window manager (a title bar, borders, etc), but for some apps, it"] + #[doc = " makes sense to drag them from somewhere else inside the window itself; for"] + #[doc = " example, one might have a borderless window that wants to be draggable from"] + #[doc = " any part, or simulate its own title bar, etc."] + #[doc = ""] + #[doc = " This function lets the app provide a callback that designates pieces of a"] + #[doc = " given window as special. This callback is run during event processing if we"] + #[doc = " need to tell the OS to treat a region of the window specially; the use of"] + #[doc = " this callback is known as \"hit testing.\""] + #[doc = ""] + #[doc = " Mouse input may not be delivered to your application if it is within a"] + #[doc = " special area; the OS will often apply that input to moving the window or"] + #[doc = " resizing the window and not deliver it to the application."] + #[doc = ""] + #[doc = " Specifying NULL for a callback disables hit-testing. Hit-testing is"] + #[doc = " disabled by default."] + #[doc = ""] + #[doc = " Platforms that don't support this functionality will return -1"] + #[doc = " unconditionally, even if you're attempting to disable hit-testing."] + #[doc = ""] + #[doc = " Your callback may fire at any time, and its firing does not indicate any"] + #[doc = " specific behavior (for example, on Windows, this certainly might fire when"] + #[doc = " the OS is deciding whether to drag your window, but it fires for lots of"] + #[doc = " other reasons, too, some unrelated to anything you probably care about _and"] + #[doc = " when the mouse isn't actually at the location it is testing_). Since this"] + #[doc = " can fire at any time, you should try to keep your callback efficient,"] + #[doc = " devoid of allocations, etc."] + #[doc = ""] + #[doc = " \\param window the window to set hit-testing on"] + #[doc = " \\param callback the function to call when doing a hit-test"] + #[doc = " \\param callback_data an app-defined void pointer passed to **callback**"] + #[doc = " \\returns 0 on success or -1 on error (including unsupported); call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.4."] pub fn SDL_SetWindowHitTest( window: *mut SDL_Window, callback: SDL_HitTest, @@ -8468,117 +11635,286 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Destroy a window."] + #[doc = " Request a window to demand attention from the user."] + #[doc = ""] + #[doc = " \\param window the window to be flashed"] + #[doc = " \\param operation the flash operation"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.16."] + pub fn SDL_FlashWindow(window: *mut SDL_Window, operation: SDL_FlashOperation) -> libc::c_int; +} +extern "C" { + #[doc = " Destroy a window."] + #[doc = ""] + #[doc = " If `window` is NULL, this function will return immediately after setting"] + #[doc = " the SDL error message to \"Invalid window\". See SDL_GetError()."] + #[doc = ""] + #[doc = " \\param window the window to destroy"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateWindow"] + #[doc = " \\sa SDL_CreateWindowFrom"] pub fn SDL_DestroyWindow(window: *mut SDL_Window); } extern "C" { - #[doc = " \\brief Returns whether the screensaver is currently enabled (default off)."] + #[doc = " Check whether the screensaver is currently enabled."] + #[doc = ""] + #[doc = " The screensaver is disabled by default since SDL 2.0.2. Before SDL 2.0.2"] + #[doc = " the screensaver was enabled by default."] + #[doc = ""] + #[doc = " The default can also be changed using `SDL_HINT_VIDEO_ALLOW_SCREENSAVER`."] #[doc = ""] - #[doc = " \\sa SDL_EnableScreenSaver()"] - #[doc = " \\sa SDL_DisableScreenSaver()"] + #[doc = " \\returns SDL_TRUE if the screensaver is enabled, SDL_FALSE if it is"] + #[doc = " disabled."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_DisableScreenSaver"] + #[doc = " \\sa SDL_EnableScreenSaver"] pub fn SDL_IsScreenSaverEnabled() -> SDL_bool; } extern "C" { - #[doc = " \\brief Allow the screen to be blanked by a screensaver"] + #[doc = " Allow the screen to be blanked by a screen saver."] #[doc = ""] - #[doc = " \\sa SDL_IsScreenSaverEnabled()"] - #[doc = " \\sa SDL_DisableScreenSaver()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_DisableScreenSaver"] + #[doc = " \\sa SDL_IsScreenSaverEnabled"] pub fn SDL_EnableScreenSaver(); } extern "C" { - #[doc = " \\brief Prevent the screen from being blanked by a screensaver"] + #[doc = " Prevent the screen from being blanked by a screen saver."] + #[doc = ""] + #[doc = " If you disable the screensaver, it is automatically re-enabled when SDL"] + #[doc = " quits."] #[doc = ""] - #[doc = " \\sa SDL_IsScreenSaverEnabled()"] - #[doc = " \\sa SDL_EnableScreenSaver()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_EnableScreenSaver"] + #[doc = " \\sa SDL_IsScreenSaverEnabled"] pub fn SDL_DisableScreenSaver(); } extern "C" { - #[doc = " \\brief Dynamically load an OpenGL library."] + #[doc = " Dynamically load an OpenGL library."] #[doc = ""] - #[doc = " \\param path The platform dependent OpenGL library name, or NULL to open the"] - #[doc = " default OpenGL library."] + #[doc = " This should be done after initializing the video driver, but before"] + #[doc = " creating any OpenGL windows. If no OpenGL library is loaded, the default"] + #[doc = " library will be loaded upon creation of the first OpenGL window."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the library couldn't be loaded."] + #[doc = " If you do this, you need to retrieve all of the GL functions used in your"] + #[doc = " program from the dynamic library using SDL_GL_GetProcAddress()."] #[doc = ""] - #[doc = " This should be done after initializing the video driver, but before"] - #[doc = " creating any OpenGL windows. If no OpenGL library is loaded, the default"] - #[doc = " library will be loaded upon creation of the first OpenGL window."] + #[doc = " \\param path the platform dependent OpenGL library name, or NULL to open the"] + #[doc = " default OpenGL library"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\note If you do this, you need to retrieve all of the GL functions used in"] - #[doc = " your program from the dynamic library using SDL_GL_GetProcAddress()."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_GL_GetProcAddress()"] - #[doc = " \\sa SDL_GL_UnloadLibrary()"] + #[doc = " \\sa SDL_GL_GetProcAddress"] + #[doc = " \\sa SDL_GL_UnloadLibrary"] pub fn SDL_GL_LoadLibrary(path: *const libc::c_char) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the address of an OpenGL function."] + #[doc = " Get an OpenGL function by name."] + #[doc = ""] + #[doc = " If the GL library is loaded at runtime with SDL_GL_LoadLibrary(), then all"] + #[doc = " GL functions must be retrieved this way. Usually this is used to retrieve"] + #[doc = " function pointers to OpenGL extensions."] + #[doc = ""] + #[doc = " There are some quirks to looking up OpenGL functions that require some"] + #[doc = " extra care from the application. If you code carefully, you can handle"] + #[doc = " these quirks without any platform-specific code, though:"] + #[doc = ""] + #[doc = " - On Windows, function pointers are specific to the current GL context;"] + #[doc = " this means you need to have created a GL context and made it current"] + #[doc = " before calling SDL_GL_GetProcAddress(). If you recreate your context or"] + #[doc = " create a second context, you should assume that any existing function"] + #[doc = " pointers aren't valid to use with it. This is (currently) a"] + #[doc = " Windows-specific limitation, and in practice lots of drivers don't suffer"] + #[doc = " this limitation, but it is still the way the wgl API is documented to"] + #[doc = " work and you should expect crashes if you don't respect it. Store a copy"] + #[doc = " of the function pointers that comes and goes with context lifespan."] + #[doc = " - On X11, function pointers returned by this function are valid for any"] + #[doc = " context, and can even be looked up before a context is created at all."] + #[doc = " This means that, for at least some common OpenGL implementations, if you"] + #[doc = " look up a function that doesn't exist, you'll get a non-NULL result that"] + #[doc = " is _NOT_ safe to call. You must always make sure the function is actually"] + #[doc = " available for a given GL context before calling it, by checking for the"] + #[doc = " existence of the appropriate extension with SDL_GL_ExtensionSupported(),"] + #[doc = " or verifying that the version of OpenGL you're using offers the function"] + #[doc = " as core functionality."] + #[doc = " - Some OpenGL drivers, on all platforms, *will* return NULL if a function"] + #[doc = " isn't supported, but you can't count on this behavior. Check for"] + #[doc = " extensions you use, and if you get a NULL anyway, act as if that"] + #[doc = " extension wasn't available. This is probably a bug in the driver, but you"] + #[doc = " can code defensively for this scenario anyhow."] + #[doc = " - Just because you're on Linux/Unix, don't assume you'll be using X11."] + #[doc = " Next-gen display servers are waiting to replace it, and may or may not"] + #[doc = " make the same promises about function pointers."] + #[doc = " - OpenGL function pointers must be declared `APIENTRY` as in the example"] + #[doc = " code. This will ensure the proper calling convention is followed on"] + #[doc = " platforms where this matters (Win32) thereby avoiding stack corruption."] + #[doc = ""] + #[doc = " \\param proc the name of an OpenGL function"] + #[doc = " \\returns a pointer to the named OpenGL function. The returned pointer"] + #[doc = " should be cast to the appropriate function signature."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GL_ExtensionSupported"] + #[doc = " \\sa SDL_GL_LoadLibrary"] + #[doc = " \\sa SDL_GL_UnloadLibrary"] pub fn SDL_GL_GetProcAddress(proc_: *const libc::c_char) -> *mut libc::c_void; } extern "C" { - #[doc = " \\brief Unload the OpenGL library previously loaded by SDL_GL_LoadLibrary()."] + #[doc = " Unload the OpenGL library previously loaded by SDL_GL_LoadLibrary()."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_GL_LoadLibrary()"] + #[doc = " \\sa SDL_GL_LoadLibrary"] pub fn SDL_GL_UnloadLibrary(); } extern "C" { - #[doc = " \\brief Return true if an OpenGL extension is supported for the current"] - #[doc = " context."] + #[doc = " Check if an OpenGL extension is supported for the current context."] + #[doc = ""] + #[doc = " This function operates on the current GL context; you must have created a"] + #[doc = " context and it must be current before calling this function. Do not assume"] + #[doc = " that all contexts you create will have the same set of extensions"] + #[doc = " available, or that recreating an existing context will offer the same"] + #[doc = " extensions again."] + #[doc = ""] + #[doc = " While it's probably not a massive overhead, this function is not an O(1)"] + #[doc = " operation. Check the extensions you care about after creating the GL"] + #[doc = " context and save that information somewhere instead of calling the function"] + #[doc = " every time you need to know."] + #[doc = ""] + #[doc = " \\param extension the name of the extension to check"] + #[doc = " \\returns SDL_TRUE if the extension is supported, SDL_FALSE otherwise."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_GL_ExtensionSupported(extension: *const libc::c_char) -> SDL_bool; } extern "C" { - #[doc = " \\brief Reset all previously set OpenGL context attributes to their default values"] + #[doc = " Reset all previously set OpenGL context attributes to their default values."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.2."] + #[doc = ""] + #[doc = " \\sa SDL_GL_GetAttribute"] + #[doc = " \\sa SDL_GL_SetAttribute"] pub fn SDL_GL_ResetAttributes(); } extern "C" { - #[doc = " \\brief Set an OpenGL window attribute before window creation."] + #[doc = " Set an OpenGL window attribute before window creation."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the attribute could not be set."] + #[doc = " This function sets the OpenGL attribute `attr` to `value`. The requested"] + #[doc = " attributes should be set before creating an OpenGL window. You should use"] + #[doc = " SDL_GL_GetAttribute() to check the values after creating the OpenGL"] + #[doc = " context, since the values obtained can differ from the requested ones."] + #[doc = ""] + #[doc = " \\param attr an SDL_GLattr enum value specifying the OpenGL attribute to set"] + #[doc = " \\param value the desired value for the attribute"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GL_GetAttribute"] + #[doc = " \\sa SDL_GL_ResetAttributes"] pub fn SDL_GL_SetAttribute(attr: SDL_GLattr, value: libc::c_int) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the actual value for an attribute from the current context."] + #[doc = " Get the actual value for an attribute from the current context."] + #[doc = ""] + #[doc = " \\param attr an SDL_GLattr enum value specifying the OpenGL attribute to get"] + #[doc = " \\param value a pointer filled in with the current value of `attr`"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the attribute could not be retrieved."] - #[doc = " The integer at \\c value will be modified in either case."] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GL_ResetAttributes"] + #[doc = " \\sa SDL_GL_SetAttribute"] pub fn SDL_GL_GetAttribute(attr: SDL_GLattr, value: *mut libc::c_int) -> libc::c_int; } extern "C" { - #[doc = " \\brief Create an OpenGL context for use with an OpenGL window, and make it"] - #[doc = " current."] + #[doc = " Create an OpenGL context for an OpenGL window, and make it current."] + #[doc = ""] + #[doc = " Windows users new to OpenGL should note that, for historical reasons, GL"] + #[doc = " functions added after OpenGL version 1.1 are not available by default."] + #[doc = " Those functions must be loaded at run-time, either with an OpenGL"] + #[doc = " extension-handling library or with SDL_GL_GetProcAddress() and its related"] + #[doc = " functions."] + #[doc = ""] + #[doc = " SDL_GLContext is an alias for `void *`. It's opaque to the application."] + #[doc = ""] + #[doc = " \\param window the window to associate with the context"] + #[doc = " \\returns the OpenGL context associated with `window` or NULL on error; call"] + #[doc = " SDL_GetError() for more details."] #[doc = ""] - #[doc = " \\sa SDL_GL_DeleteContext()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GL_DeleteContext"] + #[doc = " \\sa SDL_GL_MakeCurrent"] pub fn SDL_GL_CreateContext(window: *mut SDL_Window) -> SDL_GLContext; } extern "C" { - #[doc = " \\brief Set up an OpenGL context for rendering into an OpenGL window."] + #[doc = " Set up an OpenGL context for rendering into an OpenGL window."] + #[doc = ""] + #[doc = " The context must have been created with a compatible window."] + #[doc = ""] + #[doc = " \\param window the window to associate with the context"] + #[doc = " \\param context the OpenGL context to associate with the window"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\note The context must have been created with a compatible window."] + #[doc = " \\sa SDL_GL_CreateContext"] pub fn SDL_GL_MakeCurrent(window: *mut SDL_Window, context: SDL_GLContext) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the currently active OpenGL window."] + #[doc = " Get the currently active OpenGL window."] + #[doc = ""] + #[doc = " \\returns the currently active OpenGL window on success or NULL on failure;"] + #[doc = " call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_GL_GetCurrentWindow() -> *mut SDL_Window; } extern "C" { - #[doc = " \\brief Get the currently active OpenGL context."] + #[doc = " Get the currently active OpenGL context."] + #[doc = ""] + #[doc = " \\returns the currently active OpenGL context or NULL on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GL_MakeCurrent"] pub fn SDL_GL_GetCurrentContext() -> SDL_GLContext; } extern "C" { - #[doc = " \\brief Get the size of a window's underlying drawable in pixels (for use"] - #[doc = " with glViewport)."] + #[doc = " Get the size of a window's underlying drawable in pixels."] #[doc = ""] - #[doc = " \\param window Window from which the drawable size should be queried"] - #[doc = " \\param w Pointer to variable for storing the width in pixels, may be NULL"] - #[doc = " \\param h Pointer to variable for storing the height in pixels, may be NULL"] + #[doc = " This returns info useful for calling glViewport()."] #[doc = ""] #[doc = " This may differ from SDL_GetWindowSize() if we're rendering to a high-DPI"] - #[doc = " drawable, i.e. the window was created with SDL_WINDOW_ALLOW_HIGHDPI on a"] - #[doc = " platform with high-DPI support (Apple calls this \"Retina\"), and not disabled"] - #[doc = " by the SDL_HINT_VIDEO_HIGHDPI_DISABLED hint."] + #[doc = " drawable, i.e. the window was created with `SDL_WINDOW_ALLOW_HIGHDPI` on a"] + #[doc = " platform with high-DPI support (Apple calls this \"Retina\"), and not"] + #[doc = " disabled by the `SDL_HINT_VIDEO_HIGHDPI_DISABLED` hint."] + #[doc = ""] + #[doc = " \\param window the window from which the drawable size should be queried"] + #[doc = " \\param w a pointer to variable for storing the width in pixels, may be NULL"] + #[doc = " \\param h a pointer to variable for storing the height in pixels, may be"] + #[doc = " NULL"] #[doc = ""] - #[doc = " \\sa SDL_GetWindowSize()"] - #[doc = " \\sa SDL_CreateWindow()"] + #[doc = " \\since This function is available since SDL 2.0.1."] + #[doc = ""] + #[doc = " \\sa SDL_CreateWindow"] + #[doc = " \\sa SDL_GetWindowSize"] pub fn SDL_GL_GetDrawableSize( window: *mut SDL_Window, w: *mut libc::c_int, @@ -8586,39 +11922,77 @@ extern "C" { ); } extern "C" { - #[doc = " \\brief Set the swap interval for the current OpenGL context."] + #[doc = " Set the swap interval for the current OpenGL context."] + #[doc = ""] + #[doc = " Some systems allow specifying -1 for the interval, to enable adaptive"] + #[doc = " vsync. Adaptive vsync works the same as vsync, but if you've already missed"] + #[doc = " the vertical retrace for a given frame, it swaps buffers immediately, which"] + #[doc = " might be less jarring for the user during occasional framerate drops. If an"] + #[doc = " application requests adaptive vsync and the system does not support it,"] + #[doc = " this function will fail and return -1. In such a case, you should probably"] + #[doc = " retry the call with 1 for the interval."] #[doc = ""] - #[doc = " \\param interval 0 for immediate updates, 1 for updates synchronized with the"] - #[doc = " vertical retrace. If the system supports it, you may"] - #[doc = " specify -1 to allow late swaps to happen immediately"] - #[doc = " instead of waiting for the next retrace."] + #[doc = " Adaptive vsync is implemented for some glX drivers with"] + #[doc = " GLX_EXT_swap_control_tear:"] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if setting the swap interval is not supported."] + #[doc = " https://www.opengl.org/registry/specs/EXT/glx_swap_control_tear.txt"] #[doc = ""] - #[doc = " \\sa SDL_GL_GetSwapInterval()"] + #[doc = " and for some Windows drivers with WGL_EXT_swap_control_tear:"] + #[doc = ""] + #[doc = " https://www.opengl.org/registry/specs/EXT/wgl_swap_control_tear.txt"] + #[doc = ""] + #[doc = " Read more on the Khronos wiki:"] + #[doc = " https://www.khronos.org/opengl/wiki/Swap_Interval#Adaptive_Vsync"] + #[doc = ""] + #[doc = " \\param interval 0 for immediate updates, 1 for updates synchronized with"] + #[doc = " the vertical retrace, -1 for adaptive vsync"] + #[doc = " \\returns 0 on success or -1 if setting the swap interval is not supported;"] + #[doc = " call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GL_GetSwapInterval"] pub fn SDL_GL_SetSwapInterval(interval: libc::c_int) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the swap interval for the current OpenGL context."] + #[doc = " Get the swap interval for the current OpenGL context."] + #[doc = ""] + #[doc = " If the system can't determine the swap interval, or there isn't a valid"] + #[doc = " current context, this function will return 0 as a safe default."] #[doc = ""] - #[doc = " \\return 0 if there is no vertical retrace synchronization, 1 if the buffer"] + #[doc = " \\returns 0 if there is no vertical retrace synchronization, 1 if the buffer"] #[doc = " swap is synchronized with the vertical retrace, and -1 if late"] - #[doc = " swaps happen immediately instead of waiting for the next retrace."] - #[doc = " If the system can't determine the swap interval, or there isn't a"] - #[doc = " valid current context, this will return 0 as a safe default."] + #[doc = " swaps happen immediately instead of waiting for the next retrace;"] + #[doc = " call SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\sa SDL_GL_SetSwapInterval()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GL_SetSwapInterval"] pub fn SDL_GL_GetSwapInterval() -> libc::c_int; } extern "C" { - #[doc = " \\brief Swap the OpenGL buffers for a window, if double-buffering is"] - #[doc = " supported."] + #[doc = " Update a window with OpenGL rendering."] + #[doc = ""] + #[doc = " This is used with double-buffered OpenGL contexts, which are the default."] + #[doc = ""] + #[doc = " On macOS, make sure you bind 0 to the draw framebuffer before swapping the"] + #[doc = " window, otherwise nothing will happen. If you aren't using"] + #[doc = " glBindFramebuffer(), this is the default and you won't have to do anything"] + #[doc = " extra."] + #[doc = ""] + #[doc = " \\param window the window to change"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_GL_SwapWindow(window: *mut SDL_Window); } extern "C" { - #[doc = " \\brief Delete an OpenGL context."] + #[doc = " Delete an OpenGL context."] + #[doc = ""] + #[doc = " \\param context the OpenGL context to be deleted"] #[doc = ""] - #[doc = " \\sa SDL_GL_CreateContext()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GL_CreateContext"] pub fn SDL_GL_DeleteContext(context: SDL_GLContext); } #[repr(u32)] @@ -9213,6 +12587,9 @@ pub enum SDL_KeyCode { SDLK_AUDIOREWIND = 1073742109, SDLK_AUDIOFASTFORWARD = 1073742110, } +impl SDL_Keymod { + pub const KMOD_RESERVED: SDL_Keymod = SDL_Keymod::KMOD_SCROLL; +} #[repr(u32)] #[doc = " \\brief Enumeration of valid key mods (possibly OR'd together)."] #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] @@ -9229,7 +12606,7 @@ pub enum SDL_Keymod { KMOD_NUM = 4096, KMOD_CAPS = 8192, KMOD_MODE = 16384, - KMOD_RESERVED = 32768, + KMOD_SCROLL = 32768, KMOD_CTRL = 192, KMOD_SHIFT = 3, KMOD_ALT = 768, @@ -9303,139 +12680,238 @@ fn bindgen_test_layout_SDL_Keysym() { ); } extern "C" { - #[doc = " \\brief Get the window which currently has keyboard focus."] + #[doc = " Query the window which currently has keyboard focus."] + #[doc = ""] + #[doc = " \\returns the window with keyboard focus."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_GetKeyboardFocus() -> *mut SDL_Window; } extern "C" { - #[doc = " \\brief Get a snapshot of the current state of the keyboard."] + #[doc = " Get a snapshot of the current state of the keyboard."] #[doc = ""] - #[doc = " \\param numkeys if non-NULL, receives the length of the returned array."] + #[doc = " The pointer returned is a pointer to an internal SDL array. It will be"] + #[doc = " valid for the whole lifetime of the application and should not be freed by"] + #[doc = " the caller."] #[doc = ""] - #[doc = " \\return An array of key states. Indexes into this array are obtained by using ::SDL_Scancode values."] + #[doc = " A array element with a value of 1 means that the key is pressed and a value"] + #[doc = " of 0 means that it is not. Indexes into this array are obtained by using"] + #[doc = " SDL_Scancode values."] #[doc = ""] - #[doc = " \\b Example:"] - #[doc = " \\code"] - #[doc = " const Uint8 *state = SDL_GetKeyboardState(NULL);"] - #[doc = " if ( state[SDL_SCANCODE_RETURN] ) {"] - #[doc = " printf(\" is pressed.\\n\");"] - #[doc = " }"] - #[doc = " \\endcode"] + #[doc = " Use SDL_PumpEvents() to update the state array."] + #[doc = ""] + #[doc = " This function gives you the current state after all events have been"] + #[doc = " processed, so if a key or button has been pressed and released before you"] + #[doc = " process events, then the pressed state will never show up in the"] + #[doc = " SDL_GetKeyboardState() calls."] + #[doc = ""] + #[doc = " Note: This function doesn't take into account whether shift has been"] + #[doc = " pressed or not."] + #[doc = ""] + #[doc = " \\param numkeys if non-NULL, receives the length of the returned array"] + #[doc = " \\returns a pointer to an array of key states."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_PumpEvents"] pub fn SDL_GetKeyboardState(numkeys: *mut libc::c_int) -> *const Uint8; } extern "C" { - #[doc = " \\brief Get the current key modifier state for the keyboard."] + #[doc = " Get the current key modifier state for the keyboard."] + #[doc = ""] + #[doc = " \\returns an OR'd combination of the modifier keys for the keyboard. See"] + #[doc = " SDL_Keymod for details."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetKeyboardState"] + #[doc = " \\sa SDL_SetModState"] pub fn SDL_GetModState() -> SDL_Keymod; } extern "C" { - #[doc = " \\brief Set the current key modifier state for the keyboard."] + #[doc = " Set the current key modifier state for the keyboard."] #[doc = ""] - #[doc = " \\note This does not change the keyboard state, only the key modifier flags."] + #[doc = " The inverse of SDL_GetModState(), SDL_SetModState() allows you to impose"] + #[doc = " modifier key states on your application. Simply pass your desired modifier"] + #[doc = " states into `modstate`. This value may be a bitwise, OR'd combination of"] + #[doc = " SDL_Keymod values."] + #[doc = ""] + #[doc = " This does not change the keyboard state, only the key modifier flags that"] + #[doc = " SDL reports."] + #[doc = ""] + #[doc = " \\param modstate the desired SDL_Keymod for the keyboard"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetModState"] pub fn SDL_SetModState(modstate: SDL_Keymod); } extern "C" { - #[doc = " \\brief Get the key code corresponding to the given scancode according"] - #[doc = " to the current keyboard layout."] + #[doc = " Get the key code corresponding to the given scancode according to the"] + #[doc = " current keyboard layout."] #[doc = ""] - #[doc = " See ::SDL_Keycode for details."] + #[doc = " See SDL_Keycode for details."] #[doc = ""] - #[doc = " \\sa SDL_GetKeyName()"] + #[doc = " \\param scancode the desired SDL_Scancode to query"] + #[doc = " \\returns the SDL_Keycode that corresponds to the given SDL_Scancode."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetKeyName"] + #[doc = " \\sa SDL_GetScancodeFromKey"] pub fn SDL_GetKeyFromScancode(scancode: SDL_Scancode) -> SDL_Keycode; } extern "C" { - #[doc = " \\brief Get the scancode corresponding to the given key code according to the"] - #[doc = " current keyboard layout."] + #[doc = " Get the scancode corresponding to the given key code according to the"] + #[doc = " current keyboard layout."] + #[doc = ""] + #[doc = " See SDL_Scancode for details."] + #[doc = ""] + #[doc = " \\param key the desired SDL_Keycode to query"] + #[doc = " \\returns the SDL_Scancode that corresponds to the given SDL_Keycode."] #[doc = ""] - #[doc = " See ::SDL_Scancode for details."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_GetScancodeName()"] + #[doc = " \\sa SDL_GetKeyFromScancode"] + #[doc = " \\sa SDL_GetScancodeName"] pub fn SDL_GetScancodeFromKey(key: SDL_Keycode) -> SDL_Scancode; } extern "C" { - #[doc = " \\brief Get a human-readable name for a scancode."] + #[doc = " Get a human-readable name for a scancode."] #[doc = ""] - #[doc = " \\return A pointer to the name for the scancode."] - #[doc = " If the scancode doesn't have a name, this function returns"] - #[doc = " an empty string (\"\")."] + #[doc = " See SDL_Scancode for details."] #[doc = ""] - #[doc = " \\sa SDL_Scancode"] + #[doc = " **Warning**: The returned name is by design not stable across platforms,"] + #[doc = " e.g. the name for `SDL_SCANCODE_LGUI` is \"Left GUI\" under Linux but \"Left"] + #[doc = " Windows\" under Microsoft Windows, and some scancodes like"] + #[doc = " `SDL_SCANCODE_NONUSBACKSLASH` don't have any name at all. There are even"] + #[doc = " scancodes that share names, e.g. `SDL_SCANCODE_RETURN` and"] + #[doc = " `SDL_SCANCODE_RETURN2` (both called \"Return\"). This function is therefore"] + #[doc = " unsuitable for creating a stable cross-platform two-way mapping between"] + #[doc = " strings and scancodes."] + #[doc = ""] + #[doc = " \\param scancode the desired SDL_Scancode to query"] + #[doc = " \\returns a pointer to the name for the scancode. If the scancode doesn't"] + #[doc = " have a name this function returns an empty string (\"\")."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetScancodeFromKey"] + #[doc = " \\sa SDL_GetScancodeFromName"] pub fn SDL_GetScancodeName(scancode: SDL_Scancode) -> *const libc::c_char; } extern "C" { - #[doc = " \\brief Get a scancode from a human-readable name"] + #[doc = " Get a scancode from a human-readable name."] + #[doc = ""] + #[doc = " \\param name the human-readable scancode name"] + #[doc = " \\returns the SDL_Scancode, or `SDL_SCANCODE_UNKNOWN` if the name wasn't"] + #[doc = " recognized; call SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return scancode, or SDL_SCANCODE_UNKNOWN if the name wasn't recognized"] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_Scancode"] + #[doc = " \\sa SDL_GetKeyFromName"] + #[doc = " \\sa SDL_GetScancodeFromKey"] + #[doc = " \\sa SDL_GetScancodeName"] pub fn SDL_GetScancodeFromName(name: *const libc::c_char) -> SDL_Scancode; } extern "C" { - #[doc = " \\brief Get a human-readable name for a key."] + #[doc = " Get a human-readable name for a key."] #[doc = ""] - #[doc = " \\return A pointer to a UTF-8 string that stays valid at least until the next"] - #[doc = " call to this function. If you need it around any longer, you must"] - #[doc = " copy it. If the key doesn't have a name, this function returns an"] - #[doc = " empty string (\"\")."] + #[doc = " See SDL_Scancode and SDL_Keycode for details."] #[doc = ""] - #[doc = " \\sa SDL_Keycode"] + #[doc = " \\param key the desired SDL_Keycode to query"] + #[doc = " \\returns a pointer to a UTF-8 string that stays valid at least until the"] + #[doc = " next call to this function. If you need it around any longer, you"] + #[doc = " must copy it. If the key doesn't have a name, this function"] + #[doc = " returns an empty string (\"\")."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetKeyFromName"] + #[doc = " \\sa SDL_GetKeyFromScancode"] + #[doc = " \\sa SDL_GetScancodeFromKey"] pub fn SDL_GetKeyName(key: SDL_Keycode) -> *const libc::c_char; } extern "C" { - #[doc = " \\brief Get a key code from a human-readable name"] + #[doc = " Get a key code from a human-readable name."] #[doc = ""] - #[doc = " \\return key code, or SDLK_UNKNOWN if the name wasn't recognized"] + #[doc = " \\param name the human-readable key name"] + #[doc = " \\returns key code, or `SDLK_UNKNOWN` if the name wasn't recognized; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\sa SDL_Keycode"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetKeyFromScancode"] + #[doc = " \\sa SDL_GetKeyName"] + #[doc = " \\sa SDL_GetScancodeFromName"] pub fn SDL_GetKeyFromName(name: *const libc::c_char) -> SDL_Keycode; } extern "C" { - #[doc = " \\brief Start accepting Unicode text input events."] - #[doc = " This function will show the on-screen keyboard if supported."] + #[doc = " Start accepting Unicode text input events."] + #[doc = ""] + #[doc = " This function will start accepting Unicode text input events in the focused"] + #[doc = " SDL window, and start emitting SDL_TextInputEvent (SDL_TEXTINPUT) and"] + #[doc = " SDL_TextEditingEvent (SDL_TEXTEDITING) events. Please use this function in"] + #[doc = " pair with SDL_StopTextInput()."] #[doc = ""] - #[doc = " \\sa SDL_StopTextInput()"] - #[doc = " \\sa SDL_SetTextInputRect()"] - #[doc = " \\sa SDL_HasScreenKeyboardSupport()"] + #[doc = " On some platforms using this function activates the screen keyboard."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_SetTextInputRect"] + #[doc = " \\sa SDL_StopTextInput"] pub fn SDL_StartTextInput(); } extern "C" { - #[doc = " \\brief Return whether or not Unicode text input events are enabled."] + #[doc = " Check whether or not Unicode text input events are enabled."] + #[doc = ""] + #[doc = " \\returns SDL_TRUE if text input events are enabled else SDL_FALSE."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_StartTextInput()"] - #[doc = " \\sa SDL_StopTextInput()"] + #[doc = " \\sa SDL_StartTextInput"] pub fn SDL_IsTextInputActive() -> SDL_bool; } extern "C" { - #[doc = " \\brief Stop receiving any text input events."] - #[doc = " This function will hide the on-screen keyboard if supported."] + #[doc = " Stop receiving any text input events."] #[doc = ""] - #[doc = " \\sa SDL_StartTextInput()"] - #[doc = " \\sa SDL_HasScreenKeyboardSupport()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_StartTextInput"] pub fn SDL_StopTextInput(); } extern "C" { - #[doc = " \\brief Set the rectangle used to type Unicode text inputs."] - #[doc = " This is used as a hint for IME and on-screen keyboard placement."] + #[doc = " Set the rectangle used to type Unicode text inputs."] + #[doc = ""] + #[doc = " \\param rect the SDL_Rect structure representing the rectangle to receive"] + #[doc = " text (ignored if NULL)"] #[doc = ""] - #[doc = " \\sa SDL_StartTextInput()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_StartTextInput"] pub fn SDL_SetTextInputRect(rect: *mut SDL_Rect); } extern "C" { - #[doc = " \\brief Returns whether the platform has some screen keyboard support."] + #[doc = " Check whether the platform has screen keyboard support."] #[doc = ""] - #[doc = " \\return SDL_TRUE if some keyboard support is available else SDL_FALSE."] + #[doc = " \\returns SDL_TRUE if the platform has some screen keyboard support or"] + #[doc = " SDL_FALSE if not."] #[doc = ""] - #[doc = " \\note Not all screen keyboard functions are supported on all platforms."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_IsScreenKeyboardShown()"] + #[doc = " \\sa SDL_StartTextInput"] + #[doc = " \\sa SDL_IsScreenKeyboardShown"] pub fn SDL_HasScreenKeyboardSupport() -> SDL_bool; } extern "C" { - #[doc = " \\brief Returns whether the screen keyboard is shown for given window."] + #[doc = " Check whether the screen keyboard is shown for given window."] #[doc = ""] - #[doc = " \\param window The window for which screen keyboard should be queried."] + #[doc = " \\param window the window for which screen keyboard should be queried"] + #[doc = " \\returns SDL_TRUE if screen keyboard is shown or SDL_FALSE if not."] #[doc = ""] - #[doc = " \\return SDL_TRUE if screen keyboard is shown else SDL_FALSE."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_HasScreenKeyboardSupport()"] + #[doc = " \\sa SDL_HasScreenKeyboardSupport"] pub fn SDL_IsScreenKeyboardShown(window: *mut SDL_Window) -> SDL_bool; } #[repr(C)] @@ -9483,140 +12959,230 @@ pub enum SDL_MouseWheelDirection { SDL_MOUSEWHEEL_FLIPPED = 1, } extern "C" { - #[doc = " \\brief Get the window which currently has mouse focus."] + #[doc = " Get the window which currently has mouse focus."] + #[doc = ""] + #[doc = " \\returns the window with mouse focus."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_GetMouseFocus() -> *mut SDL_Window; } extern "C" { - #[doc = " \\brief Retrieve the current state of the mouse."] + #[doc = " Retrieve the current state of the mouse."] + #[doc = ""] + #[doc = " The current button state is returned as a button bitmask, which can be"] + #[doc = " tested using the `SDL_BUTTON(X)` macros (where `X` is generally 1 for the"] + #[doc = " left, 2 for middle, 3 for the right button), and `x` and `y` are set to the"] + #[doc = " mouse cursor position relative to the focus window. You can pass NULL for"] + #[doc = " either `x` or `y`."] + #[doc = ""] + #[doc = " \\param x the x coordinate of the mouse cursor position relative to the"] + #[doc = " focus window"] + #[doc = " \\param y the y coordinate of the mouse cursor position relative to the"] + #[doc = " focus window"] + #[doc = " \\returns a 32-bit button bitmask of the current button state."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " The current button state is returned as a button bitmask, which can"] - #[doc = " be tested using the SDL_BUTTON(X) macros, and x and y are set to the"] - #[doc = " mouse cursor position relative to the focus window for the currently"] - #[doc = " selected mouse. You can pass NULL for either x or y."] + #[doc = " \\sa SDL_GetGlobalMouseState"] + #[doc = " \\sa SDL_GetRelativeMouseState"] + #[doc = " \\sa SDL_PumpEvents"] pub fn SDL_GetMouseState(x: *mut libc::c_int, y: *mut libc::c_int) -> Uint32; } extern "C" { - #[doc = " \\brief Get the current state of the mouse, in relation to the desktop"] + #[doc = " Get the current state of the mouse in relation to the desktop."] #[doc = ""] - #[doc = " This works just like SDL_GetMouseState(), but the coordinates will be"] - #[doc = " reported relative to the top-left of the desktop. This can be useful if"] - #[doc = " you need to track the mouse outside of a specific window and"] - #[doc = " SDL_CaptureMouse() doesn't fit your needs. For example, it could be"] - #[doc = " useful if you need to track the mouse while dragging a window, where"] - #[doc = " coordinates relative to a window might not be in sync at all times."] + #[doc = " This works similarly to SDL_GetMouseState(), but the coordinates will be"] + #[doc = " reported relative to the top-left of the desktop. This can be useful if you"] + #[doc = " need to track the mouse outside of a specific window and SDL_CaptureMouse()"] + #[doc = " doesn't fit your needs. For example, it could be useful if you need to"] + #[doc = " track the mouse while dragging a window, where coordinates relative to a"] + #[doc = " window might not be in sync at all times."] #[doc = ""] - #[doc = " \\note SDL_GetMouseState() returns the mouse position as SDL understands"] - #[doc = " it from the last pump of the event queue. This function, however,"] - #[doc = " queries the OS for the current mouse position, and as such, might"] - #[doc = " be a slightly less efficient function. Unless you know what you're"] - #[doc = " doing and have a good reason to use this function, you probably want"] - #[doc = " SDL_GetMouseState() instead."] + #[doc = " Note: SDL_GetMouseState() returns the mouse position as SDL understands it"] + #[doc = " from the last pump of the event queue. This function, however, queries the"] + #[doc = " OS for the current mouse position, and as such, might be a slightly less"] + #[doc = " efficient function. Unless you know what you're doing and have a good"] + #[doc = " reason to use this function, you probably want SDL_GetMouseState() instead."] #[doc = ""] - #[doc = " \\param x Returns the current X coord, relative to the desktop. Can be NULL."] - #[doc = " \\param y Returns the current Y coord, relative to the desktop. Can be NULL."] - #[doc = " \\return The current button state as a bitmask, which can be tested using the SDL_BUTTON(X) macros."] + #[doc = " \\param x filled in with the current X coord relative to the desktop; can be"] + #[doc = " NULL"] + #[doc = " \\param y filled in with the current Y coord relative to the desktop; can be"] + #[doc = " NULL"] + #[doc = " \\returns the current button state as a bitmask which can be tested using"] + #[doc = " the SDL_BUTTON(X) macros."] #[doc = ""] - #[doc = " \\sa SDL_GetMouseState"] + #[doc = " \\since This function is available since SDL 2.0.4."] + #[doc = ""] + #[doc = " \\sa SDL_CaptureMouse"] pub fn SDL_GetGlobalMouseState(x: *mut libc::c_int, y: *mut libc::c_int) -> Uint32; } extern "C" { - #[doc = " \\brief Retrieve the relative state of the mouse."] + #[doc = " Retrieve the relative state of the mouse."] + #[doc = ""] + #[doc = " The current button state is returned as a button bitmask, which can be"] + #[doc = " tested using the `SDL_BUTTON(X)` macros (where `X` is generally 1 for the"] + #[doc = " left, 2 for middle, 3 for the right button), and `x` and `y` are set to the"] + #[doc = " mouse deltas since the last call to SDL_GetRelativeMouseState() or since"] + #[doc = " event initialization. You can pass NULL for either `x` or `y`."] + #[doc = ""] + #[doc = " \\param x a pointer filled with the last recorded x coordinate of the mouse"] + #[doc = " \\param y a pointer filled with the last recorded y coordinate of the mouse"] + #[doc = " \\returns a 32-bit button bitmask of the relative button state."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " The current button state is returned as a button bitmask, which can"] - #[doc = " be tested using the SDL_BUTTON(X) macros, and x and y are set to the"] - #[doc = " mouse deltas since the last call to SDL_GetRelativeMouseState()."] + #[doc = " \\sa SDL_GetMouseState"] pub fn SDL_GetRelativeMouseState(x: *mut libc::c_int, y: *mut libc::c_int) -> Uint32; } extern "C" { - #[doc = " \\brief Moves the mouse to the given position within the window."] + #[doc = " Move the mouse cursor to the given position within the window."] #[doc = ""] - #[doc = " \\param window The window to move the mouse into, or NULL for the current mouse focus"] - #[doc = " \\param x The x coordinate within the window"] - #[doc = " \\param y The y coordinate within the window"] + #[doc = " This function generates a mouse motion event."] #[doc = ""] - #[doc = " \\note This function generates a mouse motion event"] + #[doc = " Note that this function will appear to succeed, but not actually move the"] + #[doc = " mouse when used over Microsoft Remote Desktop."] + #[doc = ""] + #[doc = " \\param window the window to move the mouse into, or NULL for the current"] + #[doc = " mouse focus"] + #[doc = " \\param x the x coordinate within the window"] + #[doc = " \\param y the y coordinate within the window"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_WarpMouseGlobal"] pub fn SDL_WarpMouseInWindow(window: *mut SDL_Window, x: libc::c_int, y: libc::c_int); } extern "C" { - #[doc = " \\brief Moves the mouse to the given position in global screen space."] + #[doc = " Move the mouse to the given position in global screen space."] + #[doc = ""] + #[doc = " This function generates a mouse motion event."] #[doc = ""] - #[doc = " \\param x The x coordinate"] - #[doc = " \\param y The y coordinate"] - #[doc = " \\return 0 on success, -1 on error (usually: unsupported by a platform)."] + #[doc = " A failure of this function usually means that it is unsupported by a"] + #[doc = " platform."] #[doc = ""] - #[doc = " \\note This function generates a mouse motion event"] + #[doc = " Note that this function will appear to succeed, but not actually move the"] + #[doc = " mouse when used over Microsoft Remote Desktop."] + #[doc = ""] + #[doc = " \\param x the x coordinate"] + #[doc = " \\param y the y coordinate"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.4."] + #[doc = ""] + #[doc = " \\sa SDL_WarpMouseInWindow"] pub fn SDL_WarpMouseGlobal(x: libc::c_int, y: libc::c_int) -> libc::c_int; } extern "C" { - #[doc = " \\brief Set relative mouse mode."] + #[doc = " Set relative mouse mode."] + #[doc = ""] + #[doc = " While the mouse is in relative mode, the cursor is hidden, and the driver"] + #[doc = " will try to report continuous motion in the current window. Only relative"] + #[doc = " motion events will be delivered, the mouse position will not change."] #[doc = ""] - #[doc = " \\param enabled Whether or not to enable relative mode"] + #[doc = " Note that this function will not be able to provide continuous relative"] + #[doc = " motion when used over Microsoft Remote Desktop, instead motion is limited"] + #[doc = " to the bounds of the screen."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if relative mode is not supported."] + #[doc = " This function will flush any pending mouse motion."] #[doc = ""] - #[doc = " While the mouse is in relative mode, the cursor is hidden, and the"] - #[doc = " driver will try to report continuous motion in the current window."] - #[doc = " Only relative motion events will be delivered, the mouse position"] - #[doc = " will not change."] + #[doc = " \\param enabled SDL_TRUE to enable relative mode, SDL_FALSE to disable."] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\note This function will flush any pending mouse motion."] + #[doc = " If relative mode is not supported, this returns -1."] #[doc = ""] - #[doc = " \\sa SDL_GetRelativeMouseMode()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetRelativeMouseMode"] pub fn SDL_SetRelativeMouseMode(enabled: SDL_bool) -> libc::c_int; } extern "C" { - #[doc = " \\brief Capture the mouse, to track input outside an SDL window."] + #[doc = " Capture the mouse and to track input outside an SDL window."] + #[doc = ""] + #[doc = " Capturing enables your app to obtain mouse events globally, instead of just"] + #[doc = " within your window. Not all video targets support this function. When"] + #[doc = " capturing is enabled, the current window will get all mouse events, but"] + #[doc = " unlike relative mode, no change is made to the cursor and it is not"] + #[doc = " restrained to your window."] #[doc = ""] - #[doc = " \\param enabled Whether or not to enable capturing"] + #[doc = " This function may also deny mouse input to other windows--both those in"] + #[doc = " your application and others on the system--so you should use this function"] + #[doc = " sparingly, and in small bursts. For example, you might want to track the"] + #[doc = " mouse while the user is dragging something, until the user releases a mouse"] + #[doc = " button. It is not recommended that you capture the mouse for long periods"] + #[doc = " of time, such as the entire time your app is running. For that, you should"] + #[doc = " probably use SDL_SetRelativeMouseMode() or SDL_SetWindowGrab(), depending"] + #[doc = " on your goals."] #[doc = ""] - #[doc = " Capturing enables your app to obtain mouse events globally, instead of"] - #[doc = " just within your window. Not all video targets support this function."] - #[doc = " When capturing is enabled, the current window will get all mouse events,"] - #[doc = " but unlike relative mode, no change is made to the cursor and it is"] - #[doc = " not restrained to your window."] + #[doc = " While captured, mouse events still report coordinates relative to the"] + #[doc = " current (foreground) window, but those coordinates may be outside the"] + #[doc = " bounds of the window (including negative values). Capturing is only allowed"] + #[doc = " for the foreground window. If the window loses focus while capturing, the"] + #[doc = " capture will be disabled automatically."] #[doc = ""] - #[doc = " This function may also deny mouse input to other windows--both those in"] - #[doc = " your application and others on the system--so you should use this"] - #[doc = " function sparingly, and in small bursts. For example, you might want to"] - #[doc = " track the mouse while the user is dragging something, until the user"] - #[doc = " releases a mouse button. It is not recommended that you capture the mouse"] - #[doc = " for long periods of time, such as the entire time your app is running."] + #[doc = " While capturing is enabled, the current window will have the"] + #[doc = " `SDL_WINDOW_MOUSE_CAPTURE` flag set."] #[doc = ""] - #[doc = " While captured, mouse events still report coordinates relative to the"] - #[doc = " current (foreground) window, but those coordinates may be outside the"] - #[doc = " bounds of the window (including negative values). Capturing is only"] - #[doc = " allowed for the foreground window. If the window loses focus while"] - #[doc = " capturing, the capture will be disabled automatically."] + #[doc = " \\param enabled SDL_TRUE to enable capturing, SDL_FALSE to disable."] + #[doc = " \\returns 0 on success or -1 if not supported; call SDL_GetError() for more"] + #[doc = " information."] #[doc = ""] - #[doc = " While capturing is enabled, the current window will have the"] - #[doc = " SDL_WINDOW_MOUSE_CAPTURE flag set."] + #[doc = " \\since This function is available since SDL 2.0.4."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if not supported."] + #[doc = " \\sa SDL_GetGlobalMouseState"] pub fn SDL_CaptureMouse(enabled: SDL_bool) -> libc::c_int; } extern "C" { - #[doc = " \\brief Query whether relative mouse mode is enabled."] + #[doc = " Query whether relative mouse mode is enabled."] + #[doc = ""] + #[doc = " \\returns SDL_TRUE if relative mode is enabled or SDL_FALSE otherwise."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_SetRelativeMouseMode()"] + #[doc = " \\sa SDL_SetRelativeMouseMode"] pub fn SDL_GetRelativeMouseMode() -> SDL_bool; } extern "C" { - #[doc = " \\brief Create a cursor, using the specified bitmap data and"] - #[doc = " mask (in MSB format)."] + #[doc = " Create a cursor using the specified bitmap data and mask (in MSB format)."] + #[doc = ""] + #[doc = " `mask` has to be in MSB (Most Significant Bit) format."] + #[doc = ""] + #[doc = " The cursor width (`w`) must be a multiple of 8 bits."] + #[doc = ""] + #[doc = " The cursor is created in black and white according to the following:"] + #[doc = ""] + #[doc = " - data=0, mask=1: white"] + #[doc = " - data=1, mask=1: black"] + #[doc = " - data=0, mask=0: transparent"] + #[doc = " - data=1, mask=0: inverted color if possible, black if not."] #[doc = ""] - #[doc = " The cursor width must be a multiple of 8 bits."] + #[doc = " Cursors created with this function must be freed with SDL_FreeCursor()."] #[doc = ""] - #[doc = " The cursor is created in black and white according to the following:"] - #[doc = " "] - #[doc = " "] - #[doc = " "] - #[doc = " "] - #[doc = " "] - #[doc = " "] - #[doc = "
data mask resulting pixel on screen
0 1 White
1 1 Black
0 0 Transparent
1 0 Inverted color if possible, black"] - #[doc = " if not.
"] + #[doc = " If you want to have a color cursor, or create your cursor from an"] + #[doc = " SDL_Surface, you should use SDL_CreateColorCursor(). Alternately, you can"] + #[doc = " hide the cursor and draw your own as part of your game's rendering, but it"] + #[doc = " will be bound to the framerate."] #[doc = ""] - #[doc = " \\sa SDL_FreeCursor()"] + #[doc = " Also, since SDL 2.0.0, SDL_CreateSystemCursor() is available, which"] + #[doc = " provides twelve readily available system cursors to pick from."] + #[doc = ""] + #[doc = " \\param data the color value for each pixel of the cursor"] + #[doc = " \\param mask the mask value for each pixel of the cursor"] + #[doc = " \\param w the width of the cursor"] + #[doc = " \\param h the height of the cursor"] + #[doc = " \\param hot_x the X-axis location of the upper left corner of the cursor"] + #[doc = " relative to the actual mouse position"] + #[doc = " \\param hot_y the Y-axis location of the upper left corner of the cursor"] + #[doc = " relative to the actual mouse position"] + #[doc = " \\returns a new cursor with the specified parameters on success or NULL on"] + #[doc = " failure; call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_FreeCursor"] + #[doc = " \\sa SDL_SetCursor"] + #[doc = " \\sa SDL_ShowCursor"] pub fn SDL_CreateCursor( data: *const Uint8, mask: *const Uint8, @@ -9627,9 +13193,18 @@ extern "C" { ) -> *mut SDL_Cursor; } extern "C" { - #[doc = " \\brief Create a color cursor."] + #[doc = " Create a color cursor."] + #[doc = ""] + #[doc = " \\param surface an SDL_Surface structure representing the cursor image"] + #[doc = " \\param hot_x the x position of the cursor hot spot"] + #[doc = " \\param hot_y the y position of the cursor hot spot"] + #[doc = " \\returns the new cursor on success or NULL on failure; call SDL_GetError()"] + #[doc = " for more information."] #[doc = ""] - #[doc = " \\sa SDL_FreeCursor()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateCursor"] + #[doc = " \\sa SDL_FreeCursor"] pub fn SDL_CreateColorCursor( surface: *mut SDL_Surface, hot_x: libc::c_int, @@ -9637,38 +13212,91 @@ extern "C" { ) -> *mut SDL_Cursor; } extern "C" { - #[doc = " \\brief Create a system cursor."] + #[doc = " Create a system cursor."] + #[doc = ""] + #[doc = " \\param id an SDL_SystemCursor enum value"] + #[doc = " \\returns a cursor on success or NULL on failure; call SDL_GetError() for"] + #[doc = " more information."] #[doc = ""] - #[doc = " \\sa SDL_FreeCursor()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_FreeCursor"] pub fn SDL_CreateSystemCursor(id: SDL_SystemCursor) -> *mut SDL_Cursor; } extern "C" { - #[doc = " \\brief Set the active cursor."] + #[doc = " Set the active cursor."] + #[doc = ""] + #[doc = " This function sets the currently active cursor to the specified one. If the"] + #[doc = " cursor is currently visible, the change will be immediately represented on"] + #[doc = " the display. SDL_SetCursor(NULL) can be used to force cursor redraw, if"] + #[doc = " this is desired for any reason."] + #[doc = ""] + #[doc = " \\param cursor a cursor to make active"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateCursor"] + #[doc = " \\sa SDL_GetCursor"] + #[doc = " \\sa SDL_ShowCursor"] pub fn SDL_SetCursor(cursor: *mut SDL_Cursor); } extern "C" { - #[doc = " \\brief Return the active cursor."] + #[doc = " Get the active cursor."] + #[doc = ""] + #[doc = " This function returns a pointer to the current cursor which is owned by the"] + #[doc = " library. It is not necessary to free the cursor with SDL_FreeCursor()."] + #[doc = ""] + #[doc = " \\returns the active cursor or NULL if there is no mouse."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_SetCursor"] pub fn SDL_GetCursor() -> *mut SDL_Cursor; } extern "C" { - #[doc = " \\brief Return the default cursor."] - pub fn SDL_GetDefaultCursor() -> *mut SDL_Cursor; + #[doc = " Get the default cursor."] + #[doc = ""] + #[doc = " \\returns the default cursor on success or NULL on failure."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateSystemCursor"] + pub fn SDL_GetDefaultCursor() -> *mut SDL_Cursor; } extern "C" { - #[doc = " \\brief Frees a cursor created with SDL_CreateCursor() or similar functions."] + #[doc = " Free a previously-created cursor."] #[doc = ""] - #[doc = " \\sa SDL_CreateCursor()"] - #[doc = " \\sa SDL_CreateColorCursor()"] - #[doc = " \\sa SDL_CreateSystemCursor()"] + #[doc = " Use this function to free cursor resources created with SDL_CreateCursor(),"] + #[doc = " SDL_CreateColorCursor() or SDL_CreateSystemCursor()."] + #[doc = ""] + #[doc = " \\param cursor the cursor to free"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateColorCursor"] + #[doc = " \\sa SDL_CreateCursor"] + #[doc = " \\sa SDL_CreateSystemCursor"] pub fn SDL_FreeCursor(cursor: *mut SDL_Cursor); } extern "C" { - #[doc = " \\brief Toggle whether or not the cursor is shown."] + #[doc = " Toggle whether or not the cursor is shown."] + #[doc = ""] + #[doc = " The cursor starts off displayed but can be turned off. Passing `SDL_ENABLE`"] + #[doc = " displays the cursor and passing `SDL_DISABLE` hides it."] #[doc = ""] - #[doc = " \\param toggle 1 to show the cursor, 0 to hide it, -1 to query the current"] - #[doc = " state."] + #[doc = " The current state of the mouse cursor can be queried by passing"] + #[doc = " `SDL_QUERY`; either `SDL_DISABLE` or `SDL_ENABLE` will be returned."] #[doc = ""] - #[doc = " \\return 1 if the cursor is shown, or 0 if the cursor is hidden."] + #[doc = " \\param toggle `SDL_ENABLE` to show the cursor, `SDL_DISABLE` to hide it,"] + #[doc = " `SDL_QUERY` to query the current state without changing it."] + #[doc = " \\returns `SDL_ENABLE` if the cursor is shown, or `SDL_DISABLE` if the"] + #[doc = " cursor is hidden, or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateCursor"] + #[doc = " \\sa SDL_SetCursor"] pub fn SDL_ShowCursor(toggle: libc::c_int) -> libc::c_int; } #[doc = " The joystick structure used to identify an SDL joystick"] @@ -9746,81 +13374,191 @@ extern "C" { #[doc = " In particular, you are guaranteed that the joystick list won't change, so"] #[doc = " the API functions that take a joystick index will be valid, and joystick"] #[doc = " and game controller events will not be delivered."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.7."] pub fn SDL_LockJoysticks(); } extern "C" { + #[doc = " Unlocking for multi-threaded access to the joystick API"] + #[doc = ""] + #[doc = " If you are using the joystick API or handling events from multiple threads"] + #[doc = " you should use these locking functions to protect access to the joysticks."] + #[doc = ""] + #[doc = " In particular, you are guaranteed that the joystick list won't change, so"] + #[doc = " the API functions that take a joystick index will be valid, and joystick"] + #[doc = " and game controller events will not be delivered."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.7."] pub fn SDL_UnlockJoysticks(); } extern "C" { - #[doc = " Count the number of joysticks attached to the system right now"] + #[doc = " Count the number of joysticks attached to the system."] + #[doc = ""] + #[doc = " \\returns the number of attached joysticks on success or a negative error"] + #[doc = " code on failure; call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_JoystickName"] + #[doc = " \\sa SDL_JoystickOpen"] pub fn SDL_NumJoysticks() -> libc::c_int; } extern "C" { - #[doc = " Get the implementation dependent name of a joystick."] - #[doc = " This can be called before any joysticks are opened."] - #[doc = " If no name can be found, this function returns NULL."] + #[doc = " Get the implementation dependent name of a joystick."] + #[doc = ""] + #[doc = " This can be called before any joysticks are opened."] + #[doc = ""] + #[doc = " \\param device_index the index of the joystick to query (the N'th joystick"] + #[doc = " on the system)"] + #[doc = " \\returns the name of the selected joystick. If no name can be found, this"] + #[doc = " function returns NULL; call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_JoystickName"] + #[doc = " \\sa SDL_JoystickOpen"] pub fn SDL_JoystickNameForIndex(device_index: libc::c_int) -> *const libc::c_char; } extern "C" { - #[doc = " Get the player index of a joystick, or -1 if it's not available"] - #[doc = " This can be called before any joysticks are opened."] + #[doc = " Get the player index of a joystick, or -1 if it's not available This can be"] + #[doc = " called before any joysticks are opened."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.9."] pub fn SDL_JoystickGetDevicePlayerIndex(device_index: libc::c_int) -> libc::c_int; } extern "C" { - #[doc = " Return the GUID for the joystick at this index"] - #[doc = " This can be called before any joysticks are opened."] + #[doc = " Get the implementation-dependent GUID for the joystick at a given device"] + #[doc = " index."] + #[doc = ""] + #[doc = " This function can be called before any joysticks are opened."] + #[doc = ""] + #[doc = " \\param device_index the index of the joystick to query (the N'th joystick"] + #[doc = " on the system"] + #[doc = " \\returns the GUID of the selected joystick. If called on an invalid index,"] + #[doc = " this function returns a zero GUID"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_JoystickGetGUID"] + #[doc = " \\sa SDL_JoystickGetGUIDString"] pub fn SDL_JoystickGetDeviceGUID(device_index: libc::c_int) -> SDL_JoystickGUID; } extern "C" { - #[doc = " Get the USB vendor ID of a joystick, if available."] - #[doc = " This can be called before any joysticks are opened."] - #[doc = " If the vendor ID isn't available this function returns 0."] + #[doc = " Get the USB vendor ID of a joystick, if available."] + #[doc = ""] + #[doc = " This can be called before any joysticks are opened. If the vendor ID isn't"] + #[doc = " available this function returns 0."] + #[doc = ""] + #[doc = " \\param device_index the index of the joystick to query (the N'th joystick"] + #[doc = " on the system"] + #[doc = " \\returns the USB vendor ID of the selected joystick. If called on an"] + #[doc = " invalid index, this function returns zero"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.6."] pub fn SDL_JoystickGetDeviceVendor(device_index: libc::c_int) -> Uint16; } extern "C" { - #[doc = " Get the USB product ID of a joystick, if available."] - #[doc = " This can be called before any joysticks are opened."] - #[doc = " If the product ID isn't available this function returns 0."] + #[doc = " Get the USB product ID of a joystick, if available."] + #[doc = ""] + #[doc = " This can be called before any joysticks are opened. If the product ID isn't"] + #[doc = " available this function returns 0."] + #[doc = ""] + #[doc = " \\param device_index the index of the joystick to query (the N'th joystick"] + #[doc = " on the system"] + #[doc = " \\returns the USB product ID of the selected joystick. If called on an"] + #[doc = " invalid index, this function returns zero"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.6."] pub fn SDL_JoystickGetDeviceProduct(device_index: libc::c_int) -> Uint16; } extern "C" { - #[doc = " Get the product version of a joystick, if available."] - #[doc = " This can be called before any joysticks are opened."] - #[doc = " If the product version isn't available this function returns 0."] + #[doc = " Get the product version of a joystick, if available."] + #[doc = ""] + #[doc = " This can be called before any joysticks are opened. If the product version"] + #[doc = " isn't available this function returns 0."] + #[doc = ""] + #[doc = " \\param device_index the index of the joystick to query (the N'th joystick"] + #[doc = " on the system"] + #[doc = " \\returns the product version of the selected joystick. If called on an"] + #[doc = " invalid index, this function returns zero"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.6."] pub fn SDL_JoystickGetDeviceProductVersion(device_index: libc::c_int) -> Uint16; } extern "C" { - #[doc = " Get the type of a joystick, if available."] - #[doc = " This can be called before any joysticks are opened."] + #[doc = " Get the type of a joystick, if available."] + #[doc = ""] + #[doc = " This can be called before any joysticks are opened."] + #[doc = ""] + #[doc = " \\param device_index the index of the joystick to query (the N'th joystick"] + #[doc = " on the system"] + #[doc = " \\returns the SDL_JoystickType of the selected joystick. If called on an"] + #[doc = " invalid index, this function returns `SDL_JOYSTICK_TYPE_UNKNOWN`"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.6."] pub fn SDL_JoystickGetDeviceType(device_index: libc::c_int) -> SDL_JoystickType; } extern "C" { - #[doc = " Get the instance ID of a joystick."] - #[doc = " This can be called before any joysticks are opened."] - #[doc = " If the index is out of range, this function will return -1."] + #[doc = " Get the instance ID of a joystick."] + #[doc = ""] + #[doc = " This can be called before any joysticks are opened. If the index is out of"] + #[doc = " range, this function will return -1."] + #[doc = ""] + #[doc = " \\param device_index the index of the joystick to query (the N'th joystick"] + #[doc = " on the system"] + #[doc = " \\returns the instance id of the selected joystick. If called on an invalid"] + #[doc = " index, this function returns zero"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.6."] pub fn SDL_JoystickGetDeviceInstanceID(device_index: libc::c_int) -> SDL_JoystickID; } extern "C" { - #[doc = " Open a joystick for use."] - #[doc = " The index passed as an argument refers to the N'th joystick on the system."] - #[doc = " This index is not the value which will identify this joystick in future"] - #[doc = " joystick events. The joystick's instance id (::SDL_JoystickID) will be used"] - #[doc = " there instead."] + #[doc = " Open a joystick for use."] + #[doc = ""] + #[doc = " The `device_index` argument refers to the N'th joystick presently"] + #[doc = " recognized by SDL on the system. It is **NOT** the same as the instance ID"] + #[doc = " used to identify the joystick in future events. See"] + #[doc = " SDL_JoystickInstanceID() for more details about instance IDs."] + #[doc = ""] + #[doc = " The joystick subsystem must be initialized before a joystick can be opened"] + #[doc = " for use."] #[doc = ""] - #[doc = " \\return A joystick identifier, or NULL if an error occurred."] + #[doc = " \\param device_index the index of the joystick to query"] + #[doc = " \\returns a joystick identifier or NULL if an error occurred; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_JoystickClose"] + #[doc = " \\sa SDL_JoystickInstanceID"] pub fn SDL_JoystickOpen(device_index: libc::c_int) -> *mut SDL_Joystick; } extern "C" { - #[doc = " Return the SDL_Joystick associated with an instance id."] + #[doc = " Get the SDL_Joystick associated with an instance id."] + #[doc = ""] + #[doc = " \\param instance_id the instance id to get the SDL_Joystick for"] + #[doc = " \\returns an SDL_Joystick on success or NULL on failure; call SDL_GetError()"] + #[doc = " for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.4."] pub fn SDL_JoystickFromInstanceID(instance_id: SDL_JoystickID) -> *mut SDL_Joystick; } extern "C" { - #[doc = " Return the SDL_Joystick associated with a player index."] + #[doc = " Get the SDL_Joystick associated with a player index."] + #[doc = ""] + #[doc = " \\param player_index the player index to get the SDL_Joystick for"] + #[doc = " \\returns an SDL_Joystick on success or NULL on failure; call SDL_GetError()"] + #[doc = " for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.12."] pub fn SDL_JoystickFromPlayerIndex(player_index: libc::c_int) -> *mut SDL_Joystick; } extern "C" { - #[doc = " Attaches a new virtual joystick."] - #[doc = " Returns the joystick's device index, or -1 if an error occurred."] + #[doc = " Attach a new virtual joystick."] + #[doc = ""] + #[doc = " \\returns the joystick's device index, or -1 if an error occurred."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.14."] pub fn SDL_JoystickAttachVirtual( type_: SDL_JoystickType, naxes: libc::c_int, @@ -9829,23 +13567,39 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " Detaches a virtual joystick"] - #[doc = " Returns 0 on success, or -1 if an error occurred."] + #[doc = " Detach a virtual joystick."] + #[doc = ""] + #[doc = " \\param device_index a value previously returned from"] + #[doc = " SDL_JoystickAttachVirtual()"] + #[doc = " \\returns 0 on success, or -1 if an error occurred."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.14."] pub fn SDL_JoystickDetachVirtual(device_index: libc::c_int) -> libc::c_int; } extern "C" { - #[doc = " Indicates whether or not a virtual-joystick is at a given device index."] + #[doc = " Query whether or not the joystick at a given device index is virtual."] + #[doc = ""] + #[doc = " \\param device_index a joystick device index."] + #[doc = " \\returns SDL_TRUE if the joystick is virtual, SDL_FALSE otherwise."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.14."] pub fn SDL_JoystickIsVirtual(device_index: libc::c_int) -> SDL_bool; } extern "C" { - #[doc = " Set values on an opened, virtual-joystick's controls."] - #[doc = " Please note that values set here will not be applied until the next"] - #[doc = " call to SDL_JoystickUpdate, which can either be called directly,"] - #[doc = " or can be called indirectly through various other SDL APIS,"] - #[doc = " including, but not limited to the following: SDL_PollEvent,"] - #[doc = " SDL_PumpEvents, SDL_WaitEventTimeout, SDL_WaitEvent."] + #[doc = " Set values on an opened, virtual-joystick's axis."] #[doc = ""] - #[doc = " Returns 0 on success, -1 on error."] + #[doc = " Please note that values set here will not be applied until the next call to"] + #[doc = " SDL_JoystickUpdate, which can either be called directly, or can be called"] + #[doc = " indirectly through various other SDL APIs, including, but not limited to"] + #[doc = " the following: SDL_PollEvent, SDL_PumpEvents, SDL_WaitEventTimeout,"] + #[doc = " SDL_WaitEvent."] + #[doc = ""] + #[doc = " \\param joystick the virtual joystick on which to set state."] + #[doc = " \\param axis the specific axis on the virtual joystick to set."] + #[doc = " \\param value the new value for the specified axis."] + #[doc = " \\returns 0 on success, -1 on error."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.14."] pub fn SDL_JoystickSetVirtualAxis( joystick: *mut SDL_Joystick, axis: libc::c_int, @@ -9853,6 +13607,20 @@ extern "C" { ) -> libc::c_int; } extern "C" { + #[doc = " Set values on an opened, virtual-joystick's button."] + #[doc = ""] + #[doc = " Please note that values set here will not be applied until the next call to"] + #[doc = " SDL_JoystickUpdate, which can either be called directly, or can be called"] + #[doc = " indirectly through various other SDL APIs, including, but not limited to"] + #[doc = " the following: SDL_PollEvent, SDL_PumpEvents, SDL_WaitEventTimeout,"] + #[doc = " SDL_WaitEvent."] + #[doc = ""] + #[doc = " \\param joystick the virtual joystick on which to set state."] + #[doc = " \\param button the specific button on the virtual joystick to set."] + #[doc = " \\param value the new value for the specified button."] + #[doc = " \\returns 0 on success, -1 on error."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.14."] pub fn SDL_JoystickSetVirtualButton( joystick: *mut SDL_Joystick, button: libc::c_int, @@ -9860,6 +13628,20 @@ extern "C" { ) -> libc::c_int; } extern "C" { + #[doc = " Set values on an opened, virtual-joystick's hat."] + #[doc = ""] + #[doc = " Please note that values set here will not be applied until the next call to"] + #[doc = " SDL_JoystickUpdate, which can either be called directly, or can be called"] + #[doc = " indirectly through various other SDL APIs, including, but not limited to"] + #[doc = " the following: SDL_PollEvent, SDL_PumpEvents, SDL_WaitEventTimeout,"] + #[doc = " SDL_WaitEvent."] + #[doc = ""] + #[doc = " \\param joystick the virtual joystick on which to set state."] + #[doc = " \\param hat the specific hat on the virtual joystick to set."] + #[doc = " \\param value the new value for the specified hat."] + #[doc = " \\returns 0 on success, -1 on error."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.14."] pub fn SDL_JoystickSetVirtualHat( joystick: *mut SDL_Joystick, hat: libc::c_int, @@ -9867,52 +13649,123 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " Return the name for this currently opened joystick."] - #[doc = " If no name can be found, this function returns NULL."] + #[doc = " Get the implementation dependent name of a joystick."] + #[doc = ""] + #[doc = " \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()"] + #[doc = " \\returns the name of the selected joystick. If no name can be found, this"] + #[doc = " function returns NULL; call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_JoystickNameForIndex"] + #[doc = " \\sa SDL_JoystickOpen"] pub fn SDL_JoystickName(joystick: *mut SDL_Joystick) -> *const libc::c_char; } extern "C" { - #[doc = " Get the player index of an opened joystick, or -1 if it's not available"] + #[doc = " Get the player index of an opened joystick."] + #[doc = ""] + #[doc = " For XInput controllers this returns the XInput user index. Many joysticks"] + #[doc = " will not be able to supply this information."] #[doc = ""] - #[doc = " For XInput controllers this returns the XInput user index."] + #[doc = " \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()"] + #[doc = " \\returns the player index, or -1 if it's not available."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.9."] pub fn SDL_JoystickGetPlayerIndex(joystick: *mut SDL_Joystick) -> libc::c_int; } extern "C" { - #[doc = " Set the player index of an opened joystick"] + #[doc = " Set the player index of an opened joystick."] + #[doc = ""] + #[doc = " \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()"] + #[doc = " \\param player_index the player index to set."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.12."] pub fn SDL_JoystickSetPlayerIndex(joystick: *mut SDL_Joystick, player_index: libc::c_int); } extern "C" { - #[doc = " Return the GUID for this opened joystick"] + #[doc = " Get the implementation-dependent GUID for the joystick."] + #[doc = ""] + #[doc = " This function requires an open joystick."] + #[doc = ""] + #[doc = " \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()"] + #[doc = " \\returns the GUID of the given joystick. If called on an invalid index,"] + #[doc = " this function returns a zero GUID; call SDL_GetError() for more"] + #[doc = " information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_JoystickGetDeviceGUID"] + #[doc = " \\sa SDL_JoystickGetGUIDString"] pub fn SDL_JoystickGetGUID(joystick: *mut SDL_Joystick) -> SDL_JoystickGUID; } extern "C" { - #[doc = " Get the USB vendor ID of an opened joystick, if available."] - #[doc = " If the vendor ID isn't available this function returns 0."] + #[doc = " Get the USB vendor ID of an opened joystick, if available."] + #[doc = ""] + #[doc = " If the vendor ID isn't available this function returns 0."] + #[doc = ""] + #[doc = " \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()"] + #[doc = " \\returns the USB vendor ID of the selected joystick, or 0 if unavailable."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.6."] pub fn SDL_JoystickGetVendor(joystick: *mut SDL_Joystick) -> Uint16; } extern "C" { - #[doc = " Get the USB product ID of an opened joystick, if available."] - #[doc = " If the product ID isn't available this function returns 0."] + #[doc = " Get the USB product ID of an opened joystick, if available."] + #[doc = ""] + #[doc = " If the product ID isn't available this function returns 0."] + #[doc = ""] + #[doc = " \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()"] + #[doc = " \\returns the USB product ID of the selected joystick, or 0 if unavailable."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.6."] pub fn SDL_JoystickGetProduct(joystick: *mut SDL_Joystick) -> Uint16; } extern "C" { - #[doc = " Get the product version of an opened joystick, if available."] - #[doc = " If the product version isn't available this function returns 0."] + #[doc = " Get the product version of an opened joystick, if available."] + #[doc = ""] + #[doc = " If the product version isn't available this function returns 0."] + #[doc = ""] + #[doc = " \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()"] + #[doc = " \\returns the product version of the selected joystick, or 0 if unavailable."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.6."] pub fn SDL_JoystickGetProductVersion(joystick: *mut SDL_Joystick) -> Uint16; } extern "C" { - #[doc = " Get the serial number of an opened joystick, if available."] + #[doc = " Get the serial number of an opened joystick, if available."] #[doc = ""] - #[doc = " Returns the serial number of the joystick, or NULL if it is not available."] + #[doc = " Returns the serial number of the joystick, or NULL if it is not available."] + #[doc = ""] + #[doc = " \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()"] + #[doc = " \\returns the serial number of the selected joystick, or NULL if"] + #[doc = " unavailable."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.14."] pub fn SDL_JoystickGetSerial(joystick: *mut SDL_Joystick) -> *const libc::c_char; } extern "C" { - #[doc = " Get the type of an opened joystick."] + #[doc = " Get the type of an opened joystick."] + #[doc = ""] + #[doc = " \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()"] + #[doc = " \\returns the SDL_JoystickType of the selected joystick."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.6."] pub fn SDL_JoystickGetType(joystick: *mut SDL_Joystick) -> SDL_JoystickType; } extern "C" { - #[doc = " Return a string representation for this guid. pszGUID must point to at least 33 bytes"] - #[doc = " (32 for the string plus a NULL terminator)."] + #[doc = " Get an ASCII string representation for a given SDL_JoystickGUID."] + #[doc = ""] + #[doc = " You should supply at least 33 bytes for pszGUID."] + #[doc = ""] + #[doc = " \\param guid the SDL_JoystickGUID you wish to convert to string"] + #[doc = " \\param pszGUID buffer in which to write the ASCII string"] + #[doc = " \\param cbGUID the size of pszGUID"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_JoystickGetDeviceGUID"] + #[doc = " \\sa SDL_JoystickGetGUID"] + #[doc = " \\sa SDL_JoystickGetGUIDFromString"] pub fn SDL_JoystickGetGUIDString( guid: SDL_JoystickGUID, pszGUID: *mut libc::c_char, @@ -9920,69 +13773,177 @@ extern "C" { ); } extern "C" { - #[doc = " Convert a string into a joystick guid"] + #[doc = " Convert a GUID string into a SDL_JoystickGUID structure."] + #[doc = ""] + #[doc = " Performs no error checking. If this function is given a string containing"] + #[doc = " an invalid GUID, the function will silently succeed, but the GUID generated"] + #[doc = " will not be useful."] + #[doc = ""] + #[doc = " \\param pchGUID string containing an ASCII representation of a GUID"] + #[doc = " \\returns a SDL_JoystickGUID structure."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_JoystickGetGUIDString"] pub fn SDL_JoystickGetGUIDFromString(pchGUID: *const libc::c_char) -> SDL_JoystickGUID; } extern "C" { - #[doc = " Returns SDL_TRUE if the joystick has been opened and currently connected, or SDL_FALSE if it has not."] + #[doc = " Get the status of a specified joystick."] + #[doc = ""] + #[doc = " \\param joystick the joystick to query"] + #[doc = " \\returns SDL_TRUE if the joystick has been opened, SDL_FALSE if it has not;"] + #[doc = " call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_JoystickClose"] + #[doc = " \\sa SDL_JoystickOpen"] pub fn SDL_JoystickGetAttached(joystick: *mut SDL_Joystick) -> SDL_bool; } extern "C" { - #[doc = " Get the instance ID of an opened joystick or -1 if the joystick is invalid."] + #[doc = " Get the instance ID of an opened joystick."] + #[doc = ""] + #[doc = " \\param joystick an SDL_Joystick structure containing joystick information"] + #[doc = " \\returns the instance ID of the specified joystick on success or a negative"] + #[doc = " error code on failure; call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_JoystickOpen"] pub fn SDL_JoystickInstanceID(joystick: *mut SDL_Joystick) -> SDL_JoystickID; } extern "C" { - #[doc = " Get the number of general axis controls on a joystick."] + #[doc = " Get the number of general axis controls on a joystick."] + #[doc = ""] + #[doc = " Often, the directional pad on a game controller will either look like 4"] + #[doc = " separate buttons or a POV hat, and not axes, but all of this is up to the"] + #[doc = " device and platform."] + #[doc = ""] + #[doc = " \\param joystick an SDL_Joystick structure containing joystick information"] + #[doc = " \\returns the number of axis controls/number of axes on success or a"] + #[doc = " negative error code on failure; call SDL_GetError() for more"] + #[doc = " information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_JoystickGetAxis"] + #[doc = " \\sa SDL_JoystickOpen"] pub fn SDL_JoystickNumAxes(joystick: *mut SDL_Joystick) -> libc::c_int; } extern "C" { - #[doc = " Get the number of trackballs on a joystick."] + #[doc = " Get the number of trackballs on a joystick."] + #[doc = ""] + #[doc = " Joystick trackballs have only relative motion events associated with them"] + #[doc = " and their state cannot be polled."] + #[doc = ""] + #[doc = " Most joysticks do not have trackballs."] #[doc = ""] - #[doc = " Joystick trackballs have only relative motion events associated"] - #[doc = " with them and their state cannot be polled."] + #[doc = " \\param joystick an SDL_Joystick structure containing joystick information"] + #[doc = " \\returns the number of trackballs on success or a negative error code on"] + #[doc = " failure; call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_JoystickGetBall"] pub fn SDL_JoystickNumBalls(joystick: *mut SDL_Joystick) -> libc::c_int; } extern "C" { - #[doc = " Get the number of POV hats on a joystick."] + #[doc = " Get the number of POV hats on a joystick."] + #[doc = ""] + #[doc = " \\param joystick an SDL_Joystick structure containing joystick information"] + #[doc = " \\returns the number of POV hats on success or a negative error code on"] + #[doc = " failure; call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_JoystickGetHat"] + #[doc = " \\sa SDL_JoystickOpen"] pub fn SDL_JoystickNumHats(joystick: *mut SDL_Joystick) -> libc::c_int; } extern "C" { - #[doc = " Get the number of buttons on a joystick."] + #[doc = " Get the number of buttons on a joystick."] + #[doc = ""] + #[doc = " \\param joystick an SDL_Joystick structure containing joystick information"] + #[doc = " \\returns the number of buttons on success or a negative error code on"] + #[doc = " failure; call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_JoystickGetButton"] + #[doc = " \\sa SDL_JoystickOpen"] pub fn SDL_JoystickNumButtons(joystick: *mut SDL_Joystick) -> libc::c_int; } extern "C" { - #[doc = " Update the current state of the open joysticks."] + #[doc = " Update the current state of the open joysticks."] #[doc = ""] - #[doc = " This is called automatically by the event loop if any joystick"] - #[doc = " events are enabled."] + #[doc = " This is called automatically by the event loop if any joystick events are"] + #[doc = " enabled."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_JoystickEventState"] pub fn SDL_JoystickUpdate(); } extern "C" { - #[doc = " Enable/disable joystick event polling."] + #[doc = " Enable/disable joystick event polling."] + #[doc = ""] + #[doc = " If joystick events are disabled, you must call SDL_JoystickUpdate()"] + #[doc = " yourself and manually check the state of the joystick when you want"] + #[doc = " joystick information."] + #[doc = ""] + #[doc = " It is recommended that you leave joystick event handling enabled."] #[doc = ""] - #[doc = " If joystick events are disabled, you must call SDL_JoystickUpdate()"] - #[doc = " yourself and check the state of the joystick when you want joystick"] - #[doc = " information."] + #[doc = " **WARNING**: Calling this function may delete all events currently in SDL's"] + #[doc = " event queue."] #[doc = ""] - #[doc = " The state can be one of ::SDL_QUERY, ::SDL_ENABLE or ::SDL_IGNORE."] + #[doc = " \\param state can be one of `SDL_QUERY`, `SDL_IGNORE`, or `SDL_ENABLE`"] + #[doc = " \\returns 1 if enabled, 0 if disabled, or a negative error code on failure;"] + #[doc = " call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " If `state` is `SDL_QUERY` then the current state is returned,"] + #[doc = " otherwise the new processing state is returned."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GameControllerEventState"] pub fn SDL_JoystickEventState(state: libc::c_int) -> libc::c_int; } extern "C" { - #[doc = " Get the current state of an axis control on a joystick."] + #[doc = " Get the current state of an axis control on a joystick."] + #[doc = ""] + #[doc = " SDL makes no promises about what part of the joystick any given axis refers"] + #[doc = " to. Your game should have some sort of configuration UI to let users"] + #[doc = " specify what each axis should be bound to. Alternately, SDL's higher-level"] + #[doc = " Game Controller API makes a great effort to apply order to this lower-level"] + #[doc = " interface, so you know that a specific axis is the \"left thumb stick,\" etc."] #[doc = ""] - #[doc = " The state is a value ranging from -32768 to 32767."] + #[doc = " The value returned by SDL_JoystickGetAxis() is a signed integer (-32768 to"] + #[doc = " 32767) representing the current position of the axis. It may be necessary"] + #[doc = " to impose certain tolerances on these values to account for jitter."] #[doc = ""] - #[doc = " The axis indices start at index 0."] + #[doc = " \\param joystick an SDL_Joystick structure containing joystick information"] + #[doc = " \\param axis the axis to query; the axis indices start at index 0"] + #[doc = " \\returns a 16-bit signed integer representing the current position of the"] + #[doc = " axis or 0 on failure; call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_JoystickNumAxes"] pub fn SDL_JoystickGetAxis(joystick: *mut SDL_Joystick, axis: libc::c_int) -> Sint16; } extern "C" { - #[doc = " Get the initial state of an axis control on a joystick."] + #[doc = " Get the initial state of an axis control on a joystick."] #[doc = ""] - #[doc = " The state is a value ranging from -32768 to 32767."] + #[doc = " The state is a value ranging from -32768 to 32767."] #[doc = ""] - #[doc = " The axis indices start at index 0."] + #[doc = " The axis indices start at index 0."] #[doc = ""] - #[doc = " \\return SDL_TRUE if this axis has any initial value, or SDL_FALSE if not."] + #[doc = " \\param joystick an SDL_Joystick structure containing joystick information"] + #[doc = " \\param axis the axis to query; the axis indices start at index 0"] + #[doc = " \\param state Upon return, the initial value is supplied here."] + #[doc = " \\return SDL_TRUE if this axis has any initial value, or SDL_FALSE if not."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.6."] pub fn SDL_JoystickGetAxisInitialState( joystick: *mut SDL_Joystick, axis: libc::c_int, @@ -9990,28 +13951,47 @@ extern "C" { ) -> SDL_bool; } extern "C" { - #[doc = " Get the current state of a POV hat on a joystick."] + #[doc = " Get the current state of a POV hat on a joystick."] + #[doc = ""] + #[doc = " The returned value will be one of the following positions:"] #[doc = ""] - #[doc = " The hat indices start at index 0."] + #[doc = " - `SDL_HAT_CENTERED`"] + #[doc = " - `SDL_HAT_UP`"] + #[doc = " - `SDL_HAT_RIGHT`"] + #[doc = " - `SDL_HAT_DOWN`"] + #[doc = " - `SDL_HAT_LEFT`"] + #[doc = " - `SDL_HAT_RIGHTUP`"] + #[doc = " - `SDL_HAT_RIGHTDOWN`"] + #[doc = " - `SDL_HAT_LEFTUP`"] + #[doc = " - `SDL_HAT_LEFTDOWN`"] #[doc = ""] - #[doc = " \\return The return value is one of the following positions:"] - #[doc = " - ::SDL_HAT_CENTERED"] - #[doc = " - ::SDL_HAT_UP"] - #[doc = " - ::SDL_HAT_RIGHT"] - #[doc = " - ::SDL_HAT_DOWN"] - #[doc = " - ::SDL_HAT_LEFT"] - #[doc = " - ::SDL_HAT_RIGHTUP"] - #[doc = " - ::SDL_HAT_RIGHTDOWN"] - #[doc = " - ::SDL_HAT_LEFTUP"] - #[doc = " - ::SDL_HAT_LEFTDOWN"] + #[doc = " \\param joystick an SDL_Joystick structure containing joystick information"] + #[doc = " \\param hat the hat index to get the state from; indices start at index 0"] + #[doc = " \\returns the current hat position."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_JoystickNumHats"] pub fn SDL_JoystickGetHat(joystick: *mut SDL_Joystick, hat: libc::c_int) -> Uint8; } extern "C" { - #[doc = " Get the ball axis change since the last poll."] + #[doc = " Get the ball axis change since the last poll."] + #[doc = ""] + #[doc = " Trackballs can only return relative motion since the last call to"] + #[doc = " SDL_JoystickGetBall(), these motion deltas are placed into `dx` and `dy`."] + #[doc = ""] + #[doc = " Most joysticks do not have trackballs."] #[doc = ""] - #[doc = " \\return 0, or -1 if you passed it invalid parameters."] + #[doc = " \\param joystick the SDL_Joystick to query"] + #[doc = " \\param ball the ball index to query; ball indices start at index 0"] + #[doc = " \\param dx stores the difference in the x axis position since the last poll"] + #[doc = " \\param dy stores the difference in the y axis position since the last poll"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " The ball indices start at index 0."] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_JoystickNumBalls"] pub fn SDL_JoystickGetBall( joystick: *mut SDL_Joystick, ball: libc::c_int, @@ -10020,21 +14000,35 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " Get the current state of a button on a joystick."] + #[doc = " Get the current state of a button on a joystick."] + #[doc = ""] + #[doc = " \\param joystick an SDL_Joystick structure containing joystick information"] + #[doc = " \\param button the button index to get the state from; indices start at"] + #[doc = " index 0"] + #[doc = " \\returns 1 if the specified button is pressed, 0 otherwise."] #[doc = ""] - #[doc = " The button indices start at index 0."] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_JoystickNumButtons"] pub fn SDL_JoystickGetButton(joystick: *mut SDL_Joystick, button: libc::c_int) -> Uint8; } extern "C" { - #[doc = " Start a rumble effect"] - #[doc = " Each call to this function cancels any previous rumble effect, and calling it with 0 intensity stops any rumbling."] + #[doc = " Start a rumble effect."] + #[doc = ""] + #[doc = " Each call to this function cancels any previous rumble effect, and calling"] + #[doc = " it with 0 intensity stops any rumbling."] #[doc = ""] - #[doc = " \\param joystick The joystick to vibrate"] - #[doc = " \\param low_frequency_rumble The intensity of the low frequency (left) rumble motor, from 0 to 0xFFFF"] - #[doc = " \\param high_frequency_rumble The intensity of the high frequency (right) rumble motor, from 0 to 0xFFFF"] - #[doc = " \\param duration_ms The duration of the rumble effect, in milliseconds"] + #[doc = " \\param joystick The joystick to vibrate"] + #[doc = " \\param low_frequency_rumble The intensity of the low frequency (left)"] + #[doc = " rumble motor, from 0 to 0xFFFF"] + #[doc = " \\param high_frequency_rumble The intensity of the high frequency (right)"] + #[doc = " rumble motor, from 0 to 0xFFFF"] + #[doc = " \\param duration_ms The duration of the rumble effect, in milliseconds"] + #[doc = " \\returns 0, or -1 if rumble isn't supported on this joystick"] #[doc = ""] - #[doc = " \\return 0, or -1 if rumble isn't supported on this joystick"] + #[doc = " \\since This function is available since SDL 2.0.9."] + #[doc = ""] + #[doc = " \\sa SDL_JoystickHasRumble"] pub fn SDL_JoystickRumble( joystick: *mut SDL_Joystick, low_frequency_rumble: Uint16, @@ -10043,15 +14037,27 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " Start a rumble effect in the joystick's triggers"] - #[doc = " Each call to this function cancels any previous trigger rumble effect, and calling it with 0 intensity stops any rumbling."] + #[doc = " Start a rumble effect in the joystick's triggers"] + #[doc = ""] + #[doc = " Each call to this function cancels any previous trigger rumble effect, and"] + #[doc = " calling it with 0 intensity stops any rumbling."] + #[doc = ""] + #[doc = " Note that this function is for _trigger_ rumble; the first joystick to"] + #[doc = " support this was the PlayStation 5's DualShock 5 controller. If you want"] + #[doc = " the (more common) whole-controller rumble, use SDL_JoystickRumble()"] + #[doc = " instead."] + #[doc = ""] + #[doc = " \\param joystick The joystick to vibrate"] + #[doc = " \\param left_rumble The intensity of the left trigger rumble motor, from 0"] + #[doc = " to 0xFFFF"] + #[doc = " \\param right_rumble The intensity of the right trigger rumble motor, from 0"] + #[doc = " to 0xFFFF"] + #[doc = " \\param duration_ms The duration of the rumble effect, in milliseconds"] + #[doc = " \\returns 0, or -1 if trigger rumble isn't supported on this joystick"] #[doc = ""] - #[doc = " \\param joystick The joystick to vibrate"] - #[doc = " \\param left_rumble The intensity of the left trigger rumble motor, from 0 to 0xFFFF"] - #[doc = " \\param right_rumble The intensity of the right trigger rumble motor, from 0 to 0xFFFF"] - #[doc = " \\param duration_ms The duration of the rumble effect, in milliseconds"] + #[doc = " \\since This function is available since SDL 2.0.14."] #[doc = ""] - #[doc = " \\return 0, or -1 if trigger rumble isn't supported on this joystick"] + #[doc = " \\sa SDL_JoystickHasRumbleTriggers"] pub fn SDL_JoystickRumbleTriggers( joystick: *mut SDL_Joystick, left_rumble: Uint16, @@ -10060,22 +14066,52 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " Return whether a joystick has an LED"] + #[doc = " Query whether a joystick has an LED."] #[doc = ""] - #[doc = " \\param joystick The joystick to query"] + #[doc = " An example of a joystick LED is the light on the back of a PlayStation 4's"] + #[doc = " DualShock 4 controller."] #[doc = ""] - #[doc = " \\return SDL_TRUE, or SDL_FALSE if this joystick does not have a modifiable LED"] + #[doc = " \\param joystick The joystick to query"] + #[doc = " \\return SDL_TRUE if the joystick has a modifiable LED, SDL_FALSE otherwise."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.14."] pub fn SDL_JoystickHasLED(joystick: *mut SDL_Joystick) -> SDL_bool; } extern "C" { - #[doc = " Update a joystick's LED color."] + #[doc = " Query whether a joystick has rumble support."] + #[doc = ""] + #[doc = " \\param joystick The joystick to query"] + #[doc = " \\return SDL_TRUE if the joystick has rumble, SDL_FALSE otherwise."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.18."] + #[doc = ""] + #[doc = " \\sa SDL_JoystickRumble"] + pub fn SDL_JoystickHasRumble(joystick: *mut SDL_Joystick) -> SDL_bool; +} +extern "C" { + #[doc = " Query whether a joystick has rumble support on triggers."] + #[doc = ""] + #[doc = " \\param joystick The joystick to query"] + #[doc = " \\return SDL_TRUE if the joystick has trigger rumble, SDL_FALSE otherwise."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.18."] + #[doc = ""] + #[doc = " \\sa SDL_JoystickRumbleTriggers"] + pub fn SDL_JoystickHasRumbleTriggers(joystick: *mut SDL_Joystick) -> SDL_bool; +} +extern "C" { + #[doc = " Update a joystick's LED color."] + #[doc = ""] + #[doc = " An example of a joystick LED is the light on the back of a PlayStation 4's"] + #[doc = " DualShock 4 controller."] #[doc = ""] - #[doc = " \\param joystick The joystick to update"] - #[doc = " \\param red The intensity of the red LED"] - #[doc = " \\param green The intensity of the green LED"] - #[doc = " \\param blue The intensity of the blue LED"] + #[doc = " \\param joystick The joystick to update"] + #[doc = " \\param red The intensity of the red LED"] + #[doc = " \\param green The intensity of the green LED"] + #[doc = " \\param blue The intensity of the blue LED"] + #[doc = " \\returns 0 on success, -1 if this joystick does not have a modifiable LED"] #[doc = ""] - #[doc = " \\return 0, or -1 if this joystick does not have a modifiable LED"] + #[doc = " \\since This function is available since SDL 2.0.14."] pub fn SDL_JoystickSetLED( joystick: *mut SDL_Joystick, red: Uint8, @@ -10084,11 +14120,38 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " Close a joystick previously opened with SDL_JoystickOpen()."] + #[doc = " Send a joystick specific effect packet"] + #[doc = ""] + #[doc = " \\param joystick The joystick to affect"] + #[doc = " \\param data The data to send to the joystick"] + #[doc = " \\param size The size of the data to send to the joystick"] + #[doc = " \\returns 0, or -1 if this joystick or driver doesn't support effect packets"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.16."] + pub fn SDL_JoystickSendEffect( + joystick: *mut SDL_Joystick, + data: *const libc::c_void, + size: libc::c_int, + ) -> libc::c_int; +} +extern "C" { + #[doc = " Close a joystick previously opened with SDL_JoystickOpen()."] + #[doc = ""] + #[doc = " \\param joystick The joystick device to close"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_JoystickOpen"] pub fn SDL_JoystickClose(joystick: *mut SDL_Joystick); } extern "C" { - #[doc = " Return the battery level of this joystick"] + #[doc = " Get the battery level of a joystick as SDL_JoystickPowerLevel."] + #[doc = ""] + #[doc = " \\param joystick the SDL_Joystick to query"] + #[doc = " \\returns the current battery level as SDL_JoystickPowerLevel on success or"] + #[doc = " `SDL_JOYSTICK_POWER_UNKNOWN` if it is unknown"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.4."] pub fn SDL_JoystickCurrentPowerLevel(joystick: *mut SDL_Joystick) -> SDL_JoystickPowerLevel; } #[doc = " \\brief SDL_sensor.h"] @@ -10125,102 +14188,128 @@ extern "C" { #[doc = " If you are using the sensor API or handling events from multiple threads"] #[doc = " you should use these locking functions to protect access to the sensors."] #[doc = ""] - #[doc = " In particular, you are guaranteed that the sensor list won't change, so"] - #[doc = " the API functions that take a sensor index will be valid, and sensor"] - #[doc = " events will not be delivered."] + #[doc = " In particular, you are guaranteed that the sensor list won't change, so the"] + #[doc = " API functions that take a sensor index will be valid, and sensor events"] + #[doc = " will not be delivered."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.14."] pub fn SDL_LockSensors(); } extern "C" { pub fn SDL_UnlockSensors(); } extern "C" { - #[doc = " \\brief Count the number of sensors attached to the system right now"] + #[doc = " Count the number of sensors attached to the system right now."] + #[doc = ""] + #[doc = " \\returns the number of sensors detected."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.9."] pub fn SDL_NumSensors() -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the implementation dependent name of a sensor."] + #[doc = " Get the implementation dependent name of a sensor."] #[doc = ""] - #[doc = " This can be called before any sensors are opened."] + #[doc = " \\param device_index The sensor to obtain name from"] + #[doc = " \\returns the sensor name, or NULL if `device_index` is out of range."] #[doc = ""] - #[doc = " \\return The sensor name, or NULL if device_index is out of range."] + #[doc = " \\since This function is available since SDL 2.0.9."] pub fn SDL_SensorGetDeviceName(device_index: libc::c_int) -> *const libc::c_char; } extern "C" { - #[doc = " \\brief Get the type of a sensor."] + #[doc = " Get the type of a sensor."] #[doc = ""] - #[doc = " This can be called before any sensors are opened."] + #[doc = " \\param device_index The sensor to get the type from"] + #[doc = " \\returns the SDL_SensorType, or `SDL_SENSOR_INVALID` if `device_index` is"] + #[doc = " out of range."] #[doc = ""] - #[doc = " \\return The sensor type, or SDL_SENSOR_INVALID if device_index is out of range."] + #[doc = " \\since This function is available since SDL 2.0.9."] pub fn SDL_SensorGetDeviceType(device_index: libc::c_int) -> SDL_SensorType; } extern "C" { - #[doc = " \\brief Get the platform dependent type of a sensor."] + #[doc = " Get the platform dependent type of a sensor."] #[doc = ""] - #[doc = " This can be called before any sensors are opened."] + #[doc = " \\param device_index The sensor to check"] + #[doc = " \\returns the sensor platform dependent type, or -1 if `device_index` is out"] + #[doc = " of range."] #[doc = ""] - #[doc = " \\return The sensor platform dependent type, or -1 if device_index is out of range."] + #[doc = " \\since This function is available since SDL 2.0.9."] pub fn SDL_SensorGetDeviceNonPortableType(device_index: libc::c_int) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the instance ID of a sensor."] + #[doc = " Get the instance ID of a sensor."] #[doc = ""] - #[doc = " This can be called before any sensors are opened."] + #[doc = " \\param device_index The sensor to get instance id from"] + #[doc = " \\returns the sensor instance ID, or -1 if `device_index` is out of range."] #[doc = ""] - #[doc = " \\return The sensor instance ID, or -1 if device_index is out of range."] + #[doc = " \\since This function is available since SDL 2.0.9."] pub fn SDL_SensorGetDeviceInstanceID(device_index: libc::c_int) -> SDL_SensorID; } extern "C" { - #[doc = " \\brief Open a sensor for use."] + #[doc = " Open a sensor for use."] #[doc = ""] - #[doc = " The index passed as an argument refers to the N'th sensor on the system."] + #[doc = " \\param device_index The sensor to open"] + #[doc = " \\returns an SDL_Sensor sensor object, or NULL if an error occurred."] #[doc = ""] - #[doc = " \\return A sensor identifier, or NULL if an error occurred."] + #[doc = " \\since This function is available since SDL 2.0.9."] pub fn SDL_SensorOpen(device_index: libc::c_int) -> *mut SDL_Sensor; } extern "C" { #[doc = " Return the SDL_Sensor associated with an instance id."] + #[doc = ""] + #[doc = " \\param instance_id The sensor from instance id"] + #[doc = " \\returns an SDL_Sensor object."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.9."] pub fn SDL_SensorFromInstanceID(instance_id: SDL_SensorID) -> *mut SDL_Sensor; } extern "C" { - #[doc = " \\brief Get the implementation dependent name of a sensor."] + #[doc = " Get the implementation dependent name of a sensor"] #[doc = ""] - #[doc = " \\return The sensor name, or NULL if the sensor is NULL."] + #[doc = " \\param sensor The SDL_Sensor object"] + #[doc = " \\returns the sensor name, or NULL if `sensor` is NULL."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.9."] pub fn SDL_SensorGetName(sensor: *mut SDL_Sensor) -> *const libc::c_char; } extern "C" { - #[doc = " \\brief Get the type of a sensor."] + #[doc = " Get the type of a sensor."] #[doc = ""] - #[doc = " This can be called before any sensors are opened."] + #[doc = " \\param sensor The SDL_Sensor object to inspect"] + #[doc = " \\returns the SDL_SensorType type, or `SDL_SENSOR_INVALID` if `sensor` is"] + #[doc = " NULL."] #[doc = ""] - #[doc = " \\return The sensor type, or SDL_SENSOR_INVALID if the sensor is NULL."] + #[doc = " \\since This function is available since SDL 2.0.9."] pub fn SDL_SensorGetType(sensor: *mut SDL_Sensor) -> SDL_SensorType; } extern "C" { - #[doc = " \\brief Get the platform dependent type of a sensor."] + #[doc = " Get the platform dependent type of a sensor."] #[doc = ""] - #[doc = " This can be called before any sensors are opened."] + #[doc = " \\param sensor The SDL_Sensor object to inspect"] + #[doc = " \\returns the sensor platform dependent type, or -1 if `sensor` is NULL."] #[doc = ""] - #[doc = " \\return The sensor platform dependent type, or -1 if the sensor is NULL."] + #[doc = " \\since This function is available since SDL 2.0.9."] pub fn SDL_SensorGetNonPortableType(sensor: *mut SDL_Sensor) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the instance ID of a sensor."] + #[doc = " Get the instance ID of a sensor."] #[doc = ""] - #[doc = " This can be called before any sensors are opened."] + #[doc = " \\param sensor The SDL_Sensor object to inspect"] + #[doc = " \\returns the sensor instance ID, or -1 if `sensor` is NULL."] #[doc = ""] - #[doc = " \\return The sensor instance ID, or -1 if the sensor is NULL."] + #[doc = " \\since This function is available since SDL 2.0.9."] pub fn SDL_SensorGetInstanceID(sensor: *mut SDL_Sensor) -> SDL_SensorID; } extern "C" { - #[doc = " Get the current state of an opened sensor."] + #[doc = " Get the current state of an opened sensor."] #[doc = ""] - #[doc = " The number of values and interpretation of the data is sensor dependent."] + #[doc = " The number of values and interpretation of the data is sensor dependent."] #[doc = ""] - #[doc = " \\param sensor The sensor to query"] - #[doc = " \\param data A pointer filled with the current sensor state"] - #[doc = " \\param num_values The number of values to write to data"] + #[doc = " \\param sensor The SDL_Sensor object to query"] + #[doc = " \\param data A pointer filled with the current sensor state"] + #[doc = " \\param num_values The number of values to write to data"] + #[doc = " \\returns 0 or -1 if an error occurred."] #[doc = ""] - #[doc = " \\return 0 or -1 if an error occurred."] + #[doc = " \\since This function is available since SDL 2.0.9."] pub fn SDL_SensorGetData( sensor: *mut SDL_Sensor, data: *mut f32, @@ -10228,15 +14317,23 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " Close a sensor previously opened with SDL_SensorOpen()"] + #[doc = " Close a sensor previously opened with SDL_SensorOpen()."] + #[doc = ""] + #[doc = " \\param sensor The SDL_Sensor object to close"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.9."] pub fn SDL_SensorClose(sensor: *mut SDL_Sensor); } extern "C" { - #[doc = " Update the current state of the open sensors."] + #[doc = " Update the current state of the open sensors."] + #[doc = ""] + #[doc = " This is called automatically by the event loop if sensor events are"] + #[doc = " enabled."] #[doc = ""] - #[doc = " This is called automatically by the event loop if sensor events are enabled."] + #[doc = " This needs to be called from the thread that initialized the sensor"] + #[doc = " subsystem."] #[doc = ""] - #[doc = " This needs to be called from the thread that initialized the sensor subsystem."] + #[doc = " \\since This function is available since SDL 2.0.9."] pub fn SDL_SensorUpdate(); } #[doc = " The gamecontroller structure used to identify an SDL game controller"] @@ -10257,6 +14354,8 @@ pub enum SDL_GameControllerType { SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_PRO = 5, SDL_CONTROLLER_TYPE_VIRTUAL = 6, SDL_CONTROLLER_TYPE_PS5 = 7, + SDL_CONTROLLER_TYPE_AMAZON_LUNA = 8, + SDL_CONTROLLER_TYPE_GOOGLE_STADIA = 9, } #[repr(u32)] #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] @@ -10428,162 +14527,393 @@ fn bindgen_test_layout_SDL_GameControllerButtonBind() { ); } extern "C" { - #[doc = " Load a set of mappings from a seekable SDL data stream (memory or file), filtered by the current SDL_GetPlatform()"] - #[doc = " A community sourced database of controllers is available at https://raw.github.com/gabomdq/SDL_GameControllerDB/master/gamecontrollerdb.txt"] + #[doc = " Load a set of Game Controller mappings from a seekable SDL data stream."] + #[doc = ""] + #[doc = " You can call this function several times, if needed, to load different"] + #[doc = " database files."] + #[doc = ""] + #[doc = " If a new mapping is loaded for an already known controller GUID, the later"] + #[doc = " version will overwrite the one currently loaded."] #[doc = ""] - #[doc = " If \\c freerw is non-zero, the stream will be closed after being read."] + #[doc = " Mappings not belonging to the current platform or with no platform field"] + #[doc = " specified will be ignored (i.e. mappings for Linux will be ignored in"] + #[doc = " Windows, etc)."] #[doc = ""] - #[doc = " \\return number of mappings added, -1 on error"] + #[doc = " This function will load the text database entirely in memory before"] + #[doc = " processing it, so take this into consideration if you are in a memory"] + #[doc = " constrained environment."] + #[doc = ""] + #[doc = " \\param rw the data stream for the mappings to be added"] + #[doc = " \\param freerw non-zero to close the stream after being read"] + #[doc = " \\returns the number of mappings added or -1 on error; call SDL_GetError()"] + #[doc = " for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.2."] + #[doc = ""] + #[doc = " \\sa SDL_GameControllerAddMapping"] + #[doc = " \\sa SDL_GameControllerAddMappingsFromFile"] + #[doc = " \\sa SDL_GameControllerMappingForGUID"] pub fn SDL_GameControllerAddMappingsFromRW( rw: *mut SDL_RWops, freerw: libc::c_int, ) -> libc::c_int; } extern "C" { - #[doc = " Add or update an existing mapping configuration"] + #[doc = " Add support for controllers that SDL is unaware of or to cause an existing"] + #[doc = " controller to have a different binding."] + #[doc = ""] + #[doc = " The mapping string has the format \"GUID,name,mapping\", where GUID is the"] + #[doc = " string value from SDL_JoystickGetGUIDString(), name is the human readable"] + #[doc = " string for the device and mappings are controller mappings to joystick"] + #[doc = " ones. Under Windows there is a reserved GUID of \"xinput\" that covers all"] + #[doc = " XInput devices. The mapping format for joystick is: {| |bX |a joystick"] + #[doc = " button, index X |- |hX.Y |hat X with value Y |- |aX |axis X of the joystick"] + #[doc = " |} Buttons can be used as a controller axes and vice versa."] #[doc = ""] - #[doc = " \\return 1 if mapping is added, 0 if updated, -1 on error"] + #[doc = " This string shows an example of a valid mapping for a controller:"] + #[doc = ""] + #[doc = " ```c"] + #[doc = " \"341a3608000000000000504944564944,Afterglow PS3 Controller,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b8,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftshoulder:b4,rightshoulder:b5,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7\""] + #[doc = " ```"] + #[doc = ""] + #[doc = " \\param mappingString the mapping string"] + #[doc = " \\returns 1 if a new mapping is added, 0 if an existing mapping is updated,"] + #[doc = " -1 on error; call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GameControllerMapping"] + #[doc = " \\sa SDL_GameControllerMappingForGUID"] pub fn SDL_GameControllerAddMapping(mappingString: *const libc::c_char) -> libc::c_int; } extern "C" { - #[doc = " Get the number of mappings installed"] + #[doc = " Get the number of mappings installed."] #[doc = ""] - #[doc = " \\return the number of mappings"] + #[doc = " \\returns the number of mappings."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.6."] pub fn SDL_GameControllerNumMappings() -> libc::c_int; } extern "C" { - #[doc = " Get the mapping at a particular index."] + #[doc = " Get the mapping at a particular index."] + #[doc = ""] + #[doc = " \\returns the mapping string. Must be freed with SDL_free(). Returns NULL if"] + #[doc = " the index is out of range."] #[doc = ""] - #[doc = " \\return the mapping string. Must be freed with SDL_free(). Returns NULL if the index is out of range."] + #[doc = " \\since This function is available since SDL 2.0.6."] pub fn SDL_GameControllerMappingForIndex(mapping_index: libc::c_int) -> *mut libc::c_char; } extern "C" { - #[doc = " Get a mapping string for a GUID"] + #[doc = " Get the game controller mapping string for a given GUID."] + #[doc = ""] + #[doc = " The returned string must be freed with SDL_free()."] + #[doc = ""] + #[doc = " \\param guid a structure containing the GUID for which a mapping is desired"] + #[doc = " \\returns a mapping string or NULL on error; call SDL_GetError() for more"] + #[doc = " information."] #[doc = ""] - #[doc = " \\return the mapping string. Must be freed with SDL_free(). Returns NULL if no mapping is available"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_JoystickGetDeviceGUID"] + #[doc = " \\sa SDL_JoystickGetGUID"] pub fn SDL_GameControllerMappingForGUID(guid: SDL_JoystickGUID) -> *mut libc::c_char; } extern "C" { - #[doc = " Get a mapping string for an open GameController"] + #[doc = " Get the current mapping of a Game Controller."] + #[doc = ""] + #[doc = " The returned string must be freed with SDL_free()."] + #[doc = ""] + #[doc = " Details about mappings are discussed with SDL_GameControllerAddMapping()."] + #[doc = ""] + #[doc = " \\param gamecontroller the game controller you want to get the current"] + #[doc = " mapping for"] + #[doc = " \\returns a string that has the controller's mapping or NULL if no mapping"] + #[doc = " is available; call SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return the mapping string. Must be freed with SDL_free(). Returns NULL if no mapping is available"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GameControllerAddMapping"] + #[doc = " \\sa SDL_GameControllerMappingForGUID"] pub fn SDL_GameControllerMapping(gamecontroller: *mut SDL_GameController) -> *mut libc::c_char; } extern "C" { - #[doc = " Is the joystick on this index supported by the game controller interface?"] + #[doc = " Check if the given joystick is supported by the game controller interface."] + #[doc = ""] + #[doc = " `joystick_index` is the same as the `device_index` passed to"] + #[doc = " SDL_JoystickOpen()."] + #[doc = ""] + #[doc = " \\param joystick_index the device_index of a device, up to"] + #[doc = " SDL_NumJoysticks()"] + #[doc = " \\returns SDL_TRUE if the given joystick is supported by the game controller"] + #[doc = " interface, SDL_FALSE if it isn't or it's an invalid index."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GameControllerNameForIndex"] + #[doc = " \\sa SDL_GameControllerOpen"] pub fn SDL_IsGameController(joystick_index: libc::c_int) -> SDL_bool; } extern "C" { - #[doc = " Get the implementation dependent name of a game controller."] - #[doc = " This can be called before any controllers are opened."] - #[doc = " If no name can be found, this function returns NULL."] + #[doc = " Get the implementation dependent name for the game controller."] + #[doc = ""] + #[doc = " This function can be called before any controllers are opened."] + #[doc = ""] + #[doc = " `joystick_index` is the same as the `device_index` passed to"] + #[doc = " SDL_JoystickOpen()."] + #[doc = ""] + #[doc = " \\param joystick_index the device_index of a device, from zero to"] + #[doc = " SDL_NumJoysticks()-1"] + #[doc = " \\returns the implementation-dependent name for the game controller, or NULL"] + #[doc = " if there is no name or the index is invalid."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GameControllerName"] + #[doc = " \\sa SDL_GameControllerOpen"] + #[doc = " \\sa SDL_IsGameController"] pub fn SDL_GameControllerNameForIndex(joystick_index: libc::c_int) -> *const libc::c_char; } extern "C" { - #[doc = " Get the type of a game controller."] - #[doc = " This can be called before any controllers are opened."] + #[doc = " Get the type of a game controller."] + #[doc = ""] + #[doc = " This can be called before any controllers are opened."] + #[doc = ""] + #[doc = " \\param joystick_index the device_index of a device, from zero to"] + #[doc = " SDL_NumJoysticks()-1"] + #[doc = " \\returns the controller type."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.12."] pub fn SDL_GameControllerTypeForIndex(joystick_index: libc::c_int) -> SDL_GameControllerType; } extern "C" { - #[doc = " Get the mapping of a game controller."] - #[doc = " This can be called before any controllers are opened."] + #[doc = " Get the mapping of a game controller."] + #[doc = ""] + #[doc = " This can be called before any controllers are opened."] #[doc = ""] - #[doc = " \\return the mapping string. Must be freed with SDL_free(). Returns NULL if no mapping is available"] + #[doc = " \\param joystick_index the device_index of a device, from zero to"] + #[doc = " SDL_NumJoysticks()-1"] + #[doc = " \\returns the mapping string. Must be freed with SDL_free(). Returns NULL if"] + #[doc = " no mapping is available."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.9."] pub fn SDL_GameControllerMappingForDeviceIndex( joystick_index: libc::c_int, ) -> *mut libc::c_char; } extern "C" { - #[doc = " Open a game controller for use."] - #[doc = " The index passed as an argument refers to the N'th game controller on the system."] - #[doc = " This index is not the value which will identify this controller in future"] - #[doc = " controller events. The joystick's instance id (::SDL_JoystickID) will be"] - #[doc = " used there instead."] + #[doc = " Open a game controller for use."] + #[doc = ""] + #[doc = " `joystick_index` is the same as the `device_index` passed to"] + #[doc = " SDL_JoystickOpen()."] #[doc = ""] - #[doc = " \\return A controller identifier, or NULL if an error occurred."] + #[doc = " The index passed as an argument refers to the N'th game controller on the"] + #[doc = " system. This index is not the value which will identify this controller in"] + #[doc = " future controller events. The joystick's instance id (SDL_JoystickID) will"] + #[doc = " be used there instead."] + #[doc = ""] + #[doc = " \\param joystick_index the device_index of a device, up to"] + #[doc = " SDL_NumJoysticks()"] + #[doc = " \\returns a gamecontroller identifier or NULL if an error occurred; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GameControllerClose"] + #[doc = " \\sa SDL_GameControllerNameForIndex"] + #[doc = " \\sa SDL_IsGameController"] pub fn SDL_GameControllerOpen(joystick_index: libc::c_int) -> *mut SDL_GameController; } extern "C" { - #[doc = " Return the SDL_GameController associated with an instance id."] + #[doc = " Get the SDL_GameController associated with an instance id."] + #[doc = ""] + #[doc = " \\param joyid the instance id to get the SDL_GameController for"] + #[doc = " \\returns an SDL_GameController on success or NULL on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.4."] pub fn SDL_GameControllerFromInstanceID(joyid: SDL_JoystickID) -> *mut SDL_GameController; } extern "C" { - #[doc = " Return the SDL_GameController associated with a player index."] + #[doc = " Get the SDL_GameController associated with a player index."] + #[doc = ""] + #[doc = " Please note that the player index is _not_ the device index, nor is it the"] + #[doc = " instance id!"] + #[doc = ""] + #[doc = " \\param player_index the player index, which is not the device index or the"] + #[doc = " instance id!"] + #[doc = " \\returns the SDL_GameController associated with a player index."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.12."] + #[doc = ""] + #[doc = " \\sa SDL_GameControllerGetPlayerIndex"] + #[doc = " \\sa SDL_GameControllerSetPlayerIndex"] pub fn SDL_GameControllerFromPlayerIndex(player_index: libc::c_int) -> *mut SDL_GameController; } extern "C" { - #[doc = " Return the name for this currently opened controller"] + #[doc = " Get the implementation-dependent name for an opened game controller."] + #[doc = ""] + #[doc = " This is the same name as returned by SDL_GameControllerNameForIndex(), but"] + #[doc = " it takes a controller identifier instead of the (unstable) device index."] + #[doc = ""] + #[doc = " \\param gamecontroller a game controller identifier previously returned by"] + #[doc = " SDL_GameControllerOpen()"] + #[doc = " \\returns the implementation dependent name for the game controller, or NULL"] + #[doc = " if there is no name or the identifier passed is invalid."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GameControllerNameForIndex"] + #[doc = " \\sa SDL_GameControllerOpen"] pub fn SDL_GameControllerName(gamecontroller: *mut SDL_GameController) -> *const libc::c_char; } extern "C" { - #[doc = " Return the type of this currently opened controller"] + #[doc = " Get the type of this currently opened controller"] + #[doc = ""] + #[doc = " This is the same name as returned by SDL_GameControllerTypeForIndex(), but"] + #[doc = " it takes a controller identifier instead of the (unstable) device index."] + #[doc = ""] + #[doc = " \\param gamecontroller the game controller object to query."] + #[doc = " \\returns the controller type."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.12."] pub fn SDL_GameControllerGetType( gamecontroller: *mut SDL_GameController, ) -> SDL_GameControllerType; } extern "C" { - #[doc = " Get the player index of an opened game controller, or -1 if it's not available"] + #[doc = " Get the player index of an opened game controller."] #[doc = ""] - #[doc = " For XInput controllers this returns the XInput user index."] + #[doc = " For XInput controllers this returns the XInput user index."] + #[doc = ""] + #[doc = " \\param gamecontroller the game controller object to query."] + #[doc = " \\returns the player index for controller, or -1 if it's not available."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.9."] pub fn SDL_GameControllerGetPlayerIndex(gamecontroller: *mut SDL_GameController) -> libc::c_int; } extern "C" { - #[doc = " Set the player index of an opened game controller"] + #[doc = " Set the player index of an opened game controller."] + #[doc = ""] + #[doc = " \\param gamecontroller the game controller object to adjust."] + #[doc = " \\param player_index Player index to assign to this controller."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.12."] pub fn SDL_GameControllerSetPlayerIndex( gamecontroller: *mut SDL_GameController, player_index: libc::c_int, ); } extern "C" { - #[doc = " Get the USB vendor ID of an opened controller, if available."] - #[doc = " If the vendor ID isn't available this function returns 0."] + #[doc = " Get the USB vendor ID of an opened controller, if available."] + #[doc = ""] + #[doc = " If the vendor ID isn't available this function returns 0."] + #[doc = ""] + #[doc = " \\param gamecontroller the game controller object to query."] + #[doc = " \\return the USB vendor ID, or zero if unavailable."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.6."] pub fn SDL_GameControllerGetVendor(gamecontroller: *mut SDL_GameController) -> Uint16; } extern "C" { - #[doc = " Get the USB product ID of an opened controller, if available."] - #[doc = " If the product ID isn't available this function returns 0."] + #[doc = " Get the USB product ID of an opened controller, if available."] + #[doc = ""] + #[doc = " If the product ID isn't available this function returns 0."] + #[doc = ""] + #[doc = " \\param gamecontroller the game controller object to query."] + #[doc = " \\return the USB product ID, or zero if unavailable."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.6."] pub fn SDL_GameControllerGetProduct(gamecontroller: *mut SDL_GameController) -> Uint16; } extern "C" { - #[doc = " Get the product version of an opened controller, if available."] - #[doc = " If the product version isn't available this function returns 0."] + #[doc = " Get the product version of an opened controller, if available."] + #[doc = ""] + #[doc = " If the product version isn't available this function returns 0."] + #[doc = ""] + #[doc = " \\param gamecontroller the game controller object to query."] + #[doc = " \\return the USB product version, or zero if unavailable."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.6."] pub fn SDL_GameControllerGetProductVersion(gamecontroller: *mut SDL_GameController) -> Uint16; } extern "C" { - #[doc = " Get the serial number of an opened controller, if available."] + #[doc = " Get the serial number of an opened controller, if available."] + #[doc = ""] + #[doc = " Returns the serial number of the controller, or NULL if it is not"] + #[doc = " available."] #[doc = ""] - #[doc = " Returns the serial number of the controller, or NULL if it is not available."] + #[doc = " \\param gamecontroller the game controller object to query."] + #[doc = " \\return the serial number, or NULL if unavailable."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.14."] pub fn SDL_GameControllerGetSerial( gamecontroller: *mut SDL_GameController, ) -> *const libc::c_char; } extern "C" { - #[doc = " Returns SDL_TRUE if the controller has been opened and currently connected,"] - #[doc = " or SDL_FALSE if it has not."] + #[doc = " Check if a controller has been opened and is currently connected."] + #[doc = ""] + #[doc = " \\param gamecontroller a game controller identifier previously returned by"] + #[doc = " SDL_GameControllerOpen()"] + #[doc = " \\returns SDL_TRUE if the controller has been opened and is currently"] + #[doc = " connected, or SDL_FALSE if not."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GameControllerClose"] + #[doc = " \\sa SDL_GameControllerOpen"] pub fn SDL_GameControllerGetAttached(gamecontroller: *mut SDL_GameController) -> SDL_bool; } extern "C" { - #[doc = " Get the underlying joystick object used by a controller"] + #[doc = " Get the Joystick ID from a Game Controller."] + #[doc = ""] + #[doc = " This function will give you a SDL_Joystick object, which allows you to use"] + #[doc = " the SDL_Joystick functions with a SDL_GameController object. This would be"] + #[doc = " useful for getting a joystick's position at any given time, even if it"] + #[doc = " hasn't moved (moving it would produce an event, which would have the axis'"] + #[doc = " value)."] + #[doc = ""] + #[doc = " The pointer returned is owned by the SDL_GameController. You should not"] + #[doc = " call SDL_JoystickClose() on it, for example, since doing so will likely"] + #[doc = " cause SDL to crash."] + #[doc = ""] + #[doc = " \\param gamecontroller the game controller object that you want to get a"] + #[doc = " joystick from"] + #[doc = " \\returns a SDL_Joystick object; call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_GameControllerGetJoystick( gamecontroller: *mut SDL_GameController, ) -> *mut SDL_Joystick; } extern "C" { - #[doc = " Enable/disable controller event polling."] + #[doc = " Query or change current state of Game Controller events."] + #[doc = ""] + #[doc = " If controller events are disabled, you must call SDL_GameControllerUpdate()"] + #[doc = " yourself and check the state of the controller when you want controller"] + #[doc = " information."] + #[doc = ""] + #[doc = " Any number can be passed to SDL_GameControllerEventState(), but only -1, 0,"] + #[doc = " and 1 will have any effect. Other numbers will just be returned."] #[doc = ""] - #[doc = " If controller events are disabled, you must call SDL_GameControllerUpdate()"] - #[doc = " yourself and check the state of the controller when you want controller"] - #[doc = " information."] + #[doc = " \\param state can be one of `SDL_QUERY`, `SDL_IGNORE`, or `SDL_ENABLE`"] + #[doc = " \\returns the same value passed to the function, with exception to -1"] + #[doc = " (SDL_QUERY), which will return the current state."] #[doc = ""] - #[doc = " The state can be one of ::SDL_QUERY, ::SDL_ENABLE or ::SDL_IGNORE."] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_JoystickEventState"] pub fn SDL_GameControllerEventState(state: libc::c_int) -> libc::c_int; } extern "C" { - #[doc = " Update the current state of the open game controllers."] + #[doc = " Manually pump game controller updates if not using the loop."] + #[doc = ""] + #[doc = " This function is called automatically by the event loop if events are"] + #[doc = " enabled. Under such circumstances, it will not be necessary to call this"] + #[doc = " function."] #[doc = ""] - #[doc = " This is called automatically by the event loop if any game controller"] - #[doc = " events are enabled."] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_GameControllerUpdate(); } #[repr(i32)] @@ -10606,36 +14936,90 @@ pub enum SDL_GameControllerAxis { SDL_CONTROLLER_AXIS_MAX = 6, } extern "C" { - #[doc = " turn this string into a axis mapping"] - pub fn SDL_GameControllerGetAxisFromString( - pchString: *const libc::c_char, - ) -> SDL_GameControllerAxis; -} -extern "C" { - #[doc = " turn this axis enum into a string mapping"] + #[doc = " Convert a string into SDL_GameControllerAxis enum."] + #[doc = ""] + #[doc = " This function is called internally to translate SDL_GameController mapping"] + #[doc = " strings for the underlying joystick device into the consistent"] + #[doc = " SDL_GameController mapping. You do not normally need to call this function"] + #[doc = " unless you are parsing SDL_GameController mappings in your own code."] + #[doc = ""] + #[doc = " Note specially that \"righttrigger\" and \"lefttrigger\" map to"] + #[doc = " `SDL_CONTROLLER_AXIS_TRIGGERRIGHT` and `SDL_CONTROLLER_AXIS_TRIGGERLEFT`,"] + #[doc = " respectively."] + #[doc = ""] + #[doc = " \\param str string representing a SDL_GameController axis"] + #[doc = " \\returns the SDL_GameControllerAxis enum corresponding to the input string,"] + #[doc = " or `SDL_CONTROLLER_AXIS_INVALID` if no match was found."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GameControllerGetStringForAxis"] + pub fn SDL_GameControllerGetAxisFromString(str: *const libc::c_char) -> SDL_GameControllerAxis; +} +extern "C" { + #[doc = " Convert from an SDL_GameControllerAxis enum to a string."] + #[doc = ""] + #[doc = " The caller should not SDL_free() the returned string."] + #[doc = ""] + #[doc = " \\param axis an enum value for a given SDL_GameControllerAxis"] + #[doc = " \\returns a string for the given axis, or NULL if an invalid axis is"] + #[doc = " specified. The string returned is of the format used by"] + #[doc = " SDL_GameController mapping strings."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GameControllerGetAxisFromString"] pub fn SDL_GameControllerGetStringForAxis(axis: SDL_GameControllerAxis) -> *const libc::c_char; } extern "C" { - #[doc = " Get the SDL joystick layer binding for this controller button mapping"] + #[doc = " Get the SDL joystick layer binding for a controller axis mapping."] + #[doc = ""] + #[doc = " \\param gamecontroller a game controller"] + #[doc = " \\param axis an axis enum value (one of the SDL_GameControllerAxis values)"] + #[doc = " \\returns a SDL_GameControllerButtonBind describing the bind. On failure"] + #[doc = " (like the given Controller axis doesn't exist on the device), its"] + #[doc = " `.bindType` will be `SDL_CONTROLLER_BINDTYPE_NONE`."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GameControllerGetBindForButton"] pub fn SDL_GameControllerGetBindForAxis( gamecontroller: *mut SDL_GameController, axis: SDL_GameControllerAxis, ) -> SDL_GameControllerButtonBind; } extern "C" { - #[doc = " Return whether a game controller has a given axis"] + #[doc = " Query whether a game controller has a given axis."] + #[doc = ""] + #[doc = " This merely reports whether the controller's mapping defined this axis, as"] + #[doc = " that is all the information SDL has about the physical device."] + #[doc = ""] + #[doc = " \\param gamecontroller a game controller"] + #[doc = " \\param axis an axis enum value (an SDL_GameControllerAxis value)"] + #[doc = " \\returns SDL_TRUE if the controller has this axis, SDL_FALSE otherwise."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.14."] pub fn SDL_GameControllerHasAxis( gamecontroller: *mut SDL_GameController, axis: SDL_GameControllerAxis, ) -> SDL_bool; } extern "C" { - #[doc = " Get the current state of an axis control on a game controller."] + #[doc = " Get the current state of an axis control on a game controller."] + #[doc = ""] + #[doc = " The axis indices start at index 0."] + #[doc = ""] + #[doc = " The state is a value ranging from -32768 to 32767. Triggers, however, range"] + #[doc = " from 0 to 32767 (they never return a negative value)."] + #[doc = ""] + #[doc = " \\param gamecontroller a game controller"] + #[doc = " \\param axis an axis index (one of the SDL_GameControllerAxis values)"] + #[doc = " \\returns axis state (including 0) on success or 0 (also) on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " The state is a value ranging from -32768 to 32767 (except for the triggers,"] - #[doc = " which range from 0 to 32767)."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " The axis indices start at index 0."] + #[doc = " \\sa SDL_GameControllerGetButton"] pub fn SDL_GameControllerGetAxis( gamecontroller: *mut SDL_GameController, axis: SDL_GameControllerAxis, @@ -10670,55 +15054,110 @@ pub enum SDL_GameControllerButton { SDL_CONTROLLER_BUTTON_MAX = 21, } extern "C" { - #[doc = " turn this string into a button mapping"] + #[doc = " Convert a string into an SDL_GameControllerButton enum."] + #[doc = ""] + #[doc = " This function is called internally to translate SDL_GameController mapping"] + #[doc = " strings for the underlying joystick device into the consistent"] + #[doc = " SDL_GameController mapping. You do not normally need to call this function"] + #[doc = " unless you are parsing SDL_GameController mappings in your own code."] + #[doc = ""] + #[doc = " \\param str string representing a SDL_GameController axis"] + #[doc = " \\returns the SDL_GameControllerButton enum corresponding to the input"] + #[doc = " string, or `SDL_CONTROLLER_AXIS_INVALID` if no match was found."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_GameControllerGetButtonFromString( - pchString: *const libc::c_char, + str: *const libc::c_char, ) -> SDL_GameControllerButton; } extern "C" { - #[doc = " turn this button enum into a string mapping"] + #[doc = " Convert from an SDL_GameControllerButton enum to a string."] + #[doc = ""] + #[doc = " The caller should not SDL_free() the returned string."] + #[doc = ""] + #[doc = " \\param button an enum value for a given SDL_GameControllerButton"] + #[doc = " \\returns a string for the given button, or NULL if an invalid axis is"] + #[doc = " specified. The string returned is of the format used by"] + #[doc = " SDL_GameController mapping strings."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GameControllerGetButtonFromString"] pub fn SDL_GameControllerGetStringForButton( button: SDL_GameControllerButton, ) -> *const libc::c_char; } extern "C" { - #[doc = " Get the SDL joystick layer binding for this controller button mapping"] + #[doc = " Get the SDL joystick layer binding for a controller button mapping."] + #[doc = ""] + #[doc = " \\param gamecontroller a game controller"] + #[doc = " \\param button an button enum value (an SDL_GameControllerButton value)"] + #[doc = " \\returns a SDL_GameControllerButtonBind describing the bind. On failure"] + #[doc = " (like the given Controller button doesn't exist on the device),"] + #[doc = " its `.bindType` will be `SDL_CONTROLLER_BINDTYPE_NONE`."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GameControllerGetBindForAxis"] pub fn SDL_GameControllerGetBindForButton( gamecontroller: *mut SDL_GameController, button: SDL_GameControllerButton, ) -> SDL_GameControllerButtonBind; } extern "C" { - #[doc = " Return whether a game controller has a given button"] + #[doc = " Query whether a game controller has a given button."] + #[doc = ""] + #[doc = " This merely reports whether the controller's mapping defined this button,"] + #[doc = " as that is all the information SDL has about the physical device."] + #[doc = ""] + #[doc = " \\param gamecontroller a game controller"] + #[doc = " \\param button a button enum value (an SDL_GameControllerButton value)"] + #[doc = " \\returns SDL_TRUE if the controller has this button, SDL_FALSE otherwise."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.14."] pub fn SDL_GameControllerHasButton( gamecontroller: *mut SDL_GameController, button: SDL_GameControllerButton, ) -> SDL_bool; } extern "C" { - #[doc = " Get the current state of a button on a game controller."] + #[doc = " Get the current state of a button on a game controller."] + #[doc = ""] + #[doc = " \\param gamecontroller a game controller"] + #[doc = " \\param button a button index (one of the SDL_GameControllerButton values)"] + #[doc = " \\returns 1 for pressed state or 0 for not pressed state or error; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " The button indices start at index 0."] + #[doc = " \\sa SDL_GameControllerGetAxis"] pub fn SDL_GameControllerGetButton( gamecontroller: *mut SDL_GameController, button: SDL_GameControllerButton, ) -> Uint8; } extern "C" { - #[doc = " Get the number of touchpads on a game controller."] + #[doc = " Get the number of touchpads on a game controller."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.14."] pub fn SDL_GameControllerGetNumTouchpads( gamecontroller: *mut SDL_GameController, ) -> libc::c_int; } extern "C" { - #[doc = " Get the number of supported simultaneous fingers on a touchpad on a game controller."] + #[doc = " Get the number of supported simultaneous fingers on a touchpad on a game"] + #[doc = " controller."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.14."] pub fn SDL_GameControllerGetNumTouchpadFingers( gamecontroller: *mut SDL_GameController, touchpad: libc::c_int, ) -> libc::c_int; } extern "C" { - #[doc = " Get the current state of a finger on a touchpad on a game controller."] + #[doc = " Get the current state of a finger on a touchpad on a game controller."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.14."] pub fn SDL_GameControllerGetTouchpadFinger( gamecontroller: *mut SDL_GameController, touchpad: libc::c_int, @@ -10730,25 +15169,27 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " Return whether a game controller has a particular sensor."] + #[doc = " Return whether a game controller has a particular sensor."] #[doc = ""] - #[doc = " \\param gamecontroller The controller to query"] - #[doc = " \\param type The type of sensor to query"] + #[doc = " \\param gamecontroller The controller to query"] + #[doc = " \\param type The type of sensor to query"] + #[doc = " \\returns SDL_TRUE if the sensor exists, SDL_FALSE otherwise."] #[doc = ""] - #[doc = " \\return SDL_TRUE if the sensor exists, SDL_FALSE otherwise."] + #[doc = " \\since This function is available since SDL 2.0.14."] pub fn SDL_GameControllerHasSensor( gamecontroller: *mut SDL_GameController, type_: SDL_SensorType, ) -> SDL_bool; } extern "C" { - #[doc = " Set whether data reporting for a game controller sensor is enabled"] + #[doc = " Set whether data reporting for a game controller sensor is enabled."] #[doc = ""] - #[doc = " \\param gamecontroller The controller to update"] - #[doc = " \\param type The type of sensor to enable/disable"] - #[doc = " \\param enabled Whether data reporting should be enabled"] + #[doc = " \\param gamecontroller The controller to update"] + #[doc = " \\param type The type of sensor to enable/disable"] + #[doc = " \\param enabled Whether data reporting should be enabled"] + #[doc = " \\returns 0 or -1 if an error occurred."] #[doc = ""] - #[doc = " \\return 0 or -1 if an error occurred."] + #[doc = " \\since This function is available since SDL 2.0.14."] pub fn SDL_GameControllerSetSensorEnabled( gamecontroller: *mut SDL_GameController, type_: SDL_SensorType, @@ -10756,29 +15197,45 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " Query whether sensor data reporting is enabled for a game controller"] + #[doc = " Query whether sensor data reporting is enabled for a game controller."] #[doc = ""] - #[doc = " \\param gamecontroller The controller to query"] - #[doc = " \\param type The type of sensor to query"] + #[doc = " \\param gamecontroller The controller to query"] + #[doc = " \\param type The type of sensor to query"] + #[doc = " \\returns SDL_TRUE if the sensor is enabled, SDL_FALSE otherwise."] #[doc = ""] - #[doc = " \\return SDL_TRUE if the sensor is enabled, SDL_FALSE otherwise."] + #[doc = " \\since This function is available since SDL 2.0.14."] pub fn SDL_GameControllerIsSensorEnabled( gamecontroller: *mut SDL_GameController, type_: SDL_SensorType, ) -> SDL_bool; } extern "C" { - #[doc = " Get the current state of a game controller sensor."] + #[doc = " Get the data rate (number of events per second) of a game controller"] + #[doc = " sensor."] + #[doc = ""] + #[doc = " \\param gamecontroller The controller to query"] + #[doc = " \\param type The type of sensor to query"] + #[doc = " \\return the data rate, or 0.0f if the data rate is not available."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.16."] + pub fn SDL_GameControllerGetSensorDataRate( + gamecontroller: *mut SDL_GameController, + type_: SDL_SensorType, + ) -> f32; +} +extern "C" { + #[doc = " Get the current state of a game controller sensor."] #[doc = ""] - #[doc = " The number of values and interpretation of the data is sensor dependent."] - #[doc = " See SDL_sensor.h for the details for each type of sensor."] + #[doc = " The number of values and interpretation of the data is sensor dependent."] + #[doc = " See SDL_sensor.h for the details for each type of sensor."] #[doc = ""] - #[doc = " \\param gamecontroller The controller to query"] - #[doc = " \\param type The type of sensor to query"] - #[doc = " \\param data A pointer filled with the current sensor state"] - #[doc = " \\param num_values The number of values to write to data"] + #[doc = " \\param gamecontroller The controller to query"] + #[doc = " \\param type The type of sensor to query"] + #[doc = " \\param data A pointer filled with the current sensor state"] + #[doc = " \\param num_values The number of values to write to data"] + #[doc = " \\return 0 or -1 if an error occurred."] #[doc = ""] - #[doc = " \\return 0 or -1 if an error occurred."] + #[doc = " \\since This function is available since SDL 2.0.14."] pub fn SDL_GameControllerGetSensorData( gamecontroller: *mut SDL_GameController, type_: SDL_SensorType, @@ -10787,15 +15244,22 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " Start a rumble effect"] - #[doc = " Each call to this function cancels any previous rumble effect, and calling it with 0 intensity stops any rumbling."] + #[doc = " Start a rumble effect on a game controller."] + #[doc = ""] + #[doc = " Each call to this function cancels any previous rumble effect, and calling"] + #[doc = " it with 0 intensity stops any rumbling."] #[doc = ""] - #[doc = " \\param gamecontroller The controller to vibrate"] - #[doc = " \\param low_frequency_rumble The intensity of the low frequency (left) rumble motor, from 0 to 0xFFFF"] - #[doc = " \\param high_frequency_rumble The intensity of the high frequency (right) rumble motor, from 0 to 0xFFFF"] - #[doc = " \\param duration_ms The duration of the rumble effect, in milliseconds"] + #[doc = " \\param gamecontroller The controller to vibrate"] + #[doc = " \\param low_frequency_rumble The intensity of the low frequency (left)"] + #[doc = " rumble motor, from 0 to 0xFFFF"] + #[doc = " \\param high_frequency_rumble The intensity of the high frequency (right)"] + #[doc = " rumble motor, from 0 to 0xFFFF"] + #[doc = " \\param duration_ms The duration of the rumble effect, in milliseconds"] + #[doc = " \\returns 0, or -1 if rumble isn't supported on this controller"] #[doc = ""] - #[doc = " \\return 0, or -1 if rumble isn't supported on this controller"] + #[doc = " \\since This function is available since SDL 2.0.9."] + #[doc = ""] + #[doc = " \\sa SDL_GameControllerHasRumble"] pub fn SDL_GameControllerRumble( gamecontroller: *mut SDL_GameController, low_frequency_rumble: Uint16, @@ -10804,15 +15268,26 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " Start a rumble effect in the game controller's triggers"] - #[doc = " Each call to this function cancels any previous trigger rumble effect, and calling it with 0 intensity stops any rumbling."] + #[doc = " Start a rumble effect in the game controller's triggers."] + #[doc = ""] + #[doc = " Each call to this function cancels any previous trigger rumble effect, and"] + #[doc = " calling it with 0 intensity stops any rumbling."] #[doc = ""] - #[doc = " \\param gamecontroller The controller to vibrate"] - #[doc = " \\param left_rumble The intensity of the left trigger rumble motor, from 0 to 0xFFFF"] - #[doc = " \\param right_rumble The intensity of the right trigger rumble motor, from 0 to 0xFFFF"] - #[doc = " \\param duration_ms The duration of the rumble effect, in milliseconds"] + #[doc = " Note that this is rumbling of the _triggers_ and not the game controller as"] + #[doc = " a whole. The first controller to offer this feature was the PlayStation 5's"] + #[doc = " DualShock 5."] #[doc = ""] - #[doc = " \\return 0, or -1 if rumble isn't supported on this controller"] + #[doc = " \\param gamecontroller The controller to vibrate"] + #[doc = " \\param left_rumble The intensity of the left trigger rumble motor, from 0"] + #[doc = " to 0xFFFF"] + #[doc = " \\param right_rumble The intensity of the right trigger rumble motor, from 0"] + #[doc = " to 0xFFFF"] + #[doc = " \\param duration_ms The duration of the rumble effect, in milliseconds"] + #[doc = " \\returns 0, or -1 if trigger rumble isn't supported on this controller"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.14."] + #[doc = ""] + #[doc = " \\sa SDL_GameControllerHasRumbleTriggers"] pub fn SDL_GameControllerRumbleTriggers( gamecontroller: *mut SDL_GameController, left_rumble: Uint16, @@ -10821,22 +15296,50 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " Return whether a controller has an LED"] + #[doc = " Query whether a game controller has an LED."] #[doc = ""] - #[doc = " \\param gamecontroller The controller to query"] + #[doc = " \\param gamecontroller The controller to query"] + #[doc = " \\returns SDL_TRUE, or SDL_FALSE if this controller does not have a"] + #[doc = " modifiable LED"] #[doc = ""] - #[doc = " \\return SDL_TRUE, or SDL_FALSE if this controller does not have a modifiable LED"] + #[doc = " \\since This function is available since SDL 2.0.14."] pub fn SDL_GameControllerHasLED(gamecontroller: *mut SDL_GameController) -> SDL_bool; } extern "C" { - #[doc = " Update a controller's LED color."] + #[doc = " Query whether a game controller has rumble support."] + #[doc = ""] + #[doc = " \\param gamecontroller The controller to query"] + #[doc = " \\returns SDL_TRUE, or SDL_FALSE if this controller does not have rumble"] + #[doc = " support"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.18."] + #[doc = ""] + #[doc = " \\sa SDL_GameControllerRumble"] + pub fn SDL_GameControllerHasRumble(gamecontroller: *mut SDL_GameController) -> SDL_bool; +} +extern "C" { + #[doc = " Query whether a game controller has rumble support on triggers."] + #[doc = ""] + #[doc = " \\param gamecontroller The controller to query"] + #[doc = " \\returns SDL_TRUE, or SDL_FALSE if this controller does not have trigger"] + #[doc = " rumble support"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.18."] + #[doc = ""] + #[doc = " \\sa SDL_GameControllerRumbleTriggers"] + pub fn SDL_GameControllerHasRumbleTriggers(gamecontroller: *mut SDL_GameController) + -> SDL_bool; +} +extern "C" { + #[doc = " Update a game controller's LED color."] #[doc = ""] - #[doc = " \\param gamecontroller The controller to update"] - #[doc = " \\param red The intensity of the red LED"] - #[doc = " \\param green The intensity of the green LED"] - #[doc = " \\param blue The intensity of the blue LED"] + #[doc = " \\param gamecontroller The controller to update"] + #[doc = " \\param red The intensity of the red LED"] + #[doc = " \\param green The intensity of the green LED"] + #[doc = " \\param blue The intensity of the blue LED"] + #[doc = " \\returns 0, or -1 if this controller does not have a modifiable LED"] #[doc = ""] - #[doc = " \\return 0, or -1 if this controller does not have a modifiable LED"] + #[doc = " \\since This function is available since SDL 2.0.14."] pub fn SDL_GameControllerSetLED( gamecontroller: *mut SDL_GameController, red: Uint8, @@ -10845,9 +15348,64 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " Close a controller previously opened with SDL_GameControllerOpen()."] + #[doc = " Send a controller specific effect packet"] + #[doc = ""] + #[doc = " \\param gamecontroller The controller to affect"] + #[doc = " \\param data The data to send to the controller"] + #[doc = " \\param size The size of the data to send to the controller"] + #[doc = " \\returns 0, or -1 if this controller or driver doesn't support effect"] + #[doc = " packets"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.16."] + pub fn SDL_GameControllerSendEffect( + gamecontroller: *mut SDL_GameController, + data: *const libc::c_void, + size: libc::c_int, + ) -> libc::c_int; +} +extern "C" { + #[doc = " Close a game controller previously opened with SDL_GameControllerOpen()."] + #[doc = ""] + #[doc = " \\param gamecontroller a game controller identifier previously returned by"] + #[doc = " SDL_GameControllerOpen()"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GameControllerOpen"] pub fn SDL_GameControllerClose(gamecontroller: *mut SDL_GameController); } +extern "C" { + #[doc = " Return the sfSymbolsName for a given button on a game controller on Apple"] + #[doc = " platforms."] + #[doc = ""] + #[doc = " \\param gamecontroller the controller to query"] + #[doc = " \\param button a button on the game controller"] + #[doc = " \\returns the sfSymbolsName or NULL if the name can't be found"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.18."] + #[doc = ""] + #[doc = " \\sa SDL_GameControllerGetAppleSFSymbolsNameForAxis"] + pub fn SDL_GameControllerGetAppleSFSymbolsNameForButton( + gamecontroller: *mut SDL_GameController, + button: SDL_GameControllerButton, + ) -> *const libc::c_char; +} +extern "C" { + #[doc = " Return the sfSymbolsName for a given axis on a game controller on Apple"] + #[doc = " platforms."] + #[doc = ""] + #[doc = " \\param gamecontroller the controller to query"] + #[doc = " \\param axis an axis on the game controller"] + #[doc = " \\returns the sfSymbolsName or NULL if the name can't be found"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.18."] + #[doc = ""] + #[doc = " \\sa SDL_GameControllerGetAppleSFSymbolsNameForButton"] + pub fn SDL_GameControllerGetAppleSFSymbolsNameForAxis( + gamecontroller: *mut SDL_GameController, + axis: SDL_GameControllerAxis, + ) -> *const libc::c_char; +} pub type SDL_TouchID = Sint64; pub type SDL_FingerID = Sint64; #[repr(i32)] @@ -10920,52 +15478,125 @@ fn bindgen_test_layout_SDL_Finger() { ); } extern "C" { - #[doc = " \\brief Get the number of registered touch devices."] + #[doc = " Get the number of registered touch devices."] + #[doc = ""] + #[doc = " On some platforms SDL first sees the touch device if it was actually used."] + #[doc = " Therefore SDL_GetNumTouchDevices() may return 0 although devices are"] + #[doc = " available. After using all devices at least once the number will be"] + #[doc = " correct."] + #[doc = ""] + #[doc = " This was fixed for Android in SDL 2.0.1."] + #[doc = ""] + #[doc = " \\returns the number of registered touch devices."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetTouchDevice"] pub fn SDL_GetNumTouchDevices() -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the touch ID with the given index, or 0 if the index is invalid."] + #[doc = " Get the touch ID with the given index."] + #[doc = ""] + #[doc = " \\param index the touch device index"] + #[doc = " \\returns the touch ID with the given index on success or 0 if the index is"] + #[doc = " invalid; call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetNumTouchDevices"] pub fn SDL_GetTouchDevice(index: libc::c_int) -> SDL_TouchID; } extern "C" { - #[doc = " \\brief Get the type of the given touch device."] + #[doc = " Get the type of the given touch device."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.10."] pub fn SDL_GetTouchDeviceType(touchID: SDL_TouchID) -> SDL_TouchDeviceType; } extern "C" { - #[doc = " \\brief Get the number of active fingers for a given touch device."] + #[doc = " Get the number of active fingers for a given touch device."] + #[doc = ""] + #[doc = " \\param touchID the ID of a touch device"] + #[doc = " \\returns the number of active fingers for a given touch device on success"] + #[doc = " or 0 on failure; call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetTouchFinger"] pub fn SDL_GetNumTouchFingers(touchID: SDL_TouchID) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the finger object of the given touch, with the given index."] + #[doc = " Get the finger object for specified touch device ID and finger index."] + #[doc = ""] + #[doc = " The returned resource is owned by SDL and should not be deallocated."] + #[doc = ""] + #[doc = " \\param touchID the ID of the requested touch device"] + #[doc = " \\param index the index of the requested finger"] + #[doc = " \\returns a pointer to the SDL_Finger object or NULL if no object at the"] + #[doc = " given ID and index could be found."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_RecordGesture"] pub fn SDL_GetTouchFinger(touchID: SDL_TouchID, index: libc::c_int) -> *mut SDL_Finger; } pub type SDL_GestureID = Sint64; extern "C" { - #[doc = " \\brief Begin Recording a gesture on the specified touch, or all touches (-1)"] + #[doc = " Begin recording a gesture on a specified touch device or all touch devices."] + #[doc = ""] + #[doc = " If the parameter `touchId` is -1 (i.e., all devices), this function will"] + #[doc = " always return 1, regardless of whether there actually are any devices."] + #[doc = ""] + #[doc = " \\param touchId the touch device id, or -1 for all touch devices"] + #[doc = " \\returns 1 on success or 0 if the specified device could not be found."] #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] + #[doc = " \\sa SDL_GetTouchDevice"] pub fn SDL_RecordGesture(touchId: SDL_TouchID) -> libc::c_int; } extern "C" { - #[doc = " \\brief Save all currently loaded Dollar Gesture templates"] + #[doc = " Save all currently loaded Dollar Gesture templates."] #[doc = ""] + #[doc = " \\param dst a SDL_RWops to save to"] + #[doc = " \\returns the number of saved templates on success or 0 on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_LoadDollarTemplates"] + #[doc = " \\sa SDL_SaveDollarTemplate"] pub fn SDL_SaveAllDollarTemplates(dst: *mut SDL_RWops) -> libc::c_int; } extern "C" { - #[doc = " \\brief Save a currently loaded Dollar Gesture template"] + #[doc = " Save a currently loaded Dollar Gesture template."] + #[doc = ""] + #[doc = " \\param gestureId a gesture id"] + #[doc = " \\param dst a SDL_RWops to save to"] + #[doc = " \\returns 1 on success or 0 on failure; call SDL_GetError() for more"] + #[doc = " information."] #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] + #[doc = " \\sa SDL_LoadDollarTemplates"] + #[doc = " \\sa SDL_SaveAllDollarTemplates"] pub fn SDL_SaveDollarTemplate(gestureId: SDL_GestureID, dst: *mut SDL_RWops) -> libc::c_int; } extern "C" { - #[doc = " \\brief Load Dollar Gesture templates from a file"] + #[doc = " Load Dollar Gesture templates from a file."] #[doc = ""] + #[doc = " \\param touchId a touch id"] + #[doc = " \\param src a SDL_RWops to load from"] + #[doc = " \\returns the number of loaded templates on success or a negative error code"] + #[doc = " (or 0) on failure; call SDL_GetError() for more information."] #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_SaveAllDollarTemplates"] + #[doc = " \\sa SDL_SaveDollarTemplate"] pub fn SDL_LoadDollarTemplates(touchId: SDL_TouchID, src: *mut SDL_RWops) -> libc::c_int; } #[repr(u32)] -#[doc = " \\brief The types of events that can be delivered."] +#[doc = " The types of events that can be delivered."] #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub enum SDL_EventType { #[doc = "< Unused (do not remove)"] @@ -11083,6 +15714,8 @@ pub enum SDL_EventType { SDL_RENDER_TARGETS_RESET = 8192, #[doc = "< The device has been reset and all textures need to be recreated"] SDL_RENDER_DEVICE_RESET = 8193, + #[doc = "< Signals the end of an event poll cycle"] + SDL_POLLSENTINEL = 32512, #[doc = " Events ::SDL_USEREVENT through ::SDL_LASTEVENT are for your use,"] #[doc = " and should be allocated with SDL_RegisterEvents()"] SDL_USEREVENT = 32768, @@ -11913,12 +16546,16 @@ pub struct SDL_MouseWheelEvent { pub y: Sint32, #[doc = "< Set to one of the SDL_MOUSEWHEEL_* defines. When FLIPPED the values in X and Y will be opposite. Multiply by -1 to change them back"] pub direction: Uint32, + #[doc = "< The amount scrolled horizontally, positive to the right and negative to the left, with float precision (added in 2.0.18)"] + pub preciseX: f32, + #[doc = "< The amount scrolled vertically, positive away from the user and negative toward the user, with float precision (added in 2.0.18)"] + pub preciseY: f32, } #[test] fn bindgen_test_layout_SDL_MouseWheelEvent() { assert_eq!( ::core::mem::size_of::(), - 28usize, + 36usize, concat!("Size of: ", stringify!(SDL_MouseWheelEvent)) ); assert_eq!( @@ -11996,6 +16633,26 @@ fn bindgen_test_layout_SDL_MouseWheelEvent() { stringify!(direction) ) ); + assert_eq!( + unsafe { &(*(::core::ptr::null::())).preciseX as *const _ as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(SDL_MouseWheelEvent), + "::", + stringify!(preciseX) + ) + ); + assert_eq!( + unsafe { &(*(::core::ptr::null::())).preciseY as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(SDL_MouseWheelEvent), + "::", + stringify!(preciseY) + ) + ); } #[doc = " \\brief Joystick axis motion event structure (event.jaxis.*)"] #[repr(C)] @@ -14241,11 +18898,26 @@ fn bindgen_test_layout_SDL_Event() { } pub type SDL_compile_time_assert_SDL_Event = [libc::c_int; 1usize]; extern "C" { - #[doc = " Pumps the event loop, gathering events from the input devices."] + #[doc = " Pump the event loop, gathering events from the input devices."] + #[doc = ""] + #[doc = " This function updates the event queue and internal input device state."] + #[doc = ""] + #[doc = " **WARNING**: This should only be run in the thread that initialized the"] + #[doc = " video subsystem, and for extra safety, you should consider only doing those"] + #[doc = " things on the main thread in any case."] + #[doc = ""] + #[doc = " SDL_PumpEvents() gathers all the pending input information from devices and"] + #[doc = " places it in the event queue. Without calls to SDL_PumpEvents() no events"] + #[doc = " would ever be placed on the queue. Often the need for calls to"] + #[doc = " SDL_PumpEvents() is hidden from the user since SDL_PollEvent() and"] + #[doc = " SDL_WaitEvent() implicitly call SDL_PumpEvents(). However, if you are not"] + #[doc = " polling or waiting for events (e.g. you are filtering them), then you must"] + #[doc = " call SDL_PumpEvents() to force an event queue update."] #[doc = ""] - #[doc = " This function updates the event queue and internal input device state."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " This should only be run in the thread that sets the video mode."] + #[doc = " \\sa SDL_PollEvent"] + #[doc = " \\sa SDL_WaitEvent"] pub fn SDL_PumpEvents(); } #[repr(u32)] @@ -14256,22 +18928,42 @@ pub enum SDL_eventaction { SDL_GETEVENT = 2, } extern "C" { - #[doc = " Checks the event queue for messages and optionally returns them."] + #[doc = " Check the event queue for messages and optionally return them."] #[doc = ""] - #[doc = " If \\c action is ::SDL_ADDEVENT, up to \\c numevents events will be added to"] - #[doc = " the back of the event queue."] + #[doc = " `action` may be any of the following:"] #[doc = ""] - #[doc = " If \\c action is ::SDL_PEEKEVENT, up to \\c numevents events at the front"] - #[doc = " of the event queue, within the specified minimum and maximum type,"] - #[doc = " will be returned and will not be removed from the queue."] + #[doc = " - `SDL_ADDEVENT`: up to `numevents` events will be added to the back of the"] + #[doc = " event queue."] + #[doc = " - `SDL_PEEKEVENT`: `numevents` events at the front of the event queue,"] + #[doc = " within the specified minimum and maximum type, will be returned to the"] + #[doc = " caller and will _not_ be removed from the queue."] + #[doc = " - `SDL_GETEVENT`: up to `numevents` events at the front of the event queue,"] + #[doc = " within the specified minimum and maximum type, will be returned to the"] + #[doc = " caller and will be removed from the queue."] #[doc = ""] - #[doc = " If \\c action is ::SDL_GETEVENT, up to \\c numevents events at the front"] - #[doc = " of the event queue, within the specified minimum and maximum type,"] - #[doc = " will be returned and will be removed from the queue."] + #[doc = " You may have to call SDL_PumpEvents() before calling this function."] + #[doc = " Otherwise, the events may not be ready to be filtered when you call"] + #[doc = " SDL_PeepEvents()."] #[doc = ""] - #[doc = " \\return The number of events actually stored, or -1 if there was an error."] + #[doc = " This function is thread-safe."] #[doc = ""] - #[doc = " This function is thread-safe."] + #[doc = " \\param events destination buffer for the retrieved events"] + #[doc = " \\param numevents if action is SDL_ADDEVENT, the number of events to add"] + #[doc = " back to the event queue; if action is SDL_PEEKEVENT or"] + #[doc = " SDL_GETEVENT, the maximum number of events to retrieve"] + #[doc = " \\param action action to take; see [[#action|Remarks]] for details"] + #[doc = " \\param minType minimum value of the event type to be considered;"] + #[doc = " SDL_FIRSTEVENT is a safe choice"] + #[doc = " \\param maxType maximum value of the event type to be considered;"] + #[doc = " SDL_LASTEVENT is a safe choice"] + #[doc = " \\returns the number of events actually stored or a negative error code on"] + #[doc = " failure; call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_PollEvent"] + #[doc = " \\sa SDL_PumpEvents"] + #[doc = " \\sa SDL_PushEvent"] pub fn SDL_PeepEvents( events: *mut SDL_Event, numevents: libc::c_int, @@ -14281,208 +18973,470 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " Checks to see if certain event types are in the event queue."] + #[doc = " Check for the existence of a certain event type in the event queue."] + #[doc = ""] + #[doc = " If you need to check for a range of event types, use SDL_HasEvents()"] + #[doc = " instead."] + #[doc = ""] + #[doc = " \\param type the type of event to be queried; see SDL_EventType for details"] + #[doc = " \\returns SDL_TRUE if events matching `type` are present, or SDL_FALSE if"] + #[doc = " events matching `type` are not present."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HasEvents"] pub fn SDL_HasEvent(type_: Uint32) -> SDL_bool; } extern "C" { + #[doc = " Check for the existence of certain event types in the event queue."] + #[doc = ""] + #[doc = " If you need to check for a single event type, use SDL_HasEvent() instead."] + #[doc = ""] + #[doc = " \\param minType the low end of event type to be queried, inclusive; see"] + #[doc = " SDL_EventType for details"] + #[doc = " \\param maxType the high end of event type to be queried, inclusive; see"] + #[doc = " SDL_EventType for details"] + #[doc = " \\returns SDL_TRUE if events with type >= `minType` and <= `maxType` are"] + #[doc = " present, or SDL_FALSE if not."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HasEvents"] pub fn SDL_HasEvents(minType: Uint32, maxType: Uint32) -> SDL_bool; } extern "C" { - #[doc = " This function clears events from the event queue"] - #[doc = " This function only affects currently queued events. If you want to make"] - #[doc = " sure that all pending OS events are flushed, you can call SDL_PumpEvents()"] - #[doc = " on the main thread immediately before the flush call."] + #[doc = " Clear events of a specific type from the event queue."] + #[doc = ""] + #[doc = " This will unconditionally remove any events from the queue that match"] + #[doc = " `type`. If you need to remove a range of event types, use SDL_FlushEvents()"] + #[doc = " instead."] + #[doc = ""] + #[doc = " It's also normal to just ignore events you don't care about in your event"] + #[doc = " loop without calling this function."] + #[doc = ""] + #[doc = " This function only affects currently queued events. If you want to make"] + #[doc = " sure that all pending OS events are flushed, you can call SDL_PumpEvents()"] + #[doc = " on the main thread immediately before the flush call."] + #[doc = ""] + #[doc = " \\param type the type of event to be cleared; see SDL_EventType for details"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_FlushEvents"] pub fn SDL_FlushEvent(type_: Uint32); } extern "C" { + #[doc = " Clear events of a range of types from the event queue."] + #[doc = ""] + #[doc = " This will unconditionally remove any events from the queue that are in the"] + #[doc = " range of `minType` to `maxType`, inclusive. If you need to remove a single"] + #[doc = " event type, use SDL_FlushEvent() instead."] + #[doc = ""] + #[doc = " It's also normal to just ignore events you don't care about in your event"] + #[doc = " loop without calling this function."] + #[doc = ""] + #[doc = " This function only affects currently queued events. If you want to make"] + #[doc = " sure that all pending OS events are flushed, you can call SDL_PumpEvents()"] + #[doc = " on the main thread immediately before the flush call."] + #[doc = ""] + #[doc = " \\param minType the low end of event type to be cleared, inclusive; see"] + #[doc = " SDL_EventType for details"] + #[doc = " \\param maxType the high end of event type to be cleared, inclusive; see"] + #[doc = " SDL_EventType for details"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_FlushEvent"] pub fn SDL_FlushEvents(minType: Uint32, maxType: Uint32); } extern "C" { - #[doc = " \\brief Polls for currently pending events."] + #[doc = " Poll for currently pending events."] + #[doc = ""] + #[doc = " If `event` is not NULL, the next event is removed from the queue and stored"] + #[doc = " in the SDL_Event structure pointed to by `event`. The 1 returned refers to"] + #[doc = " this event, immediately stored in the SDL Event structure -- not an event"] + #[doc = " to follow."] + #[doc = ""] + #[doc = " If `event` is NULL, it simply returns 1 if there is an event in the queue,"] + #[doc = " but will not remove it from the queue."] #[doc = ""] - #[doc = " \\return 1 if there are any pending events, or 0 if there are none available."] + #[doc = " As this function may implicitly call SDL_PumpEvents(), you can only call"] + #[doc = " this function in the thread that set the video mode."] #[doc = ""] - #[doc = " \\param event If not NULL, the next event is removed from the queue and"] - #[doc = " stored in that area."] + #[doc = " SDL_PollEvent() is the favored way of receiving system events since it can"] + #[doc = " be done from the main loop and does not suspend the main loop while waiting"] + #[doc = " on an event to be posted."] + #[doc = ""] + #[doc = " The common practice is to fully process the event queue once every frame,"] + #[doc = " usually as a first step before updating the game's state:"] + #[doc = ""] + #[doc = " ```c"] + #[doc = " while (game_is_still_running) {"] + #[doc = " SDL_Event event;"] + #[doc = " while (SDL_PollEvent(&event)) { // poll until all events are handled!"] + #[doc = " // decide what to do with this event."] + #[doc = " }"] + #[doc = ""] + #[doc = " // update game state, draw the current frame"] + #[doc = " }"] + #[doc = " ```"] + #[doc = ""] + #[doc = " \\param event the SDL_Event structure to be filled with the next event from"] + #[doc = " the queue, or NULL"] + #[doc = " \\returns 1 if there is a pending event or 0 if there are none available."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetEventFilter"] + #[doc = " \\sa SDL_PeepEvents"] + #[doc = " \\sa SDL_PushEvent"] + #[doc = " \\sa SDL_SetEventFilter"] + #[doc = " \\sa SDL_WaitEvent"] + #[doc = " \\sa SDL_WaitEventTimeout"] pub fn SDL_PollEvent(event: *mut SDL_Event) -> libc::c_int; } extern "C" { - #[doc = " \\brief Waits indefinitely for the next available event."] + #[doc = " Wait indefinitely for the next available event."] + #[doc = ""] + #[doc = " If `event` is not NULL, the next event is removed from the queue and stored"] + #[doc = " in the SDL_Event structure pointed to by `event`."] + #[doc = ""] + #[doc = " As this function may implicitly call SDL_PumpEvents(), you can only call"] + #[doc = " this function in the thread that initialized the video subsystem."] #[doc = ""] - #[doc = " \\return 1, or 0 if there was an error while waiting for events."] + #[doc = " \\param event the SDL_Event structure to be filled in with the next event"] + #[doc = " from the queue, or NULL"] + #[doc = " \\returns 1 on success or 0 if there was an error while waiting for events;"] + #[doc = " call SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\param event If not NULL, the next event is removed from the queue and"] - #[doc = " stored in that area."] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_PollEvent"] + #[doc = " \\sa SDL_PumpEvents"] + #[doc = " \\sa SDL_WaitEventTimeout"] pub fn SDL_WaitEvent(event: *mut SDL_Event) -> libc::c_int; } extern "C" { - #[doc = " \\brief Waits until the specified timeout (in milliseconds) for the next"] - #[doc = " available event."] + #[doc = " Wait until the specified timeout (in milliseconds) for the next available"] + #[doc = " event."] + #[doc = ""] + #[doc = " If `event` is not NULL, the next event is removed from the queue and stored"] + #[doc = " in the SDL_Event structure pointed to by `event`."] + #[doc = ""] + #[doc = " As this function may implicitly call SDL_PumpEvents(), you can only call"] + #[doc = " this function in the thread that initialized the video subsystem."] + #[doc = ""] + #[doc = " \\param event the SDL_Event structure to be filled in with the next event"] + #[doc = " from the queue, or NULL"] + #[doc = " \\param timeout the maximum number of milliseconds to wait for the next"] + #[doc = " available event"] + #[doc = " \\returns 1 on success or 0 if there was an error while waiting for events;"] + #[doc = " call SDL_GetError() for more information. This also returns 0 if"] + #[doc = " the timeout elapsed without an event arriving."] #[doc = ""] - #[doc = " \\return 1, or 0 if there was an error while waiting for events."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\param event If not NULL, the next event is removed from the queue and"] - #[doc = " stored in that area."] - #[doc = " \\param timeout The timeout (in milliseconds) to wait for next event."] + #[doc = " \\sa SDL_PollEvent"] + #[doc = " \\sa SDL_PumpEvents"] + #[doc = " \\sa SDL_WaitEvent"] pub fn SDL_WaitEventTimeout(event: *mut SDL_Event, timeout: libc::c_int) -> libc::c_int; } extern "C" { - #[doc = " \\brief Add an event to the event queue."] + #[doc = " Add an event to the event queue."] + #[doc = ""] + #[doc = " The event queue can actually be used as a two way communication channel."] + #[doc = " Not only can events be read from the queue, but the user can also push"] + #[doc = " their own events onto it. `event` is a pointer to the event structure you"] + #[doc = " wish to push onto the queue. The event is copied into the queue, and the"] + #[doc = " caller may dispose of the memory pointed to after SDL_PushEvent() returns."] + #[doc = ""] + #[doc = " Note: Pushing device input events onto the queue doesn't modify the state"] + #[doc = " of the device within SDL."] + #[doc = ""] + #[doc = " This function is thread-safe, and can be called from other threads safely."] + #[doc = ""] + #[doc = " Note: Events pushed onto the queue with SDL_PushEvent() get passed through"] + #[doc = " the event filter but events added with SDL_PeepEvents() do not."] #[doc = ""] - #[doc = " \\return 1 on success, 0 if the event was filtered, or -1 if the event queue"] - #[doc = " was full or there was some other error."] + #[doc = " For pushing application-specific events, please use SDL_RegisterEvents() to"] + #[doc = " get an event type that does not conflict with other code that also wants"] + #[doc = " its own custom event types."] + #[doc = ""] + #[doc = " \\param event the SDL_Event to be added to the queue"] + #[doc = " \\returns 1 on success, 0 if the event was filtered, or a negative error"] + #[doc = " code on failure; call SDL_GetError() for more information. A"] + #[doc = " common reason for error is the event queue being full."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_PeepEvents"] + #[doc = " \\sa SDL_PollEvent"] + #[doc = " \\sa SDL_RegisterEvents"] pub fn SDL_PushEvent(event: *mut SDL_Event) -> libc::c_int; } +#[doc = " A function pointer used for callbacks that watch the event queue."] +#[doc = ""] +#[doc = " \\param userdata what was passed as `userdata` to SDL_SetEventFilter()"] +#[doc = " or SDL_AddEventWatch, etc"] +#[doc = " \\param event the event that triggered the callback"] +#[doc = " \\returns 1 to permit event to be added to the queue, and 0 to disallow"] +#[doc = " it. When used with SDL_AddEventWatch, the return value is ignored."] +#[doc = ""] +#[doc = " \\sa SDL_SetEventFilter"] +#[doc = " \\sa SDL_AddEventWatch"] pub type SDL_EventFilter = ::core::option::Option< unsafe extern "C" fn(userdata: *mut libc::c_void, event: *mut SDL_Event) -> libc::c_int, >; extern "C" { - #[doc = " Sets up a filter to process all events before they change internal state and"] - #[doc = " are posted to the internal event queue."] + #[doc = " Set up a filter to process all events before they change internal state and"] + #[doc = " are posted to the internal event queue."] + #[doc = ""] + #[doc = " If the filter function returns 1 when called, then the event will be added"] + #[doc = " to the internal queue. If it returns 0, then the event will be dropped from"] + #[doc = " the queue, but the internal state will still be updated. This allows"] + #[doc = " selective filtering of dynamically arriving events."] + #[doc = ""] + #[doc = " **WARNING**: Be very careful of what you do in the event filter function,"] + #[doc = " as it may run in a different thread!"] + #[doc = ""] + #[doc = " On platforms that support it, if the quit event is generated by an"] + #[doc = " interrupt signal (e.g. pressing Ctrl-C), it will be delivered to the"] + #[doc = " application at the next event poll."] #[doc = ""] - #[doc = " The filter is prototyped as:"] - #[doc = " \\code"] - #[doc = " int SDL_EventFilter(void *userdata, SDL_Event * event);"] - #[doc = " \\endcode"] + #[doc = " There is one caveat when dealing with the ::SDL_QuitEvent event type. The"] + #[doc = " event filter is only called when the window manager desires to close the"] + #[doc = " application window. If the event filter returns 1, then the window will be"] + #[doc = " closed, otherwise the window will remain open if possible."] #[doc = ""] - #[doc = " If the filter returns 1, then the event will be added to the internal queue."] - #[doc = " If it returns 0, then the event will be dropped from the queue, but the"] - #[doc = " internal state will still be updated. This allows selective filtering of"] - #[doc = " dynamically arriving events."] + #[doc = " Note: Disabled events never make it to the event filter function; see"] + #[doc = " SDL_EventState()."] #[doc = ""] - #[doc = " \\warning Be very careful of what you do in the event filter function, as"] - #[doc = " it may run in a different thread!"] + #[doc = " Note: If you just want to inspect events without filtering, you should use"] + #[doc = " SDL_AddEventWatch() instead."] #[doc = ""] - #[doc = " There is one caveat when dealing with the ::SDL_QuitEvent event type. The"] - #[doc = " event filter is only called when the window manager desires to close the"] - #[doc = " application window. If the event filter returns 1, then the window will"] - #[doc = " be closed, otherwise the window will remain open if possible."] + #[doc = " Note: Events pushed onto the queue with SDL_PushEvent() get passed through"] + #[doc = " the event filter, but events pushed onto the queue with SDL_PeepEvents() do"] + #[doc = " not."] #[doc = ""] - #[doc = " If the quit event is generated by an interrupt signal, it will bypass the"] - #[doc = " internal queue and be delivered to the application at the next event poll."] + #[doc = " \\param filter An SDL_EventFilter function to call when an event happens"] + #[doc = " \\param userdata a pointer that is passed to `filter`"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_AddEventWatch"] + #[doc = " \\sa SDL_EventState"] + #[doc = " \\sa SDL_GetEventFilter"] + #[doc = " \\sa SDL_PeepEvents"] + #[doc = " \\sa SDL_PushEvent"] pub fn SDL_SetEventFilter(filter: SDL_EventFilter, userdata: *mut libc::c_void); } extern "C" { - #[doc = " Return the current event filter - can be used to \"chain\" filters."] - #[doc = " If there is no event filter set, this function returns SDL_FALSE."] + #[doc = " Query the current event filter."] + #[doc = ""] + #[doc = " This function can be used to \"chain\" filters, by saving the existing filter"] + #[doc = " before replacing it with a function that will call that saved filter."] + #[doc = ""] + #[doc = " \\param filter the current callback function will be stored here"] + #[doc = " \\param userdata the pointer that is passed to the current event filter will"] + #[doc = " be stored here"] + #[doc = " \\returns SDL_TRUE on success or SDL_FALSE if there is no event filter set."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_SetEventFilter"] pub fn SDL_GetEventFilter( filter: *mut SDL_EventFilter, userdata: *mut *mut libc::c_void, ) -> SDL_bool; } extern "C" { - #[doc = " Add a function which is called when an event is added to the queue."] + #[doc = " Add a callback to be triggered when an event is added to the event queue."] + #[doc = ""] + #[doc = " `filter` will be called when an event happens, and its return value is"] + #[doc = " ignored."] + #[doc = ""] + #[doc = " **WARNING**: Be very careful of what you do in the event filter function,"] + #[doc = " as it may run in a different thread!"] + #[doc = ""] + #[doc = " If the quit event is generated by a signal (e.g. SIGINT), it will bypass"] + #[doc = " the internal queue and be delivered to the watch callback immediately, and"] + #[doc = " arrive at the next event poll."] + #[doc = ""] + #[doc = " Note: the callback is called for events posted by the user through"] + #[doc = " SDL_PushEvent(), but not for disabled events, nor for events by a filter"] + #[doc = " callback set with SDL_SetEventFilter(), nor for events posted by the user"] + #[doc = " through SDL_PeepEvents()."] + #[doc = ""] + #[doc = " \\param filter an SDL_EventFilter function to call when an event happens."] + #[doc = " \\param userdata a pointer that is passed to `filter`"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_DelEventWatch"] + #[doc = " \\sa SDL_SetEventFilter"] pub fn SDL_AddEventWatch(filter: SDL_EventFilter, userdata: *mut libc::c_void); } extern "C" { - #[doc = " Remove an event watch function added with SDL_AddEventWatch()"] + #[doc = " Remove an event watch callback added with SDL_AddEventWatch()."] + #[doc = ""] + #[doc = " This function takes the same input as SDL_AddEventWatch() to identify and"] + #[doc = " delete the corresponding callback."] + #[doc = ""] + #[doc = " \\param filter the function originally passed to SDL_AddEventWatch()"] + #[doc = " \\param userdata the pointer originally passed to SDL_AddEventWatch()"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_AddEventWatch"] pub fn SDL_DelEventWatch(filter: SDL_EventFilter, userdata: *mut libc::c_void); } extern "C" { - #[doc = " Run the filter function on the current event queue, removing any"] - #[doc = " events for which the filter returns 0."] + #[doc = " Run a specific filter function on the current event queue, removing any"] + #[doc = " events for which the filter returns 0."] + #[doc = ""] + #[doc = " See SDL_SetEventFilter() for more information. Unlike SDL_SetEventFilter(),"] + #[doc = " this function does not change the filter permanently, it only uses the"] + #[doc = " supplied filter until this function returns."] + #[doc = ""] + #[doc = " \\param filter the SDL_EventFilter function to call when an event happens"] + #[doc = " \\param userdata a pointer that is passed to `filter`"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetEventFilter"] + #[doc = " \\sa SDL_SetEventFilter"] pub fn SDL_FilterEvents(filter: SDL_EventFilter, userdata: *mut libc::c_void); } extern "C" { - #[doc = " This function allows you to set the state of processing certain events."] - #[doc = " - If \\c state is set to ::SDL_IGNORE, that event will be automatically"] - #[doc = " dropped from the event queue and will not be filtered."] - #[doc = " - If \\c state is set to ::SDL_ENABLE, that event will be processed"] - #[doc = " normally."] - #[doc = " - If \\c state is set to ::SDL_QUERY, SDL_EventState() will return the"] - #[doc = " current processing state of the specified event."] + #[doc = " Set the state of processing events by type."] + #[doc = ""] + #[doc = " `state` may be any of the following:"] + #[doc = ""] + #[doc = " - `SDL_QUERY`: returns the current processing state of the specified event"] + #[doc = " - `SDL_IGNORE` (aka `SDL_DISABLE`): the event will automatically be dropped"] + #[doc = " from the event queue and will not be filtered"] + #[doc = " - `SDL_ENABLE`: the event will be processed normally"] + #[doc = ""] + #[doc = " \\param type the type of event; see SDL_EventType for details"] + #[doc = " \\param state how to process the event"] + #[doc = " \\returns `SDL_DISABLE` or `SDL_ENABLE`, representing the processing state"] + #[doc = " of the event before this function makes any changes to it."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetEventState"] pub fn SDL_EventState(type_: Uint32, state: libc::c_int) -> Uint8; } extern "C" { - #[doc = " This function allocates a set of user-defined events, and returns"] - #[doc = " the beginning event number for that set of events."] + #[doc = " Allocate a set of user-defined events, and return the beginning event"] + #[doc = " number for that set of events."] + #[doc = ""] + #[doc = " Calling this function with `numevents` <= 0 is an error and will return"] + #[doc = " (Uint32)-1."] + #[doc = ""] + #[doc = " Note, (Uint32)-1 means the maximum unsigned 32-bit integer value (or"] + #[doc = " 0xFFFFFFFF), but is clearer to write."] #[doc = ""] - #[doc = " If there aren't enough user-defined events left, this function"] - #[doc = " returns (Uint32)-1"] + #[doc = " \\param numevents the number of events to be allocated"] + #[doc = " \\returns the beginning event number, or (Uint32)-1 if there are not enough"] + #[doc = " user-defined events left."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_PushEvent"] pub fn SDL_RegisterEvents(numevents: libc::c_int) -> Uint32; } extern "C" { - #[doc = " \\brief Get the path where the application resides."] + #[doc = " Get the directory where the application was run from."] + #[doc = ""] + #[doc = " This is not necessarily a fast call, so you should call this once near"] + #[doc = " startup and save the string if you need it."] + #[doc = ""] + #[doc = " **Mac OS X and iOS Specific Functionality**: If the application is in a"] + #[doc = " \".app\" bundle, this function returns the Resource directory (e.g."] + #[doc = " MyApp.app/Contents/Resources/). This behaviour can be overridden by adding"] + #[doc = " a property to the Info.plist file. Adding a string key with the name"] + #[doc = " SDL_FILESYSTEM_BASE_DIR_TYPE with a supported value will change the"] + #[doc = " behaviour."] #[doc = ""] - #[doc = " Get the \"base path\". This is the directory where the application was run"] - #[doc = " from, which is probably the installation directory, and may or may not"] - #[doc = " be the process's current working directory."] + #[doc = " Supported values for the SDL_FILESYSTEM_BASE_DIR_TYPE property (Given an"] + #[doc = " application in /Applications/SDLApp/MyApp.app):"] #[doc = ""] - #[doc = " This returns an absolute path in UTF-8 encoding, and is guaranteed to"] - #[doc = " end with a path separator ('\\\\' on Windows, '/' most other places)."] + #[doc = " - `resource`: bundle resource directory (the default). For example:"] + #[doc = " `/Applications/SDLApp/MyApp.app/Contents/Resources`"] + #[doc = " - `bundle`: the Bundle directory. For example:"] + #[doc = " `/Applications/SDLApp/MyApp.app/`"] + #[doc = " - `parent`: the containing directory of the bundle. For example:"] + #[doc = " `/Applications/SDLApp/`"] #[doc = ""] - #[doc = " The pointer returned by this function is owned by you. Please call"] - #[doc = " SDL_free() on the pointer when you are done with it, or it will be a"] - #[doc = " memory leak. This is not necessarily a fast call, though, so you should"] - #[doc = " call this once near startup and save the string if you need it."] + #[doc = " The returned path is guaranteed to end with a path separator ('\\' on"] + #[doc = " Windows, '/' on most other platforms)."] #[doc = ""] - #[doc = " Some platforms can't determine the application's path, and on other"] - #[doc = " platforms, this might be meaningless. In such cases, this function will"] - #[doc = " return NULL."] + #[doc = " The pointer returned is owned by the caller. Please call SDL_free() on the"] + #[doc = " pointer when done with it."] #[doc = ""] - #[doc = " \\return String of base dir in UTF-8 encoding, or NULL on error."] + #[doc = " \\returns an absolute path in UTF-8 encoding to the application data"] + #[doc = " directory. NULL will be returned on error or when the platform"] + #[doc = " doesn't implement this functionality, call SDL_GetError() for more"] + #[doc = " information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.1."] #[doc = ""] #[doc = " \\sa SDL_GetPrefPath"] pub fn SDL_GetBasePath() -> *mut libc::c_char; } extern "C" { - #[doc = " \\brief Get the user-and-app-specific path where files can be written."] + #[doc = " Get the user-and-app-specific path where files can be written."] #[doc = ""] #[doc = " Get the \"pref dir\". This is meant to be where users can write personal"] - #[doc = " files (preferences and save games, etc) that are specific to your"] - #[doc = " application. This directory is unique per user, per application."] + #[doc = " files (preferences and save games, etc) that are specific to your"] + #[doc = " application. This directory is unique per user, per application."] #[doc = ""] - #[doc = " This function will decide the appropriate location in the native filesystem,"] - #[doc = " create the directory if necessary, and return a string of the absolute"] - #[doc = " path to the directory in UTF-8 encoding."] + #[doc = " This function will decide the appropriate location in the native"] + #[doc = " filesystem, create the directory if necessary, and return a string of the"] + #[doc = " absolute path to the directory in UTF-8 encoding."] #[doc = ""] #[doc = " On Windows, the string might look like:"] - #[doc = " \"C:\\\\Users\\\\bob\\\\AppData\\\\Roaming\\\\My Company\\\\My Program Name\\\\\""] #[doc = ""] - #[doc = " On Linux, the string might look like:"] - #[doc = " \"/home/bob/.local/share/My Program Name/\""] + #[doc = " `C:\\\\Users\\\\bob\\\\AppData\\\\Roaming\\\\My Company\\\\My Program Name\\\\`"] #[doc = ""] - #[doc = " On Mac OS X, the string might look like:"] - #[doc = " \"/Users/bob/Library/Application Support/My Program Name/\""] + #[doc = " On Linux, the string might look like\""] #[doc = ""] - #[doc = " (etc.)"] + #[doc = " `/home/bob/.local/share/My Program Name/`"] + #[doc = ""] + #[doc = " On Mac OS X, the string might look like:"] #[doc = ""] - #[doc = " You specify the name of your organization (if it's not a real organization,"] - #[doc = " your name or an Internet domain you own might do) and the name of your"] - #[doc = " application. These should be untranslated proper names."] + #[doc = " `/Users/bob/Library/Application Support/My Program Name/`"] #[doc = ""] - #[doc = " Both the org and app strings may become part of a directory name, so"] - #[doc = " please follow these rules:"] + #[doc = " You should assume the path returned by this function is the only safe place"] + #[doc = " to write files (and that SDL_GetBasePath(), while it might be writable, or"] + #[doc = " even the parent of the returned path, isn't where you should be writing"] + #[doc = " things)."] #[doc = ""] - #[doc = " - Try to use the same org string (including case-sensitivity) for"] - #[doc = " all your applications that use this function."] - #[doc = " - Always use a unique app string for each one, and make sure it never"] - #[doc = " changes for an app once you've decided on it."] - #[doc = " - Unicode characters are legal, as long as it's UTF-8 encoded, but..."] - #[doc = " - ...only use letters, numbers, and spaces. Avoid punctuation like"] - #[doc = " \"Game Name 2: Bad Guy's Revenge!\" ... \"Game Name 2\" is sufficient."] + #[doc = " Both the org and app strings may become part of a directory name, so please"] + #[doc = " follow these rules:"] #[doc = ""] - #[doc = " This returns an absolute path in UTF-8 encoding, and is guaranteed to"] - #[doc = " end with a path separator ('\\\\' on Windows, '/' most other places)."] + #[doc = " - Try to use the same org string (_including case-sensitivity_) for all"] + #[doc = " your applications that use this function."] + #[doc = " - Always use a unique app string for each one, and make sure it never"] + #[doc = " changes for an app once you've decided on it."] + #[doc = " - Unicode characters are legal, as long as it's UTF-8 encoded, but..."] + #[doc = " - ...only use letters, numbers, and spaces. Avoid punctuation like \"Game"] + #[doc = " Name 2: Bad Guy's Revenge!\" ... \"Game Name 2\" is sufficient."] #[doc = ""] - #[doc = " The pointer returned by this function is owned by you. Please call"] - #[doc = " SDL_free() on the pointer when you are done with it, or it will be a"] - #[doc = " memory leak. This is not necessarily a fast call, though, so you should"] - #[doc = " call this once near startup and save the string if you need it."] + #[doc = " The returned path is guaranteed to end with a path separator ('\\' on"] + #[doc = " Windows, '/' on most other platforms)."] #[doc = ""] - #[doc = " You should assume the path returned by this function is the only safe"] - #[doc = " place to write files (and that SDL_GetBasePath(), while it might be"] - #[doc = " writable, or even the parent of the returned path, aren't where you"] - #[doc = " should be writing things)."] + #[doc = " The pointer returned is owned by the caller. Please call SDL_free() on the"] + #[doc = " pointer when done with it."] #[doc = ""] - #[doc = " Some platforms can't determine the pref path, and on other"] - #[doc = " platforms, this might be meaningless. In such cases, this function will"] - #[doc = " return NULL."] + #[doc = " \\param org the name of your organization"] + #[doc = " \\param app the name of your application"] + #[doc = " \\returns a UTF-8 string of the user directory in platform-dependent"] + #[doc = " notation. NULL if there's a problem (creating directory failed,"] + #[doc = " etc.)."] #[doc = ""] - #[doc = " \\param org The name of your organization."] - #[doc = " \\param app The name of your application."] - #[doc = " \\return UTF-8 string of user dir in platform-dependent notation. NULL"] - #[doc = " if there's a problem (creating directory failed, etc)."] + #[doc = " \\since This function is available since SDL 2.0.1."] #[doc = ""] #[doc = " \\sa SDL_GetBasePath"] pub fn SDL_GetPrefPath(org: *const libc::c_char, app: *const libc::c_char) @@ -15841,396 +20795,1054 @@ fn bindgen_test_layout_SDL_HapticEffect() { ); } extern "C" { - #[doc = " \\brief Count the number of haptic devices attached to the system."] + #[doc = " Count the number of haptic devices attached to the system."] #[doc = ""] - #[doc = " \\return Number of haptic devices detected on the system."] + #[doc = " \\returns the number of haptic devices detected on the system or a negative"] + #[doc = " error code on failure; call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HapticName"] pub fn SDL_NumHaptics() -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the implementation dependent name of a haptic device."] + #[doc = " Get the implementation dependent name of a haptic device."] #[doc = ""] - #[doc = " This can be called before any joysticks are opened."] - #[doc = " If no name can be found, this function returns NULL."] + #[doc = " This can be called before any joysticks are opened. If no name can be"] + #[doc = " found, this function returns NULL."] #[doc = ""] - #[doc = " \\param device_index Index of the device to get its name."] - #[doc = " \\return Name of the device or NULL on error."] + #[doc = " \\param device_index index of the device to query."] + #[doc = " \\returns the name of the device or NULL on failure; call SDL_GetError() for"] + #[doc = " more information."] #[doc = ""] - #[doc = " \\sa SDL_NumHaptics"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_NumHaptics"] pub fn SDL_HapticName(device_index: libc::c_int) -> *const libc::c_char; } extern "C" { - #[doc = " \\brief Opens a haptic device for use."] + #[doc = " Open a haptic device for use."] + #[doc = ""] + #[doc = " The index passed as an argument refers to the N'th haptic device on this"] + #[doc = " system."] #[doc = ""] - #[doc = " The index passed as an argument refers to the N'th haptic device on this"] - #[doc = " system."] + #[doc = " When opening a haptic device, its gain will be set to maximum and"] + #[doc = " autocenter will be disabled. To modify these values use SDL_HapticSetGain()"] + #[doc = " and SDL_HapticSetAutocenter()."] #[doc = ""] - #[doc = " When opening a haptic device, its gain will be set to maximum and"] - #[doc = " autocenter will be disabled. To modify these values use"] - #[doc = " SDL_HapticSetGain() and SDL_HapticSetAutocenter()."] + #[doc = " \\param device_index index of the device to open"] + #[doc = " \\returns the device identifier or NULL on failure; call SDL_GetError() for"] + #[doc = " more information."] #[doc = ""] - #[doc = " \\param device_index Index of the device to open."] - #[doc = " \\return Device identifier or NULL on error."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_HapticIndex"] - #[doc = " \\sa SDL_HapticOpenFromMouse"] - #[doc = " \\sa SDL_HapticOpenFromJoystick"] - #[doc = " \\sa SDL_HapticClose"] - #[doc = " \\sa SDL_HapticSetGain"] - #[doc = " \\sa SDL_HapticSetAutocenter"] - #[doc = " \\sa SDL_HapticPause"] - #[doc = " \\sa SDL_HapticStopAll"] + #[doc = " \\sa SDL_HapticClose"] + #[doc = " \\sa SDL_HapticIndex"] + #[doc = " \\sa SDL_HapticOpenFromJoystick"] + #[doc = " \\sa SDL_HapticOpenFromMouse"] + #[doc = " \\sa SDL_HapticPause"] + #[doc = " \\sa SDL_HapticSetAutocenter"] + #[doc = " \\sa SDL_HapticSetGain"] + #[doc = " \\sa SDL_HapticStopAll"] pub fn SDL_HapticOpen(device_index: libc::c_int) -> *mut SDL_Haptic; } extern "C" { - #[doc = " \\brief Checks if the haptic device at index has been opened."] + #[doc = " Check if the haptic device at the designated index has been opened."] #[doc = ""] - #[doc = " \\param device_index Index to check to see if it has been opened."] - #[doc = " \\return 1 if it has been opened or 0 if it hasn't."] + #[doc = " \\param device_index the index of the device to query"] + #[doc = " \\returns 1 if it has been opened, 0 if it hasn't or on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\sa SDL_HapticOpen"] - #[doc = " \\sa SDL_HapticIndex"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HapticIndex"] + #[doc = " \\sa SDL_HapticOpen"] pub fn SDL_HapticOpened(device_index: libc::c_int) -> libc::c_int; } extern "C" { - #[doc = " \\brief Gets the index of a haptic device."] + #[doc = " Get the index of a haptic device."] + #[doc = ""] + #[doc = " \\param haptic the SDL_Haptic device to query"] + #[doc = " \\returns the index of the specified haptic device or a negative error code"] + #[doc = " on failure; call SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\param haptic Haptic device to get the index of."] - #[doc = " \\return The index of the haptic device or -1 on error."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_HapticOpen"] - #[doc = " \\sa SDL_HapticOpened"] + #[doc = " \\sa SDL_HapticOpen"] + #[doc = " \\sa SDL_HapticOpened"] pub fn SDL_HapticIndex(haptic: *mut SDL_Haptic) -> libc::c_int; } extern "C" { - #[doc = " \\brief Gets whether or not the current mouse has haptic capabilities."] + #[doc = " Query whether or not the current mouse has haptic capabilities."] #[doc = ""] - #[doc = " \\return SDL_TRUE if the mouse is haptic, SDL_FALSE if it isn't."] + #[doc = " \\returns SDL_TRUE if the mouse is haptic or SDL_FALSE if it isn't."] #[doc = ""] - #[doc = " \\sa SDL_HapticOpenFromMouse"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HapticOpenFromMouse"] pub fn SDL_MouseIsHaptic() -> libc::c_int; } extern "C" { - #[doc = " \\brief Tries to open a haptic device from the current mouse."] + #[doc = " Try to open a haptic device from the current mouse."] + #[doc = ""] + #[doc = " \\returns the haptic device identifier or NULL on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HapticOpen"] + #[doc = " \\sa SDL_MouseIsHaptic"] + pub fn SDL_HapticOpenFromMouse() -> *mut SDL_Haptic; +} +extern "C" { + #[doc = " Query if a joystick has haptic features."] + #[doc = ""] + #[doc = " \\param joystick the SDL_Joystick to test for haptic capabilities"] + #[doc = " \\returns SDL_TRUE if the joystick is haptic, SDL_FALSE if it isn't, or a"] + #[doc = " negative error code on failure; call SDL_GetError() for more"] + #[doc = " information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HapticOpenFromJoystick"] + pub fn SDL_JoystickIsHaptic(joystick: *mut SDL_Joystick) -> libc::c_int; +} +extern "C" { + #[doc = " Open a haptic device for use from a joystick device."] + #[doc = ""] + #[doc = " You must still close the haptic device separately. It will not be closed"] + #[doc = " with the joystick."] + #[doc = ""] + #[doc = " When opened from a joystick you should first close the haptic device before"] + #[doc = " closing the joystick device. If not, on some implementations the haptic"] + #[doc = " device will also get unallocated and you'll be unable to use force feedback"] + #[doc = " on that device."] + #[doc = ""] + #[doc = " \\param joystick the SDL_Joystick to create a haptic device from"] + #[doc = " \\returns a valid haptic device identifier on success or NULL on failure;"] + #[doc = " call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HapticClose"] + #[doc = " \\sa SDL_HapticOpen"] + #[doc = " \\sa SDL_JoystickIsHaptic"] + pub fn SDL_HapticOpenFromJoystick(joystick: *mut SDL_Joystick) -> *mut SDL_Haptic; +} +extern "C" { + #[doc = " Close a haptic device previously opened with SDL_HapticOpen()."] + #[doc = ""] + #[doc = " \\param haptic the SDL_Haptic device to close"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HapticOpen"] + pub fn SDL_HapticClose(haptic: *mut SDL_Haptic); +} +extern "C" { + #[doc = " Get the number of effects a haptic device can store."] + #[doc = ""] + #[doc = " On some platforms this isn't fully supported, and therefore is an"] + #[doc = " approximation. Always check to see if your created effect was actually"] + #[doc = " created and do not rely solely on SDL_HapticNumEffects()."] + #[doc = ""] + #[doc = " \\param haptic the SDL_Haptic device to query"] + #[doc = " \\returns the number of effects the haptic device can store or a negative"] + #[doc = " error code on failure; call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HapticNumEffectsPlaying"] + #[doc = " \\sa SDL_HapticQuery"] + pub fn SDL_HapticNumEffects(haptic: *mut SDL_Haptic) -> libc::c_int; +} +extern "C" { + #[doc = " Get the number of effects a haptic device can play at the same time."] + #[doc = ""] + #[doc = " This is not supported on all platforms, but will always return a value."] + #[doc = ""] + #[doc = " \\param haptic the SDL_Haptic device to query maximum playing effects"] + #[doc = " \\returns the number of effects the haptic device can play at the same time"] + #[doc = " or a negative error code on failure; call SDL_GetError() for more"] + #[doc = " information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HapticNumEffects"] + #[doc = " \\sa SDL_HapticQuery"] + pub fn SDL_HapticNumEffectsPlaying(haptic: *mut SDL_Haptic) -> libc::c_int; +} +extern "C" { + #[doc = " Get the haptic device's supported features in bitwise manner."] + #[doc = ""] + #[doc = " \\param haptic the SDL_Haptic device to query"] + #[doc = " \\returns a list of supported haptic features in bitwise manner (OR'd), or 0"] + #[doc = " on failure; call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HapticEffectSupported"] + #[doc = " \\sa SDL_HapticNumEffects"] + pub fn SDL_HapticQuery(haptic: *mut SDL_Haptic) -> libc::c_uint; +} +extern "C" { + #[doc = " Get the number of haptic axes the device has."] + #[doc = ""] + #[doc = " The number of haptic axes might be useful if working with the"] + #[doc = " SDL_HapticDirection effect."] + #[doc = ""] + #[doc = " \\param haptic the SDL_Haptic device to query"] + #[doc = " \\returns the number of axes on success or a negative error code on failure;"] + #[doc = " call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + pub fn SDL_HapticNumAxes(haptic: *mut SDL_Haptic) -> libc::c_int; +} +extern "C" { + #[doc = " Check to see if an effect is supported by a haptic device."] + #[doc = ""] + #[doc = " \\param haptic the SDL_Haptic device to query"] + #[doc = " \\param effect the desired effect to query"] + #[doc = " \\returns SDL_TRUE if effect is supported, SDL_FALSE if it isn't, or a"] + #[doc = " negative error code on failure; call SDL_GetError() for more"] + #[doc = " information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HapticNewEffect"] + #[doc = " \\sa SDL_HapticQuery"] + pub fn SDL_HapticEffectSupported( + haptic: *mut SDL_Haptic, + effect: *mut SDL_HapticEffect, + ) -> libc::c_int; +} +extern "C" { + #[doc = " Create a new haptic effect on a specified device."] + #[doc = ""] + #[doc = " \\param haptic an SDL_Haptic device to create the effect on"] + #[doc = " \\param effect an SDL_HapticEffect structure containing the properties of"] + #[doc = " the effect to create"] + #[doc = " \\returns the ID of the effect on success or a negative error code on"] + #[doc = " failure; call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HapticDestroyEffect"] + #[doc = " \\sa SDL_HapticRunEffect"] + #[doc = " \\sa SDL_HapticUpdateEffect"] + pub fn SDL_HapticNewEffect( + haptic: *mut SDL_Haptic, + effect: *mut SDL_HapticEffect, + ) -> libc::c_int; +} +extern "C" { + #[doc = " Update the properties of an effect."] + #[doc = ""] + #[doc = " Can be used dynamically, although behavior when dynamically changing"] + #[doc = " direction may be strange. Specifically the effect may re-upload itself and"] + #[doc = " start playing from the start. You also cannot change the type either when"] + #[doc = " running SDL_HapticUpdateEffect()."] + #[doc = ""] + #[doc = " \\param haptic the SDL_Haptic device that has the effect"] + #[doc = " \\param effect the identifier of the effect to update"] + #[doc = " \\param data an SDL_HapticEffect structure containing the new effect"] + #[doc = " properties to use"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HapticDestroyEffect"] + #[doc = " \\sa SDL_HapticNewEffect"] + #[doc = " \\sa SDL_HapticRunEffect"] + pub fn SDL_HapticUpdateEffect( + haptic: *mut SDL_Haptic, + effect: libc::c_int, + data: *mut SDL_HapticEffect, + ) -> libc::c_int; +} +extern "C" { + #[doc = " Run the haptic effect on its associated haptic device."] + #[doc = ""] + #[doc = " To repeat the effect over and over indefinitely, set `iterations` to"] + #[doc = " `SDL_HAPTIC_INFINITY`. (Repeats the envelope - attack and fade.) To make"] + #[doc = " one instance of the effect last indefinitely (so the effect does not fade),"] + #[doc = " set the effect's `length` in its structure/union to `SDL_HAPTIC_INFINITY`"] + #[doc = " instead."] + #[doc = ""] + #[doc = " \\param haptic the SDL_Haptic device to run the effect on"] + #[doc = " \\param effect the ID of the haptic effect to run"] + #[doc = " \\param iterations the number of iterations to run the effect; use"] + #[doc = " `SDL_HAPTIC_INFINITY` to repeat forever"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HapticDestroyEffect"] + #[doc = " \\sa SDL_HapticGetEffectStatus"] + #[doc = " \\sa SDL_HapticStopEffect"] + pub fn SDL_HapticRunEffect( + haptic: *mut SDL_Haptic, + effect: libc::c_int, + iterations: Uint32, + ) -> libc::c_int; +} +extern "C" { + #[doc = " Stop the haptic effect on its associated haptic device."] + #[doc = ""] + #[doc = " *"] + #[doc = ""] + #[doc = " \\param haptic the SDL_Haptic device to stop the effect on"] + #[doc = " \\param effect the ID of the haptic effect to stop"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HapticDestroyEffect"] + #[doc = " \\sa SDL_HapticRunEffect"] + pub fn SDL_HapticStopEffect(haptic: *mut SDL_Haptic, effect: libc::c_int) -> libc::c_int; +} +extern "C" { + #[doc = " Destroy a haptic effect on the device."] + #[doc = ""] + #[doc = " This will stop the effect if it's running. Effects are automatically"] + #[doc = " destroyed when the device is closed."] + #[doc = ""] + #[doc = " \\param haptic the SDL_Haptic device to destroy the effect on"] + #[doc = " \\param effect the ID of the haptic effect to destroy"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HapticNewEffect"] + pub fn SDL_HapticDestroyEffect(haptic: *mut SDL_Haptic, effect: libc::c_int); +} +extern "C" { + #[doc = " Get the status of the current effect on the specified haptic device."] + #[doc = ""] + #[doc = " Device must support the SDL_HAPTIC_STATUS feature."] + #[doc = ""] + #[doc = " \\param haptic the SDL_Haptic device to query for the effect status on"] + #[doc = " \\param effect the ID of the haptic effect to query its status"] + #[doc = " \\returns 0 if it isn't playing, 1 if it is playing, or a negative error"] + #[doc = " code on failure; call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HapticRunEffect"] + #[doc = " \\sa SDL_HapticStopEffect"] + pub fn SDL_HapticGetEffectStatus(haptic: *mut SDL_Haptic, effect: libc::c_int) -> libc::c_int; +} +extern "C" { + #[doc = " Set the global gain of the specified haptic device."] + #[doc = ""] + #[doc = " Device must support the SDL_HAPTIC_GAIN feature."] + #[doc = ""] + #[doc = " The user may specify the maximum gain by setting the environment variable"] + #[doc = " `SDL_HAPTIC_GAIN_MAX` which should be between 0 and 100. All calls to"] + #[doc = " SDL_HapticSetGain() will scale linearly using `SDL_HAPTIC_GAIN_MAX` as the"] + #[doc = " maximum."] + #[doc = ""] + #[doc = " \\param haptic the SDL_Haptic device to set the gain on"] + #[doc = " \\param gain value to set the gain to, should be between 0 and 100 (0 - 100)"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HapticQuery"] + pub fn SDL_HapticSetGain(haptic: *mut SDL_Haptic, gain: libc::c_int) -> libc::c_int; +} +extern "C" { + #[doc = " Set the global autocenter of the device."] + #[doc = ""] + #[doc = " Autocenter should be between 0 and 100. Setting it to 0 will disable"] + #[doc = " autocentering."] + #[doc = ""] + #[doc = " Device must support the SDL_HAPTIC_AUTOCENTER feature."] + #[doc = ""] + #[doc = " \\param haptic the SDL_Haptic device to set autocentering on"] + #[doc = " \\param autocenter value to set autocenter to (0-100)"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HapticQuery"] + pub fn SDL_HapticSetAutocenter(haptic: *mut SDL_Haptic, autocenter: libc::c_int) + -> libc::c_int; +} +extern "C" { + #[doc = " Pause a haptic device."] + #[doc = ""] + #[doc = " Device must support the `SDL_HAPTIC_PAUSE` feature. Call"] + #[doc = " SDL_HapticUnpause() to resume playback."] + #[doc = ""] + #[doc = " Do not modify the effects nor add new ones while the device is paused. That"] + #[doc = " can cause all sorts of weird errors."] + #[doc = ""] + #[doc = " \\param haptic the SDL_Haptic device to pause"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HapticUnpause"] + pub fn SDL_HapticPause(haptic: *mut SDL_Haptic) -> libc::c_int; +} +extern "C" { + #[doc = " Unpause a haptic device."] + #[doc = ""] + #[doc = " Call to unpause after SDL_HapticPause()."] + #[doc = ""] + #[doc = " \\param haptic the SDL_Haptic device to unpause"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HapticPause"] + pub fn SDL_HapticUnpause(haptic: *mut SDL_Haptic) -> libc::c_int; +} +extern "C" { + #[doc = " Stop all the currently playing effects on a haptic device."] + #[doc = ""] + #[doc = " \\param haptic the SDL_Haptic device to stop"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + pub fn SDL_HapticStopAll(haptic: *mut SDL_Haptic) -> libc::c_int; +} +extern "C" { + #[doc = " Check whether rumble is supported on a haptic device."] + #[doc = ""] + #[doc = " \\param haptic haptic device to check for rumble support"] + #[doc = " \\returns SDL_TRUE if effect is supported, SDL_FALSE if it isn't, or a"] + #[doc = " negative error code on failure; call SDL_GetError() for more"] + #[doc = " information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HapticRumbleInit"] + #[doc = " \\sa SDL_HapticRumblePlay"] + #[doc = " \\sa SDL_HapticRumbleStop"] + pub fn SDL_HapticRumbleSupported(haptic: *mut SDL_Haptic) -> libc::c_int; +} +extern "C" { + #[doc = " Initialize a haptic device for simple rumble playback."] + #[doc = ""] + #[doc = " \\param haptic the haptic device to initialize for simple rumble playback"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HapticOpen"] + #[doc = " \\sa SDL_HapticRumblePlay"] + #[doc = " \\sa SDL_HapticRumbleStop"] + #[doc = " \\sa SDL_HapticRumbleSupported"] + pub fn SDL_HapticRumbleInit(haptic: *mut SDL_Haptic) -> libc::c_int; +} +extern "C" { + #[doc = " Run a simple rumble effect on a haptic device."] + #[doc = ""] + #[doc = " \\param haptic the haptic device to play the rumble effect on"] + #[doc = " \\param strength strength of the rumble to play as a 0-1 float value"] + #[doc = " \\param length length of the rumble to play in milliseconds"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HapticRumbleInit"] + #[doc = " \\sa SDL_HapticRumbleStop"] + #[doc = " \\sa SDL_HapticRumbleSupported"] + pub fn SDL_HapticRumblePlay( + haptic: *mut SDL_Haptic, + strength: f32, + length: Uint32, + ) -> libc::c_int; +} +extern "C" { + #[doc = " Stop the simple rumble on a haptic device."] + #[doc = ""] + #[doc = " \\param haptic the haptic device to stop the rumble effect on"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_HapticRumbleInit"] + #[doc = " \\sa SDL_HapticRumblePlay"] + #[doc = " \\sa SDL_HapticRumbleSupported"] + pub fn SDL_HapticRumbleStop(haptic: *mut SDL_Haptic) -> libc::c_int; +} +#[doc = " \\brief A handle representing an open HID device"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SDL_hid_device_ { + _unused: [u8; 0], +} +pub type SDL_hid_device = SDL_hid_device_; +#[doc = " hidapi info structure */"] +#[doc = " \\brief Information about a connected HID device"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SDL_hid_device_info { + #[doc = " Platform-specific device path"] + pub path: *mut libc::c_char, + #[doc = " Device Vendor ID"] + pub vendor_id: libc::c_ushort, + #[doc = " Device Product ID"] + pub product_id: libc::c_ushort, + #[doc = " Serial Number"] + pub serial_number: *mut wchar_t, + #[doc = " Device Release Number in binary-coded decimal,"] + #[doc = "also known as Device Version Number"] + pub release_number: libc::c_ushort, + #[doc = " Manufacturer String"] + pub manufacturer_string: *mut wchar_t, + #[doc = " Product string"] + pub product_string: *mut wchar_t, + #[doc = " Usage Page for this Device/Interface"] + #[doc = "(Windows/Mac only)."] + pub usage_page: libc::c_ushort, + #[doc = " Usage for this Device/Interface"] + #[doc = "(Windows/Mac only)."] + pub usage: libc::c_ushort, + #[doc = " The USB interface which this logical device"] + #[doc = "represents."] + #[doc = ""] + #[doc = " Valid on both Linux implementations in all cases."] + #[doc = " Valid on the Windows implementation only if the device"] + #[doc = "contains more than one interface."] + pub interface_number: libc::c_int, + #[doc = " Additional information about the USB interface."] + #[doc = "Valid on libusb and Android implementations."] + pub interface_class: libc::c_int, + pub interface_subclass: libc::c_int, + pub interface_protocol: libc::c_int, + #[doc = " Pointer to the next device"] + pub next: *mut SDL_hid_device_info, +} +#[test] +fn bindgen_test_layout_SDL_hid_device_info() { + assert_eq!( + ::core::mem::size_of::(), + 80usize, + concat!("Size of: ", stringify!(SDL_hid_device_info)) + ); + assert_eq!( + ::core::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(SDL_hid_device_info)) + ); + assert_eq!( + unsafe { &(*(::core::ptr::null::())).path as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(SDL_hid_device_info), + "::", + stringify!(path) + ) + ); + assert_eq!( + unsafe { &(*(::core::ptr::null::())).vendor_id as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(SDL_hid_device_info), + "::", + stringify!(vendor_id) + ) + ); + assert_eq!( + unsafe { &(*(::core::ptr::null::())).product_id as *const _ as usize }, + 10usize, + concat!( + "Offset of field: ", + stringify!(SDL_hid_device_info), + "::", + stringify!(product_id) + ) + ); + assert_eq!( + unsafe { + &(*(::core::ptr::null::())).serial_number as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(SDL_hid_device_info), + "::", + stringify!(serial_number) + ) + ); + assert_eq!( + unsafe { + &(*(::core::ptr::null::())).release_number as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(SDL_hid_device_info), + "::", + stringify!(release_number) + ) + ); + assert_eq!( + unsafe { + &(*(::core::ptr::null::())).manufacturer_string as *const _ + as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(SDL_hid_device_info), + "::", + stringify!(manufacturer_string) + ) + ); + assert_eq!( + unsafe { + &(*(::core::ptr::null::())).product_string as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(SDL_hid_device_info), + "::", + stringify!(product_string) + ) + ); + assert_eq!( + unsafe { &(*(::core::ptr::null::())).usage_page as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(SDL_hid_device_info), + "::", + stringify!(usage_page) + ) + ); + assert_eq!( + unsafe { &(*(::core::ptr::null::())).usage as *const _ as usize }, + 50usize, + concat!( + "Offset of field: ", + stringify!(SDL_hid_device_info), + "::", + stringify!(usage) + ) + ); + assert_eq!( + unsafe { + &(*(::core::ptr::null::())).interface_number as *const _ as usize + }, + 52usize, + concat!( + "Offset of field: ", + stringify!(SDL_hid_device_info), + "::", + stringify!(interface_number) + ) + ); + assert_eq!( + unsafe { + &(*(::core::ptr::null::())).interface_class as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(SDL_hid_device_info), + "::", + stringify!(interface_class) + ) + ); + assert_eq!( + unsafe { + &(*(::core::ptr::null::())).interface_subclass as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(SDL_hid_device_info), + "::", + stringify!(interface_subclass) + ) + ); + assert_eq!( + unsafe { + &(*(::core::ptr::null::())).interface_protocol as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(SDL_hid_device_info), + "::", + stringify!(interface_protocol) + ) + ); + assert_eq!( + unsafe { &(*(::core::ptr::null::())).next as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(SDL_hid_device_info), + "::", + stringify!(next) + ) + ); +} +extern "C" { + #[doc = " Initialize the HIDAPI library."] #[doc = ""] - #[doc = " \\return The haptic device identifier or NULL on error."] + #[doc = " This function initializes the HIDAPI library. Calling it is not strictly"] + #[doc = " necessary, as it will be called automatically by SDL_hid_enumerate() and"] + #[doc = " any of the SDL_hid_open_*() functions if it is needed. This function should"] + #[doc = " be called at the beginning of execution however, if there is a chance of"] + #[doc = " HIDAPI handles being opened by different threads simultaneously."] #[doc = ""] - #[doc = " \\sa SDL_MouseIsHaptic"] - #[doc = " \\sa SDL_HapticOpen"] - pub fn SDL_HapticOpenFromMouse() -> *mut SDL_Haptic; -} -extern "C" { - #[doc = " \\brief Checks to see if a joystick has haptic features."] + #[doc = " Each call to this function should have a matching call to SDL_hid_exit()"] #[doc = ""] - #[doc = " \\param joystick Joystick to test for haptic capabilities."] - #[doc = " \\return SDL_TRUE if the joystick is haptic, SDL_FALSE if it isn't"] - #[doc = " or -1 if an error occurred."] + #[doc = " \\returns 0 on success and -1 on error."] #[doc = ""] - #[doc = " \\sa SDL_HapticOpenFromJoystick"] - pub fn SDL_JoystickIsHaptic(joystick: *mut SDL_Joystick) -> libc::c_int; + #[doc = " \\since This function is available since SDL 2.0.18."] + #[doc = ""] + #[doc = " \\sa SDL_hid_exit"] + pub fn SDL_hid_init() -> libc::c_int; } extern "C" { - #[doc = " \\brief Opens a haptic device for use from a joystick device."] - #[doc = ""] - #[doc = " You must still close the haptic device separately. It will not be closed"] - #[doc = " with the joystick."] + #[doc = " Finalize the HIDAPI library."] #[doc = ""] - #[doc = " When opening from a joystick you should first close the haptic device before"] - #[doc = " closing the joystick device. If not, on some implementations the haptic"] - #[doc = " device will also get unallocated and you'll be unable to use force feedback"] - #[doc = " on that device."] + #[doc = " This function frees all of the static data associated with HIDAPI. It"] + #[doc = " should be called at the end of execution to avoid memory leaks."] #[doc = ""] - #[doc = " \\param joystick Joystick to create a haptic device from."] - #[doc = " \\return A valid haptic device identifier on success or NULL on error."] + #[doc = " \\returns 0 on success and -1 on error."] #[doc = ""] - #[doc = " \\sa SDL_HapticOpen"] - #[doc = " \\sa SDL_HapticClose"] - pub fn SDL_HapticOpenFromJoystick(joystick: *mut SDL_Joystick) -> *mut SDL_Haptic; -} -extern "C" { - #[doc = " \\brief Closes a haptic device previously opened with SDL_HapticOpen()."] + #[doc = " \\since This function is available since SDL 2.0.18."] #[doc = ""] - #[doc = " \\param haptic Haptic device to close."] - pub fn SDL_HapticClose(haptic: *mut SDL_Haptic); + #[doc = " \\sa SDL_hid_init"] + pub fn SDL_hid_exit() -> libc::c_int; } extern "C" { - #[doc = " \\brief Returns the number of effects a haptic device can store."] + #[doc = " Check to see if devices may have been added or removed."] #[doc = ""] - #[doc = " On some platforms this isn't fully supported, and therefore is an"] - #[doc = " approximation. Always check to see if your created effect was actually"] - #[doc = " created and do not rely solely on SDL_HapticNumEffects()."] + #[doc = " Enumerating the HID devices is an expensive operation, so you can call this"] + #[doc = " to see if there have been any system device changes since the last call to"] + #[doc = " this function. A change in the counter returned doesn't necessarily mean"] + #[doc = " that anything has changed, but you can call SDL_hid_enumerate() to get an"] + #[doc = " updated device list."] #[doc = ""] - #[doc = " \\param haptic The haptic device to query effect max."] - #[doc = " \\return The number of effects the haptic device can store or"] - #[doc = " -1 on error."] - #[doc = ""] - #[doc = " \\sa SDL_HapticNumEffectsPlaying"] - #[doc = " \\sa SDL_HapticQuery"] - pub fn SDL_HapticNumEffects(haptic: *mut SDL_Haptic) -> libc::c_int; -} -extern "C" { - #[doc = " \\brief Returns the number of effects a haptic device can play at the same"] - #[doc = " time."] + #[doc = " Calling this function for the first time may cause a thread or other system"] + #[doc = " resource to be allocated to track device change notifications."] #[doc = ""] - #[doc = " This is not supported on all platforms, but will always return a value."] - #[doc = " Added here for the sake of completeness."] + #[doc = " \\returns a change counter that is incremented with each potential device"] + #[doc = " change, or 0 if device change detection isn't available."] #[doc = ""] - #[doc = " \\param haptic The haptic device to query maximum playing effects."] - #[doc = " \\return The number of effects the haptic device can play at the same time"] - #[doc = " or -1 on error."] + #[doc = " \\since This function is available since SDL 2.0.18."] #[doc = ""] - #[doc = " \\sa SDL_HapticNumEffects"] - #[doc = " \\sa SDL_HapticQuery"] - pub fn SDL_HapticNumEffectsPlaying(haptic: *mut SDL_Haptic) -> libc::c_int; + #[doc = " \\sa SDL_hid_enumerate"] + pub fn SDL_hid_device_change_count() -> Uint32; } extern "C" { - #[doc = " \\brief Gets the haptic device's supported features in bitwise manner."] + #[doc = " Enumerate the HID Devices."] #[doc = ""] - #[doc = " Example:"] - #[doc = " \\code"] - #[doc = " if (SDL_HapticQuery(haptic) & SDL_HAPTIC_CONSTANT) {"] - #[doc = " printf(\"We have constant haptic effect!\\n\");"] - #[doc = " }"] - #[doc = " \\endcode"] + #[doc = " This function returns a linked list of all the HID devices attached to the"] + #[doc = " system which match vendor_id and product_id. If `vendor_id` is set to 0"] + #[doc = " then any vendor matches. If `product_id` is set to 0 then any product"] + #[doc = " matches. If `vendor_id` and `product_id` are both set to 0, then all HID"] + #[doc = " devices will be returned."] #[doc = ""] - #[doc = " \\param haptic The haptic device to query."] - #[doc = " \\return Haptic features in bitwise manner (OR'd)."] + #[doc = " \\param vendor_id The Vendor ID (VID) of the types of device to open."] + #[doc = " \\param product_id The Product ID (PID) of the types of device to open."] + #[doc = " \\returns a pointer to a linked list of type SDL_hid_device_info, containing"] + #[doc = " information about the HID devices attached to the system, or NULL"] + #[doc = " in the case of failure. Free this linked list by calling"] + #[doc = " SDL_hid_free_enumeration()."] #[doc = ""] - #[doc = " \\sa SDL_HapticNumEffects"] - #[doc = " \\sa SDL_HapticEffectSupported"] - pub fn SDL_HapticQuery(haptic: *mut SDL_Haptic) -> libc::c_uint; -} -extern "C" { - #[doc = " \\brief Gets the number of haptic axes the device has."] + #[doc = " \\since This function is available since SDL 2.0.18."] #[doc = ""] - #[doc = " \\sa SDL_HapticDirection"] - pub fn SDL_HapticNumAxes(haptic: *mut SDL_Haptic) -> libc::c_int; + #[doc = " \\sa SDL_hid_device_change_count"] + pub fn SDL_hid_enumerate( + vendor_id: libc::c_ushort, + product_id: libc::c_ushort, + ) -> *mut SDL_hid_device_info; } extern "C" { - #[doc = " \\brief Checks to see if effect is supported by haptic."] - #[doc = ""] - #[doc = " \\param haptic Haptic device to check on."] - #[doc = " \\param effect Effect to check to see if it is supported."] - #[doc = " \\return SDL_TRUE if effect is supported, SDL_FALSE if it isn't or -1 on error."] + #[doc = " Free an enumeration Linked List"] #[doc = ""] - #[doc = " \\sa SDL_HapticQuery"] - #[doc = " \\sa SDL_HapticNewEffect"] - pub fn SDL_HapticEffectSupported( - haptic: *mut SDL_Haptic, - effect: *mut SDL_HapticEffect, - ) -> libc::c_int; -} -extern "C" { - #[doc = " \\brief Creates a new haptic effect on the device."] + #[doc = " This function frees a linked list created by SDL_hid_enumerate()."] #[doc = ""] - #[doc = " \\param haptic Haptic device to create the effect on."] - #[doc = " \\param effect Properties of the effect to create."] - #[doc = " \\return The identifier of the effect on success or -1 on error."] + #[doc = " \\param devs Pointer to a list of struct_device returned from"] + #[doc = " SDL_hid_enumerate()."] #[doc = ""] - #[doc = " \\sa SDL_HapticUpdateEffect"] - #[doc = " \\sa SDL_HapticRunEffect"] - #[doc = " \\sa SDL_HapticDestroyEffect"] - pub fn SDL_HapticNewEffect( - haptic: *mut SDL_Haptic, - effect: *mut SDL_HapticEffect, - ) -> libc::c_int; + #[doc = " \\since This function is available since SDL 2.0.18."] + pub fn SDL_hid_free_enumeration(devs: *mut SDL_hid_device_info); } extern "C" { - #[doc = " \\brief Updates the properties of an effect."] + #[doc = " Open a HID device using a Vendor ID (VID), Product ID (PID) and optionally"] + #[doc = " a serial number."] #[doc = ""] - #[doc = " Can be used dynamically, although behavior when dynamically changing"] - #[doc = " direction may be strange. Specifically the effect may reupload itself"] - #[doc = " and start playing from the start. You cannot change the type either when"] - #[doc = " running SDL_HapticUpdateEffect()."] + #[doc = " If `serial_number` is NULL, the first device with the specified VID and PID"] + #[doc = " is opened."] #[doc = ""] - #[doc = " \\param haptic Haptic device that has the effect."] - #[doc = " \\param effect Identifier of the effect to update."] - #[doc = " \\param data New effect properties to use."] - #[doc = " \\return 0 on success or -1 on error."] + #[doc = " \\param vendor_id The Vendor ID (VID) of the device to open."] + #[doc = " \\param product_id The Product ID (PID) of the device to open."] + #[doc = " \\param serial_number The Serial Number of the device to open (Optionally"] + #[doc = " NULL)."] + #[doc = " \\returns a pointer to a SDL_hid_device object on success or NULL on"] + #[doc = " failure."] #[doc = ""] - #[doc = " \\sa SDL_HapticNewEffect"] - #[doc = " \\sa SDL_HapticRunEffect"] - #[doc = " \\sa SDL_HapticDestroyEffect"] - pub fn SDL_HapticUpdateEffect( - haptic: *mut SDL_Haptic, - effect: libc::c_int, - data: *mut SDL_HapticEffect, - ) -> libc::c_int; + #[doc = " \\since This function is available since SDL 2.0.18."] + pub fn SDL_hid_open( + vendor_id: libc::c_ushort, + product_id: libc::c_ushort, + serial_number: *const wchar_t, + ) -> *mut SDL_hid_device; } extern "C" { - #[doc = " \\brief Runs the haptic effect on its associated haptic device."] + #[doc = " Open a HID device by its path name."] #[doc = ""] - #[doc = " If iterations are ::SDL_HAPTIC_INFINITY, it'll run the effect over and over"] - #[doc = " repeating the envelope (attack and fade) every time. If you only want the"] - #[doc = " effect to last forever, set ::SDL_HAPTIC_INFINITY in the effect's length"] - #[doc = " parameter."] + #[doc = " The path name be determined by calling SDL_hid_enumerate(), or a"] + #[doc = " platform-specific path name can be used (eg: /dev/hidraw0 on Linux)."] #[doc = ""] - #[doc = " \\param haptic Haptic device to run the effect on."] - #[doc = " \\param effect Identifier of the haptic effect to run."] - #[doc = " \\param iterations Number of iterations to run the effect. Use"] - #[doc = " ::SDL_HAPTIC_INFINITY for infinity."] - #[doc = " \\return 0 on success or -1 on error."] + #[doc = " \\param path The path name of the device to open"] + #[doc = " \\returns a pointer to a SDL_hid_device object on success or NULL on"] + #[doc = " failure."] #[doc = ""] - #[doc = " \\sa SDL_HapticStopEffect"] - #[doc = " \\sa SDL_HapticDestroyEffect"] - #[doc = " \\sa SDL_HapticGetEffectStatus"] - pub fn SDL_HapticRunEffect( - haptic: *mut SDL_Haptic, - effect: libc::c_int, - iterations: Uint32, - ) -> libc::c_int; + #[doc = " \\since This function is available since SDL 2.0.18."] + pub fn SDL_hid_open_path( + path: *const libc::c_char, + bExclusive: libc::c_int, + ) -> *mut SDL_hid_device; } extern "C" { - #[doc = " \\brief Stops the haptic effect on its associated haptic device."] + #[doc = " Write an Output report to a HID device."] #[doc = ""] - #[doc = " \\param haptic Haptic device to stop the effect on."] - #[doc = " \\param effect Identifier of the effect to stop."] - #[doc = " \\return 0 on success or -1 on error."] + #[doc = " The first byte of `data` must contain the Report ID. For devices which only"] + #[doc = " support a single report, this must be set to 0x0. The remaining bytes"] + #[doc = " contain the report data. Since the Report ID is mandatory, calls to"] + #[doc = " SDL_hid_write() will always contain one more byte than the report contains."] + #[doc = " For example, if a hid report is 16 bytes long, 17 bytes must be passed to"] + #[doc = " SDL_hid_write(), the Report ID (or 0x0, for devices with a single report),"] + #[doc = " followed by the report data (16 bytes). In this example, the length passed"] + #[doc = " in would be 17."] #[doc = ""] - #[doc = " \\sa SDL_HapticRunEffect"] - #[doc = " \\sa SDL_HapticDestroyEffect"] - pub fn SDL_HapticStopEffect(haptic: *mut SDL_Haptic, effect: libc::c_int) -> libc::c_int; + #[doc = " SDL_hid_write() will send the data on the first OUT endpoint, if one"] + #[doc = " exists. If it does not, it will send the data through the Control Endpoint"] + #[doc = " (Endpoint 0)."] + #[doc = ""] + #[doc = " \\param dev A device handle returned from SDL_hid_open()."] + #[doc = " \\param data The data to send, including the report number as the first"] + #[doc = " byte."] + #[doc = " \\param length The length in bytes of the data to send."] + #[doc = " \\returns the actual number of bytes written and -1 on error."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.18."] + pub fn SDL_hid_write( + dev: *mut SDL_hid_device, + data: *const libc::c_uchar, + length: size_t, + ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Destroys a haptic effect on the device."] + #[doc = " Read an Input report from a HID device with timeout."] #[doc = ""] - #[doc = " This will stop the effect if it's running. Effects are automatically"] - #[doc = " destroyed when the device is closed."] + #[doc = " Input reports are returned to the host through the INTERRUPT IN endpoint."] + #[doc = " The first byte will contain the Report number if the device uses numbered"] + #[doc = " reports."] #[doc = ""] - #[doc = " \\param haptic Device to destroy the effect on."] - #[doc = " \\param effect Identifier of the effect to destroy."] + #[doc = " \\param dev A device handle returned from SDL_hid_open()."] + #[doc = " \\param data A buffer to put the read data into."] + #[doc = " \\param length The number of bytes to read. For devices with multiple"] + #[doc = " reports, make sure to read an extra byte for the report"] + #[doc = " number."] + #[doc = " \\param milliseconds timeout in milliseconds or -1 for blocking wait."] + #[doc = " \\returns the actual number of bytes read and -1 on error. If no packet was"] + #[doc = " available to be read within the timeout period, this function"] + #[doc = " returns 0."] #[doc = ""] - #[doc = " \\sa SDL_HapticNewEffect"] - pub fn SDL_HapticDestroyEffect(haptic: *mut SDL_Haptic, effect: libc::c_int); + #[doc = " \\since This function is available since SDL 2.0.18."] + pub fn SDL_hid_read_timeout( + dev: *mut SDL_hid_device, + data: *mut libc::c_uchar, + length: size_t, + milliseconds: libc::c_int, + ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Gets the status of the current effect on the haptic device."] + #[doc = " Read an Input report from a HID device."] #[doc = ""] - #[doc = " Device must support the ::SDL_HAPTIC_STATUS feature."] + #[doc = " Input reports are returned to the host through the INTERRUPT IN endpoint."] + #[doc = " The first byte will contain the Report number if the device uses numbered"] + #[doc = " reports."] #[doc = ""] - #[doc = " \\param haptic Haptic device to query the effect status on."] - #[doc = " \\param effect Identifier of the effect to query its status."] - #[doc = " \\return 0 if it isn't playing, 1 if it is playing or -1 on error."] + #[doc = " \\param dev A device handle returned from SDL_hid_open()."] + #[doc = " \\param data A buffer to put the read data into."] + #[doc = " \\param length The number of bytes to read. For devices with multiple"] + #[doc = " reports, make sure to read an extra byte for the report"] + #[doc = " number."] + #[doc = " \\returns the actual number of bytes read and -1 on error. If no packet was"] + #[doc = " available to be read and the handle is in non-blocking mode, this"] + #[doc = " function returns 0."] #[doc = ""] - #[doc = " \\sa SDL_HapticRunEffect"] - #[doc = " \\sa SDL_HapticStopEffect"] - pub fn SDL_HapticGetEffectStatus(haptic: *mut SDL_Haptic, effect: libc::c_int) -> libc::c_int; + #[doc = " \\since This function is available since SDL 2.0.18."] + pub fn SDL_hid_read( + dev: *mut SDL_hid_device, + data: *mut libc::c_uchar, + length: size_t, + ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Sets the global gain of the device."] + #[doc = " Set the device handle to be non-blocking."] #[doc = ""] - #[doc = " Device must support the ::SDL_HAPTIC_GAIN feature."] + #[doc = " In non-blocking mode calls to SDL_hid_read() will return immediately with a"] + #[doc = " value of 0 if there is no data to be read. In blocking mode, SDL_hid_read()"] + #[doc = " will wait (block) until there is data to read before returning."] #[doc = ""] - #[doc = " The user may specify the maximum gain by setting the environment variable"] - #[doc = " SDL_HAPTIC_GAIN_MAX which should be between 0 and 100. All calls to"] - #[doc = " SDL_HapticSetGain() will scale linearly using SDL_HAPTIC_GAIN_MAX as the"] - #[doc = " maximum."] + #[doc = " Nonblocking can be turned on and off at any time."] #[doc = ""] - #[doc = " \\param haptic Haptic device to set the gain on."] - #[doc = " \\param gain Value to set the gain to, should be between 0 and 100."] - #[doc = " \\return 0 on success or -1 on error."] + #[doc = " \\param dev A device handle returned from SDL_hid_open()."] + #[doc = " \\param nonblock enable or not the nonblocking reads - 1 to enable"] + #[doc = " nonblocking - 0 to disable nonblocking."] + #[doc = " \\returns 0 on success and -1 on error."] #[doc = ""] - #[doc = " \\sa SDL_HapticQuery"] - pub fn SDL_HapticSetGain(haptic: *mut SDL_Haptic, gain: libc::c_int) -> libc::c_int; + #[doc = " \\since This function is available since SDL 2.0.18."] + pub fn SDL_hid_set_nonblocking(dev: *mut SDL_hid_device, nonblock: libc::c_int) -> libc::c_int; } extern "C" { - #[doc = " \\brief Sets the global autocenter of the device."] - #[doc = ""] - #[doc = " Autocenter should be between 0 and 100. Setting it to 0 will disable"] - #[doc = " autocentering."] + #[doc = " Send a Feature report to the device."] #[doc = ""] - #[doc = " Device must support the ::SDL_HAPTIC_AUTOCENTER feature."] + #[doc = " Feature reports are sent over the Control endpoint as a Set_Report"] + #[doc = " transfer. The first byte of `data` must contain the Report ID. For devices"] + #[doc = " which only support a single report, this must be set to 0x0. The remaining"] + #[doc = " bytes contain the report data. Since the Report ID is mandatory, calls to"] + #[doc = " SDL_hid_send_feature_report() will always contain one more byte than the"] + #[doc = " report contains. For example, if a hid report is 16 bytes long, 17 bytes"] + #[doc = " must be passed to SDL_hid_send_feature_report(): the Report ID (or 0x0, for"] + #[doc = " devices which do not use numbered reports), followed by the report data (16"] + #[doc = " bytes). In this example, the length passed in would be 17."] #[doc = ""] - #[doc = " \\param haptic Haptic device to set autocentering on."] - #[doc = " \\param autocenter Value to set autocenter to, 0 disables autocentering."] - #[doc = " \\return 0 on success or -1 on error."] + #[doc = " \\param dev A device handle returned from SDL_hid_open()."] + #[doc = " \\param data The data to send, including the report number as the first"] + #[doc = " byte."] + #[doc = " \\param length The length in bytes of the data to send, including the report"] + #[doc = " number."] + #[doc = " \\returns the actual number of bytes written and -1 on error."] #[doc = ""] - #[doc = " \\sa SDL_HapticQuery"] - pub fn SDL_HapticSetAutocenter(haptic: *mut SDL_Haptic, autocenter: libc::c_int) - -> libc::c_int; + #[doc = " \\since This function is available since SDL 2.0.18."] + pub fn SDL_hid_send_feature_report( + dev: *mut SDL_hid_device, + data: *const libc::c_uchar, + length: size_t, + ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Pauses a haptic device."] - #[doc = ""] - #[doc = " Device must support the ::SDL_HAPTIC_PAUSE feature. Call"] - #[doc = " SDL_HapticUnpause() to resume playback."] + #[doc = " Get a feature report from a HID device."] #[doc = ""] - #[doc = " Do not modify the effects nor add new ones while the device is paused."] - #[doc = " That can cause all sorts of weird errors."] + #[doc = " Set the first byte of `data` to the Report ID of the report to be read."] + #[doc = " Make sure to allow space for this extra byte in `data`. Upon return, the"] + #[doc = " first byte will still contain the Report ID, and the report data will start"] + #[doc = " in data[1]."] #[doc = ""] - #[doc = " \\param haptic Haptic device to pause."] - #[doc = " \\return 0 on success or -1 on error."] + #[doc = " \\param dev A device handle returned from SDL_hid_open()."] + #[doc = " \\param data A buffer to put the read data into, including the Report ID."] + #[doc = " Set the first byte of `data` to the Report ID of the report to"] + #[doc = " be read, or set it to zero if your device does not use numbered"] + #[doc = " reports."] + #[doc = " \\param length The number of bytes to read, including an extra byte for the"] + #[doc = " report ID. The buffer can be longer than the actual report."] + #[doc = " \\returns the number of bytes read plus one for the report ID (which is"] + #[doc = " still in the first byte), or -1 on error."] #[doc = ""] - #[doc = " \\sa SDL_HapticUnpause"] - pub fn SDL_HapticPause(haptic: *mut SDL_Haptic) -> libc::c_int; + #[doc = " \\since This function is available since SDL 2.0.18."] + pub fn SDL_hid_get_feature_report( + dev: *mut SDL_hid_device, + data: *mut libc::c_uchar, + length: size_t, + ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Unpauses a haptic device."] + #[doc = " Close a HID device."] #[doc = ""] - #[doc = " Call to unpause after SDL_HapticPause()."] + #[doc = " \\param dev A device handle returned from SDL_hid_open()."] #[doc = ""] - #[doc = " \\param haptic Haptic device to unpause."] - #[doc = " \\return 0 on success or -1 on error."] - #[doc = ""] - #[doc = " \\sa SDL_HapticPause"] - pub fn SDL_HapticUnpause(haptic: *mut SDL_Haptic) -> libc::c_int; + #[doc = " \\since This function is available since SDL 2.0.18."] + pub fn SDL_hid_close(dev: *mut SDL_hid_device); } extern "C" { - #[doc = " \\brief Stops all the currently playing effects on a haptic device."] + #[doc = " Get The Manufacturer String from a HID device."] #[doc = ""] - #[doc = " \\param haptic Haptic device to stop."] - #[doc = " \\return 0 on success or -1 on error."] - pub fn SDL_HapticStopAll(haptic: *mut SDL_Haptic) -> libc::c_int; + #[doc = " \\param dev A device handle returned from SDL_hid_open()."] + #[doc = " \\param string A wide string buffer to put the data into."] + #[doc = " \\param maxlen The length of the buffer in multiples of wchar_t."] + #[doc = " \\returns 0 on success and -1 on error."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.18."] + pub fn SDL_hid_get_manufacturer_string( + dev: *mut SDL_hid_device, + string: *mut wchar_t, + maxlen: size_t, + ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Checks to see if rumble is supported on a haptic device."] + #[doc = " Get The Product String from a HID device."] #[doc = ""] - #[doc = " \\param haptic Haptic device to check to see if it supports rumble."] - #[doc = " \\return SDL_TRUE if effect is supported, SDL_FALSE if it isn't or -1 on error."] + #[doc = " \\param dev A device handle returned from SDL_hid_open()."] + #[doc = " \\param string A wide string buffer to put the data into."] + #[doc = " \\param maxlen The length of the buffer in multiples of wchar_t."] + #[doc = " \\returns 0 on success and -1 on error."] #[doc = ""] - #[doc = " \\sa SDL_HapticRumbleInit"] - #[doc = " \\sa SDL_HapticRumblePlay"] - #[doc = " \\sa SDL_HapticRumbleStop"] - pub fn SDL_HapticRumbleSupported(haptic: *mut SDL_Haptic) -> libc::c_int; + #[doc = " \\since This function is available since SDL 2.0.18."] + pub fn SDL_hid_get_product_string( + dev: *mut SDL_hid_device, + string: *mut wchar_t, + maxlen: size_t, + ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Initializes the haptic device for simple rumble playback."] + #[doc = " Get The Serial Number String from a HID device."] #[doc = ""] - #[doc = " \\param haptic Haptic device to initialize for simple rumble playback."] - #[doc = " \\return 0 on success or -1 on error."] + #[doc = " \\param dev A device handle returned from SDL_hid_open()."] + #[doc = " \\param string A wide string buffer to put the data into."] + #[doc = " \\param maxlen The length of the buffer in multiples of wchar_t."] + #[doc = " \\returns 0 on success and -1 on error."] #[doc = ""] - #[doc = " \\sa SDL_HapticOpen"] - #[doc = " \\sa SDL_HapticRumbleSupported"] - #[doc = " \\sa SDL_HapticRumblePlay"] - #[doc = " \\sa SDL_HapticRumbleStop"] - pub fn SDL_HapticRumbleInit(haptic: *mut SDL_Haptic) -> libc::c_int; + #[doc = " \\since This function is available since SDL 2.0.18."] + pub fn SDL_hid_get_serial_number_string( + dev: *mut SDL_hid_device, + string: *mut wchar_t, + maxlen: size_t, + ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Runs simple rumble on a haptic device"] + #[doc = " Get a string from a HID device, based on its string index."] #[doc = ""] - #[doc = " \\param haptic Haptic device to play rumble effect on."] - #[doc = " \\param strength Strength of the rumble to play as a 0-1 float value."] - #[doc = " \\param length Length of the rumble to play in milliseconds."] - #[doc = " \\return 0 on success or -1 on error."] + #[doc = " \\param dev A device handle returned from SDL_hid_open()."] + #[doc = " \\param string_index The index of the string to get."] + #[doc = " \\param string A wide string buffer to put the data into."] + #[doc = " \\param maxlen The length of the buffer in multiples of wchar_t."] + #[doc = " \\returns 0 on success and -1 on error."] #[doc = ""] - #[doc = " \\sa SDL_HapticRumbleSupported"] - #[doc = " \\sa SDL_HapticRumbleInit"] - #[doc = " \\sa SDL_HapticRumbleStop"] - pub fn SDL_HapticRumblePlay( - haptic: *mut SDL_Haptic, - strength: f32, - length: Uint32, + #[doc = " \\since This function is available since SDL 2.0.18."] + pub fn SDL_hid_get_indexed_string( + dev: *mut SDL_hid_device, + string_index: libc::c_int, + string: *mut wchar_t, + maxlen: size_t, ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Stops the simple rumble on a haptic device."] + #[doc = " Start or stop a BLE scan on iOS and tvOS to pair Steam Controllers"] #[doc = ""] - #[doc = " \\param haptic Haptic to stop the rumble on."] - #[doc = " \\return 0 on success or -1 on error."] + #[doc = " \\param active SDL_TRUE to start the scan, SDL_FALSE to stop the scan"] #[doc = ""] - #[doc = " \\sa SDL_HapticRumbleSupported"] - #[doc = " \\sa SDL_HapticRumbleInit"] - #[doc = " \\sa SDL_HapticRumblePlay"] - pub fn SDL_HapticRumbleStop(haptic: *mut SDL_Haptic) -> libc::c_int; + #[doc = " \\since This function is available since SDL 2.0.18."] + pub fn SDL_hid_ble_scan(active: SDL_bool); } #[repr(u32)] #[doc = " \\brief An enumeration of hint priorities"] @@ -16241,13 +21853,21 @@ pub enum SDL_HintPriority { SDL_HINT_OVERRIDE = 2, } extern "C" { - #[doc = " \\brief Set a hint with a specific priority"] + #[doc = " Set a hint with a specific priority."] + #[doc = ""] + #[doc = " The priority controls the behavior when setting a hint that already has a"] + #[doc = " value. Hints will replace existing hints of their priority and lower."] + #[doc = " Environment variables are considered to have override priority."] + #[doc = ""] + #[doc = " \\param name the hint to set"] + #[doc = " \\param value the value of the hint variable"] + #[doc = " \\param priority the SDL_HintPriority level for the hint"] + #[doc = " \\returns SDL_TRUE if the hint was set, SDL_FALSE otherwise."] #[doc = ""] - #[doc = " The priority controls the behavior when setting a hint that already"] - #[doc = " has a value. Hints will replace existing hints of their priority and"] - #[doc = " lower. Environment variables are considered to have override priority."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\return SDL_TRUE if the hint was set, SDL_FALSE otherwise"] + #[doc = " \\sa SDL_GetHint"] + #[doc = " \\sa SDL_SetHint"] pub fn SDL_SetHintWithPriority( name: *const libc::c_char, value: *const libc::c_char, @@ -16255,24 +21875,54 @@ extern "C" { ) -> SDL_bool; } extern "C" { - #[doc = " \\brief Set a hint with normal priority"] + #[doc = " Set a hint with normal priority."] #[doc = ""] - #[doc = " \\return SDL_TRUE if the hint was set, SDL_FALSE otherwise"] + #[doc = " Hints will not be set if there is an existing override hint or environment"] + #[doc = " variable that takes precedence. You can use SDL_SetHintWithPriority() to"] + #[doc = " set the hint with override priority instead."] + #[doc = ""] + #[doc = " \\param name the hint to set"] + #[doc = " \\param value the value of the hint variable"] + #[doc = " \\returns SDL_TRUE if the hint was set, SDL_FALSE otherwise."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetHint"] + #[doc = " \\sa SDL_SetHintWithPriority"] pub fn SDL_SetHint(name: *const libc::c_char, value: *const libc::c_char) -> SDL_bool; } extern "C" { - #[doc = " \\brief Get a hint"] + #[doc = " Get the value of a hint."] + #[doc = ""] + #[doc = " \\param name the hint to query"] + #[doc = " \\returns the string value of a hint or NULL if the hint isn't set."] #[doc = ""] - #[doc = " \\return The string value of a hint variable."] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_SetHint"] + #[doc = " \\sa SDL_SetHintWithPriority"] pub fn SDL_GetHint(name: *const libc::c_char) -> *const libc::c_char; } extern "C" { - #[doc = " \\brief Get a hint"] + #[doc = " Get the boolean value of a hint variable."] + #[doc = ""] + #[doc = " \\param name the name of the hint to get the boolean value from"] + #[doc = " \\param default_value the value to return if the hint does not exist"] + #[doc = " \\returns the boolean value of a hint or the provided default value if the"] + #[doc = " hint does not exist."] #[doc = ""] - #[doc = " \\return The boolean value of a hint variable."] + #[doc = " \\since This function is available since SDL 2.0.5."] + #[doc = ""] + #[doc = " \\sa SDL_GetHint"] + #[doc = " \\sa SDL_SetHint"] pub fn SDL_GetHintBoolean(name: *const libc::c_char, default_value: SDL_bool) -> SDL_bool; } -#[doc = " \\brief type definition of the hint callback function."] +#[doc = " Type definition of the hint callback function."] +#[doc = ""] +#[doc = " \\param userdata what was passed as `userdata` to SDL_AddHintCallback()"] +#[doc = " \\param name what was passed as `name` to SDL_AddHintCallback()"] +#[doc = " \\param oldValue the previous hint value"] +#[doc = " \\param newValue the new value hint is to be set to"] pub type SDL_HintCallback = ::core::option::Option< unsafe extern "C" fn( userdata: *mut libc::c_void, @@ -16282,11 +21932,16 @@ pub type SDL_HintCallback = ::core::option::Option< ), >; extern "C" { - #[doc = " \\brief Add a function to watch a particular hint"] + #[doc = " Add a function to watch a particular hint."] #[doc = ""] - #[doc = " \\param name The hint to watch"] - #[doc = " \\param callback The function to call when the hint value changes"] - #[doc = " \\param userdata A pointer to pass to the callback function"] + #[doc = " \\param name the hint to watch"] + #[doc = " \\param callback An SDL_HintCallback function that will be called when the"] + #[doc = " hint value changes"] + #[doc = " \\param userdata a pointer to pass to the callback function"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_DelHintCallback"] pub fn SDL_AddHintCallback( name: *const libc::c_char, callback: SDL_HintCallback, @@ -16294,11 +21949,16 @@ extern "C" { ); } extern "C" { - #[doc = " \\brief Remove a function watching a particular hint"] + #[doc = " Remove a function watching a particular hint."] + #[doc = ""] + #[doc = " \\param name the hint being watched"] + #[doc = " \\param callback An SDL_HintCallback function that will be called when the"] + #[doc = " hint value changes"] + #[doc = " \\param userdata a pointer being passed to the callback function"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\param name The hint being watched"] - #[doc = " \\param callback The function being called when the hint value changes"] - #[doc = " \\param userdata A pointer being passed to the callback function"] + #[doc = " \\sa SDL_AddHintCallback"] pub fn SDL_DelHintCallback( name: *const libc::c_char, callback: SDL_HintCallback, @@ -16306,28 +21966,64 @@ extern "C" { ); } extern "C" { - #[doc = " \\brief Clear all hints"] + #[doc = " Clear all hints."] #[doc = ""] - #[doc = " This function is called during SDL_Quit() to free stored hints."] + #[doc = " This function is automatically called during SDL_Quit()."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_ClearHints(); } extern "C" { - #[doc = " This function dynamically loads a shared object and returns a pointer"] - #[doc = " to the object handle (or NULL if there was an error)."] - #[doc = " The 'sofile' parameter is a system dependent name of the object file."] + #[doc = " Dynamically load a shared object."] + #[doc = ""] + #[doc = " \\param sofile a system-dependent name of the object file"] + #[doc = " \\returns an opaque pointer to the object handle or NULL if there was an"] + #[doc = " error; call SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_LoadFunction"] + #[doc = " \\sa SDL_UnloadObject"] pub fn SDL_LoadObject(sofile: *const libc::c_char) -> *mut libc::c_void; } extern "C" { - #[doc = " Given an object handle, this function looks up the address of the"] - #[doc = " named function in the shared object and returns it. This address"] - #[doc = " is no longer valid after calling SDL_UnloadObject()."] + #[doc = " Look up the address of the named function in a shared object."] + #[doc = ""] + #[doc = " This function pointer is no longer valid after calling SDL_UnloadObject()."] + #[doc = ""] + #[doc = " This function can only look up C function names. Other languages may have"] + #[doc = " name mangling and intrinsic language support that varies from compiler to"] + #[doc = " compiler."] + #[doc = ""] + #[doc = " Make sure you declare your function pointers with the same calling"] + #[doc = " convention as the actual library function. Your code will crash"] + #[doc = " mysteriously if you do not do this."] + #[doc = ""] + #[doc = " If the requested function doesn't exist, NULL is returned."] + #[doc = ""] + #[doc = " \\param handle a valid shared object handle returned by SDL_LoadObject()"] + #[doc = " \\param name the name of the function to look up"] + #[doc = " \\returns a pointer to the function or NULL if there was an error; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_LoadObject"] + #[doc = " \\sa SDL_UnloadObject"] pub fn SDL_LoadFunction( handle: *mut libc::c_void, name: *const libc::c_char, ) -> *mut libc::c_void; } extern "C" { - #[doc = " Unload a shared object from memory."] + #[doc = " Unload a shared object from memory."] + #[doc = ""] + #[doc = " \\param handle a valid shared object handle returned by SDL_LoadObject()"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_LoadFunction"] + #[doc = " \\sa SDL_LoadObject"] pub fn SDL_UnloadObject(handle: *mut libc::c_void); } #[repr(u32)] @@ -16373,53 +22069,208 @@ pub enum SDL_LogPriority { SDL_NUM_LOG_PRIORITIES = 7, } extern "C" { - #[doc = " \\brief Set the priority of all log categories"] + #[doc = " Set the priority of all log categories."] + #[doc = ""] + #[doc = " \\param priority the SDL_LogPriority to assign"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_LogSetPriority"] pub fn SDL_LogSetAllPriority(priority: SDL_LogPriority); } extern "C" { - #[doc = " \\brief Set the priority of a particular log category"] + #[doc = " Set the priority of a particular log category."] + #[doc = ""] + #[doc = " \\param category the category to assign a priority to"] + #[doc = " \\param priority the SDL_LogPriority to assign"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_LogGetPriority"] + #[doc = " \\sa SDL_LogSetAllPriority"] pub fn SDL_LogSetPriority(category: libc::c_int, priority: SDL_LogPriority); } extern "C" { - #[doc = " \\brief Get the priority of a particular log category"] + #[doc = " Get the priority of a particular log category."] + #[doc = ""] + #[doc = " \\param category the category to query"] + #[doc = " \\returns the SDL_LogPriority for the requested category"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_LogSetPriority"] pub fn SDL_LogGetPriority(category: libc::c_int) -> SDL_LogPriority; } extern "C" { - #[doc = " \\brief Reset all priorities to default."] + #[doc = " Reset all priorities to default."] + #[doc = ""] + #[doc = " This is called by SDL_Quit()."] #[doc = ""] - #[doc = " \\note This is called in SDL_Quit()."] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_LogSetAllPriority"] + #[doc = " \\sa SDL_LogSetPriority"] pub fn SDL_LogResetPriorities(); } extern "C" { - #[doc = " \\brief Log a message with SDL_LOG_CATEGORY_APPLICATION and SDL_LOG_PRIORITY_INFO"] + #[doc = " Log a message with SDL_LOG_CATEGORY_APPLICATION and SDL_LOG_PRIORITY_INFO."] + #[doc = ""] + #[doc = " = * \\param fmt a printf() style message format string"] + #[doc = ""] + #[doc = " \\param ... additional parameters matching % tokens in the `fmt` string, if"] + #[doc = " any"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_LogCritical"] + #[doc = " \\sa SDL_LogDebug"] + #[doc = " \\sa SDL_LogError"] + #[doc = " \\sa SDL_LogInfo"] + #[doc = " \\sa SDL_LogMessage"] + #[doc = " \\sa SDL_LogMessageV"] + #[doc = " \\sa SDL_LogVerbose"] + #[doc = " \\sa SDL_LogWarn"] pub fn SDL_Log(fmt: *const libc::c_char, ...); } extern "C" { - #[doc = " \\brief Log a message with SDL_LOG_PRIORITY_VERBOSE"] + #[doc = " Log a message with SDL_LOG_PRIORITY_VERBOSE."] + #[doc = ""] + #[doc = " \\param category the category of the message"] + #[doc = " \\param fmt a printf() style message format string"] + #[doc = " \\param ... additional parameters matching % tokens in the **fmt** string,"] + #[doc = " if any"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_Log"] + #[doc = " \\sa SDL_LogCritical"] + #[doc = " \\sa SDL_LogDebug"] + #[doc = " \\sa SDL_LogError"] + #[doc = " \\sa SDL_LogInfo"] + #[doc = " \\sa SDL_LogMessage"] + #[doc = " \\sa SDL_LogMessageV"] + #[doc = " \\sa SDL_LogWarn"] pub fn SDL_LogVerbose(category: libc::c_int, fmt: *const libc::c_char, ...); } extern "C" { - #[doc = " \\brief Log a message with SDL_LOG_PRIORITY_DEBUG"] + #[doc = " Log a message with SDL_LOG_PRIORITY_DEBUG."] + #[doc = ""] + #[doc = " \\param category the category of the message"] + #[doc = " \\param fmt a printf() style message format string"] + #[doc = " \\param ... additional parameters matching % tokens in the **fmt** string,"] + #[doc = " if any"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_Log"] + #[doc = " \\sa SDL_LogCritical"] + #[doc = " \\sa SDL_LogError"] + #[doc = " \\sa SDL_LogInfo"] + #[doc = " \\sa SDL_LogMessage"] + #[doc = " \\sa SDL_LogMessageV"] + #[doc = " \\sa SDL_LogVerbose"] + #[doc = " \\sa SDL_LogWarn"] pub fn SDL_LogDebug(category: libc::c_int, fmt: *const libc::c_char, ...); } extern "C" { - #[doc = " \\brief Log a message with SDL_LOG_PRIORITY_INFO"] + #[doc = " Log a message with SDL_LOG_PRIORITY_INFO."] + #[doc = ""] + #[doc = " \\param category the category of the message"] + #[doc = " \\param fmt a printf() style message format string"] + #[doc = " \\param ... additional parameters matching % tokens in the **fmt** string,"] + #[doc = " if any"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_Log"] + #[doc = " \\sa SDL_LogCritical"] + #[doc = " \\sa SDL_LogDebug"] + #[doc = " \\sa SDL_LogError"] + #[doc = " \\sa SDL_LogMessage"] + #[doc = " \\sa SDL_LogMessageV"] + #[doc = " \\sa SDL_LogVerbose"] + #[doc = " \\sa SDL_LogWarn"] pub fn SDL_LogInfo(category: libc::c_int, fmt: *const libc::c_char, ...); } extern "C" { - #[doc = " \\brief Log a message with SDL_LOG_PRIORITY_WARN"] + #[doc = " Log a message with SDL_LOG_PRIORITY_WARN."] + #[doc = ""] + #[doc = " \\param category the category of the message"] + #[doc = " \\param fmt a printf() style message format string"] + #[doc = " \\param ... additional parameters matching % tokens in the **fmt** string,"] + #[doc = " if any"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_Log"] + #[doc = " \\sa SDL_LogCritical"] + #[doc = " \\sa SDL_LogDebug"] + #[doc = " \\sa SDL_LogError"] + #[doc = " \\sa SDL_LogInfo"] + #[doc = " \\sa SDL_LogMessage"] + #[doc = " \\sa SDL_LogMessageV"] + #[doc = " \\sa SDL_LogVerbose"] pub fn SDL_LogWarn(category: libc::c_int, fmt: *const libc::c_char, ...); } extern "C" { - #[doc = " \\brief Log a message with SDL_LOG_PRIORITY_ERROR"] + #[doc = " Log a message with SDL_LOG_PRIORITY_ERROR."] + #[doc = ""] + #[doc = " \\param category the category of the message"] + #[doc = " \\param fmt a printf() style message format string"] + #[doc = " \\param ... additional parameters matching % tokens in the **fmt** string,"] + #[doc = " if any"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_Log"] + #[doc = " \\sa SDL_LogCritical"] + #[doc = " \\sa SDL_LogDebug"] + #[doc = " \\sa SDL_LogInfo"] + #[doc = " \\sa SDL_LogMessage"] + #[doc = " \\sa SDL_LogMessageV"] + #[doc = " \\sa SDL_LogVerbose"] + #[doc = " \\sa SDL_LogWarn"] pub fn SDL_LogError(category: libc::c_int, fmt: *const libc::c_char, ...); } extern "C" { - #[doc = " \\brief Log a message with SDL_LOG_PRIORITY_CRITICAL"] + #[doc = " Log a message with SDL_LOG_PRIORITY_CRITICAL."] + #[doc = ""] + #[doc = " \\param category the category of the message"] + #[doc = " \\param fmt a printf() style message format string"] + #[doc = " \\param ... additional parameters matching % tokens in the **fmt** string,"] + #[doc = " if any"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_Log"] + #[doc = " \\sa SDL_LogDebug"] + #[doc = " \\sa SDL_LogError"] + #[doc = " \\sa SDL_LogInfo"] + #[doc = " \\sa SDL_LogMessage"] + #[doc = " \\sa SDL_LogMessageV"] + #[doc = " \\sa SDL_LogVerbose"] + #[doc = " \\sa SDL_LogWarn"] pub fn SDL_LogCritical(category: libc::c_int, fmt: *const libc::c_char, ...); } extern "C" { - #[doc = " \\brief Log a message with the specified category and priority."] + #[doc = " Log a message with the specified category and priority."] + #[doc = ""] + #[doc = " \\param category the category of the message"] + #[doc = " \\param priority the priority of the message"] + #[doc = " \\param fmt a printf() style message format string"] + #[doc = " \\param ... additional parameters matching % tokens in the **fmt** string,"] + #[doc = " if any"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_Log"] + #[doc = " \\sa SDL_LogCritical"] + #[doc = " \\sa SDL_LogDebug"] + #[doc = " \\sa SDL_LogError"] + #[doc = " \\sa SDL_LogInfo"] + #[doc = " \\sa SDL_LogMessageV"] + #[doc = " \\sa SDL_LogVerbose"] + #[doc = " \\sa SDL_LogWarn"] pub fn SDL_LogMessage( category: libc::c_int, priority: SDL_LogPriority, @@ -16428,7 +22279,23 @@ extern "C" { ); } extern "C" { - #[doc = " \\brief Log a message with the specified category and priority."] + #[doc = " Log a message with the specified category and priority."] + #[doc = ""] + #[doc = " \\param category the category of the message"] + #[doc = " \\param priority the priority of the message"] + #[doc = " \\param fmt a printf() style message format string"] + #[doc = " \\param ap a variable argument list"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_Log"] + #[doc = " \\sa SDL_LogCritical"] + #[doc = " \\sa SDL_LogDebug"] + #[doc = " \\sa SDL_LogError"] + #[doc = " \\sa SDL_LogInfo"] + #[doc = " \\sa SDL_LogMessage"] + #[doc = " \\sa SDL_LogVerbose"] + #[doc = " \\sa SDL_LogWarn"] pub fn SDL_LogMessageV( category: libc::c_int, priority: SDL_LogPriority, @@ -16436,7 +22303,14 @@ extern "C" { ap: *mut __va_list_tag, ); } -#[doc = " \\brief The prototype for the log output function"] +#[doc = " The prototype for the log output callback function."] +#[doc = ""] +#[doc = " This function is called by SDL when there is new text to be logged."] +#[doc = ""] +#[doc = " \\param userdata what was passed as `userdata` to SDL_LogSetOutputFunction()"] +#[doc = " \\param category the category of the message"] +#[doc = " \\param priority the priority of the message"] +#[doc = " \\param message the message being output"] pub type SDL_LogOutputFunction = ::core::option::Option< unsafe extern "C" fn( userdata: *mut libc::c_void, @@ -16446,19 +22320,34 @@ pub type SDL_LogOutputFunction = ::core::option::Option< ), >; extern "C" { - #[doc = " \\brief Get the current log output function."] + #[doc = " Get the current log output function."] + #[doc = ""] + #[doc = " \\param callback an SDL_LogOutputFunction filled in with the current log"] + #[doc = " callback"] + #[doc = " \\param userdata a pointer filled in with the pointer that is passed to"] + #[doc = " `callback`"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_LogSetOutputFunction"] pub fn SDL_LogGetOutputFunction( callback: *mut SDL_LogOutputFunction, userdata: *mut *mut libc::c_void, ); } extern "C" { - #[doc = " \\brief This function allows you to replace the default log output"] - #[doc = " function with one of your own."] + #[doc = " Replace the default log output function with one of your own."] + #[doc = ""] + #[doc = " \\param callback an SDL_LogOutputFunction to call instead of the default"] + #[doc = " \\param userdata a pointer that is passed to `callback`"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_LogGetOutputFunction"] pub fn SDL_LogSetOutputFunction(callback: SDL_LogOutputFunction, userdata: *mut libc::c_void); } #[repr(u32)] -#[doc = " \\brief SDL_MessageBox flags. If supported will display warning icon, etc."] +#[doc = " SDL_MessageBox flags. If supported will display warning icon, etc."] #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub enum SDL_MessageBoxFlags { #[doc = "< error dialog"] @@ -16473,7 +22362,7 @@ pub enum SDL_MessageBoxFlags { SDL_MESSAGEBOX_BUTTONS_RIGHT_TO_LEFT = 256, } #[repr(u32)] -#[doc = " \\brief Flags for SDL_MessageBoxButtonData."] +#[doc = " Flags for SDL_MessageBoxButtonData."] #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub enum SDL_MessageBoxButtonFlags { #[doc = "< Marks the default button when return is hit"] @@ -16481,7 +22370,7 @@ pub enum SDL_MessageBoxButtonFlags { #[doc = "< Marks the default button when escape is hit"] SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT = 2, } -#[doc = " \\brief Individual button data."] +#[doc = " Individual button data."] #[repr(C)] #[derive(Copy, Clone)] pub struct SDL_MessageBoxButtonData { @@ -16537,7 +22426,7 @@ fn bindgen_test_layout_SDL_MessageBoxButtonData() { ) ); } -#[doc = " \\brief RGB value used in a message box color scheme"] +#[doc = " RGB value used in a message box color scheme"] #[repr(C)] #[derive(Copy, Clone)] pub struct SDL_MessageBoxColor { @@ -16598,7 +22487,7 @@ pub enum SDL_MessageBoxColorType { SDL_MESSAGEBOX_COLOR_BUTTON_SELECTED = 4, SDL_MESSAGEBOX_COLOR_MAX = 5, } -#[doc = " \\brief A set of colors to use for message box dialogs"] +#[doc = " A set of colors to use for message box dialogs"] #[repr(C)] #[derive(Copy, Clone)] pub struct SDL_MessageBoxColorScheme { @@ -16629,7 +22518,7 @@ fn bindgen_test_layout_SDL_MessageBoxColorScheme() { ) ); } -#[doc = " \\brief MessageBox structure containing title, text, window, etc."] +#[doc = " MessageBox structure containing title, text, window, etc."] #[repr(C)] #[derive(Copy, Clone)] pub struct SDL_MessageBoxData { @@ -16730,34 +22619,81 @@ fn bindgen_test_layout_SDL_MessageBoxData() { ); } extern "C" { - #[doc = " \\brief Create a modal message box."] + #[doc = " Create a modal message box."] + #[doc = ""] + #[doc = " If your needs aren't complex, it might be easier to use"] + #[doc = " SDL_ShowSimpleMessageBox."] + #[doc = ""] + #[doc = " This function should be called on the thread that created the parent"] + #[doc = " window, or on the main thread if the messagebox has no parent. It will"] + #[doc = " block execution of that thread until the user clicks a button or closes the"] + #[doc = " messagebox."] + #[doc = ""] + #[doc = " This function may be called at any time, even before SDL_Init(). This makes"] + #[doc = " it useful for reporting errors like a failure to create a renderer or"] + #[doc = " OpenGL context."] #[doc = ""] - #[doc = " \\param messageboxdata The SDL_MessageBoxData structure with title, text, etc."] - #[doc = " \\param buttonid The pointer to which user id of hit button should be copied."] + #[doc = " On X11, SDL rolls its own dialog box with X11 primitives instead of a"] + #[doc = " formal toolkit like GTK+ or Qt."] #[doc = ""] - #[doc = " \\return -1 on error, otherwise 0 and buttonid contains user id of button"] - #[doc = " hit or -1 if dialog was closed."] + #[doc = " Note that if SDL_Init() would fail because there isn't any available video"] + #[doc = " target, this function is likely to fail for the same reasons. If this is a"] + #[doc = " concern, check the return value from this function and fall back to writing"] + #[doc = " to stderr if you can."] #[doc = ""] - #[doc = " \\note This function should be called on the thread that created the parent"] - #[doc = " window, or on the main thread if the messagebox has no parent. It will"] - #[doc = " block execution of that thread until the user clicks a button or"] - #[doc = " closes the messagebox."] + #[doc = " \\param messageboxdata the SDL_MessageBoxData structure with title, text and"] + #[doc = " other options"] + #[doc = " \\param buttonid the pointer to which user id of hit button should be copied"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_ShowSimpleMessageBox"] pub fn SDL_ShowMessageBox( messageboxdata: *const SDL_MessageBoxData, buttonid: *mut libc::c_int, ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Create a simple modal message box"] + #[doc = " Display a simple modal message box."] + #[doc = ""] + #[doc = " If your needs aren't complex, this function is preferred over"] + #[doc = " SDL_ShowMessageBox."] + #[doc = ""] + #[doc = " `flags` may be any of the following:"] + #[doc = ""] + #[doc = " - `SDL_MESSAGEBOX_ERROR`: error dialog"] + #[doc = " - `SDL_MESSAGEBOX_WARNING`: warning dialog"] + #[doc = " - `SDL_MESSAGEBOX_INFORMATION`: informational dialog"] + #[doc = ""] + #[doc = " This function should be called on the thread that created the parent"] + #[doc = " window, or on the main thread if the messagebox has no parent. It will"] + #[doc = " block execution of that thread until the user clicks a button or closes the"] + #[doc = " messagebox."] + #[doc = ""] + #[doc = " This function may be called at any time, even before SDL_Init(). This makes"] + #[doc = " it useful for reporting errors like a failure to create a renderer or"] + #[doc = " OpenGL context."] + #[doc = ""] + #[doc = " On X11, SDL rolls its own dialog box with X11 primitives instead of a"] + #[doc = " formal toolkit like GTK+ or Qt."] #[doc = ""] - #[doc = " \\param flags ::SDL_MessageBoxFlags"] - #[doc = " \\param title UTF-8 title text"] - #[doc = " \\param message UTF-8 message text"] - #[doc = " \\param window The parent window, or NULL for no parent"] + #[doc = " Note that if SDL_Init() would fail because there isn't any available video"] + #[doc = " target, this function is likely to fail for the same reasons. If this is a"] + #[doc = " concern, check the return value from this function and fall back to writing"] + #[doc = " to stderr if you can."] #[doc = ""] - #[doc = " \\return 0 on success, -1 on error"] + #[doc = " \\param flags an SDL_MessageBoxFlags value"] + #[doc = " \\param title UTF-8 title text"] + #[doc = " \\param message UTF-8 message text"] + #[doc = " \\param window the parent window, or NULL for no parent"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\sa SDL_ShowMessageBox"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_ShowMessageBox"] pub fn SDL_ShowSimpleMessageBox( flags: Uint32, title: *const libc::c_char, @@ -16770,56 +22706,51 @@ extern "C" { #[doc = " \\note This can be cast directly to an NSView or UIView."] pub type SDL_MetalView = *mut libc::c_void; extern "C" { - #[doc = " \\brief Create a CAMetalLayer-backed NSView/UIView and attach it to the"] - #[doc = " specified window."] + #[doc = " Create a CAMetalLayer-backed NSView/UIView and attach it to the specified"] + #[doc = " window."] #[doc = ""] - #[doc = " On macOS, this does *not* associate a MTLDevice with the CAMetalLayer on its"] - #[doc = " own. It is up to user code to do that."] + #[doc = " On macOS, this does *not* associate a MTLDevice with the CAMetalLayer on"] + #[doc = " its own. It is up to user code to do that."] #[doc = ""] - #[doc = " The returned handle can be casted directly to a NSView or UIView."] - #[doc = " To access the backing CAMetalLayer, call SDL_Metal_GetLayer()."] + #[doc = " The returned handle can be casted directly to a NSView or UIView. To access"] + #[doc = " the backing CAMetalLayer, call SDL_Metal_GetLayer()."] #[doc = ""] - #[doc = " \\note \\a window must be created with the SDL_WINDOW_METAL flag."] + #[doc = " \\since This function is available since SDL 2.0.12."] #[doc = ""] - #[doc = " \\sa SDL_Metal_DestroyView"] - #[doc = " \\sa SDL_Metal_GetLayer"] + #[doc = " \\sa SDL_Metal_DestroyView"] + #[doc = " \\sa SDL_Metal_GetLayer"] pub fn SDL_Metal_CreateView(window: *mut SDL_Window) -> SDL_MetalView; } extern "C" { - #[doc = " \\brief Destroy an existing SDL_MetalView object."] + #[doc = " Destroy an existing SDL_MetalView object."] + #[doc = ""] + #[doc = " This should be called before SDL_DestroyWindow, if SDL_Metal_CreateView was"] + #[doc = " called after SDL_CreateWindow."] #[doc = ""] - #[doc = " This should be called before SDL_DestroyWindow, if SDL_Metal_CreateView was"] - #[doc = " called after SDL_CreateWindow."] + #[doc = " \\since This function is available since SDL 2.0.12."] #[doc = ""] - #[doc = " \\sa SDL_Metal_CreateView"] + #[doc = " \\sa SDL_Metal_CreateView"] pub fn SDL_Metal_DestroyView(view: SDL_MetalView); } extern "C" { - #[doc = " \\brief Get a pointer to the backing CAMetalLayer for the given view."] + #[doc = " Get a pointer to the backing CAMetalLayer for the given view."] #[doc = ""] - #[doc = " \\sa SDL_MetalCreateView"] + #[doc = " \\since This function is available since SDL 2.0.14."] + #[doc = ""] + #[doc = " \\sa SDL_MetalCreateView"] pub fn SDL_Metal_GetLayer(view: SDL_MetalView) -> *mut libc::c_void; } extern "C" { - #[doc = " \\brief Get the size of a window's underlying drawable in pixels (for use"] - #[doc = " with setting viewport, scissor & etc)."] - #[doc = ""] - #[doc = " \\param window SDL_Window from which the drawable size should be queried"] - #[doc = " \\param w Pointer to variable for storing the width in pixels,"] - #[doc = " may be NULL"] - #[doc = " \\param h Pointer to variable for storing the height in pixels,"] - #[doc = " may be NULL"] + #[doc = " Get the size of a window's underlying drawable in pixels (for use with"] + #[doc = " setting viewport, scissor & etc)."] #[doc = ""] - #[doc = " This may differ from SDL_GetWindowSize() if we're rendering to a high-DPI"] - #[doc = " drawable, i.e. the window was created with SDL_WINDOW_ALLOW_HIGHDPI on a"] - #[doc = " platform with high-DPI support (Apple calls this \"Retina\"), and not disabled"] - #[doc = " by the \\c SDL_HINT_VIDEO_HIGHDPI_DISABLED hint."] + #[doc = " \\param window SDL_Window from which the drawable size should be queried"] + #[doc = " \\param w Pointer to variable for storing the width in pixels, may be NULL"] #[doc = ""] - #[doc = " \\note On macOS high-DPI support must be enabled for an application by"] - #[doc = " setting NSHighResolutionCapable to true in its Info.plist."] + #[doc = " \\since This function is available since SDL 2.0.14."] #[doc = ""] - #[doc = " \\sa SDL_GetWindowSize()"] - #[doc = " \\sa SDL_CreateWindow()"] + #[doc = " \\sa SDL_GetWindowSize"] + #[doc = " \\sa SDL_CreateWindow"] pub fn SDL_Metal_GetDrawableSize( window: *mut SDL_Window, w: *mut libc::c_int, @@ -16827,7 +22758,7 @@ extern "C" { ); } #[repr(u32)] -#[doc = " \\brief The basic state for the system's power supply."] +#[doc = " The basic state for the system's power supply."] #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub enum SDL_PowerState { #[doc = "< cannot determine power status"] @@ -16842,21 +22773,34 @@ pub enum SDL_PowerState { SDL_POWERSTATE_CHARGED = 4, } extern "C" { - #[doc = " \\brief Get the current power supply details."] + #[doc = " Get the current power supply details."] + #[doc = ""] + #[doc = " You should never take a battery status as absolute truth. Batteries"] + #[doc = " (especially failing batteries) are delicate hardware, and the values"] + #[doc = " reported here are best estimates based on what that hardware reports. It's"] + #[doc = " not uncommon for older batteries to lose stored power much faster than it"] + #[doc = " reports, or completely drain when reporting it has 20 percent left, etc."] #[doc = ""] - #[doc = " \\param secs Seconds of battery life left. You can pass a NULL here if"] - #[doc = " you don't care. Will return -1 if we can't determine a"] - #[doc = " value, or we're not running on a battery."] + #[doc = " Battery status can change at any time; if you are concerned with power"] + #[doc = " state, you should call this function frequently, and perhaps ignore changes"] + #[doc = " until they seem to be stable for a few seconds."] #[doc = ""] - #[doc = " \\param pct Percentage of battery life left, between 0 and 100. You can"] - #[doc = " pass a NULL here if you don't care. Will return -1 if we"] - #[doc = " can't determine a value, or we're not running on a battery."] + #[doc = " It's possible a platform can only report battery percentage or time left"] + #[doc = " but not both."] #[doc = ""] - #[doc = " \\return The state of the battery (if any)."] + #[doc = " \\param secs seconds of battery life left, you can pass a NULL here if you"] + #[doc = " don't care, will return -1 if we can't determine a value, or"] + #[doc = " we're not running on a battery"] + #[doc = " \\param pct percentage of battery life left, between 0 and 100, you can pass"] + #[doc = " a NULL here if you don't care, will return -1 if we can't"] + #[doc = " determine a value, or we're not running on a battery"] + #[doc = " \\returns an SDL_PowerState enum representing the current battery state."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_GetPowerInfo(secs: *mut libc::c_int, pct: *mut libc::c_int) -> SDL_PowerState; } #[repr(u32)] -#[doc = " \\brief Flags used when creating a rendering context"] +#[doc = " Flags used when creating a rendering context"] #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub enum SDL_RendererFlags { #[doc = "< The renderer is a software fallback"] @@ -16871,7 +22815,7 @@ pub enum SDL_RendererFlags { #[doc = "rendering to texture"] SDL_RENDERER_TARGETTEXTURE = 8, } -#[doc = " \\brief Information on the capabilities of a render driver or context."] +#[doc = " Information on the capabilities of a render driver or context."] #[repr(C)] #[derive(Copy, Clone)] pub struct SDL_RendererInfo { @@ -16969,8 +22913,62 @@ fn bindgen_test_layout_SDL_RendererInfo() { ) ); } +#[doc = " Vertex structure"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SDL_Vertex { + #[doc = "< Vertex position, in SDL_Renderer coordinates"] + pub position: SDL_FPoint, + #[doc = "< Vertex color"] + pub color: SDL_Color, + #[doc = "< Normalized texture coordinates, if needed"] + pub tex_coord: SDL_FPoint, +} +#[test] +fn bindgen_test_layout_SDL_Vertex() { + assert_eq!( + ::core::mem::size_of::(), + 20usize, + concat!("Size of: ", stringify!(SDL_Vertex)) + ); + assert_eq!( + ::core::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(SDL_Vertex)) + ); + assert_eq!( + unsafe { &(*(::core::ptr::null::())).position as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(SDL_Vertex), + "::", + stringify!(position) + ) + ); + assert_eq!( + unsafe { &(*(::core::ptr::null::())).color as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(SDL_Vertex), + "::", + stringify!(color) + ) + ); + assert_eq!( + unsafe { &(*(::core::ptr::null::())).tex_coord as *const _ as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(SDL_Vertex), + "::", + stringify!(tex_coord) + ) + ); +} #[repr(u32)] -#[doc = " \\brief The scaling mode for a texture."] +#[doc = " The scaling mode for a texture."] #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub enum SDL_ScaleMode { #[doc = "< nearest pixel sampling"] @@ -16981,7 +22979,7 @@ pub enum SDL_ScaleMode { SDL_ScaleModeBest = 2, } #[repr(u32)] -#[doc = " \\brief The access pattern allowed for a texture."] +#[doc = " The access pattern allowed for a texture."] #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub enum SDL_TextureAccess { #[doc = "< Changes rarely, not lockable"] @@ -16992,7 +22990,7 @@ pub enum SDL_TextureAccess { SDL_TEXTUREACCESS_TARGET = 2, } #[repr(u32)] -#[doc = " \\brief The texture channel modulation used in SDL_RenderCopy()."] +#[doc = " The texture channel modulation used in SDL_RenderCopy()."] #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub enum SDL_TextureModulate { #[doc = "< No modulation"] @@ -17003,7 +23001,7 @@ pub enum SDL_TextureModulate { SDL_TEXTUREMODULATE_ALPHA = 2, } #[repr(u32)] -#[doc = " \\brief Flip constants for SDL_RenderCopyEx"] +#[doc = " Flip constants for SDL_RenderCopyEx"] #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub enum SDL_RendererFlip { #[doc = "< Do not flip"] @@ -17013,53 +23011,67 @@ pub enum SDL_RendererFlip { #[doc = "< flip vertically"] SDL_FLIP_VERTICAL = 2, } -#[doc = " \\brief A structure representing rendering state"] +#[doc = " A structure representing rendering state"] #[repr(C)] #[derive(Copy, Clone)] pub struct SDL_Renderer { _unused: [u8; 0], } -#[doc = " \\brief An efficient driver-specific representation of pixel data"] +#[doc = " An efficient driver-specific representation of pixel data"] #[repr(C)] #[derive(Copy, Clone)] pub struct SDL_Texture { _unused: [u8; 0], } extern "C" { - #[doc = " \\brief Get the number of 2D rendering drivers available for the current"] - #[doc = " display."] + #[doc = " Get the number of 2D rendering drivers available for the current display."] #[doc = ""] - #[doc = " A render driver is a set of code that handles rendering and texture"] - #[doc = " management on a particular display. Normally there is only one, but"] - #[doc = " some drivers may have several available with different capabilities."] + #[doc = " A render driver is a set of code that handles rendering and texture"] + #[doc = " management on a particular display. Normally there is only one, but some"] + #[doc = " drivers may have several available with different capabilities."] #[doc = ""] - #[doc = " \\sa SDL_GetRenderDriverInfo()"] - #[doc = " \\sa SDL_CreateRenderer()"] + #[doc = " There may be none if SDL was compiled without render support."] + #[doc = ""] + #[doc = " \\returns a number >= 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateRenderer"] + #[doc = " \\sa SDL_GetRenderDriverInfo"] pub fn SDL_GetNumRenderDrivers() -> libc::c_int; } extern "C" { - #[doc = " \\brief Get information about a specific 2D rendering driver for the current"] - #[doc = " display."] + #[doc = " Get info about a specific 2D rendering driver for the current display."] #[doc = ""] - #[doc = " \\param index The index of the driver to query information about."] - #[doc = " \\param info A pointer to an SDL_RendererInfo struct to be filled with"] - #[doc = " information on the rendering driver."] + #[doc = " \\param index the index of the driver to query information about"] + #[doc = " \\param info an SDL_RendererInfo structure to be filled with information on"] + #[doc = " the rendering driver"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, -1 if the index was out of range."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_CreateRenderer()"] + #[doc = " \\sa SDL_CreateRenderer"] + #[doc = " \\sa SDL_GetNumRenderDrivers"] pub fn SDL_GetRenderDriverInfo(index: libc::c_int, info: *mut SDL_RendererInfo) -> libc::c_int; } extern "C" { - #[doc = " \\brief Create a window and default renderer"] + #[doc = " Create a window and default renderer."] + #[doc = ""] + #[doc = " \\param width the width of the window"] + #[doc = " \\param height the height of the window"] + #[doc = " \\param window_flags the flags used to create the window (see"] + #[doc = " SDL_CreateWindow())"] + #[doc = " \\param window a pointer filled with the window, or NULL on error"] + #[doc = " \\param renderer a pointer filled with the renderer, or NULL on error"] + #[doc = " \\returns 0 on success, or -1 on error; call SDL_GetError() for more"] + #[doc = " information."] #[doc = ""] - #[doc = " \\param width The width of the window"] - #[doc = " \\param height The height of the window"] - #[doc = " \\param window_flags The flags used to create the window"] - #[doc = " \\param window A pointer filled with the window, or NULL on error"] - #[doc = " \\param renderer A pointer filled with the renderer, or NULL on error"] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\sa SDL_CreateRenderer"] + #[doc = " \\sa SDL_CreateWindow"] pub fn SDL_CreateWindowAndRenderer( width: libc::c_int, height: libc::c_int, @@ -17069,18 +23081,21 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Create a 2D rendering context for a window."] + #[doc = " Create a 2D rendering context for a window."] #[doc = ""] - #[doc = " \\param window The window where rendering is displayed."] - #[doc = " \\param index The index of the rendering driver to initialize, or -1 to"] - #[doc = " initialize the first one supporting the requested flags."] - #[doc = " \\param flags ::SDL_RendererFlags."] + #[doc = " \\param window the window where rendering is displayed"] + #[doc = " \\param index the index of the rendering driver to initialize, or -1 to"] + #[doc = " initialize the first one supporting the requested flags"] + #[doc = " \\param flags 0, or one or more SDL_RendererFlags OR'd together"] + #[doc = " \\returns a valid rendering context or NULL if there was an error; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return A valid rendering context or NULL if there was an error."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_CreateSoftwareRenderer()"] - #[doc = " \\sa SDL_GetRendererInfo()"] - #[doc = " \\sa SDL_DestroyRenderer()"] + #[doc = " \\sa SDL_CreateSoftwareRenderer"] + #[doc = " \\sa SDL_DestroyRenderer"] + #[doc = " \\sa SDL_GetNumRenderDrivers"] + #[doc = " \\sa SDL_GetRendererInfo"] pub fn SDL_CreateRenderer( window: *mut SDL_Window, index: libc::c_int, @@ -17088,29 +23103,70 @@ extern "C" { ) -> *mut SDL_Renderer; } extern "C" { - #[doc = " \\brief Create a 2D software rendering context for a surface."] + #[doc = " Create a 2D software rendering context for a surface."] #[doc = ""] - #[doc = " \\param surface The surface where rendering is done."] + #[doc = " Two other API which can be used to create SDL_Renderer:"] + #[doc = " SDL_CreateRenderer() and SDL_CreateWindowAndRenderer(). These can _also_"] + #[doc = " create a software renderer, but they are intended to be used with an"] + #[doc = " SDL_Window as the final destination and not an SDL_Surface."] #[doc = ""] - #[doc = " \\return A valid rendering context or NULL if there was an error."] + #[doc = " \\param surface the SDL_Surface structure representing the surface where"] + #[doc = " rendering is done"] + #[doc = " \\returns a valid rendering context or NULL if there was an error; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\sa SDL_CreateRenderer()"] - #[doc = " \\sa SDL_DestroyRenderer()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateRenderer"] + #[doc = " \\sa SDL_CreateWindowRenderer"] + #[doc = " \\sa SDL_DestroyRenderer"] pub fn SDL_CreateSoftwareRenderer(surface: *mut SDL_Surface) -> *mut SDL_Renderer; } extern "C" { - #[doc = " \\brief Get the renderer associated with a window."] + #[doc = " Get the renderer associated with a window."] + #[doc = ""] + #[doc = " \\param window the window to query"] + #[doc = " \\returns the rendering context on success or NULL on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateRenderer"] pub fn SDL_GetRenderer(window: *mut SDL_Window) -> *mut SDL_Renderer; } extern "C" { - #[doc = " \\brief Get information about a rendering context."] + #[doc = " Get information about a rendering context."] + #[doc = ""] + #[doc = " \\param renderer the rendering context"] + #[doc = " \\param info an SDL_RendererInfo structure filled with information about the"] + #[doc = " current renderer"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateRenderer"] pub fn SDL_GetRendererInfo( renderer: *mut SDL_Renderer, info: *mut SDL_RendererInfo, ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the output size in pixels of a rendering context."] + #[doc = " Get the output size in pixels of a rendering context."] + #[doc = ""] + #[doc = " Due to high-dpi displays, you might end up with a rendering context that"] + #[doc = " has more pixels than the window that contains it, so use this instead of"] + #[doc = " SDL_GetWindowSize() to decide how much drawing area you have."] + #[doc = ""] + #[doc = " \\param renderer the rendering context"] + #[doc = " \\param w an int filled with the width"] + #[doc = " \\param h an int filled with the height"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetRenderer"] pub fn SDL_GetRendererOutputSize( renderer: *mut SDL_Renderer, w: *mut libc::c_int, @@ -17118,23 +23174,26 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Create a texture for a rendering context."] + #[doc = " Create a texture for a rendering context."] #[doc = ""] - #[doc = " \\param renderer The renderer."] - #[doc = " \\param format The format of the texture."] - #[doc = " \\param access One of the enumerated values in ::SDL_TextureAccess."] - #[doc = " \\param w The width of the texture in pixels."] - #[doc = " \\param h The height of the texture in pixels."] + #[doc = " You can set the texture scaling method by setting"] + #[doc = " `SDL_HINT_RENDER_SCALE_QUALITY` before creating the texture."] #[doc = ""] - #[doc = " \\return The created texture is returned, or NULL if no rendering context was"] - #[doc = " active, the format was unsupported, or the width or height were out"] - #[doc = " of range."] + #[doc = " \\param renderer the rendering context"] + #[doc = " \\param format one of the enumerated values in SDL_PixelFormatEnum"] + #[doc = " \\param access one of the enumerated values in SDL_TextureAccess"] + #[doc = " \\param w the width of the texture in pixels"] + #[doc = " \\param h the height of the texture in pixels"] + #[doc = " \\returns a pointer to the created texture or NULL if no rendering context"] + #[doc = " was active, the format was unsupported, or the width or height"] + #[doc = " were out of range; call SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\note The contents of the texture are not defined at creation."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_QueryTexture()"] - #[doc = " \\sa SDL_UpdateTexture()"] - #[doc = " \\sa SDL_DestroyTexture()"] + #[doc = " \\sa SDL_CreateTextureFromSurface"] + #[doc = " \\sa SDL_DestroyTexture"] + #[doc = " \\sa SDL_QueryTexture"] + #[doc = " \\sa SDL_UpdateTexture"] pub fn SDL_CreateTexture( renderer: *mut SDL_Renderer, format: Uint32, @@ -17144,34 +23203,50 @@ extern "C" { ) -> *mut SDL_Texture; } extern "C" { - #[doc = " \\brief Create a texture from an existing surface."] + #[doc = " Create a texture from an existing surface."] #[doc = ""] - #[doc = " \\param renderer The renderer."] - #[doc = " \\param surface The surface containing pixel data used to fill the texture."] + #[doc = " The surface is not modified or freed by this function."] #[doc = ""] - #[doc = " \\return The created texture is returned, or NULL on error."] + #[doc = " The SDL_TextureAccess hint for the created texture is"] + #[doc = " `SDL_TEXTUREACCESS_STATIC`."] #[doc = ""] - #[doc = " \\note The surface is not modified or freed by this function."] + #[doc = " The pixel format of the created texture may be different from the pixel"] + #[doc = " format of the surface. Use SDL_QueryTexture() to query the pixel format of"] + #[doc = " the texture."] #[doc = ""] - #[doc = " \\sa SDL_QueryTexture()"] - #[doc = " \\sa SDL_DestroyTexture()"] + #[doc = " \\param renderer the rendering context"] + #[doc = " \\param surface the SDL_Surface structure containing pixel data used to fill"] + #[doc = " the texture"] + #[doc = " \\returns the created texture or NULL on failure; call SDL_GetError() for"] + #[doc = " more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateTexture"] + #[doc = " \\sa SDL_DestroyTexture"] + #[doc = " \\sa SDL_QueryTexture"] pub fn SDL_CreateTextureFromSurface( renderer: *mut SDL_Renderer, surface: *mut SDL_Surface, ) -> *mut SDL_Texture; } extern "C" { - #[doc = " \\brief Query the attributes of a texture"] + #[doc = " Query the attributes of a texture."] #[doc = ""] - #[doc = " \\param texture A texture to be queried."] - #[doc = " \\param format A pointer filled in with the raw format of the texture. The"] - #[doc = " actual format may differ, but pixel transfers will use this"] - #[doc = " format."] - #[doc = " \\param access A pointer filled in with the actual access to the texture."] - #[doc = " \\param w A pointer filled in with the width of the texture in pixels."] - #[doc = " \\param h A pointer filled in with the height of the texture in pixels."] + #[doc = " \\param texture the texture to query"] + #[doc = " \\param format a pointer filled in with the raw format of the texture; the"] + #[doc = " actual format may differ, but pixel transfers will use this"] + #[doc = " format (one of the SDL_PixelFormatEnum values)"] + #[doc = " \\param access a pointer filled in with the actual access to the texture"] + #[doc = " (one of the SDL_TextureAccess values)"] + #[doc = " \\param w a pointer filled in with the width of the texture in pixels"] + #[doc = " \\param h a pointer filled in with the height of the texture in pixels"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the texture is not valid."] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateTexture"] pub fn SDL_QueryTexture( texture: *mut SDL_Texture, format: *mut Uint32, @@ -17181,17 +23256,28 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Set an additional color value used in render copy operations."] + #[doc = " Set an additional color value multiplied into render copy operations."] + #[doc = ""] + #[doc = " When this texture is rendered, during the copy operation each source color"] + #[doc = " channel is modulated by the appropriate color value according to the"] + #[doc = " following formula:"] #[doc = ""] - #[doc = " \\param texture The texture to update."] - #[doc = " \\param r The red color value multiplied into copy operations."] - #[doc = " \\param g The green color value multiplied into copy operations."] - #[doc = " \\param b The blue color value multiplied into copy operations."] + #[doc = " `srcC = srcC * (color / 255)`"] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the texture is not valid or color modulation"] - #[doc = " is not supported."] + #[doc = " Color modulation is not always supported by the renderer; it will return -1"] + #[doc = " if color modulation is not supported."] #[doc = ""] - #[doc = " \\sa SDL_GetTextureColorMod()"] + #[doc = " \\param texture the texture to update"] + #[doc = " \\param r the red color value multiplied into copy operations"] + #[doc = " \\param g the green color value multiplied into copy operations"] + #[doc = " \\param b the blue color value multiplied into copy operations"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetTextureColorMod"] + #[doc = " \\sa SDL_SetTextureAlphaMod"] pub fn SDL_SetTextureColorMod( texture: *mut SDL_Texture, r: Uint8, @@ -17200,16 +23286,19 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the additional color value used in render copy operations."] + #[doc = " Get the additional color value multiplied into render copy operations."] #[doc = ""] - #[doc = " \\param texture The texture to query."] - #[doc = " \\param r A pointer filled in with the current red color value."] - #[doc = " \\param g A pointer filled in with the current green color value."] - #[doc = " \\param b A pointer filled in with the current blue color value."] + #[doc = " \\param texture the texture to query"] + #[doc = " \\param r a pointer filled in with the current red color value"] + #[doc = " \\param g a pointer filled in with the current green color value"] + #[doc = " \\param b a pointer filled in with the current blue color value"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the texture is not valid."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_SetTextureColorMod()"] + #[doc = " \\sa SDL_GetTextureAlphaMod"] + #[doc = " \\sa SDL_SetTextureColorMod"] pub fn SDL_GetTextureColorMod( texture: *mut SDL_Texture, r: *mut Uint8, @@ -17218,106 +23307,164 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Set an additional alpha value used in render copy operations."] + #[doc = " Set an additional alpha value multiplied into render copy operations."] + #[doc = ""] + #[doc = " When this texture is rendered, during the copy operation the source alpha"] + #[doc = " value is modulated by this alpha value according to the following formula:"] + #[doc = ""] + #[doc = " `srcA = srcA * (alpha / 255)`"] #[doc = ""] - #[doc = " \\param texture The texture to update."] - #[doc = " \\param alpha The alpha value multiplied into copy operations."] + #[doc = " Alpha modulation is not always supported by the renderer; it will return -1"] + #[doc = " if alpha modulation is not supported."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the texture is not valid or alpha modulation"] - #[doc = " is not supported."] + #[doc = " \\param texture the texture to update"] + #[doc = " \\param alpha the source alpha value multiplied into copy operations"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\sa SDL_GetTextureAlphaMod()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetTextureAlphaMod"] + #[doc = " \\sa SDL_SetTextureColorMod"] pub fn SDL_SetTextureAlphaMod(texture: *mut SDL_Texture, alpha: Uint8) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the additional alpha value used in render copy operations."] + #[doc = " Get the additional alpha value multiplied into render copy operations."] #[doc = ""] - #[doc = " \\param texture The texture to query."] - #[doc = " \\param alpha A pointer filled in with the current alpha value."] + #[doc = " \\param texture the texture to query"] + #[doc = " \\param alpha a pointer filled in with the current alpha value"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the texture is not valid."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_SetTextureAlphaMod()"] + #[doc = " \\sa SDL_GetTextureColorMod"] + #[doc = " \\sa SDL_SetTextureAlphaMod"] pub fn SDL_GetTextureAlphaMod(texture: *mut SDL_Texture, alpha: *mut Uint8) -> libc::c_int; } extern "C" { - #[doc = " \\brief Set the blend mode used for texture copy operations."] + #[doc = " Set the blend mode for a texture, used by SDL_RenderCopy()."] #[doc = ""] - #[doc = " \\param texture The texture to update."] - #[doc = " \\param blendMode ::SDL_BlendMode to use for texture blending."] + #[doc = " If the blend mode is not supported, the closest supported mode is chosen"] + #[doc = " and this function returns -1."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the texture is not valid or the blend mode is"] - #[doc = " not supported."] + #[doc = " \\param texture the texture to update"] + #[doc = " \\param blendMode the SDL_BlendMode to use for texture blending"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\note If the blend mode is not supported, the closest supported mode is"] - #[doc = " chosen."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_GetTextureBlendMode()"] + #[doc = " \\sa SDL_GetTextureBlendMode"] + #[doc = " \\sa SDL_RenderCopy"] pub fn SDL_SetTextureBlendMode( texture: *mut SDL_Texture, blendMode: SDL_BlendMode, ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the blend mode used for texture copy operations."] + #[doc = " Get the blend mode used for texture copy operations."] #[doc = ""] - #[doc = " \\param texture The texture to query."] - #[doc = " \\param blendMode A pointer filled in with the current blend mode."] + #[doc = " \\param texture the texture to query"] + #[doc = " \\param blendMode a pointer filled in with the current SDL_BlendMode"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the texture is not valid."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_SetTextureBlendMode()"] + #[doc = " \\sa SDL_SetTextureBlendMode"] pub fn SDL_GetTextureBlendMode( texture: *mut SDL_Texture, blendMode: *mut SDL_BlendMode, ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Set the scale mode used for texture scale operations."] + #[doc = " Set the scale mode used for texture scale operations."] #[doc = ""] - #[doc = " \\param texture The texture to update."] - #[doc = " \\param scaleMode ::SDL_ScaleMode to use for texture scaling."] + #[doc = " If the scale mode is not supported, the closest supported mode is chosen."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the texture is not valid."] + #[doc = " \\param texture The texture to update."] + #[doc = " \\param scaleMode the SDL_ScaleMode to use for texture scaling."] + #[doc = " \\returns 0 on success, or -1 if the texture is not valid."] #[doc = ""] - #[doc = " \\note If the scale mode is not supported, the closest supported mode is"] - #[doc = " chosen."] + #[doc = " \\since This function is available since SDL 2.0.12."] #[doc = ""] - #[doc = " \\sa SDL_GetTextureScaleMode()"] + #[doc = " \\sa SDL_GetTextureScaleMode"] pub fn SDL_SetTextureScaleMode( texture: *mut SDL_Texture, scaleMode: SDL_ScaleMode, ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the scale mode used for texture scale operations."] + #[doc = " Get the scale mode used for texture scale operations."] #[doc = ""] - #[doc = " \\param texture The texture to query."] - #[doc = " \\param scaleMode A pointer filled in with the current scale mode."] + #[doc = " \\param texture the texture to query."] + #[doc = " \\param scaleMode a pointer filled in with the current scale mode."] + #[doc = " \\return 0 on success, or -1 if the texture is not valid."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the texture is not valid."] + #[doc = " \\since This function is available since SDL 2.0.12."] #[doc = ""] - #[doc = " \\sa SDL_SetTextureScaleMode()"] + #[doc = " \\sa SDL_SetTextureScaleMode"] pub fn SDL_GetTextureScaleMode( texture: *mut SDL_Texture, scaleMode: *mut SDL_ScaleMode, ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Update the given texture rectangle with new pixel data."] + #[doc = " Associate a user-specified pointer with a texture."] + #[doc = ""] + #[doc = " \\param texture the texture to update."] + #[doc = " \\param userdata the pointer to associate with the texture."] + #[doc = " \\returns 0 on success, or -1 if the texture is not valid."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.18."] + #[doc = ""] + #[doc = " \\sa SDL_GetTextureUserData"] + pub fn SDL_SetTextureUserData( + texture: *mut SDL_Texture, + userdata: *mut libc::c_void, + ) -> libc::c_int; +} +extern "C" { + #[doc = " Get the user-specified pointer associated with a texture"] + #[doc = ""] + #[doc = " \\param texture the texture to query."] + #[doc = " \\return the pointer associated with the texture, or NULL if the texture is"] + #[doc = " not valid."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.18."] + #[doc = ""] + #[doc = " \\sa SDL_SetTextureUserData"] + pub fn SDL_GetTextureUserData(texture: *mut SDL_Texture) -> *mut libc::c_void; +} +extern "C" { + #[doc = " Update the given texture rectangle with new pixel data."] + #[doc = ""] + #[doc = " The pixel data must be in the pixel format of the texture. Use"] + #[doc = " SDL_QueryTexture() to query the pixel format of the texture."] + #[doc = ""] + #[doc = " This is a fairly slow function, intended for use with static textures that"] + #[doc = " do not change often."] #[doc = ""] - #[doc = " \\param texture The texture to update"] - #[doc = " \\param rect A pointer to the rectangle of pixels to update, or NULL to"] - #[doc = " update the entire texture."] - #[doc = " \\param pixels The raw pixel data in the format of the texture."] - #[doc = " \\param pitch The number of bytes in a row of pixel data, including padding between lines."] + #[doc = " If the texture is intended to be updated often, it is preferred to create"] + #[doc = " the texture as streaming and use the locking functions referenced below."] + #[doc = " While this function will work with streaming textures, for optimization"] + #[doc = " reasons you may not get the pixels back if you lock the texture afterward."] #[doc = ""] - #[doc = " The pixel data must be in the format of the texture. The pixel format can be"] - #[doc = " queried with SDL_QueryTexture."] + #[doc = " \\param texture the texture to update"] + #[doc = " \\param rect an SDL_Rect structure representing the area to update, or NULL"] + #[doc = " to update the entire texture"] + #[doc = " \\param pixels the raw pixel data in the format of the texture"] + #[doc = " \\param pitch the number of bytes in a row of pixel data, including padding"] + #[doc = " between lines"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the texture is not valid."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\note This is a fairly slow function."] + #[doc = " \\sa SDL_CreateTexture"] + #[doc = " \\sa SDL_LockTexture"] + #[doc = " \\sa SDL_UnlockTexture"] pub fn SDL_UpdateTexture( texture: *mut SDL_Texture, rect: *const SDL_Rect, @@ -17326,48 +23473,96 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Update a rectangle within a planar YV12 or IYUV texture with new pixel data."] + #[doc = " Update a rectangle within a planar YV12 or IYUV texture with new pixel"] + #[doc = " data."] + #[doc = ""] + #[doc = " You can use SDL_UpdateTexture() as long as your pixel data is a contiguous"] + #[doc = " block of Y and U/V planes in the proper order, but this function is"] + #[doc = " available if your pixel data is not contiguous."] + #[doc = ""] + #[doc = " \\param texture the texture to update"] + #[doc = " \\param rect a pointer to the rectangle of pixels to update, or NULL to"] + #[doc = " update the entire texture"] + #[doc = " \\param Yplane the raw pixel data for the Y plane"] + #[doc = " \\param Ypitch the number of bytes between rows of pixel data for the Y"] + #[doc = " plane"] + #[doc = " \\param Uplane the raw pixel data for the U plane"] + #[doc = " \\param Upitch the number of bytes between rows of pixel data for the U"] + #[doc = " plane"] + #[doc = " \\param Vplane the raw pixel data for the V plane"] + #[doc = " \\param Vpitch the number of bytes between rows of pixel data for the V"] + #[doc = " plane"] + #[doc = " \\returns 0 on success or -1 if the texture is not valid; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.1."] + #[doc = ""] + #[doc = " \\sa SDL_UpdateTexture"] + pub fn SDL_UpdateYUVTexture( + texture: *mut SDL_Texture, + rect: *const SDL_Rect, + Yplane: *const Uint8, + Ypitch: libc::c_int, + Uplane: *const Uint8, + Upitch: libc::c_int, + Vplane: *const Uint8, + Vpitch: libc::c_int, + ) -> libc::c_int; +} +extern "C" { + #[doc = " Update a rectangle within a planar NV12 or NV21 texture with new pixels."] #[doc = ""] - #[doc = " \\param texture The texture to update"] - #[doc = " \\param rect A pointer to the rectangle of pixels to update, or NULL to"] - #[doc = " update the entire texture."] - #[doc = " \\param Yplane The raw pixel data for the Y plane."] - #[doc = " \\param Ypitch The number of bytes between rows of pixel data for the Y plane."] - #[doc = " \\param Uplane The raw pixel data for the U plane."] - #[doc = " \\param Upitch The number of bytes between rows of pixel data for the U plane."] - #[doc = " \\param Vplane The raw pixel data for the V plane."] - #[doc = " \\param Vpitch The number of bytes between rows of pixel data for the V plane."] + #[doc = " You can use SDL_UpdateTexture() as long as your pixel data is a contiguous"] + #[doc = " block of NV12/21 planes in the proper order, but this function is available"] + #[doc = " if your pixel data is not contiguous."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the texture is not valid."] + #[doc = " \\param texture the texture to update"] + #[doc = " \\param rect a pointer to the rectangle of pixels to update, or NULL to"] + #[doc = " update the entire texture."] + #[doc = " \\param Yplane the raw pixel data for the Y plane."] + #[doc = " \\param Ypitch the number of bytes between rows of pixel data for the Y"] + #[doc = " plane."] + #[doc = " \\param UVplane the raw pixel data for the UV plane."] + #[doc = " \\param UVpitch the number of bytes between rows of pixel data for the UV"] + #[doc = " plane."] + #[doc = " \\return 0 on success, or -1 if the texture is not valid."] #[doc = ""] - #[doc = " \\note You can use SDL_UpdateTexture() as long as your pixel data is"] - #[doc = " a contiguous block of Y and U/V planes in the proper order, but"] - #[doc = " this function is available if your pixel data is not contiguous."] - pub fn SDL_UpdateYUVTexture( + #[doc = " \\since This function is available since SDL 2.0.16."] + pub fn SDL_UpdateNVTexture( texture: *mut SDL_Texture, rect: *const SDL_Rect, Yplane: *const Uint8, Ypitch: libc::c_int, - Uplane: *const Uint8, - Upitch: libc::c_int, - Vplane: *const Uint8, - Vpitch: libc::c_int, + UVplane: *const Uint8, + UVpitch: libc::c_int, ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Lock a portion of the texture for write-only pixel access."] + #[doc = " Lock a portion of the texture for **write-only** pixel access."] + #[doc = ""] + #[doc = " As an optimization, the pixels made available for editing don't necessarily"] + #[doc = " contain the old texture data. This is a write-only operation, and if you"] + #[doc = " need to keep a copy of the texture data you should do that at the"] + #[doc = " application level."] #[doc = ""] - #[doc = " \\param texture The texture to lock for access, which was created with"] - #[doc = " ::SDL_TEXTUREACCESS_STREAMING."] - #[doc = " \\param rect A pointer to the rectangle to lock for access. If the rect"] - #[doc = " is NULL, the entire texture will be locked."] - #[doc = " \\param pixels This is filled in with a pointer to the locked pixels,"] - #[doc = " appropriately offset by the locked area."] - #[doc = " \\param pitch This is filled in with the pitch of the locked pixels."] + #[doc = " You must use SDL_UnlockTexture() to unlock the pixels and apply any"] + #[doc = " changes."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the texture is not valid or was not created with ::SDL_TEXTUREACCESS_STREAMING."] + #[doc = " \\param texture the texture to lock for access, which was created with"] + #[doc = " `SDL_TEXTUREACCESS_STREAMING`"] + #[doc = " \\param rect an SDL_Rect structure representing the area to lock for access;"] + #[doc = " NULL to lock the entire texture"] + #[doc = " \\param pixels this is filled in with a pointer to the locked pixels,"] + #[doc = " appropriately offset by the locked area"] + #[doc = " \\param pitch this is filled in with the pitch of the locked pixels; the"] + #[doc = " pitch is the length of one row in bytes"] + #[doc = " \\returns 0 on success or a negative error code if the texture is not valid"] + #[doc = " or was not created with `SDL_TEXTUREACCESS_STREAMING`; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\sa SDL_UnlockTexture()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_UnlockTexture"] pub fn SDL_LockTexture( texture: *mut SDL_Texture, rect: *const SDL_Rect, @@ -17376,19 +23571,36 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Lock a portion of the texture for write-only pixel access."] - #[doc = " Expose it as a SDL surface."] + #[doc = " Lock a portion of the texture for **write-only** pixel access, and expose"] + #[doc = " it as a SDL surface."] + #[doc = ""] + #[doc = " Besides providing an SDL_Surface instead of raw pixel data, this function"] + #[doc = " operates like SDL_LockTexture."] #[doc = ""] - #[doc = " \\param texture The texture to lock for access, which was created with"] - #[doc = " ::SDL_TEXTUREACCESS_STREAMING."] - #[doc = " \\param rect A pointer to the rectangle to lock for access. If the rect"] - #[doc = " is NULL, the entire texture will be locked."] - #[doc = " \\param surface This is filled in with a SDL surface representing the locked area"] - #[doc = " Surface is freed internally after calling SDL_UnlockTexture or SDL_DestroyTexture."] + #[doc = " As an optimization, the pixels made available for editing don't necessarily"] + #[doc = " contain the old texture data. This is a write-only operation, and if you"] + #[doc = " need to keep a copy of the texture data you should do that at the"] + #[doc = " application level."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the texture is not valid or was not created with ::SDL_TEXTUREACCESS_STREAMING."] + #[doc = " You must use SDL_UnlockTexture() to unlock the pixels and apply any"] + #[doc = " changes."] #[doc = ""] - #[doc = " \\sa SDL_UnlockTexture()"] + #[doc = " The returned surface is freed internally after calling SDL_UnlockTexture()"] + #[doc = " or SDL_DestroyTexture(). The caller should not free it."] + #[doc = ""] + #[doc = " \\param texture the texture to lock for access, which was created with"] + #[doc = " `SDL_TEXTUREACCESS_STREAMING`"] + #[doc = " \\param rect a pointer to the rectangle to lock for access. If the rect is"] + #[doc = " NULL, the entire texture will be locked"] + #[doc = " \\param surface this is filled in with an SDL surface representing the"] + #[doc = " locked area"] + #[doc = " \\returns 0 on success, or -1 if the texture is not valid or was not created"] + #[doc = " with `SDL_TEXTUREACCESS_STREAMING`"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.12."] + #[doc = ""] + #[doc = " \\sa SDL_LockTexture"] + #[doc = " \\sa SDL_UnlockTexture"] pub fn SDL_LockTextureToSurface( texture: *mut SDL_Texture, rect: *const SDL_Rect, @@ -17396,65 +23608,99 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Unlock a texture, uploading the changes to video memory, if needed."] - #[doc = " If SDL_LockTextureToSurface() was called for locking, the SDL surface is freed."] + #[doc = " Unlock a texture, uploading the changes to video memory, if needed."] + #[doc = ""] + #[doc = " **Warning**: Please note that SDL_LockTexture() is intended to be"] + #[doc = " write-only; it will not guarantee the previous contents of the texture will"] + #[doc = " be provided. You must fully initialize any area of a texture that you lock"] + #[doc = " before unlocking it, as the pixels might otherwise be uninitialized memory."] #[doc = ""] - #[doc = " \\sa SDL_LockTexture()"] - #[doc = " \\sa SDL_LockTextureToSurface()"] + #[doc = " Which is to say: locking and immediately unlocking a texture can result in"] + #[doc = " corrupted textures, depending on the renderer in use."] + #[doc = ""] + #[doc = " \\param texture a texture locked by SDL_LockTexture()"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_LockTexture"] pub fn SDL_UnlockTexture(texture: *mut SDL_Texture); } extern "C" { - #[doc = " \\brief Determines whether a window supports the use of render targets"] + #[doc = " Determine whether a renderer supports the use of render targets."] + #[doc = ""] + #[doc = " \\param renderer the renderer that will be checked"] + #[doc = " \\returns SDL_TRUE if supported or SDL_FALSE if not."] #[doc = ""] - #[doc = " \\param renderer The renderer that will be checked"] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\return SDL_TRUE if supported, SDL_FALSE if not."] + #[doc = " \\sa SDL_SetRenderTarget"] pub fn SDL_RenderTargetSupported(renderer: *mut SDL_Renderer) -> SDL_bool; } extern "C" { - #[doc = " \\brief Set a texture as the current rendering target."] + #[doc = " Set a texture as the current rendering target."] #[doc = ""] - #[doc = " \\param renderer The renderer."] - #[doc = " \\param texture The targeted texture, which must be created with the SDL_TEXTUREACCESS_TARGET flag, or NULL for the default render target"] + #[doc = " Before using this function, you should check the"] + #[doc = " `SDL_RENDERER_TARGETTEXTURE` bit in the flags of SDL_RendererInfo to see if"] + #[doc = " render targets are supported."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " The default render target is the window for which the renderer was created."] + #[doc = " To stop rendering to a texture and render to the window again, call this"] + #[doc = " function with a NULL `texture`."] + #[doc = ""] + #[doc = " \\param renderer the rendering context"] + #[doc = " \\param texture the targeted texture, which must be created with the"] + #[doc = " `SDL_TEXTUREACCESS_TARGET` flag, or NULL to render to the"] + #[doc = " window instead of a texture."] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\sa SDL_GetRenderTarget()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetRenderTarget"] pub fn SDL_SetRenderTarget( renderer: *mut SDL_Renderer, texture: *mut SDL_Texture, ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the current render target or NULL for the default render target."] + #[doc = " Get the current render target."] + #[doc = ""] + #[doc = " The default render target is the window for which the renderer was created,"] + #[doc = " and is reported a NULL here."] #[doc = ""] - #[doc = " \\return The current render target"] + #[doc = " \\param renderer the rendering context"] + #[doc = " \\returns the current render target or NULL for the default render target."] #[doc = ""] - #[doc = " \\sa SDL_SetRenderTarget()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_SetRenderTarget"] pub fn SDL_GetRenderTarget(renderer: *mut SDL_Renderer) -> *mut SDL_Texture; } extern "C" { - #[doc = " \\brief Set device independent resolution for rendering"] + #[doc = " Set a device independent resolution for rendering."] + #[doc = ""] + #[doc = " This function uses the viewport and scaling functionality to allow a fixed"] + #[doc = " logical resolution for rendering, regardless of the actual output"] + #[doc = " resolution. If the actual output resolution doesn't have the same aspect"] + #[doc = " ratio the output rendering will be centered within the output display."] #[doc = ""] - #[doc = " \\param renderer The renderer for which resolution should be set."] - #[doc = " \\param w The width of the logical resolution"] - #[doc = " \\param h The height of the logical resolution"] + #[doc = " If the output display is a window, mouse and touch events in the window"] + #[doc = " will be filtered and scaled so they seem to arrive within the logical"] + #[doc = " resolution. The SDL_HINT_MOUSE_RELATIVE_SCALING hint controls whether"] + #[doc = " relative motion events are also scaled."] #[doc = ""] - #[doc = " This function uses the viewport and scaling functionality to allow a fixed logical"] - #[doc = " resolution for rendering, regardless of the actual output resolution. If the actual"] - #[doc = " output resolution doesn't have the same aspect ratio the output rendering will be"] - #[doc = " centered within the output display."] + #[doc = " If this function results in scaling or subpixel drawing by the rendering"] + #[doc = " backend, it will be handled using the appropriate quality hints."] #[doc = ""] - #[doc = " If the output display is a window, mouse events in the window will be filtered"] - #[doc = " and scaled so they seem to arrive within the logical resolution."] + #[doc = " \\param renderer the renderer for which resolution should be set"] + #[doc = " \\param w the width of the logical resolution"] + #[doc = " \\param h the height of the logical resolution"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\note If this function results in scaling or subpixel drawing by the"] - #[doc = " rendering backend, it will be handled using the appropriate"] - #[doc = " quality hints."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_RenderGetLogicalSize()"] - #[doc = " \\sa SDL_RenderSetScale()"] - #[doc = " \\sa SDL_RenderSetViewport()"] + #[doc = " \\sa SDL_RenderGetLogicalSize"] pub fn SDL_RenderSetLogicalSize( renderer: *mut SDL_Renderer, w: libc::c_int, @@ -17462,13 +23708,19 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get device independent resolution for rendering"] + #[doc = " Get device independent resolution for rendering."] + #[doc = ""] + #[doc = " This may return 0 for `w` and `h` if the SDL_Renderer has never had its"] + #[doc = " logical size set by SDL_RenderSetLogicalSize() and never had a render"] + #[doc = " target set."] + #[doc = ""] + #[doc = " \\param renderer a rendering context"] + #[doc = " \\param w an int to be filled with the width"] + #[doc = " \\param h an int to be filled with the height"] #[doc = ""] - #[doc = " \\param renderer The renderer from which resolution should be queried."] - #[doc = " \\param w A pointer filled with the width of the logical resolution"] - #[doc = " \\param h A pointer filled with the height of the logical resolution"] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_RenderSetLogicalSize()"] + #[doc = " \\sa SDL_RenderSetLogicalSize"] pub fn SDL_RenderGetLogicalSize( renderer: *mut SDL_Renderer, w: *mut libc::c_int, @@ -17476,121 +23728,225 @@ extern "C" { ); } extern "C" { - #[doc = " \\brief Set whether to force integer scales for resolution-independent rendering"] + #[doc = " Set whether to force integer scales for resolution-independent rendering."] #[doc = ""] - #[doc = " \\param renderer The renderer for which integer scaling should be set."] - #[doc = " \\param enable Enable or disable integer scaling"] + #[doc = " This function restricts the logical viewport to integer values - that is,"] + #[doc = " when a resolution is between two multiples of a logical size, the viewport"] + #[doc = " size is rounded down to the lower multiple."] #[doc = ""] - #[doc = " This function restricts the logical viewport to integer values - that is, when"] - #[doc = " a resolution is between two multiples of a logical size, the viewport size is"] - #[doc = " rounded down to the lower multiple."] + #[doc = " \\param renderer the renderer for which integer scaling should be set"] + #[doc = " \\param enable enable or disable the integer scaling for rendering"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\sa SDL_RenderSetLogicalSize()"] + #[doc = " \\since This function is available since SDL 2.0.5."] + #[doc = ""] + #[doc = " \\sa SDL_RenderGetIntegerScale"] + #[doc = " \\sa SDL_RenderSetLogicalSize"] pub fn SDL_RenderSetIntegerScale(renderer: *mut SDL_Renderer, enable: SDL_bool) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get whether integer scales are forced for resolution-independent rendering"] + #[doc = " Get whether integer scales are forced for resolution-independent rendering."] + #[doc = ""] + #[doc = " \\param renderer the renderer from which integer scaling should be queried"] + #[doc = " \\returns SDL_TRUE if integer scales are forced or SDL_FALSE if not and on"] + #[doc = " failure; call SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\param renderer The renderer from which integer scaling should be queried."] + #[doc = " \\since This function is available since SDL 2.0.5."] #[doc = ""] - #[doc = " \\sa SDL_RenderSetIntegerScale()"] + #[doc = " \\sa SDL_RenderSetIntegerScale"] pub fn SDL_RenderGetIntegerScale(renderer: *mut SDL_Renderer) -> SDL_bool; } extern "C" { - #[doc = " \\brief Set the drawing area for rendering on the current target."] + #[doc = " Set the drawing area for rendering on the current target."] #[doc = ""] - #[doc = " \\param renderer The renderer for which the drawing area should be set."] - #[doc = " \\param rect The rectangle representing the drawing area, or NULL to set the viewport to the entire target."] + #[doc = " When the window is resized, the viewport is reset to fill the entire new"] + #[doc = " window size."] #[doc = ""] - #[doc = " The x,y of the viewport rect represents the origin for rendering."] + #[doc = " \\param renderer the rendering context"] + #[doc = " \\param rect the SDL_Rect structure representing the drawing area, or NULL"] + #[doc = " to set the viewport to the entire target"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\note If the window associated with the renderer is resized, the viewport is automatically reset."] - #[doc = ""] - #[doc = " \\sa SDL_RenderGetViewport()"] - #[doc = " \\sa SDL_RenderSetLogicalSize()"] + #[doc = " \\sa SDL_RenderGetViewport"] pub fn SDL_RenderSetViewport(renderer: *mut SDL_Renderer, rect: *const SDL_Rect) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the drawing area for the current target."] + #[doc = " Get the drawing area for the current target."] + #[doc = ""] + #[doc = " \\param renderer the rendering context"] + #[doc = " \\param rect an SDL_Rect structure filled in with the current drawing area"] #[doc = ""] - #[doc = " \\sa SDL_RenderSetViewport()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_RenderSetViewport"] pub fn SDL_RenderGetViewport(renderer: *mut SDL_Renderer, rect: *mut SDL_Rect); } extern "C" { - #[doc = " \\brief Set the clip rectangle for the current target."] + #[doc = " Set the clip rectangle for rendering on the specified target."] #[doc = ""] - #[doc = " \\param renderer The renderer for which clip rectangle should be set."] - #[doc = " \\param rect A pointer to the rectangle to set as the clip rectangle,"] - #[doc = " relative to the viewport, or NULL to disable clipping."] + #[doc = " \\param renderer the rendering context for which clip rectangle should be"] + #[doc = " set"] + #[doc = " \\param rect an SDL_Rect structure representing the clip area, relative to"] + #[doc = " the viewport, or NULL to disable clipping"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_RenderGetClipRect()"] + #[doc = " \\sa SDL_RenderGetClipRect"] + #[doc = " \\sa SDL_RenderIsClipEnabled"] pub fn SDL_RenderSetClipRect(renderer: *mut SDL_Renderer, rect: *const SDL_Rect) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the clip rectangle for the current target."] + #[doc = " Get the clip rectangle for the current target."] + #[doc = ""] + #[doc = " \\param renderer the rendering context from which clip rectangle should be"] + #[doc = " queried"] + #[doc = " \\param rect an SDL_Rect structure filled in with the current clipping area"] + #[doc = " or an empty rectangle if clipping is disabled"] #[doc = ""] - #[doc = " \\param renderer The renderer from which clip rectangle should be queried."] - #[doc = " \\param rect A pointer filled in with the current clip rectangle, or"] - #[doc = " an empty rectangle if clipping is disabled."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_RenderSetClipRect()"] + #[doc = " \\sa SDL_RenderIsClipEnabled"] + #[doc = " \\sa SDL_RenderSetClipRect"] pub fn SDL_RenderGetClipRect(renderer: *mut SDL_Renderer, rect: *mut SDL_Rect); } extern "C" { - #[doc = " \\brief Get whether clipping is enabled on the given renderer."] + #[doc = " Get whether clipping is enabled on the given renderer."] #[doc = ""] - #[doc = " \\param renderer The renderer from which clip state should be queried."] + #[doc = " \\param renderer the renderer from which clip state should be queried"] + #[doc = " \\returns SDL_TRUE if clipping is enabled or SDL_FALSE if not; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\sa SDL_RenderGetClipRect()"] + #[doc = " \\since This function is available since SDL 2.0.4."] + #[doc = ""] + #[doc = " \\sa SDL_RenderGetClipRect"] + #[doc = " \\sa SDL_RenderSetClipRect"] pub fn SDL_RenderIsClipEnabled(renderer: *mut SDL_Renderer) -> SDL_bool; } extern "C" { - #[doc = " \\brief Set the drawing scale for rendering on the current target."] + #[doc = " Set the drawing scale for rendering on the current target."] + #[doc = ""] + #[doc = " The drawing coordinates are scaled by the x/y scaling factors before they"] + #[doc = " are used by the renderer. This allows resolution independent drawing with a"] + #[doc = " single coordinate system."] #[doc = ""] - #[doc = " \\param renderer The renderer for which the drawing scale should be set."] - #[doc = " \\param scaleX The horizontal scaling factor"] - #[doc = " \\param scaleY The vertical scaling factor"] + #[doc = " If this results in scaling or subpixel drawing by the rendering backend, it"] + #[doc = " will be handled using the appropriate quality hints. For best results use"] + #[doc = " integer scaling factors."] #[doc = ""] - #[doc = " The drawing coordinates are scaled by the x/y scaling factors"] - #[doc = " before they are used by the renderer. This allows resolution"] - #[doc = " independent drawing with a single coordinate system."] + #[doc = " \\param renderer a rendering context"] + #[doc = " \\param scaleX the horizontal scaling factor"] + #[doc = " \\param scaleY the vertical scaling factor"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\note If this results in scaling or subpixel drawing by the"] - #[doc = " rendering backend, it will be handled using the appropriate"] - #[doc = " quality hints. For best results use integer scaling factors."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_RenderGetScale()"] - #[doc = " \\sa SDL_RenderSetLogicalSize()"] + #[doc = " \\sa SDL_RenderGetScale"] + #[doc = " \\sa SDL_RenderSetLogicalSize"] pub fn SDL_RenderSetScale(renderer: *mut SDL_Renderer, scaleX: f32, scaleY: f32) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the drawing scale for the current target."] + #[doc = " Get the drawing scale for the current target."] #[doc = ""] - #[doc = " \\param renderer The renderer from which drawing scale should be queried."] - #[doc = " \\param scaleX A pointer filled in with the horizontal scaling factor"] - #[doc = " \\param scaleY A pointer filled in with the vertical scaling factor"] + #[doc = " \\param renderer the renderer from which drawing scale should be queried"] + #[doc = " \\param scaleX a pointer filled in with the horizontal scaling factor"] + #[doc = " \\param scaleY a pointer filled in with the vertical scaling factor"] #[doc = ""] - #[doc = " \\sa SDL_RenderSetScale()"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_RenderSetScale"] pub fn SDL_RenderGetScale(renderer: *mut SDL_Renderer, scaleX: *mut f32, scaleY: *mut f32); } extern "C" { - #[doc = " \\brief Set the color used for drawing operations (Rect, Line and Clear)."] + #[doc = " Get logical coordinates of point in renderer when given real coordinates of"] + #[doc = " point in window."] + #[doc = ""] + #[doc = " Logical coordinates will differ from real coordinates when render is scaled"] + #[doc = " and logical renderer size set"] + #[doc = ""] + #[doc = " \\param renderer the renderer from which the logical coordinates should be"] + #[doc = " calcualted"] + #[doc = " \\param windowX the real X coordinate in the window"] + #[doc = " \\param windowY the real Y coordinate in the window"] + #[doc = " \\param logicalX the pointer filled with the logical x coordinate"] + #[doc = " \\param logicalY the pointer filled with the logical y coordinate"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.18."] + #[doc = ""] + #[doc = " \\sa SDL_RenderGetScale"] + #[doc = " \\sa SDL_RenderSetScale"] + #[doc = " \\sa SDL_RenderGetLogicalSize"] + #[doc = " \\sa SDL_RenderSetLogicalSize"] + pub fn SDL_RenderWindowToLogical( + renderer: *mut SDL_Renderer, + windowX: libc::c_int, + windowY: libc::c_int, + logicalX: *mut f32, + logicalY: *mut f32, + ); +} +extern "C" { + #[doc = " Get real coordinates of point in window when given logical coordinates of point in renderer."] + #[doc = " Logical coordinates will differ from real coordinates when render is scaled and logical renderer size set"] + #[doc = ""] + #[doc = " \\param renderer the renderer from which the window coordinates should be calculated"] + #[doc = " \\param logicalX the logical x coordinate"] + #[doc = " \\param logicalY the logical y coordinate"] + #[doc = " \\param windowX the pointer filled with the real X coordinate in the window"] + #[doc = " \\param windowY the pointer filled with the real Y coordinate in the window"] #[doc = ""] - #[doc = " \\param renderer The renderer for which drawing color should be set."] - #[doc = " \\param r The red value used to draw on the rendering target."] - #[doc = " \\param g The green value used to draw on the rendering target."] - #[doc = " \\param b The blue value used to draw on the rendering target."] - #[doc = " \\param a The alpha value used to draw on the rendering target, usually"] - #[doc = " ::SDL_ALPHA_OPAQUE (255)."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\since This function is available since SDL 2.0.18."] + #[doc = ""] + #[doc = " \\sa SDL_RenderGetScale"] + #[doc = " \\sa SDL_RenderSetScale"] + #[doc = " \\sa SDL_RenderGetLogicalSize"] + #[doc = " \\sa SDL_RenderSetLogicalSize"] + pub fn SDL_RenderLogicalToWindow( + renderer: *mut SDL_Renderer, + logicalX: f32, + logicalY: f32, + windowX: *mut libc::c_int, + windowY: *mut libc::c_int, + ); +} +extern "C" { + #[doc = " Set the color used for drawing operations (Rect, Line and Clear)."] + #[doc = ""] + #[doc = " Set the color for drawing or filling rectangles, lines, and points, and for"] + #[doc = " SDL_RenderClear()."] + #[doc = ""] + #[doc = " \\param renderer the rendering context"] + #[doc = " \\param r the red value used to draw on the rendering target"] + #[doc = " \\param g the green value used to draw on the rendering target"] + #[doc = " \\param b the blue value used to draw on the rendering target"] + #[doc = " \\param a the alpha value used to draw on the rendering target; usually"] + #[doc = " `SDL_ALPHA_OPAQUE` (255). Use SDL_SetRenderDrawBlendMode to"] + #[doc = " specify how the alpha channel is used"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetRenderDrawColor"] + #[doc = " \\sa SDL_RenderClear"] + #[doc = " \\sa SDL_RenderDrawLine"] + #[doc = " \\sa SDL_RenderDrawLines"] + #[doc = " \\sa SDL_RenderDrawPoint"] + #[doc = " \\sa SDL_RenderDrawPoints"] + #[doc = " \\sa SDL_RenderDrawRect"] + #[doc = " \\sa SDL_RenderDrawRects"] + #[doc = " \\sa SDL_RenderFillRect"] + #[doc = " \\sa SDL_RenderFillRects"] pub fn SDL_SetRenderDrawColor( renderer: *mut SDL_Renderer, r: Uint8, @@ -17600,16 +23956,23 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the color used for drawing operations (Rect, Line and Clear)."] + #[doc = " Get the color used for drawing operations (Rect, Line and Clear)."] #[doc = ""] - #[doc = " \\param renderer The renderer from which drawing color should be queried."] - #[doc = " \\param r A pointer to the red value used to draw on the rendering target."] - #[doc = " \\param g A pointer to the green value used to draw on the rendering target."] - #[doc = " \\param b A pointer to the blue value used to draw on the rendering target."] - #[doc = " \\param a A pointer to the alpha value used to draw on the rendering target,"] - #[doc = " usually ::SDL_ALPHA_OPAQUE (255)."] + #[doc = " \\param renderer the rendering context"] + #[doc = " \\param r a pointer filled in with the red value used to draw on the"] + #[doc = " rendering target"] + #[doc = " \\param g a pointer filled in with the green value used to draw on the"] + #[doc = " rendering target"] + #[doc = " \\param b a pointer filled in with the blue value used to draw on the"] + #[doc = " rendering target"] + #[doc = " \\param a a pointer filled in with the alpha value used to draw on the"] + #[doc = " rendering target; usually `SDL_ALPHA_OPAQUE` (255)"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_SetRenderDrawColor"] pub fn SDL_GetRenderDrawColor( renderer: *mut SDL_Renderer, r: *mut Uint8, @@ -17619,53 +23982,86 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Set the blend mode used for drawing operations (Fill and Line)."] + #[doc = " Set the blend mode used for drawing operations (Fill and Line)."] #[doc = ""] - #[doc = " \\param renderer The renderer for which blend mode should be set."] - #[doc = " \\param blendMode ::SDL_BlendMode to use for blending."] + #[doc = " If the blend mode is not supported, the closest supported mode is chosen."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\param renderer the rendering context"] + #[doc = " \\param blendMode the SDL_BlendMode to use for blending"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\note If the blend mode is not supported, the closest supported mode is"] - #[doc = " chosen."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_GetRenderDrawBlendMode()"] + #[doc = " \\sa SDL_GetRenderDrawBlendMode"] + #[doc = " \\sa SDL_RenderDrawLine"] + #[doc = " \\sa SDL_RenderDrawLines"] + #[doc = " \\sa SDL_RenderDrawPoint"] + #[doc = " \\sa SDL_RenderDrawPoints"] + #[doc = " \\sa SDL_RenderDrawRect"] + #[doc = " \\sa SDL_RenderDrawRects"] + #[doc = " \\sa SDL_RenderFillRect"] + #[doc = " \\sa SDL_RenderFillRects"] pub fn SDL_SetRenderDrawBlendMode( renderer: *mut SDL_Renderer, blendMode: SDL_BlendMode, ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the blend mode used for drawing operations."] + #[doc = " Get the blend mode used for drawing operations."] #[doc = ""] - #[doc = " \\param renderer The renderer from which blend mode should be queried."] - #[doc = " \\param blendMode A pointer filled in with the current blend mode."] + #[doc = " \\param renderer the rendering context"] + #[doc = " \\param blendMode a pointer filled in with the current SDL_BlendMode"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_SetRenderDrawBlendMode()"] + #[doc = " \\sa SDL_SetRenderDrawBlendMode"] pub fn SDL_GetRenderDrawBlendMode( renderer: *mut SDL_Renderer, blendMode: *mut SDL_BlendMode, ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Clear the current rendering target with the drawing color"] + #[doc = " Clear the current rendering target with the drawing color."] + #[doc = ""] + #[doc = " This function clears the entire rendering target, ignoring the viewport and"] + #[doc = " the clip rectangle."] #[doc = ""] - #[doc = " This function clears the entire rendering target, ignoring the viewport and"] - #[doc = " the clip rectangle."] + #[doc = " \\param renderer the rendering context"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_SetRenderDrawColor"] pub fn SDL_RenderClear(renderer: *mut SDL_Renderer) -> libc::c_int; } extern "C" { - #[doc = " \\brief Draw a point on the current rendering target."] + #[doc = " Draw a point on the current rendering target."] + #[doc = ""] + #[doc = " SDL_RenderDrawPoint() draws a single point. If you want to draw multiple,"] + #[doc = " use SDL_RenderDrawPoints() instead."] #[doc = ""] - #[doc = " \\param renderer The renderer which should draw a point."] - #[doc = " \\param x The x coordinate of the point."] - #[doc = " \\param y The y coordinate of the point."] + #[doc = " \\param renderer the rendering context"] + #[doc = " \\param x the x coordinate of the point"] + #[doc = " \\param y the y coordinate of the point"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_RenderDrawLine"] + #[doc = " \\sa SDL_RenderDrawLines"] + #[doc = " \\sa SDL_RenderDrawPoints"] + #[doc = " \\sa SDL_RenderDrawRect"] + #[doc = " \\sa SDL_RenderDrawRects"] + #[doc = " \\sa SDL_RenderFillRect"] + #[doc = " \\sa SDL_RenderFillRects"] + #[doc = " \\sa SDL_RenderPresent"] + #[doc = " \\sa SDL_SetRenderDrawBlendMode"] + #[doc = " \\sa SDL_SetRenderDrawColor"] pub fn SDL_RenderDrawPoint( renderer: *mut SDL_Renderer, x: libc::c_int, @@ -17673,13 +24069,27 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Draw multiple points on the current rendering target."] + #[doc = " Draw multiple points on the current rendering target."] + #[doc = ""] + #[doc = " \\param renderer the rendering context"] + #[doc = " \\param points an array of SDL_Point structures that represent the points to"] + #[doc = " draw"] + #[doc = " \\param count the number of points to draw"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\param renderer The renderer which should draw multiple points."] - #[doc = " \\param points The points to draw"] - #[doc = " \\param count The number of points to draw"] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\sa SDL_RenderDrawLine"] + #[doc = " \\sa SDL_RenderDrawLines"] + #[doc = " \\sa SDL_RenderDrawPoint"] + #[doc = " \\sa SDL_RenderDrawRect"] + #[doc = " \\sa SDL_RenderDrawRects"] + #[doc = " \\sa SDL_RenderFillRect"] + #[doc = " \\sa SDL_RenderFillRects"] + #[doc = " \\sa SDL_RenderPresent"] + #[doc = " \\sa SDL_SetRenderDrawBlendMode"] + #[doc = " \\sa SDL_SetRenderDrawColor"] pub fn SDL_RenderDrawPoints( renderer: *mut SDL_Renderer, points: *const SDL_Point, @@ -17687,15 +24097,31 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Draw a line on the current rendering target."] + #[doc = " Draw a line on the current rendering target."] + #[doc = ""] + #[doc = " SDL_RenderDrawLine() draws the line to include both end points. If you want"] + #[doc = " to draw multiple, connecting lines use SDL_RenderDrawLines() instead."] + #[doc = ""] + #[doc = " \\param renderer the rendering context"] + #[doc = " \\param x1 the x coordinate of the start point"] + #[doc = " \\param y1 the y coordinate of the start point"] + #[doc = " \\param x2 the x coordinate of the end point"] + #[doc = " \\param y2 the y coordinate of the end point"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\param renderer The renderer which should draw a line."] - #[doc = " \\param x1 The x coordinate of the start point."] - #[doc = " \\param y1 The y coordinate of the start point."] - #[doc = " \\param x2 The x coordinate of the end point."] - #[doc = " \\param y2 The y coordinate of the end point."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\sa SDL_RenderDrawLines"] + #[doc = " \\sa SDL_RenderDrawPoint"] + #[doc = " \\sa SDL_RenderDrawPoints"] + #[doc = " \\sa SDL_RenderDrawRect"] + #[doc = " \\sa SDL_RenderDrawRects"] + #[doc = " \\sa SDL_RenderFillRect"] + #[doc = " \\sa SDL_RenderFillRects"] + #[doc = " \\sa SDL_RenderPresent"] + #[doc = " \\sa SDL_SetRenderDrawBlendMode"] + #[doc = " \\sa SDL_SetRenderDrawColor"] pub fn SDL_RenderDrawLine( renderer: *mut SDL_Renderer, x1: libc::c_int, @@ -17705,13 +24131,27 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Draw a series of connected lines on the current rendering target."] + #[doc = " Draw a series of connected lines on the current rendering target."] #[doc = ""] - #[doc = " \\param renderer The renderer which should draw multiple lines."] - #[doc = " \\param points The points along the lines"] - #[doc = " \\param count The number of points, drawing count-1 lines"] + #[doc = " \\param renderer the rendering context"] + #[doc = " \\param points an array of SDL_Point structures representing points along"] + #[doc = " the lines"] + #[doc = " \\param count the number of points, drawing count-1 lines"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_RenderDrawLine"] + #[doc = " \\sa SDL_RenderDrawPoint"] + #[doc = " \\sa SDL_RenderDrawPoints"] + #[doc = " \\sa SDL_RenderDrawRect"] + #[doc = " \\sa SDL_RenderDrawRects"] + #[doc = " \\sa SDL_RenderFillRect"] + #[doc = " \\sa SDL_RenderFillRects"] + #[doc = " \\sa SDL_RenderPresent"] + #[doc = " \\sa SDL_SetRenderDrawBlendMode"] + #[doc = " \\sa SDL_SetRenderDrawColor"] pub fn SDL_RenderDrawLines( renderer: *mut SDL_Renderer, points: *const SDL_Point, @@ -17719,22 +24159,50 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Draw a rectangle on the current rendering target."] + #[doc = " Draw a rectangle on the current rendering target."] + #[doc = ""] + #[doc = " \\param renderer the rendering context"] + #[doc = " \\param rect an SDL_Rect structure representing the rectangle to draw, or"] + #[doc = " NULL to outline the entire rendering target"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\param renderer The renderer which should draw a rectangle."] - #[doc = " \\param rect A pointer to the destination rectangle, or NULL to outline the entire rendering target."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\sa SDL_RenderDrawLine"] + #[doc = " \\sa SDL_RenderDrawLines"] + #[doc = " \\sa SDL_RenderDrawPoint"] + #[doc = " \\sa SDL_RenderDrawPoints"] + #[doc = " \\sa SDL_RenderDrawRects"] + #[doc = " \\sa SDL_RenderFillRect"] + #[doc = " \\sa SDL_RenderFillRects"] + #[doc = " \\sa SDL_RenderPresent"] + #[doc = " \\sa SDL_SetRenderDrawBlendMode"] + #[doc = " \\sa SDL_SetRenderDrawColor"] pub fn SDL_RenderDrawRect(renderer: *mut SDL_Renderer, rect: *const SDL_Rect) -> libc::c_int; } extern "C" { - #[doc = " \\brief Draw some number of rectangles on the current rendering target."] + #[doc = " Draw some number of rectangles on the current rendering target."] #[doc = ""] - #[doc = " \\param renderer The renderer which should draw multiple rectangles."] - #[doc = " \\param rects A pointer to an array of destination rectangles."] - #[doc = " \\param count The number of rectangles."] + #[doc = " \\param renderer the rendering context"] + #[doc = " \\param rects an array of SDL_Rect structures representing the rectangles to"] + #[doc = " be drawn"] + #[doc = " \\param count the number of rectangles"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_RenderDrawLine"] + #[doc = " \\sa SDL_RenderDrawLines"] + #[doc = " \\sa SDL_RenderDrawPoint"] + #[doc = " \\sa SDL_RenderDrawPoints"] + #[doc = " \\sa SDL_RenderDrawRect"] + #[doc = " \\sa SDL_RenderFillRect"] + #[doc = " \\sa SDL_RenderFillRects"] + #[doc = " \\sa SDL_RenderPresent"] + #[doc = " \\sa SDL_SetRenderDrawBlendMode"] + #[doc = " \\sa SDL_SetRenderDrawColor"] pub fn SDL_RenderDrawRects( renderer: *mut SDL_Renderer, rects: *const SDL_Rect, @@ -17742,23 +24210,53 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Fill a rectangle on the current rendering target with the drawing color."] + #[doc = " Fill a rectangle on the current rendering target with the drawing color."] + #[doc = ""] + #[doc = " The current drawing color is set by SDL_SetRenderDrawColor(), and the"] + #[doc = " color's alpha value is ignored unless blending is enabled with the"] + #[doc = " appropriate call to SDL_SetRenderDrawBlendMode()."] #[doc = ""] - #[doc = " \\param renderer The renderer which should fill a rectangle."] - #[doc = " \\param rect A pointer to the destination rectangle, or NULL for the entire"] - #[doc = " rendering target."] + #[doc = " \\param renderer the rendering context"] + #[doc = " \\param rect the SDL_Rect structure representing the rectangle to fill, or"] + #[doc = " NULL for the entire rendering target"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_RenderDrawLine"] + #[doc = " \\sa SDL_RenderDrawLines"] + #[doc = " \\sa SDL_RenderDrawPoint"] + #[doc = " \\sa SDL_RenderDrawPoints"] + #[doc = " \\sa SDL_RenderDrawRect"] + #[doc = " \\sa SDL_RenderDrawRects"] + #[doc = " \\sa SDL_RenderFillRects"] + #[doc = " \\sa SDL_RenderPresent"] + #[doc = " \\sa SDL_SetRenderDrawBlendMode"] + #[doc = " \\sa SDL_SetRenderDrawColor"] pub fn SDL_RenderFillRect(renderer: *mut SDL_Renderer, rect: *const SDL_Rect) -> libc::c_int; } extern "C" { - #[doc = " \\brief Fill some number of rectangles on the current rendering target with the drawing color."] + #[doc = " Fill some number of rectangles on the current rendering target with the"] + #[doc = " drawing color."] + #[doc = ""] + #[doc = " \\param renderer the rendering context"] + #[doc = " \\param rects an array of SDL_Rect structures representing the rectangles to"] + #[doc = " be filled"] + #[doc = " \\param count the number of rectangles"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] #[doc = ""] - #[doc = " \\param renderer The renderer which should fill multiple rectangles."] - #[doc = " \\param rects A pointer to an array of destination rectangles."] - #[doc = " \\param count The number of rectangles."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\sa SDL_RenderDrawLine"] + #[doc = " \\sa SDL_RenderDrawLines"] + #[doc = " \\sa SDL_RenderDrawPoint"] + #[doc = " \\sa SDL_RenderDrawPoints"] + #[doc = " \\sa SDL_RenderDrawRect"] + #[doc = " \\sa SDL_RenderDrawRects"] + #[doc = " \\sa SDL_RenderFillRect"] + #[doc = " \\sa SDL_RenderPresent"] pub fn SDL_RenderFillRects( renderer: *mut SDL_Renderer, rects: *const SDL_Rect, @@ -17766,16 +24264,32 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Copy a portion of the texture to the current rendering target."] + #[doc = " Copy a portion of the texture to the current rendering target."] + #[doc = ""] + #[doc = " The texture is blended with the destination based on its blend mode set"] + #[doc = " with SDL_SetTextureBlendMode()."] + #[doc = ""] + #[doc = " The texture color is affected based on its color modulation set by"] + #[doc = " SDL_SetTextureColorMod()."] #[doc = ""] - #[doc = " \\param renderer The renderer which should copy parts of a texture."] - #[doc = " \\param texture The source texture."] - #[doc = " \\param srcrect A pointer to the source rectangle, or NULL for the entire"] - #[doc = " texture."] - #[doc = " \\param dstrect A pointer to the destination rectangle, or NULL for the"] - #[doc = " entire rendering target."] + #[doc = " The texture alpha is affected based on its alpha modulation set by"] + #[doc = " SDL_SetTextureAlphaMod()."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\param renderer the rendering context"] + #[doc = " \\param texture the source texture"] + #[doc = " \\param srcrect the source SDL_Rect structure or NULL for the entire texture"] + #[doc = " \\param dstrect the destination SDL_Rect structure or NULL for the entire"] + #[doc = " rendering target; the texture will be stretched to fill the"] + #[doc = " given rectangle"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_RenderCopyEx"] + #[doc = " \\sa SDL_SetTextureAlphaMod"] + #[doc = " \\sa SDL_SetTextureBlendMode"] + #[doc = " \\sa SDL_SetTextureColorMod"] pub fn SDL_RenderCopy( renderer: *mut SDL_Renderer, texture: *mut SDL_Texture, @@ -17784,19 +24298,43 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Copy a portion of the source texture to the current rendering target, rotating it by angle around the given center"] + #[doc = " Copy a portion of the texture to the current rendering, with optional"] + #[doc = " rotation and flipping."] + #[doc = ""] + #[doc = " Copy a portion of the texture to the current rendering target, optionally"] + #[doc = " rotating it by angle around the given center and also flipping it"] + #[doc = " top-bottom and/or left-right."] + #[doc = ""] + #[doc = " The texture is blended with the destination based on its blend mode set"] + #[doc = " with SDL_SetTextureBlendMode()."] #[doc = ""] - #[doc = " \\param renderer The renderer which should copy parts of a texture."] - #[doc = " \\param texture The source texture."] - #[doc = " \\param srcrect A pointer to the source rectangle, or NULL for the entire"] - #[doc = " texture."] - #[doc = " \\param dstrect A pointer to the destination rectangle, or NULL for the"] - #[doc = " entire rendering target."] - #[doc = " \\param angle An angle in degrees that indicates the rotation that will be applied to dstrect, rotating it in a clockwise direction"] - #[doc = " \\param center A pointer to a point indicating the point around which dstrect will be rotated (if NULL, rotation will be done around dstrect.w/2, dstrect.h/2)."] - #[doc = " \\param flip An SDL_RendererFlip value stating which flipping actions should be performed on the texture"] + #[doc = " The texture color is affected based on its color modulation set by"] + #[doc = " SDL_SetTextureColorMod()."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " The texture alpha is affected based on its alpha modulation set by"] + #[doc = " SDL_SetTextureAlphaMod()."] + #[doc = ""] + #[doc = " \\param renderer the rendering context"] + #[doc = " \\param texture the source texture"] + #[doc = " \\param srcrect the source SDL_Rect structure or NULL for the entire texture"] + #[doc = " \\param dstrect the destination SDL_Rect structure or NULL for the entire"] + #[doc = " rendering target"] + #[doc = " \\param angle an angle in degrees that indicates the rotation that will be"] + #[doc = " applied to dstrect, rotating it in a clockwise direction"] + #[doc = " \\param center a pointer to a point indicating the point around which"] + #[doc = " dstrect will be rotated (if NULL, rotation will be done"] + #[doc = " around `dstrect.w / 2`, `dstrect.h / 2`)"] + #[doc = " \\param flip a SDL_RendererFlip value stating which flipping actions should"] + #[doc = " be performed on the texture"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_RenderCopy"] + #[doc = " \\sa SDL_SetTextureAlphaMod"] + #[doc = " \\sa SDL_SetTextureBlendMode"] + #[doc = " \\sa SDL_SetTextureColorMod"] pub fn SDL_RenderCopyEx( renderer: *mut SDL_Renderer, texture: *mut SDL_Texture, @@ -17808,23 +24346,25 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Draw a point on the current rendering target."] + #[doc = " Draw a point on the current rendering target at subpixel precision."] #[doc = ""] - #[doc = " \\param renderer The renderer which should draw a point."] - #[doc = " \\param x The x coordinate of the point."] - #[doc = " \\param y The y coordinate of the point."] + #[doc = " \\param renderer The renderer which should draw a point."] + #[doc = " \\param x The x coordinate of the point."] + #[doc = " \\param y The y coordinate of the point."] + #[doc = " \\return 0 on success, or -1 on error"] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\since This function is available since SDL 2.0.10."] pub fn SDL_RenderDrawPointF(renderer: *mut SDL_Renderer, x: f32, y: f32) -> libc::c_int; } extern "C" { - #[doc = " \\brief Draw multiple points on the current rendering target."] + #[doc = " Draw multiple points on the current rendering target at subpixel precision."] #[doc = ""] - #[doc = " \\param renderer The renderer which should draw multiple points."] - #[doc = " \\param points The points to draw"] - #[doc = " \\param count The number of points to draw"] + #[doc = " \\param renderer The renderer which should draw multiple points."] + #[doc = " \\param points The points to draw"] + #[doc = " \\param count The number of points to draw"] + #[doc = " \\return 0 on success, or -1 on error"] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\since This function is available since SDL 2.0.10."] pub fn SDL_RenderDrawPointsF( renderer: *mut SDL_Renderer, points: *const SDL_FPoint, @@ -17832,15 +24372,16 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Draw a line on the current rendering target."] + #[doc = " Draw a line on the current rendering target at subpixel precision."] #[doc = ""] - #[doc = " \\param renderer The renderer which should draw a line."] - #[doc = " \\param x1 The x coordinate of the start point."] - #[doc = " \\param y1 The y coordinate of the start point."] - #[doc = " \\param x2 The x coordinate of the end point."] - #[doc = " \\param y2 The y coordinate of the end point."] + #[doc = " \\param renderer The renderer which should draw a line."] + #[doc = " \\param x1 The x coordinate of the start point."] + #[doc = " \\param y1 The y coordinate of the start point."] + #[doc = " \\param x2 The x coordinate of the end point."] + #[doc = " \\param y2 The y coordinate of the end point."] + #[doc = " \\return 0 on success, or -1 on error"] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\since This function is available since SDL 2.0.10."] pub fn SDL_RenderDrawLineF( renderer: *mut SDL_Renderer, x1: f32, @@ -17850,13 +24391,15 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Draw a series of connected lines on the current rendering target."] + #[doc = " Draw a series of connected lines on the current rendering target at"] + #[doc = " subpixel precision."] #[doc = ""] - #[doc = " \\param renderer The renderer which should draw multiple lines."] - #[doc = " \\param points The points along the lines"] - #[doc = " \\param count The number of points, drawing count-1 lines"] + #[doc = " \\param renderer The renderer which should draw multiple lines."] + #[doc = " \\param points The points along the lines"] + #[doc = " \\param count The number of points, drawing count-1 lines"] + #[doc = " \\return 0 on success, or -1 on error"] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\since This function is available since SDL 2.0.10."] pub fn SDL_RenderDrawLinesF( renderer: *mut SDL_Renderer, points: *const SDL_FPoint, @@ -17864,22 +24407,26 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Draw a rectangle on the current rendering target."] + #[doc = " Draw a rectangle on the current rendering target at subpixel precision."] #[doc = ""] - #[doc = " \\param renderer The renderer which should draw a rectangle."] - #[doc = " \\param rect A pointer to the destination rectangle, or NULL to outline the entire rendering target."] + #[doc = " \\param renderer The renderer which should draw a rectangle."] + #[doc = " \\param rect A pointer to the destination rectangle, or NULL to outline the"] + #[doc = " entire rendering target."] + #[doc = " \\return 0 on success, or -1 on error"] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\since This function is available since SDL 2.0.10."] pub fn SDL_RenderDrawRectF(renderer: *mut SDL_Renderer, rect: *const SDL_FRect) -> libc::c_int; } extern "C" { - #[doc = " \\brief Draw some number of rectangles on the current rendering target."] + #[doc = " Draw some number of rectangles on the current rendering target at subpixel"] + #[doc = " precision."] #[doc = ""] - #[doc = " \\param renderer The renderer which should draw multiple rectangles."] - #[doc = " \\param rects A pointer to an array of destination rectangles."] - #[doc = " \\param count The number of rectangles."] + #[doc = " \\param renderer The renderer which should draw multiple rectangles."] + #[doc = " \\param rects A pointer to an array of destination rectangles."] + #[doc = " \\param count The number of rectangles."] + #[doc = " \\return 0 on success, or -1 on error"] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\since This function is available since SDL 2.0.10."] pub fn SDL_RenderDrawRectsF( renderer: *mut SDL_Renderer, rects: *const SDL_FRect, @@ -17887,23 +24434,27 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Fill a rectangle on the current rendering target with the drawing color."] + #[doc = " Fill a rectangle on the current rendering target with the drawing color at"] + #[doc = " subpixel precision."] #[doc = ""] - #[doc = " \\param renderer The renderer which should fill a rectangle."] - #[doc = " \\param rect A pointer to the destination rectangle, or NULL for the entire"] - #[doc = " rendering target."] + #[doc = " \\param renderer The renderer which should fill a rectangle."] + #[doc = " \\param rect A pointer to the destination rectangle, or NULL for the entire"] + #[doc = " rendering target."] + #[doc = " \\return 0 on success, or -1 on error"] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\since This function is available since SDL 2.0.10."] pub fn SDL_RenderFillRectF(renderer: *mut SDL_Renderer, rect: *const SDL_FRect) -> libc::c_int; } extern "C" { - #[doc = " \\brief Fill some number of rectangles on the current rendering target with the drawing color."] + #[doc = " Fill some number of rectangles on the current rendering target with the"] + #[doc = " drawing color at subpixel precision."] #[doc = ""] - #[doc = " \\param renderer The renderer which should fill multiple rectangles."] - #[doc = " \\param rects A pointer to an array of destination rectangles."] - #[doc = " \\param count The number of rectangles."] + #[doc = " \\param renderer The renderer which should fill multiple rectangles."] + #[doc = " \\param rects A pointer to an array of destination rectangles."] + #[doc = " \\param count The number of rectangles."] + #[doc = " \\return 0 on success, or -1 on error"] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\since This function is available since SDL 2.0.10."] pub fn SDL_RenderFillRectsF( renderer: *mut SDL_Renderer, rects: *const SDL_FRect, @@ -17911,16 +24462,18 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Copy a portion of the texture to the current rendering target."] + #[doc = " Copy a portion of the texture to the current rendering target at subpixel"] + #[doc = " precision."] #[doc = ""] - #[doc = " \\param renderer The renderer which should copy parts of a texture."] - #[doc = " \\param texture The source texture."] - #[doc = " \\param srcrect A pointer to the source rectangle, or NULL for the entire"] - #[doc = " texture."] - #[doc = " \\param dstrect A pointer to the destination rectangle, or NULL for the"] - #[doc = " entire rendering target."] + #[doc = " \\param renderer The renderer which should copy parts of a texture."] + #[doc = " \\param texture The source texture."] + #[doc = " \\param srcrect A pointer to the source rectangle, or NULL for the entire"] + #[doc = " texture."] + #[doc = " \\param dstrect A pointer to the destination rectangle, or NULL for the"] + #[doc = " entire rendering target."] + #[doc = " \\return 0 on success, or -1 on error"] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\since This function is available since SDL 2.0.10."] pub fn SDL_RenderCopyF( renderer: *mut SDL_Renderer, texture: *mut SDL_Texture, @@ -17929,19 +24482,25 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Copy a portion of the source texture to the current rendering target, rotating it by angle around the given center"] + #[doc = " Copy a portion of the source texture to the current rendering target, with"] + #[doc = " rotation and flipping, at subpixel precision."] #[doc = ""] - #[doc = " \\param renderer The renderer which should copy parts of a texture."] - #[doc = " \\param texture The source texture."] - #[doc = " \\param srcrect A pointer to the source rectangle, or NULL for the entire"] - #[doc = " texture."] - #[doc = " \\param dstrect A pointer to the destination rectangle, or NULL for the"] - #[doc = " entire rendering target."] - #[doc = " \\param angle An angle in degrees that indicates the rotation that will be applied to dstrect, rotating it in a clockwise direction"] - #[doc = " \\param center A pointer to a point indicating the point around which dstrect will be rotated (if NULL, rotation will be done around dstrect.w/2, dstrect.h/2)."] - #[doc = " \\param flip An SDL_RendererFlip value stating which flipping actions should be performed on the texture"] + #[doc = " \\param renderer The renderer which should copy parts of a texture."] + #[doc = " \\param texture The source texture."] + #[doc = " \\param srcrect A pointer to the source rectangle, or NULL for the entire"] + #[doc = " texture."] + #[doc = " \\param dstrect A pointer to the destination rectangle, or NULL for the"] + #[doc = " entire rendering target."] + #[doc = " \\param angle An angle in degrees that indicates the rotation that will be"] + #[doc = " applied to dstrect, rotating it in a clockwise direction"] + #[doc = " \\param center A pointer to a point indicating the point around which"] + #[doc = " dstrect will be rotated (if NULL, rotation will be done"] + #[doc = " around dstrect.w/2, dstrect.h/2)."] + #[doc = " \\param flip An SDL_RendererFlip value stating which flipping actions should"] + #[doc = " be performed on the texture"] + #[doc = " \\return 0 on success, or -1 on error"] #[doc = ""] - #[doc = " \\return 0 on success, or -1 on error"] + #[doc = " \\since This function is available since SDL 2.0.10."] pub fn SDL_RenderCopyExF( renderer: *mut SDL_Renderer, texture: *mut SDL_Texture, @@ -17953,19 +24512,94 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Read pixels from the current rendering target."] + #[doc = " Render a list of triangles, optionally using a texture and indices into the"] + #[doc = " vertex array Color and alpha modulation is done per vertex"] + #[doc = " (SDL_SetTextureColorMod and SDL_SetTextureAlphaMod are ignored)."] #[doc = ""] - #[doc = " \\param renderer The renderer from which pixels should be read."] - #[doc = " \\param rect A pointer to the rectangle to read, or NULL for the entire"] - #[doc = " render target."] - #[doc = " \\param format The desired format of the pixel data, or 0 to use the format"] - #[doc = " of the rendering target"] - #[doc = " \\param pixels A pointer to be filled in with the pixel data"] - #[doc = " \\param pitch The pitch of the pixels parameter."] + #[doc = " \\param texture (optional) The SDL texture to use."] + #[doc = " \\param vertices Vertices."] + #[doc = " \\param num_vertices Number of vertices."] + #[doc = " \\param indices (optional) An array of integer indices into the 'vertices'"] + #[doc = " array, if NULL all vertices will be rendered in sequential"] + #[doc = " order."] + #[doc = " \\param num_indices Number of indices."] + #[doc = " \\return 0 on success, or -1 if the operation is not supported"] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if pixel reading is not supported."] + #[doc = " \\since This function is available since SDL 2.0.18."] #[doc = ""] - #[doc = " \\warning This is a very slow operation, and should not be used frequently."] + #[doc = " \\sa SDL_RenderGeometryRaw"] + #[doc = " \\sa SDL_Vertex"] + pub fn SDL_RenderGeometry( + renderer: *mut SDL_Renderer, + texture: *mut SDL_Texture, + vertices: *const SDL_Vertex, + num_vertices: libc::c_int, + indices: *const libc::c_int, + num_indices: libc::c_int, + ) -> libc::c_int; +} +extern "C" { + #[doc = " Render a list of triangles, optionally using a texture and indices into the"] + #[doc = " vertex arrays Color and alpha modulation is done per vertex"] + #[doc = " (SDL_SetTextureColorMod and SDL_SetTextureAlphaMod are ignored)."] + #[doc = ""] + #[doc = " \\param texture (optional) The SDL texture to use."] + #[doc = " \\param xy Vertex positions"] + #[doc = " \\param xy_stride Byte size to move from one element to the next element"] + #[doc = " \\param color Vertex colors (as SDL_Color)"] + #[doc = " \\param color_stride Byte size to move from one element to the next element"] + #[doc = " \\param uv Vertex normalized texture coordinates"] + #[doc = " \\param uv_stride Byte size to move from one element to the next element"] + #[doc = " \\param num_vertices Number of vertices."] + #[doc = " \\param indices (optional) An array of indices into the 'vertices' arrays,"] + #[doc = " if NULL all vertices will be rendered in sequential order."] + #[doc = " \\param num_indices Number of indices."] + #[doc = " \\param size_indices Index size: 1 (byte), 2 (short), 4 (int)"] + #[doc = " \\return 0 on success, or -1 if the operation is not supported"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.18."] + #[doc = ""] + #[doc = " \\sa SDL_RenderGeometry"] + #[doc = " \\sa SDL_Vertex"] + pub fn SDL_RenderGeometryRaw( + renderer: *mut SDL_Renderer, + texture: *mut SDL_Texture, + xy: *const f32, + xy_stride: libc::c_int, + color: *const SDL_Color, + color_stride: libc::c_int, + uv: *const f32, + uv_stride: libc::c_int, + num_vertices: libc::c_int, + indices: *const libc::c_void, + num_indices: libc::c_int, + size_indices: libc::c_int, + ) -> libc::c_int; +} +extern "C" { + #[doc = " Read pixels from the current rendering target to an array of pixels."] + #[doc = ""] + #[doc = " **WARNING**: This is a very slow operation, and should not be used"] + #[doc = " frequently."] + #[doc = ""] + #[doc = " `pitch` specifies the number of bytes between rows in the destination"] + #[doc = " `pixels` data. This allows you to write to a subrectangle or have padded"] + #[doc = " rows in the destination. Generally, `pitch` should equal the number of"] + #[doc = " pixels per row in the `pixels` data times the number of bytes per pixel,"] + #[doc = " but it might contain additional padding (for example, 24bit RGB Windows"] + #[doc = " Bitmap data pads all rows to multiples of 4 bytes)."] + #[doc = ""] + #[doc = " \\param renderer the rendering context"] + #[doc = " \\param rect an SDL_Rect structure representing the area to read, or NULL"] + #[doc = " for the entire render target"] + #[doc = " \\param format an SDL_PixelFormatEnum value of the desired format of the"] + #[doc = " pixel data, or 0 to use the format of the rendering target"] + #[doc = " \\param pixels a pointer to the pixel data to copy into"] + #[doc = " \\param pitch the pitch of the `pixels` parameter"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_RenderReadPixels( renderer: *mut SDL_Renderer, rect: *const SDL_Rect, @@ -17975,56 +24609,129 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Update the screen with rendering performed."] + #[doc = " Update the screen with any rendering performed since the previous call."] + #[doc = ""] + #[doc = " SDL's rendering functions operate on a backbuffer; that is, calling a"] + #[doc = " rendering function such as SDL_RenderDrawLine() does not directly put a"] + #[doc = " line on the screen, but rather updates the backbuffer. As such, you compose"] + #[doc = " your entire scene and *present* the composed backbuffer to the screen as a"] + #[doc = " complete picture."] + #[doc = ""] + #[doc = " Therefore, when using SDL's rendering API, one does all drawing intended"] + #[doc = " for the frame, and then calls this function once per frame to present the"] + #[doc = " final drawing to the user."] + #[doc = ""] + #[doc = " The backbuffer should be considered invalidated after each present; do not"] + #[doc = " assume that previous contents will exist between frames. You are strongly"] + #[doc = " encouraged to call SDL_RenderClear() to initialize the backbuffer before"] + #[doc = " starting each new frame's drawing, even if you plan to overwrite every"] + #[doc = " pixel."] + #[doc = ""] + #[doc = " \\param renderer the rendering context"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_RenderClear"] + #[doc = " \\sa SDL_RenderDrawLine"] + #[doc = " \\sa SDL_RenderDrawLines"] + #[doc = " \\sa SDL_RenderDrawPoint"] + #[doc = " \\sa SDL_RenderDrawPoints"] + #[doc = " \\sa SDL_RenderDrawRect"] + #[doc = " \\sa SDL_RenderDrawRects"] + #[doc = " \\sa SDL_RenderFillRect"] + #[doc = " \\sa SDL_RenderFillRects"] + #[doc = " \\sa SDL_SetRenderDrawBlendMode"] + #[doc = " \\sa SDL_SetRenderDrawColor"] pub fn SDL_RenderPresent(renderer: *mut SDL_Renderer); } extern "C" { - #[doc = " \\brief Destroy the specified texture."] + #[doc = " Destroy the specified texture."] + #[doc = ""] + #[doc = " Passing NULL or an otherwise invalid texture will set the SDL error message"] + #[doc = " to \"Invalid texture\"."] #[doc = ""] - #[doc = " \\sa SDL_CreateTexture()"] - #[doc = " \\sa SDL_CreateTextureFromSurface()"] + #[doc = " \\param texture the texture to destroy"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_CreateTexture"] + #[doc = " \\sa SDL_CreateTextureFromSurface"] pub fn SDL_DestroyTexture(texture: *mut SDL_Texture); } extern "C" { - #[doc = " \\brief Destroy the rendering context for a window and free associated"] - #[doc = " textures."] + #[doc = " Destroy the rendering context for a window and free associated textures."] + #[doc = ""] + #[doc = " \\param renderer the rendering context"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_CreateRenderer()"] + #[doc = " \\sa SDL_CreateRenderer"] pub fn SDL_DestroyRenderer(renderer: *mut SDL_Renderer); } extern "C" { - #[doc = " \\brief Force the rendering context to flush any pending commands to the"] - #[doc = " underlying rendering API."] + #[doc = " Force the rendering context to flush any pending commands to the underlying"] + #[doc = " rendering API."] #[doc = ""] - #[doc = " You do not need to (and in fact, shouldn't) call this function unless"] - #[doc = " you are planning to call into OpenGL/Direct3D/Metal/whatever directly"] - #[doc = " in addition to using an SDL_Renderer."] + #[doc = " You do not need to (and in fact, shouldn't) call this function unless you"] + #[doc = " are planning to call into OpenGL/Direct3D/Metal/whatever directly in"] + #[doc = " addition to using an SDL_Renderer."] #[doc = ""] - #[doc = " This is for a very-specific case: if you are using SDL's render API,"] - #[doc = " you asked for a specific renderer backend (OpenGL, Direct3D, etc),"] - #[doc = " you set SDL_HINT_RENDER_BATCHING to \"1\", and you plan to make"] - #[doc = " OpenGL/D3D/whatever calls in addition to SDL render API calls. If all of"] - #[doc = " this applies, you should call SDL_RenderFlush() between calls to SDL's"] - #[doc = " render API and the low-level API you're using in cooperation."] + #[doc = " This is for a very-specific case: if you are using SDL's render API, you"] + #[doc = " asked for a specific renderer backend (OpenGL, Direct3D, etc), you set"] + #[doc = " SDL_HINT_RENDER_BATCHING to \"1\", and you plan to make OpenGL/D3D/whatever"] + #[doc = " calls in addition to SDL render API calls. If all of this applies, you"] + #[doc = " should call SDL_RenderFlush() between calls to SDL's render API and the"] + #[doc = " low-level API you're using in cooperation."] #[doc = ""] - #[doc = " In all other cases, you can ignore this function. This is only here to"] - #[doc = " get maximum performance out of a specific situation. In all other cases,"] - #[doc = " SDL will do the right thing, perhaps at a performance loss."] + #[doc = " In all other cases, you can ignore this function. This is only here to get"] + #[doc = " maximum performance out of a specific situation. In all other cases, SDL"] + #[doc = " will do the right thing, perhaps at a performance loss."] #[doc = ""] - #[doc = " This function is first available in SDL 2.0.10, and is not needed in"] - #[doc = " 2.0.9 and earlier, as earlier versions did not queue rendering commands"] - #[doc = " at all, instead flushing them to the OS immediately."] + #[doc = " This function is first available in SDL 2.0.10, and is not needed in 2.0.9"] + #[doc = " and earlier, as earlier versions did not queue rendering commands at all,"] + #[doc = " instead flushing them to the OS immediately."] + #[doc = ""] + #[doc = " \\param renderer the rendering context"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.10."] pub fn SDL_RenderFlush(renderer: *mut SDL_Renderer) -> libc::c_int; } extern "C" { - #[doc = " \\brief Bind the texture to the current OpenGL/ES/ES2 context for use with"] - #[doc = " OpenGL instructions."] + #[doc = " Bind an OpenGL/ES/ES2 texture to the current context."] + #[doc = ""] + #[doc = " This is for use with OpenGL instructions when rendering OpenGL primitives"] + #[doc = " directly."] + #[doc = ""] + #[doc = " If not NULL, `texw` and `texh` will be filled with the width and height"] + #[doc = " values suitable for the provided texture. In most cases, both will be 1.0,"] + #[doc = " however, on systems that support the GL_ARB_texture_rectangle extension,"] + #[doc = " these values will actually be the pixel width and height used to create the"] + #[doc = " texture, so this factor needs to be taken into account when providing"] + #[doc = " texture coordinates to OpenGL."] #[doc = ""] - #[doc = " \\param texture The SDL texture to bind"] - #[doc = " \\param texw A pointer to a float that will be filled with the texture width"] - #[doc = " \\param texh A pointer to a float that will be filled with the texture height"] + #[doc = " You need a renderer to create an SDL_Texture, therefore you can only use"] + #[doc = " this function with an implicit OpenGL context from SDL_CreateRenderer(),"] + #[doc = " not with your own OpenGL context. If you need control over your OpenGL"] + #[doc = " context, you need to write your own texture-loading methods."] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the operation is not supported"] + #[doc = " Also note that SDL may upload RGB textures as BGR (or vice-versa), and"] + #[doc = " re-order the color channels in the shaders phase, so the uploaded texture"] + #[doc = " may have swapped color channels."] + #[doc = ""] + #[doc = " \\param texture the texture to bind to the current OpenGL/ES/ES2 context"] + #[doc = " \\param texw a pointer to a float value which will be filled with the"] + #[doc = " texture width or NULL if you don't need that value"] + #[doc = " \\param texh a pointer to a float value which will be filled with the"] + #[doc = " texture height or NULL if you don't need that value"] + #[doc = " \\returns 0 on success, or -1 if the operation is not supported; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GL_MakeCurrent"] + #[doc = " \\sa SDL_GL_UnbindTexture"] pub fn SDL_GL_BindTexture( texture: *mut SDL_Texture, texw: *mut f32, @@ -18032,52 +24739,86 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Unbind a texture from the current OpenGL/ES/ES2 context."] + #[doc = " Unbind an OpenGL/ES/ES2 texture from the current context."] + #[doc = ""] + #[doc = " See SDL_GL_BindTexture() for examples on how to use these functions"] #[doc = ""] - #[doc = " \\param texture The SDL texture to unbind"] + #[doc = " \\param texture the texture to unbind from the current OpenGL/ES/ES2 context"] + #[doc = " \\returns 0 on success, or -1 if the operation is not supported"] #[doc = ""] - #[doc = " \\return 0 on success, or -1 if the operation is not supported"] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GL_BindTexture"] + #[doc = " \\sa SDL_GL_MakeCurrent"] pub fn SDL_GL_UnbindTexture(texture: *mut SDL_Texture) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the CAMetalLayer associated with the given Metal renderer"] + #[doc = " Get the CAMetalLayer associated with the given Metal renderer."] + #[doc = ""] + #[doc = " This function returns `void *`, so SDL doesn't have to include Metal's"] + #[doc = " headers, but it can be safely cast to a `CAMetalLayer *`."] #[doc = ""] - #[doc = " \\param renderer The renderer to query"] + #[doc = " \\param renderer The renderer to query"] + #[doc = " \\returns a `CAMetalLayer *` on success, or NULL if the renderer isn't a"] + #[doc = " Metal renderer"] #[doc = ""] - #[doc = " \\return CAMetalLayer* on success, or NULL if the renderer isn't a Metal renderer"] + #[doc = " \\since This function is available since SDL 2.0.8."] #[doc = ""] - #[doc = " \\sa SDL_RenderGetMetalCommandEncoder()"] + #[doc = " \\sa SDL_RenderGetMetalCommandEncoder"] pub fn SDL_RenderGetMetalLayer(renderer: *mut SDL_Renderer) -> *mut libc::c_void; } extern "C" { - #[doc = " \\brief Get the Metal command encoder for the current frame"] + #[doc = " Get the Metal command encoder for the current frame"] + #[doc = ""] + #[doc = " This function returns `void *`, so SDL doesn't have to include Metal's"] + #[doc = " headers, but it can be safely cast to an `id`."] + #[doc = ""] + #[doc = " Note that as of SDL 2.0.18, this will return NULL if Metal refuses to give"] + #[doc = " SDL a drawable to render to, which might happen if the window is"] + #[doc = " hidden/minimized/offscreen. This doesn't apply to command encoders for"] + #[doc = " render targets, just the window's backbacker. Check your return values!"] #[doc = ""] - #[doc = " \\param renderer The renderer to query"] + #[doc = " \\param renderer The renderer to query"] + #[doc = " \\returns an `id` on success, or NULL if the"] + #[doc = " renderer isn't a Metal renderer or there was an error."] #[doc = ""] - #[doc = " \\return id on success, or NULL if the renderer isn't a Metal renderer"] + #[doc = " \\since This function is available since SDL 2.0.8."] #[doc = ""] - #[doc = " \\sa SDL_RenderGetMetalLayer()"] + #[doc = " \\sa SDL_RenderGetMetalLayer"] pub fn SDL_RenderGetMetalCommandEncoder(renderer: *mut SDL_Renderer) -> *mut libc::c_void; } extern "C" { - #[doc = " \\brief Create a window that can be shaped with the specified position, dimensions, and flags."] + #[doc = " Toggle VSync of the given renderer."] #[doc = ""] - #[doc = " \\param title The title of the window, in UTF-8 encoding."] - #[doc = " \\param x The x position of the window, ::SDL_WINDOWPOS_CENTERED, or"] - #[doc = " ::SDL_WINDOWPOS_UNDEFINED."] - #[doc = " \\param y The y position of the window, ::SDL_WINDOWPOS_CENTERED, or"] - #[doc = " ::SDL_WINDOWPOS_UNDEFINED."] - #[doc = " \\param w The width of the window."] - #[doc = " \\param h The height of the window."] - #[doc = " \\param flags The flags for the window, a mask of SDL_WINDOW_BORDERLESS with any of the following:"] - #[doc = " ::SDL_WINDOW_OPENGL, ::SDL_WINDOW_INPUT_GRABBED,"] - #[doc = " ::SDL_WINDOW_HIDDEN, ::SDL_WINDOW_RESIZABLE,"] - #[doc = " ::SDL_WINDOW_MAXIMIZED, ::SDL_WINDOW_MINIMIZED,"] - #[doc = " ::SDL_WINDOW_BORDERLESS is always set, and ::SDL_WINDOW_FULLSCREEN is always unset."] + #[doc = " \\param renderer The renderer to toggle"] + #[doc = " \\param vsync 1 for on, 0 for off. All other values are reserved"] + #[doc = " \\returns a 0 int on success, or non-zero on failure"] #[doc = ""] - #[doc = " \\return The window created, or NULL if window creation failed."] + #[doc = " \\since This function is available since SDL 2.0.18."] + pub fn SDL_RenderSetVSync(renderer: *mut SDL_Renderer, vsync: libc::c_int) -> libc::c_int; +} +extern "C" { + #[doc = " Create a window that can be shaped with the specified position, dimensions,"] + #[doc = " and flags."] + #[doc = ""] + #[doc = " \\param title The title of the window, in UTF-8 encoding."] + #[doc = " \\param x The x position of the window, ::SDL_WINDOWPOS_CENTERED, or"] + #[doc = " ::SDL_WINDOWPOS_UNDEFINED."] + #[doc = " \\param y The y position of the window, ::SDL_WINDOWPOS_CENTERED, or"] + #[doc = " ::SDL_WINDOWPOS_UNDEFINED."] + #[doc = " \\param w The width of the window."] + #[doc = " \\param h The height of the window."] + #[doc = " \\param flags The flags for the window, a mask of SDL_WINDOW_BORDERLESS with"] + #[doc = " any of the following: ::SDL_WINDOW_OPENGL,"] + #[doc = " ::SDL_WINDOW_INPUT_GRABBED, ::SDL_WINDOW_HIDDEN,"] + #[doc = " ::SDL_WINDOW_RESIZABLE, ::SDL_WINDOW_MAXIMIZED,"] + #[doc = " ::SDL_WINDOW_MINIMIZED, ::SDL_WINDOW_BORDERLESS is always set,"] + #[doc = " and ::SDL_WINDOW_FULLSCREEN is always unset."] + #[doc = " \\return the window created, or NULL if window creation failed."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_DestroyWindow()"] + #[doc = " \\sa SDL_DestroyWindow"] pub fn SDL_CreateShapedWindow( title: *const libc::c_char, x: libc::c_uint, @@ -18088,11 +24829,13 @@ extern "C" { ) -> *mut SDL_Window; } extern "C" { - #[doc = " \\brief Return whether the given window is a shaped window."] + #[doc = " Return whether the given window is a shaped window."] #[doc = ""] #[doc = " \\param window The window to query for being shaped."] + #[doc = " \\return SDL_TRUE if the window is a window that can be shaped, SDL_FALSE if"] + #[doc = " the window is unshaped or NULL."] #[doc = ""] - #[doc = " \\return SDL_TRUE if the window is a window that can be shaped, SDL_FALSE if the window is unshaped or NULL."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] #[doc = " \\sa SDL_CreateShapedWindow"] pub fn SDL_IsShapedWindow(window: *const SDL_Window) -> SDL_bool; @@ -18198,17 +24941,19 @@ fn bindgen_test_layout_SDL_WindowShapeMode() { ); } extern "C" { - #[doc = " \\brief Set the shape and parameters of a shaped window."] + #[doc = " Set the shape and parameters of a shaped window."] #[doc = ""] #[doc = " \\param window The shaped window whose parameters should be set."] #[doc = " \\param shape A surface encoding the desired shape for the window."] #[doc = " \\param shape_mode The parameters to set for the shaped window."] + #[doc = " \\return 0 on success, SDL_INVALID_SHAPE_ARGUMENT on an invalid shape"] + #[doc = " argument, or SDL_NONSHAPEABLE_WINDOW if the SDL_Window given does"] + #[doc = " not reference a valid shaped window."] #[doc = ""] - #[doc = " \\return 0 on success, SDL_INVALID_SHAPE_ARGUMENT on an invalid shape argument, or SDL_NONSHAPEABLE_WINDOW"] - #[doc = " if the SDL_Window given does not reference a valid shaped window."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] #[doc = " \\sa SDL_WindowShapeMode"] - #[doc = " \\sa SDL_GetShapedWindowMode."] + #[doc = " \\sa SDL_GetShapedWindowMode"] pub fn SDL_SetWindowShape( window: *mut SDL_Window, shape: *mut SDL_Surface, @@ -18216,14 +24961,18 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the shape parameters of a shaped window."] + #[doc = " Get the shape parameters of a shaped window."] #[doc = ""] #[doc = " \\param window The shaped window whose parameters should be retrieved."] - #[doc = " \\param shape_mode An empty shape-mode structure to fill, or NULL to check whether the window has a shape."] + #[doc = " \\param shape_mode An empty shape-mode structure to fill, or NULL to check"] + #[doc = " whether the window has a shape."] + #[doc = " \\return 0 if the window has a shape and, provided shape_mode was not NULL,"] + #[doc = " shape_mode has been filled with the mode data,"] + #[doc = " SDL_NONSHAPEABLE_WINDOW if the SDL_Window given is not a shaped"] + #[doc = " window, or SDL_WINDOW_LACKS_SHAPE if the SDL_Window given is a"] + #[doc = " shapeable window currently lacking a shape."] #[doc = ""] - #[doc = " \\return 0 if the window has a shape and, provided shape_mode was not NULL, shape_mode has been filled with the mode"] - #[doc = " data, SDL_NONSHAPEABLE_WINDOW if the SDL_Window given is not a shaped window, or SDL_WINDOW_LACKS_SHAPE if"] - #[doc = " the SDL_Window given is a shapeable window currently lacking a shape."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] #[doc = " \\sa SDL_WindowShapeMode"] #[doc = " \\sa SDL_SetWindowShape"] @@ -18233,13 +24982,43 @@ extern "C" { ) -> libc::c_int; } extern "C" { - #[doc = "\\brief Sets the UNIX nice value for a thread, using setpriority() if possible, and RealtimeKit if available."] + #[doc = " Sets the UNIX nice value for a thread."] #[doc = ""] - #[doc = "\\return 0 on success, or -1 on error."] + #[doc = " This uses setpriority() if possible, and RealtimeKit if available."] + #[doc = ""] + #[doc = " \\param threadID the Unix thread ID to change priority of."] + #[doc = " \\param priority The new, Unix-specific, priority value."] + #[doc = " \\returns 0 on success, or -1 on error."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.9."] pub fn SDL_LinuxSetThreadPriority(threadID: Sint64, priority: libc::c_int) -> libc::c_int; } extern "C" { - #[doc = "\\brief Return true if the current device is a tablet."] + #[doc = " Sets the priority (not nice level) and scheduling policy for a thread."] + #[doc = ""] + #[doc = " This uses setpriority() if possible, and RealtimeKit if available."] + #[doc = ""] + #[doc = " \\param threadID The Unix thread ID to change priority of."] + #[doc = " \\param sdlPriority The new SDL_ThreadPriority value."] + #[doc = " \\param schedPolicy The new scheduling policy (SCHED_FIFO, SCHED_RR,"] + #[doc = " SCHED_OTHER, etc...)"] + #[doc = " \\returns 0 on success, or -1 on error."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.18."] + pub fn SDL_LinuxSetThreadPriorityAndPolicy( + threadID: Sint64, + sdlPriority: libc::c_int, + schedPolicy: libc::c_int, + ) -> libc::c_int; +} +extern "C" { + #[doc = " Query if the current device is a tablet."] + #[doc = ""] + #[doc = " If SDL can't determine this, it will return SDL_FALSE."] + #[doc = ""] + #[doc = " \\returns SDL_TRUE if the device is a tablet, SDL_FALSE otherwise."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.9."] pub fn SDL_IsTablet() -> SDL_bool; } extern "C" { @@ -18261,38 +25040,127 @@ extern "C" { pub fn SDL_OnApplicationDidBecomeActive(); } extern "C" { - #[doc = " \\brief Get the number of milliseconds since the SDL library initialization."] + #[doc = " Get the number of milliseconds since SDL library initialization."] + #[doc = ""] + #[doc = " This value wraps if the program runs for more than ~49 days."] #[doc = ""] - #[doc = " \\note This value wraps if the program runs for more than ~49 days."] + #[doc = " This function is not recommended as of SDL 2.0.18; use SDL_GetTicks64()"] + #[doc = " instead, where the value doesn't wrap every ~49 days. There are places in"] + #[doc = " SDL where we provide a 32-bit timestamp that can not change without"] + #[doc = " breaking binary compatibility, though, so this function isn't officially"] + #[doc = " deprecated."] + #[doc = ""] + #[doc = " \\returns an unsigned 32-bit value representing the number of milliseconds"] + #[doc = " since the SDL library initialized."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_TICKS_PASSED"] pub fn SDL_GetTicks() -> Uint32; } extern "C" { - #[doc = " \\brief Get the current value of the high resolution counter"] + #[doc = " Get the number of milliseconds since SDL library initialization."] + #[doc = ""] + #[doc = " Note that you should not use the SDL_TICKS_PASSED macro with values"] + #[doc = " returned by this function, as that macro does clever math to compensate for"] + #[doc = " the 32-bit overflow every ~49 days that SDL_GetTicks() suffers from. 64-bit"] + #[doc = " values from this function can be safely compared directly."] + #[doc = ""] + #[doc = " For example, if you want to wait 100 ms, you could do this:"] + #[doc = ""] + #[doc = " ```c"] + #[doc = " const Uint64 timeout = SDL_GetTicks64() + 100;"] + #[doc = " while (SDL_GetTicks64() < timeout) {"] + #[doc = " // ... do work until timeout has elapsed"] + #[doc = " }"] + #[doc = " ```"] + #[doc = ""] + #[doc = " \\returns an unsigned 64-bit value representing the number of milliseconds"] + #[doc = " since the SDL library initialized."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.18."] + pub fn SDL_GetTicks64() -> Uint64; +} +extern "C" { + #[doc = " Get the current value of the high resolution counter."] + #[doc = ""] + #[doc = " This function is typically used for profiling."] + #[doc = ""] + #[doc = " The counter values are only meaningful relative to each other. Differences"] + #[doc = " between values can be converted to times by using"] + #[doc = " SDL_GetPerformanceFrequency()."] + #[doc = ""] + #[doc = " \\returns the current counter value."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetPerformanceFrequency"] pub fn SDL_GetPerformanceCounter() -> Uint64; } extern "C" { - #[doc = " \\brief Get the count per second of the high resolution counter"] + #[doc = " Get the count per second of the high resolution counter."] + #[doc = ""] + #[doc = " \\returns a platform-specific count per second."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetPerformanceCounter"] pub fn SDL_GetPerformanceFrequency() -> Uint64; } extern "C" { - #[doc = " \\brief Wait a specified number of milliseconds before returning."] + #[doc = " Wait a specified number of milliseconds before returning."] + #[doc = ""] + #[doc = " This function waits a specified number of milliseconds before returning. It"] + #[doc = " waits at least the specified time, but possibly longer due to OS"] + #[doc = " scheduling."] + #[doc = ""] + #[doc = " \\param ms the number of milliseconds to delay"] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_Delay(ms: Uint32); } -#[doc = " Function prototype for the timer callback function."] +#[doc = " Function prototype for the timer callback function."] #[doc = ""] -#[doc = " The callback function is passed the current timer interval and returns"] -#[doc = " the next timer interval. If the returned value is the same as the one"] -#[doc = " passed in, the periodic alarm continues, otherwise a new alarm is"] -#[doc = " scheduled. If the callback returns 0, the periodic alarm is cancelled."] +#[doc = " The callback function is passed the current timer interval and returns"] +#[doc = " the next timer interval. If the returned value is the same as the one"] +#[doc = " passed in, the periodic alarm continues, otherwise a new alarm is"] +#[doc = " scheduled. If the callback returns 0, the periodic alarm is cancelled."] pub type SDL_TimerCallback = ::core::option::Option< unsafe extern "C" fn(interval: Uint32, param: *mut libc::c_void) -> Uint32, >; #[doc = " Definition of the timer ID type."] pub type SDL_TimerID = libc::c_int; extern "C" { - #[doc = " \\brief Add a new timer to the pool of timers already running."] + #[doc = " Call a callback function at a future time."] + #[doc = ""] + #[doc = " If you use this function, you must pass `SDL_INIT_TIMER` to SDL_Init()."] + #[doc = ""] + #[doc = " The callback function is passed the current timer interval and the user"] + #[doc = " supplied parameter from the SDL_AddTimer() call and should return the next"] + #[doc = " timer interval. If the value returned from the callback is 0, the timer is"] + #[doc = " canceled."] + #[doc = ""] + #[doc = " The callback is run on a separate thread."] #[doc = ""] - #[doc = " \\return A timer ID, or 0 when an error occurs."] + #[doc = " Timers take into account the amount of time it took to execute the"] + #[doc = " callback. For example, if the callback took 250 ms to execute and returned"] + #[doc = " 1000 (ms), the timer would only wait another 750 ms before its next"] + #[doc = " iteration."] + #[doc = ""] + #[doc = " Timing may be inexact due to OS scheduling. Be sure to note the current"] + #[doc = " time with SDL_GetTicks() or SDL_GetPerformanceCounter() in case your"] + #[doc = " callback needs to adjust for variances."] + #[doc = ""] + #[doc = " \\param interval the timer delay, in milliseconds, passed to `callback`"] + #[doc = " \\param callback the SDL_TimerCallback function to call when the specified"] + #[doc = " `interval` elapses"] + #[doc = " \\param param a pointer that is passed to `callback`"] + #[doc = " \\returns a timer ID or 0 if an error occurs; call SDL_GetError() for more"] + #[doc = " information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_RemoveTimer"] pub fn SDL_AddTimer( interval: Uint32, callback: SDL_TimerCallback, @@ -18300,23 +25168,27 @@ extern "C" { ) -> SDL_TimerID; } extern "C" { - #[doc = " \\brief Remove a timer knowing its ID."] + #[doc = " Remove a timer created with SDL_AddTimer()."] #[doc = ""] - #[doc = " \\return A boolean value indicating success or failure."] + #[doc = " \\param id the ID of the timer to remove"] + #[doc = " \\returns SDL_TRUE if the timer is removed or SDL_FALSE if the timer wasn't"] + #[doc = " found."] #[doc = ""] - #[doc = " \\warning It is not safe to remove a timer multiple times."] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_AddTimer"] pub fn SDL_RemoveTimer(id: SDL_TimerID) -> SDL_bool; } -#[doc = " \\brief Information the version of SDL in use."] +#[doc = " Information about the version of SDL in use."] #[doc = ""] -#[doc = " Represents the library's version as three levels: major revision"] -#[doc = " (increments with massive changes, additions, and enhancements),"] -#[doc = " minor revision (increments with backwards-compatible changes to the"] -#[doc = " major revision), and patchlevel (increments with fixes to the minor"] -#[doc = " revision)."] +#[doc = " Represents the library's version as three levels: major revision"] +#[doc = " (increments with massive changes, additions, and enhancements),"] +#[doc = " minor revision (increments with backwards-compatible changes to the"] +#[doc = " major revision), and patchlevel (increments with fixes to the minor"] +#[doc = " revision)."] #[doc = ""] -#[doc = " \\sa SDL_VERSION"] -#[doc = " \\sa SDL_GetVersion"] +#[doc = " \\sa SDL_VERSION"] +#[doc = " \\sa SDL_GetVersion"] #[repr(C)] #[derive(Copy, Clone)] pub struct SDL_version { @@ -18371,44 +25243,70 @@ fn bindgen_test_layout_SDL_version() { ); } extern "C" { - #[doc = " \\brief Get the version of SDL that is linked against your program."] + #[doc = " Get the version of SDL that is linked against your program."] #[doc = ""] - #[doc = " If you are linking to SDL dynamically, then it is possible that the"] - #[doc = " current version will be different than the version you compiled against."] - #[doc = " This function returns the current version, while SDL_VERSION() is a"] - #[doc = " macro that tells you what version you compiled with."] + #[doc = " If you are linking to SDL dynamically, then it is possible that the current"] + #[doc = " version will be different than the version you compiled against. This"] + #[doc = " function returns the current version, while SDL_VERSION() is a macro that"] + #[doc = " tells you what version you compiled with."] #[doc = ""] - #[doc = " \\code"] - #[doc = " SDL_version compiled;"] - #[doc = " SDL_version linked;"] + #[doc = " This function may be called safely at any time, even before SDL_Init()."] #[doc = ""] - #[doc = " SDL_VERSION(&compiled);"] - #[doc = " SDL_GetVersion(&linked);"] - #[doc = " printf(\"We compiled against SDL version %d.%d.%d ...\\n\","] - #[doc = " compiled.major, compiled.minor, compiled.patch);"] - #[doc = " printf(\"But we linked against SDL version %d.%d.%d.\\n\","] - #[doc = " linked.major, linked.minor, linked.patch);"] - #[doc = " \\endcode"] + #[doc = " \\param ver the SDL_version structure that contains the version information"] #[doc = ""] - #[doc = " This function may be called safely at any time, even before SDL_Init()."] + #[doc = " \\since This function is available since SDL 2.0.0."] #[doc = ""] - #[doc = " \\sa SDL_VERSION"] + #[doc = " \\sa SDL_GetRevision"] pub fn SDL_GetVersion(ver: *mut SDL_version); } extern "C" { - #[doc = " \\brief Get the code revision of SDL that is linked against your program."] + #[doc = " Get the code revision of SDL that is linked against your program."] + #[doc = ""] + #[doc = " This value is the revision of the code you are linked with and may be"] + #[doc = " different from the code you are compiling with, which is found in the"] + #[doc = " constant SDL_REVISION."] + #[doc = ""] + #[doc = " The revision is arbitrary string (a hash value) uniquely identifying the"] + #[doc = " exact revision of the SDL library in use, and is only useful in comparing"] + #[doc = " against other revisions. It is NOT an incrementing number."] + #[doc = ""] + #[doc = " If SDL wasn't built from a git repository with the appropriate tools, this"] + #[doc = " will return an empty string."] #[doc = ""] - #[doc = " Returns an arbitrary string (a hash value) uniquely identifying the"] - #[doc = " exact revision of the SDL library in use, and is only useful in comparing"] - #[doc = " against other revisions. It is NOT an incrementing number."] + #[doc = " Prior to SDL 2.0.16, before development moved to GitHub, this returned a"] + #[doc = " hash for a Mercurial repository."] + #[doc = ""] + #[doc = " You shouldn't use this function for anything but logging it for debugging"] + #[doc = " purposes. The string is not intended to be reliable in any way."] + #[doc = ""] + #[doc = " \\returns an arbitrary string, uniquely identifying the exact revision of"] + #[doc = " the SDL library in use."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetVersion"] pub fn SDL_GetRevision() -> *const libc::c_char; } extern "C" { - #[doc = " \\brief Get the revision number of SDL that is linked against your program."] + #[doc = " Obsolete function, do not use."] + #[doc = ""] + #[doc = " When SDL was hosted in a Mercurial repository, and was built carefully,"] + #[doc = " this would return the revision number that the build was created from. This"] + #[doc = " number was not reliable for several reasons, but more importantly, SDL is"] + #[doc = " now hosted in a git repository, which does not offer numbers at all, only"] + #[doc = " hashes. This function only ever returns zero now. Don't use it."] + #[doc = ""] + #[doc = " Before SDL 2.0.16, this might have returned an unreliable, but non-zero"] + #[doc = " number."] + #[doc = ""] + #[doc = " \\deprecated Use SDL_GetRevision() instead; if SDL was carefully built, it"] + #[doc = " will return a git hash."] + #[doc = ""] + #[doc = " \\returns zero, always, in modern SDL releases."] #[doc = ""] - #[doc = " Returns a number uniquely identifying the exact revision of the SDL"] - #[doc = " library in use. It is an incrementing number based on commits to"] - #[doc = " hg.libsdl.org."] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_GetRevision"] pub fn SDL_GetRevisionNumber() -> libc::c_int; } #[repr(C)] @@ -18453,100 +25351,199 @@ fn bindgen_test_layout_SDL_Locale() { ); } extern "C" { - #[doc = " \\brief Report the user's preferred locale."] + #[doc = " Report the user's preferred locale."] + #[doc = ""] + #[doc = " This returns an array of SDL_Locale structs, the final item zeroed out."] + #[doc = " When the caller is done with this array, it should call SDL_free() on the"] + #[doc = " returned value; all the memory involved is allocated in a single block, so"] + #[doc = " a single SDL_free() will suffice."] #[doc = ""] - #[doc = " This returns an array of SDL_Locale structs, the final item zeroed out."] - #[doc = " When the caller is done with this array, it should call SDL_free() on"] - #[doc = " the returned value; all the memory involved is allocated in a single"] - #[doc = " block, so a single SDL_free() will suffice."] + #[doc = " Returned language strings are in the format xx, where 'xx' is an ISO-639"] + #[doc = " language specifier (such as \"en\" for English, \"de\" for German, etc)."] + #[doc = " Country strings are in the format YY, where \"YY\" is an ISO-3166 country"] + #[doc = " code (such as \"US\" for the United States, \"CA\" for Canada, etc). Country"] + #[doc = " might be NULL if there's no specific guidance on them (so you might get {"] + #[doc = " \"en\", \"US\" } for American English, but { \"en\", NULL } means \"English"] + #[doc = " language, generically\"). Language strings are never NULL, except to"] + #[doc = " terminate the array."] #[doc = ""] - #[doc = " Returned language strings are in the format xx, where 'xx' is an ISO-639"] - #[doc = " language specifier (such as \"en\" for English, \"de\" for German, etc)."] - #[doc = " Country strings are in the format YY, where \"YY\" is an ISO-3166 country"] - #[doc = " code (such as \"US\" for the United States, \"CA\" for Canada, etc). Country"] - #[doc = " might be NULL if there's no specific guidance on them (so you might get"] - #[doc = " { \"en\", \"US\" } for American English, but { \"en\", NULL } means \"English"] - #[doc = " language, generically\"). Language strings are never NULL, except to"] - #[doc = " terminate the array."] + #[doc = " Please note that not all of these strings are 2 characters; some are three"] + #[doc = " or more."] #[doc = ""] - #[doc = " Please note that not all of these strings are 2 characters; some are"] - #[doc = " three or more."] + #[doc = " The returned list of locales are in the order of the user's preference. For"] + #[doc = " example, a German citizen that is fluent in US English and knows enough"] + #[doc = " Japanese to navigate around Tokyo might have a list like: { \"de\", \"en_US\","] + #[doc = " \"jp\", NULL }. Someone from England might prefer British English (where"] + #[doc = " \"color\" is spelled \"colour\", etc), but will settle for anything like it: {"] + #[doc = " \"en_GB\", \"en\", NULL }."] #[doc = ""] - #[doc = " The returned list of locales are in the order of the user's preference."] - #[doc = " For example, a German citizen that is fluent in US English and knows"] - #[doc = " enough Japanese to navigate around Tokyo might have a list like:"] - #[doc = " { \"de\", \"en_US\", \"jp\", NULL }. Someone from England might prefer British"] - #[doc = " English (where \"color\" is spelled \"colour\", etc), but will settle for"] - #[doc = " anything like it: { \"en_GB\", \"en\", NULL }."] + #[doc = " This function returns NULL on error, including when the platform does not"] + #[doc = " supply this information at all."] #[doc = ""] - #[doc = " This function returns NULL on error, including when the platform does not"] - #[doc = " supply this information at all."] + #[doc = " This might be a \"slow\" call that has to query the operating system. It's"] + #[doc = " best to ask for this once and save the results. However, this list can"] + #[doc = " change, usually because the user has changed a system preference outside of"] + #[doc = " your program; SDL will send an SDL_LOCALECHANGED event in this case, if"] + #[doc = " possible, and you can call this function again to get an updated copy of"] + #[doc = " preferred locales."] #[doc = ""] - #[doc = " This might be a \"slow\" call that has to query the operating system. It's"] - #[doc = " best to ask for this once and save the results. However, this list can"] - #[doc = " change, usually because the user has changed a system preference outside"] - #[doc = " of your program; SDL will send an SDL_LOCALECHANGED event in this case,"] - #[doc = " if possible, and you can call this function again to get an updated copy"] - #[doc = " of preferred locales."] + #[doc = " \\return array of locales, terminated with a locale with a NULL language"] + #[doc = " field. Will return NULL on error."] #[doc = ""] - #[doc = " \\return array of locales, terminated with a locale with a NULL language"] - #[doc = " field. Will return NULL on error."] + #[doc = " \\since This function is available since SDL 2.0.14."] pub fn SDL_GetPreferredLocales() -> *mut SDL_Locale; } extern "C" { - #[doc = " \\brief Open an URL / URI in the browser or other"] + #[doc = " Open a URL/URI in the browser or other appropriate external application."] #[doc = ""] #[doc = " Open a URL in a separate, system-provided application. How this works will"] - #[doc = " vary wildly depending on the platform. This will likely launch what"] - #[doc = " makes sense to handle a specific URL's protocol (a web browser for http://,"] - #[doc = " etc), but it might also be able to launch file managers for directories"] - #[doc = " and other things."] + #[doc = " vary wildly depending on the platform. This will likely launch what makes"] + #[doc = " sense to handle a specific URL's protocol (a web browser for `http://`,"] + #[doc = " etc), but it might also be able to launch file managers for directories and"] + #[doc = " other things."] #[doc = ""] #[doc = " What happens when you open a URL varies wildly as well: your game window"] - #[doc = " may lose focus (and may or may not lose focus if your game was fullscreen"] - #[doc = " or grabbing input at the time). On mobile devices, your app will likely"] - #[doc = " move to the background or your process might be paused. Any given platform"] - #[doc = " may or may not handle a given URL."] + #[doc = " may lose focus (and may or may not lose focus if your game was fullscreen"] + #[doc = " or grabbing input at the time). On mobile devices, your app will likely"] + #[doc = " move to the background or your process might be paused. Any given platform"] + #[doc = " may or may not handle a given URL."] #[doc = ""] #[doc = " If this is unimplemented (or simply unavailable) for a platform, this will"] - #[doc = " fail with an error. A successful result does not mean the URL loaded, just"] - #[doc = " that we launched something to handle it (or at least believe we did)."] + #[doc = " fail with an error. A successful result does not mean the URL loaded, just"] + #[doc = " that we launched _something_ to handle it (or at least believe we did)."] #[doc = ""] #[doc = " All this to say: this function can be useful, but you should definitely"] - #[doc = " test it on every platform you target."] + #[doc = " test it on every platform you target."] #[doc = ""] - #[doc = " \\param url A valid URL to open."] - #[doc = " \\return 0 on success, or -1 on error."] + #[doc = " \\param url A valid URL/URI to open. Use `file:///full/path/to/file` for"] + #[doc = " local files, if supported."] + #[doc = " \\returns 0 on success, or -1 on error; call SDL_GetError() for more"] + #[doc = " information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.14."] pub fn SDL_OpenURL(url: *const libc::c_char) -> libc::c_int; } extern "C" { - #[doc = " This function initializes the subsystems specified by \\c flags"] + #[doc = " Initialize the SDL library."] + #[doc = ""] + #[doc = " SDL_Init() simply forwards to calling SDL_InitSubSystem(). Therefore, the"] + #[doc = " two may be used interchangeably. Though for readability of your code"] + #[doc = " SDL_InitSubSystem() might be preferred."] + #[doc = ""] + #[doc = " The file I/O (for example: SDL_RWFromFile) and threading (SDL_CreateThread)"] + #[doc = " subsystems are initialized by default. Message boxes"] + #[doc = " (SDL_ShowSimpleMessageBox) also attempt to work without initializing the"] + #[doc = " video subsystem, in hopes of being useful in showing an error dialog when"] + #[doc = " SDL_Init fails. You must specifically initialize other subsystems if you"] + #[doc = " use them in your application."] + #[doc = ""] + #[doc = " Logging (such as SDL_Log) works without initialization, too."] + #[doc = ""] + #[doc = " `flags` may be any of the following OR'd together:"] + #[doc = ""] + #[doc = " - `SDL_INIT_TIMER`: timer subsystem"] + #[doc = " - `SDL_INIT_AUDIO`: audio subsystem"] + #[doc = " - `SDL_INIT_VIDEO`: video subsystem; automatically initializes the events"] + #[doc = " subsystem"] + #[doc = " - `SDL_INIT_JOYSTICK`: joystick subsystem; automatically initializes the"] + #[doc = " events subsystem"] + #[doc = " - `SDL_INIT_HAPTIC`: haptic (force feedback) subsystem"] + #[doc = " - `SDL_INIT_GAMECONTROLLER`: controller subsystem; automatically"] + #[doc = " initializes the joystick subsystem"] + #[doc = " - `SDL_INIT_EVENTS`: events subsystem"] + #[doc = " - `SDL_INIT_EVERYTHING`: all of the above subsystems"] + #[doc = " - `SDL_INIT_NOPARACHUTE`: compatibility; this flag is ignored"] + #[doc = ""] + #[doc = " Subsystem initialization is ref-counted, you must call SDL_QuitSubSystem()"] + #[doc = " for each SDL_InitSubSystem() to correctly shutdown a subsystem manually (or"] + #[doc = " call SDL_Quit() to force shutdown). If a subsystem is already loaded then"] + #[doc = " this call will increase the ref-count and return."] + #[doc = ""] + #[doc = " \\param flags subsystem initialization flags"] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_InitSubSystem"] + #[doc = " \\sa SDL_Quit"] + #[doc = " \\sa SDL_SetMainReady"] + #[doc = " \\sa SDL_WasInit"] pub fn SDL_Init(flags: Uint32) -> libc::c_int; } extern "C" { - #[doc = " This function initializes specific SDL subsystems"] + #[doc = " Compatibility function to initialize the SDL library."] #[doc = ""] - #[doc = " Subsystem initialization is ref-counted, you must call"] - #[doc = " SDL_QuitSubSystem() for each SDL_InitSubSystem() to correctly"] - #[doc = " shutdown a subsystem manually (or call SDL_Quit() to force shutdown)."] - #[doc = " If a subsystem is already loaded then this call will"] - #[doc = " increase the ref-count and return."] + #[doc = " In SDL2, this function and SDL_Init() are interchangeable."] + #[doc = ""] + #[doc = " \\param flags any of the flags used by SDL_Init(); see SDL_Init for details."] + #[doc = " \\returns 0 on success or a negative error code on failure; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_Init"] + #[doc = " \\sa SDL_Quit"] + #[doc = " \\sa SDL_QuitSubSystem"] pub fn SDL_InitSubSystem(flags: Uint32) -> libc::c_int; } extern "C" { - #[doc = " This function cleans up specific SDL subsystems"] + #[doc = " Shut down specific SDL subsystems."] + #[doc = ""] + #[doc = " If you start a subsystem using a call to that subsystem's init function"] + #[doc = " (for example SDL_VideoInit()) instead of SDL_Init() or SDL_InitSubSystem(),"] + #[doc = " SDL_QuitSubSystem() and SDL_WasInit() will not work. You will need to use"] + #[doc = " that subsystem's quit function (SDL_VideoQuit()) directly instead. But"] + #[doc = " generally, you should not be using those functions directly anyhow; use"] + #[doc = " SDL_Init() instead."] + #[doc = ""] + #[doc = " You still need to call SDL_Quit() even if you close all open subsystems"] + #[doc = " with SDL_QuitSubSystem()."] + #[doc = ""] + #[doc = " \\param flags any of the flags used by SDL_Init(); see SDL_Init for details."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_InitSubSystem"] + #[doc = " \\sa SDL_Quit"] pub fn SDL_QuitSubSystem(flags: Uint32); } extern "C" { - #[doc = " This function returns a mask of the specified subsystems which have"] - #[doc = " previously been initialized."] + #[doc = " Get a mask of the specified subsystems which are currently initialized."] #[doc = ""] - #[doc = " If \\c flags is 0, it returns a mask of all initialized subsystems."] + #[doc = " \\param flags any of the flags used by SDL_Init(); see SDL_Init for details."] + #[doc = " \\returns a mask of all initialized subsystems if `flags` is 0, otherwise it"] + #[doc = " returns the initialization status of the specified subsystems."] + #[doc = ""] + #[doc = " The return value does not include SDL_INIT_NOPARACHUTE."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_Init"] + #[doc = " \\sa SDL_InitSubSystem"] pub fn SDL_WasInit(flags: Uint32) -> Uint32; } extern "C" { - #[doc = " This function cleans up all initialized subsystems. You should"] - #[doc = " call it upon all exit conditions."] + #[doc = " Clean up all initialized subsystems."] + #[doc = ""] + #[doc = " You should call this function even if you have already shutdown each"] + #[doc = " initialized subsystem with SDL_QuitSubSystem(). It is safe to call this"] + #[doc = " function even in the case of errors in initialization."] + #[doc = ""] + #[doc = " If you start a subsystem using a call to that subsystem's init function"] + #[doc = " (for example SDL_VideoInit()) instead of SDL_Init() or SDL_InitSubSystem(),"] + #[doc = " then you must use that subsystem's quit function (SDL_VideoQuit()) to shut"] + #[doc = " it down before calling SDL_Quit(). But generally, you should not be using"] + #[doc = " those functions directly anyhow; use SDL_Init() instead."] + #[doc = ""] + #[doc = " You can use this function with atexit() to ensure that it is run when your"] + #[doc = " application is shutdown, but it is not wise to do this from a library or"] + #[doc = " other dynamically loaded code."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.0."] + #[doc = ""] + #[doc = " \\sa SDL_Init"] + #[doc = " \\sa SDL_QuitSubSystem"] pub fn SDL_Quit(); } pub type XID = libc::c_ulong; @@ -30230,6 +37227,8 @@ pub enum SDL_SYSWM_TYPE { SDL_SYSWM_VIVANTE = 10, SDL_SYSWM_OS2 = 11, SDL_SYSWM_HAIKU = 12, + SDL_SYSWM_KMSDRM = 13, + SDL_SYSWM_RISCOS = 14, } #[doc = " The custom event structure."] #[repr(C)] @@ -30442,14 +37441,20 @@ pub struct SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2 { pub display: *mut wl_display, #[doc = "< Wayland surface"] pub surface: *mut wl_surface, - #[doc = "< Wayland shell_surface (window manager handle)"] - pub shell_surface: *mut wl_shell_surface, + #[doc = "< DEPRECATED Wayland shell_surface (window manager handle)"] + pub shell_surface: *mut libc::c_void, + #[doc = "< Wayland EGL window (native window)"] + pub egl_window: *mut wl_egl_window, + #[doc = "< Wayland xdg surface (window manager handle)"] + pub xdg_surface: *mut xdg_surface, + #[doc = "< Wayland xdg toplevel role"] + pub xdg_toplevel: *mut xdg_toplevel, } #[test] fn bindgen_test_layout_SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2() { assert_eq!( ::core::mem::size_of::(), - 24usize, + 48usize, concat!( "Size of: ", stringify!(SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2) @@ -30502,6 +37507,45 @@ fn bindgen_test_layout_SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2() { stringify!(shell_surface) ) ); + assert_eq!( + unsafe { + &(*(::core::ptr::null::())).egl_window + as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2), + "::", + stringify!(egl_window) + ) + ); + assert_eq!( + unsafe { + &(*(::core::ptr::null::())).xdg_surface + as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2), + "::", + stringify!(xdg_surface) + ) + ); + assert_eq!( + unsafe { + &(*(::core::ptr::null::())).xdg_toplevel + as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2), + "::", + stringify!(xdg_toplevel) + ) + ); } #[test] fn bindgen_test_layout_SDL_SysWMinfo__bindgen_ty_1() { @@ -30594,21 +37638,21 @@ fn bindgen_test_layout_SDL_SysWMinfo() { ); } extern "C" { - #[doc = " \\brief This function allows access to driver-dependent window information."] + #[doc = " Get driver-specific information about a window."] + #[doc = ""] + #[doc = " You must include SDL_syswm.h for the declaration of SDL_SysWMinfo."] #[doc = ""] - #[doc = " \\param window The window about which information is being requested"] - #[doc = " \\param info This structure must be initialized with the SDL version, and is"] - #[doc = " then filled in with information about the given window."] + #[doc = " The caller must initialize the `info` structure's version by using"] + #[doc = " `SDL_VERSION(&info.version)`, and then this function will fill in the rest"] + #[doc = " of the structure with information about the given window."] #[doc = ""] - #[doc = " \\return SDL_TRUE if the function is implemented and the version member of"] - #[doc = " the \\c info struct is valid, SDL_FALSE otherwise."] + #[doc = " \\param window the window about which information is being requested"] + #[doc = " \\param info an SDL_SysWMinfo structure filled in with window information"] + #[doc = " \\returns SDL_TRUE if the function is implemented and the `version` member"] + #[doc = " of the `info` struct is valid, or SDL_FALSE if the information"] + #[doc = " could not be retrieved; call SDL_GetError() for more information."] #[doc = ""] - #[doc = " You typically use this function like this:"] - #[doc = " \\code"] - #[doc = " SDL_SysWMinfo info;"] - #[doc = " SDL_VERSION(&info.version);"] - #[doc = " if ( SDL_GetWindowWMInfo(window, &info) ) { ... }"] - #[doc = " \\endcode"] + #[doc = " \\since This function is available since SDL 2.0.0."] pub fn SDL_GetWindowWMInfo(window: *mut SDL_Window, info: *mut SDL_SysWMinfo) -> SDL_bool; } #[repr(C)] @@ -30624,140 +37668,93 @@ pub struct VkSurfaceKHR_T { pub type SDL_vulkanInstance = VkInstance; pub type SDL_vulkanSurface = VkSurfaceKHR; extern "C" { - #[doc = " \\brief Dynamically load a Vulkan loader library."] - #[doc = ""] - #[doc = " \\param [in] path The platform dependent Vulkan loader library name, or"] - #[doc = " \\c NULL."] - #[doc = ""] - #[doc = " \\return \\c 0 on success, or \\c -1 if the library couldn't be loaded."] - #[doc = ""] - #[doc = " If \\a path is NULL SDL will use the value of the environment variable"] - #[doc = " \\c SDL_VULKAN_LIBRARY, if set, otherwise it loads the default Vulkan"] - #[doc = " loader library."] - #[doc = ""] - #[doc = " This should be called after initializing the video driver, but before"] - #[doc = " creating any Vulkan windows. If no Vulkan loader library is loaded, the"] - #[doc = " default library will be loaded upon creation of the first Vulkan window."] - #[doc = ""] - #[doc = " \\note It is fairly common for Vulkan applications to link with \\a libvulkan"] - #[doc = " instead of explicitly loading it at run time. This will work with"] - #[doc = " SDL provided the application links to a dynamic library and both it"] - #[doc = " and SDL use the same search path."] - #[doc = ""] - #[doc = " \\note If you specify a non-NULL \\c path, an application should retrieve all"] - #[doc = " of the Vulkan functions it uses from the dynamic library using"] - #[doc = " \\c SDL_Vulkan_GetVkGetInstanceProcAddr() unless you can guarantee"] - #[doc = " \\c path points to the same vulkan loader library the application"] - #[doc = " linked to."] - #[doc = ""] - #[doc = " \\note On Apple devices, if \\a path is NULL, SDL will attempt to find"] - #[doc = " the vkGetInstanceProcAddr address within all the mach-o images of"] - #[doc = " the current process. This is because it is fairly common for Vulkan"] - #[doc = " applications to link with libvulkan (and historically MoltenVK was"] - #[doc = " provided as a static library). If it is not found then, on macOS, SDL"] - #[doc = " will attempt to load \\c vulkan.framework/vulkan, \\c libvulkan.1.dylib,"] - #[doc = " followed by \\c libvulkan.dylib, in that order."] - #[doc = " On iOS SDL will attempt to load \\c libvulkan.dylib only. Applications"] - #[doc = " using a dynamic framework or .dylib must ensure it is included in its"] - #[doc = " application bundle."] - #[doc = ""] - #[doc = " \\note On non-Apple devices, application linking with a static libvulkan is"] - #[doc = " not supported. Either do not link to the Vulkan loader or link to a"] - #[doc = " dynamic library version."] - #[doc = ""] - #[doc = " \\note This function will fail if there are no working Vulkan drivers"] - #[doc = " installed."] - #[doc = ""] - #[doc = " \\sa SDL_Vulkan_GetVkGetInstanceProcAddr()"] - #[doc = " \\sa SDL_Vulkan_UnloadLibrary()"] + #[doc = " Dynamically load the Vulkan loader library."] + #[doc = ""] + #[doc = " This should be called after initializing the video driver, but before"] + #[doc = " creating any Vulkan windows. If no Vulkan loader library is loaded, the"] + #[doc = " default library will be loaded upon creation of the first Vulkan window."] + #[doc = ""] + #[doc = " It is fairly common for Vulkan applications to link with libvulkan instead"] + #[doc = " of explicitly loading it at run time. This will work with SDL provided the"] + #[doc = " application links to a dynamic library and both it and SDL use the same"] + #[doc = " search path."] + #[doc = ""] + #[doc = " If you specify a non-NULL `path`, an application should retrieve all of the"] + #[doc = " Vulkan functions it uses from the dynamic library using"] + #[doc = " SDL_Vulkan_GetVkGetInstanceProcAddr unless you can guarantee `path` points"] + #[doc = " to the same vulkan loader library the application linked to."] + #[doc = ""] + #[doc = " On Apple devices, if `path` is NULL, SDL will attempt to find the"] + #[doc = " `vkGetInstanceProcAddr` address within all the Mach-O images of the current"] + #[doc = " process. This is because it is fairly common for Vulkan applications to"] + #[doc = " link with libvulkan (and historically MoltenVK was provided as a static"] + #[doc = " library). If it is not found, on macOS, SDL will attempt to load"] + #[doc = " `vulkan.framework/vulkan`, `libvulkan.1.dylib`,"] + #[doc = " `MoltenVK.framework/MoltenVK`, and `libMoltenVK.dylib`, in that order. On"] + #[doc = " iOS, SDL will attempt to load `libMoltenVK.dylib`. Applications using a"] + #[doc = " dynamic framework or .dylib must ensure it is included in its application"] + #[doc = " bundle."] + #[doc = ""] + #[doc = " On non-Apple devices, application linking with a static libvulkan is not"] + #[doc = " supported. Either do not link to the Vulkan loader or link to a dynamic"] + #[doc = " library version."] + #[doc = ""] + #[doc = " \\param path The platform dependent Vulkan loader library name or NULL"] + #[doc = " \\returns 0 on success or -1 if the library couldn't be loaded; call"] + #[doc = " SDL_GetError() for more information."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.6."] + #[doc = ""] + #[doc = " \\sa SDL_Vulkan_GetVkInstanceProcAddr"] + #[doc = " \\sa SDL_Vulkan_UnloadLibrary"] pub fn SDL_Vulkan_LoadLibrary(path: *const libc::c_char) -> libc::c_int; } extern "C" { - #[doc = " \\brief Get the address of the \\c vkGetInstanceProcAddr function."] + #[doc = " Get the address of the `vkGetInstanceProcAddr` function."] + #[doc = ""] + #[doc = " This should be called after either calling SDL_Vulkan_LoadLibrary() or"] + #[doc = " creating an SDL_Window with the `SDL_WINDOW_VULKAN` flag."] + #[doc = ""] + #[doc = " \\returns the function pointer for `vkGetInstanceProcAddr` or NULL on error."] #[doc = ""] - #[doc = " \\note This should be called after either calling SDL_Vulkan_LoadLibrary"] - #[doc = " or creating an SDL_Window with the SDL_WINDOW_VULKAN flag."] + #[doc = " \\since This function is available since SDL 2.0.6."] pub fn SDL_Vulkan_GetVkGetInstanceProcAddr() -> *mut libc::c_void; } extern "C" { - #[doc = " \\brief Unload the Vulkan loader library previously loaded by"] - #[doc = " \\c SDL_Vulkan_LoadLibrary()."] + #[doc = " Unload the Vulkan library previously loaded by SDL_Vulkan_LoadLibrary()"] #[doc = ""] - #[doc = " \\sa SDL_Vulkan_LoadLibrary()"] + #[doc = " \\since This function is available since SDL 2.0.6."] + #[doc = ""] + #[doc = " \\sa SDL_Vulkan_LoadLibrary"] pub fn SDL_Vulkan_UnloadLibrary(); } extern "C" { - #[doc = " \\brief Get the names of the Vulkan instance extensions needed to create"] - #[doc = " a surface with \\c SDL_Vulkan_CreateSurface()."] - #[doc = ""] - #[doc = " \\param [in] \\c NULL or window Window for which the required Vulkan instance"] - #[doc = " extensions should be retrieved"] - #[doc = " \\param [in,out] pCount pointer to an \\c unsigned related to the number of"] - #[doc = " required Vulkan instance extensions"] - #[doc = " \\param [out] pNames \\c NULL or a pointer to an array to be filled with the"] - #[doc = " required Vulkan instance extensions"] - #[doc = ""] - #[doc = " \\return \\c SDL_TRUE on success, \\c SDL_FALSE on error."] - #[doc = ""] - #[doc = " If \\a pNames is \\c NULL, then the number of required Vulkan instance"] - #[doc = " extensions is returned in pCount. Otherwise, \\a pCount must point to a"] - #[doc = " variable set to the number of elements in the \\a pNames array, and on"] - #[doc = " return the variable is overwritten with the number of names actually"] - #[doc = " written to \\a pNames. If \\a pCount is less than the number of required"] - #[doc = " extensions, at most \\a pCount structures will be written. If \\a pCount"] - #[doc = " is smaller than the number of required extensions, \\c SDL_FALSE will be"] - #[doc = " returned instead of \\c SDL_TRUE, to indicate that not all the required"] - #[doc = " extensions were returned."] - #[doc = ""] - #[doc = " \\note If \\c window is not NULL, it will be checked against its creation"] - #[doc = " flags to ensure that the Vulkan flag is present. This parameter"] - #[doc = " will be removed in a future major release."] - #[doc = ""] - #[doc = " \\note The returned list of extensions will contain \\c VK_KHR_surface"] - #[doc = " and zero or more platform specific extensions"] - #[doc = ""] - #[doc = " \\note The extension names queried here must be enabled when calling"] - #[doc = " VkCreateInstance, otherwise surface creation will fail."] - #[doc = ""] - #[doc = " \\note \\c window should have been created with the \\c SDL_WINDOW_VULKAN flag"] - #[doc = " or be \\c NULL"] - #[doc = ""] - #[doc = " \\code"] - #[doc = " unsigned int count;"] - #[doc = " // get count of required extensions"] - #[doc = " if(!SDL_Vulkan_GetInstanceExtensions(NULL, &count, NULL))"] - #[doc = " handle_error();"] - #[doc = ""] - #[doc = " static const char *const additionalExtensions[] ="] - #[doc = " {"] - #[doc = " VK_EXT_DEBUG_REPORT_EXTENSION_NAME, // example additional extension"] - #[doc = " };"] - #[doc = " size_t additionalExtensionsCount = sizeof(additionalExtensions) / sizeof(additionalExtensions[0]);"] - #[doc = " size_t extensionCount = count + additionalExtensionsCount;"] - #[doc = " const char **names = malloc(sizeof(const char *) * extensionCount);"] - #[doc = " if(!names)"] - #[doc = " handle_error();"] - #[doc = ""] - #[doc = " // get names of required extensions"] - #[doc = " if(!SDL_Vulkan_GetInstanceExtensions(NULL, &count, names))"] - #[doc = " handle_error();"] - #[doc = ""] - #[doc = " // copy additional extensions after required extensions"] - #[doc = " for(size_t i = 0; i < additionalExtensionsCount; i++)"] - #[doc = " names[i + count] = additionalExtensions[i];"] - #[doc = ""] - #[doc = " VkInstanceCreateInfo instanceCreateInfo = {};"] - #[doc = " instanceCreateInfo.enabledExtensionCount = extensionCount;"] - #[doc = " instanceCreateInfo.ppEnabledExtensionNames = names;"] - #[doc = " // fill in rest of instanceCreateInfo"] - #[doc = ""] - #[doc = " VkInstance instance;"] - #[doc = " // create the Vulkan instance"] - #[doc = " VkResult result = vkCreateInstance(&instanceCreateInfo, NULL, &instance);"] - #[doc = " free(names);"] - #[doc = " \\endcode"] - #[doc = ""] - #[doc = " \\sa SDL_Vulkan_CreateSurface()"] + #[doc = " Get the names of the Vulkan instance extensions needed to create a surface"] + #[doc = " with SDL_Vulkan_CreateSurface."] + #[doc = ""] + #[doc = " If `pNames` is NULL, then the number of required Vulkan instance extensions"] + #[doc = " is returned in `pCount`. Otherwise, `pCount` must point to a variable set"] + #[doc = " to the number of elements in the `pNames` array, and on return the variable"] + #[doc = " is overwritten with the number of names actually written to `pNames`. If"] + #[doc = " `pCount` is less than the number of required extensions, at most `pCount`"] + #[doc = " structures will be written. If `pCount` is smaller than the number of"] + #[doc = " required extensions, SDL_FALSE will be returned instead of SDL_TRUE, to"] + #[doc = " indicate that not all the required extensions were returned."] + #[doc = ""] + #[doc = " The `window` parameter is currently needed to be valid as of SDL 2.0.8,"] + #[doc = " however, this parameter will likely be removed in future releases"] + #[doc = ""] + #[doc = " \\param window A window for which the required Vulkan instance extensions"] + #[doc = " should be retrieved (will be deprecated in a future release)"] + #[doc = " \\param pCount A pointer to an unsigned int corresponding to the number of"] + #[doc = " extensions to be returned"] + #[doc = " \\param pNames NULL or a pointer to an array to be filled with required"] + #[doc = " Vulkan instance extensions"] + #[doc = " \\returns SDL_TRUE on success, SDL_FALSE on error."] + #[doc = ""] + #[doc = " \\since This function is available since SDL 2.0.6."] + #[doc = ""] + #[doc = " \\sa SDL_Vulkan_CreateSurface"] pub fn SDL_Vulkan_GetInstanceExtensions( window: *mut SDL_Window, pCount: *mut libc::c_uint, @@ -30765,33 +37762,22 @@ extern "C" { ) -> SDL_bool; } extern "C" { - #[doc = " \\brief Create a Vulkan rendering surface for a window."] - #[doc = ""] - #[doc = " \\param [in] window SDL_Window to which to attach the rendering surface."] - #[doc = " \\param [in] instance handle to the Vulkan instance to use."] - #[doc = " \\param [out] surface pointer to a VkSurfaceKHR handle to receive the"] - #[doc = " handle of the newly created surface."] - #[doc = ""] - #[doc = " \\return \\c SDL_TRUE on success, \\c SDL_FALSE on error."] + #[doc = " Create a Vulkan rendering surface for a window."] #[doc = ""] - #[doc = " \\code"] - #[doc = " VkInstance instance;"] - #[doc = " SDL_Window *window;"] + #[doc = " The `window` must have been created with the `SDL_WINDOW_VULKAN` flag and"] + #[doc = " `instance` must have been created with extensions returned by"] + #[doc = " SDL_Vulkan_GetInstanceExtensions() enabled."] #[doc = ""] - #[doc = " // create instance and window"] + #[doc = " \\param window The window to which to attach the Vulkan surface"] + #[doc = " \\param instance The Vulkan instance handle"] + #[doc = " \\param surface A pointer to a VkSurfaceKHR handle to output the newly"] + #[doc = " created surface"] + #[doc = " \\returns SDL_TRUE on success, SDL_FALSE on error."] #[doc = ""] - #[doc = " // create the Vulkan surface"] - #[doc = " VkSurfaceKHR surface;"] - #[doc = " if(!SDL_Vulkan_CreateSurface(window, instance, &surface))"] - #[doc = " handle_error();"] - #[doc = " \\endcode"] + #[doc = " \\since This function is available since SDL 2.0.6."] #[doc = ""] - #[doc = " \\note \\a window should have been created with the \\c SDL_WINDOW_VULKAN flag."] - #[doc = ""] - #[doc = " \\note \\a instance should have been created with the extensions returned"] - #[doc = " by \\c SDL_Vulkan_CreateSurface() enabled."] - #[doc = ""] - #[doc = " \\sa SDL_Vulkan_GetInstanceExtensions()"] + #[doc = " \\sa SDL_Vulkan_GetInstanceExtensions"] + #[doc = " \\sa SDL_Vulkan_GetDrawableSize"] pub fn SDL_Vulkan_CreateSurface( window: *mut SDL_Window, instance: VkInstance, @@ -30799,25 +37785,22 @@ extern "C" { ) -> SDL_bool; } extern "C" { - #[doc = " \\brief Get the size of a window's underlying drawable in pixels (for use"] - #[doc = " with setting viewport, scissor & etc)."] - #[doc = ""] - #[doc = " \\param window SDL_Window from which the drawable size should be queried"] - #[doc = " \\param w Pointer to variable for storing the width in pixels,"] - #[doc = " may be NULL"] - #[doc = " \\param h Pointer to variable for storing the height in pixels,"] - #[doc = " may be NULL"] + #[doc = " Get the size of the window's underlying drawable dimensions in pixels."] #[doc = ""] #[doc = " This may differ from SDL_GetWindowSize() if we're rendering to a high-DPI"] - #[doc = " drawable, i.e. the window was created with SDL_WINDOW_ALLOW_HIGHDPI on a"] - #[doc = " platform with high-DPI support (Apple calls this \"Retina\"), and not disabled"] - #[doc = " by the \\c SDL_HINT_VIDEO_HIGHDPI_DISABLED hint."] + #[doc = " drawable, i.e. the window was created with `SDL_WINDOW_ALLOW_HIGHDPI` on a"] + #[doc = " platform with high-DPI support (Apple calls this \"Retina\"), and not"] + #[doc = " disabled by the `SDL_HINT_VIDEO_HIGHDPI_DISABLED` hint."] + #[doc = ""] + #[doc = " \\param window an SDL_Window for which the size is to be queried"] + #[doc = " \\param w Pointer to the variable to write the width to or NULL"] + #[doc = " \\param h Pointer to the variable to write the height to or NULL"] #[doc = ""] - #[doc = " \\note On macOS high-DPI support must be enabled for an application by"] - #[doc = " setting NSHighResolutionCapable to true in its Info.plist."] + #[doc = " \\since This function is available since SDL 2.0.6."] #[doc = ""] - #[doc = " \\sa SDL_GetWindowSize()"] - #[doc = " \\sa SDL_CreateWindow()"] + #[doc = " \\sa SDL_GetWindowSize"] + #[doc = " \\sa SDL_CreateWindow"] + #[doc = " \\sa SDL_Vulkan_CreateSurface"] pub fn SDL_Vulkan_GetDrawableSize( window: *mut SDL_Window, w: *mut libc::c_int, @@ -30910,9 +37893,21 @@ pub struct wl_display { pub struct wl_surface { pub _address: u8, } -#[doc = "< Wayland shell_surface (window manager handle)"] +#[doc = "< Wayland EGL window (native window)"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct wl_egl_window { + pub _address: u8, +} +#[doc = "< Wayland xdg surface (window manager handle)"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct xdg_surface { + pub _address: u8, +} +#[doc = "< Wayland xdg toplevel role"] #[repr(C)] #[derive(Copy, Clone)] -pub struct wl_shell_surface { +pub struct xdg_toplevel { pub _address: u8, } From 24be1eeed366e7b1e9c3a1ba2d7597a0f12e43c2 Mon Sep 17 00:00:00 2001 From: Scott Percival Date: Sun, 6 Mar 2022 23:36:48 +0800 Subject: [PATCH 02/13] Update Event::MouseWheel to include precise_x and precise_y --- src/sdl2/event.rs | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/sdl2/event.rs b/src/sdl2/event.rs index a84d1a7a3c..71d2480913 100644 --- a/src/sdl2/event.rs +++ b/src/sdl2/event.rs @@ -664,6 +664,8 @@ pub enum Event { x: i32, y: i32, direction: MouseWheelDirection, + precise_x: f32, + precise_y: f32, }, JoyAxisMotion { @@ -1193,6 +1195,8 @@ impl Event { x, y, direction, + precise_x, + precise_y, } => { let event = sys::SDL_MouseWheelEvent { type_: SDL_EventType::SDL_MOUSEWHEEL as u32, @@ -1202,6 +1206,8 @@ impl Event { x, y, direction: direction.to_ll(), + preciseX: precise_x, + preciseY: precise_y, }; unsafe { ptr::copy(&event, ret.as_mut_ptr() as *mut sys::SDL_MouseWheelEvent, 1); @@ -1664,6 +1670,8 @@ impl Event { x: event.x, y: event.y, direction: mouse::MouseWheelDirection::from_ll(event.direction), + precise_x: event.preciseX, + precise_y: event.preciseY, } } @@ -2905,6 +2913,8 @@ mod test { x: 23, y: 91, direction: MouseWheelDirection::Flipped, + precise_x: 1.6, + precise_y: 2.7, }; let e2 = Event::from_ll(e.clone().to_ll().unwrap()); assert_eq!(e, e2); From 56c8eaf06ccba0c31db6ccfa977b8054bb8b40e7 Mon Sep 17 00:00:00 2001 From: Scott Percival Date: Sun, 6 Mar 2022 22:57:27 +0800 Subject: [PATCH 03/13] Implement SDL_SoftStretchLinear --- src/sdl2/surface.rs | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/src/sdl2/surface.rs b/src/sdl2/surface.rs index 0f8b490a5c..bb92e182f9 100644 --- a/src/sdl2/surface.rs +++ b/src/sdl2/surface.rs @@ -723,6 +723,7 @@ impl SurfaceRef { /// /// Unless you know what you're doing, use `blit()` instead, which will clip the input rectangles. /// This function could crash if the rectangles aren't pre-clipped to the surface, and is therefore unsafe. + #[doc(alias = "SDL_LowerBlit")] pub unsafe fn lower_blit( &self, src_rect: R1, @@ -747,6 +748,40 @@ impl SurfaceRef { } } + /// Performs bilinear scaling between two surfaces of the same format, 32BPP. + /// + /// Returns the final blit rectangle, if a `dst_rect` was provided. + #[doc(alias = "SDL_SoftStretchLinear")] + pub unsafe fn soft_stretch_linear( + &self, + src_rect: R1, + dst: &mut SurfaceRef, + dst_rect: R2, + ) -> Result, String> + where + R1: Into>, + R2: Into>, + { + let src_rect = src_rect.into(); + let dst_rect = dst_rect.into(); + + match { + let src_rect_ptr = src_rect.as_ref().map(|r| r.raw()).unwrap_or(ptr::null()); + + // Copy the rect here to make a mutable copy without requiring + // a mutable argument + let mut dst_rect = dst_rect; + let dst_rect_ptr = dst_rect + .as_mut() + .map(|r| r.raw_mut()) + .unwrap_or(ptr::null_mut()); + sys::SDL_SoftStretchLinear(self.raw(), src_rect_ptr, dst.raw(), dst_rect_ptr) + } { + 0 => Ok(dst_rect), + _ => Err(get_error()), + } + } + /// Performs scaled surface bliting (surface copying). /// /// Returns the final blit rectangle, if a `dst_rect` was provided. @@ -785,6 +820,7 @@ impl SurfaceRef { /// /// Unless you know what you're doing, use `blit_scaled()` instead, which will clip the input rectangles. /// This function could crash if the rectangles aren't pre-clipped to the surface, and is therefore unsafe. + #[doc(alias = "SDL_LowerBlitScaled")] pub unsafe fn lower_blit_scaled( &self, src_rect: R1, From 946aadf286eaad5c086295d0155d8331f57eebfc Mon Sep 17 00:00:00 2001 From: Scott Percival Date: Sun, 6 Mar 2022 23:38:27 +0800 Subject: [PATCH 04/13] Implement SDL_FlashWindow --- src/sdl2/video.rs | 41 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) diff --git a/src/sdl2/video.rs b/src/sdl2/video.rs index e22925144e..f354c4f233 100644 --- a/src/sdl2/video.rs +++ b/src/sdl2/video.rs @@ -637,6 +637,36 @@ impl Orientation { } } +/// Represents a setting for a window flash operation. +#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)] +#[repr(i32)] +pub enum FlashOperation { + /// Cancel any window flash state + Cancel = sys::SDL_FlashOperation::SDL_FLASH_CANCEL as i32, + /// Flash the window briefly to get attention + Briefly = sys::SDL_FlashOperation::SDL_FLASH_BRIEFLY as i32, + /// Flash the window until it gets focus + UntilFocused = sys::SDL_FlashOperation::SDL_FLASH_UNTIL_FOCUSED as i32, +} + +impl FlashOperation { + pub fn from_ll(flash_operation: sys::SDL_FlashOperation) -> FlashOperation { + match flash_operation { + sys::SDL_FlashOperation::SDL_FLASH_CANCEL => FlashOperation::Cancel, + sys::SDL_FlashOperation::SDL_FLASH_BRIEFLY => FlashOperation::Briefly, + sys::SDL_FlashOperation::SDL_FLASH_UNTIL_FOCUSED => FlashOperation::UntilFocused, + } + } + + pub fn to_ll(self) -> sys::SDL_FlashOperation { + match self { + FlashOperation::Cancel => sys::SDL_FlashOperation::SDL_FLASH_CANCEL, + FlashOperation::Briefly => sys::SDL_FlashOperation::SDL_FLASH_BRIEFLY, + FlashOperation::UntilFocused => sys::SDL_FlashOperation::SDL_FLASH_UNTIL_FOCUSED, + } + } +} + /// Represents the "shell" of a `Window`. /// /// You can set get and set many of the `SDL_Window` properties (i.e., border, size, `PixelFormat`, etc) @@ -1768,6 +1798,17 @@ impl Window { Ok(opacity) } } + + /// Requests a window to demand attention from the user. + #[doc(alias = "SDL_FlashWindow")] + pub fn flash(&mut self, operation: FlashOperation) -> Result<(), String> { + let result = unsafe { sys::SDL_FlashWindow(self.context.raw, operation.to_ll()) }; + if result == 0 { + Ok(()) + } else { + Err(get_error()) + } + } } #[derive(Copy, Clone)] From 550f3f8f62c8c7c8ac65db30efabec6d121a36f4 Mon Sep 17 00:00:00 2001 From: Scott Percival Date: Mon, 7 Mar 2022 09:58:47 +0800 Subject: [PATCH 05/13] Implement several features for controllers/joysticks --- src/sdl2/controller.rs | 75 +++++++++++++++++++++++++++++++++++++++++- src/sdl2/joystick.rs | 64 +++++++++++++++++++++++++++++++++++ 2 files changed, 138 insertions(+), 1 deletion(-) diff --git a/src/sdl2/controller.rs b/src/sdl2/controller.rs index d6ea91dbe3..212d9ed00e 100644 --- a/src/sdl2/controller.rs +++ b/src/sdl2/controller.rs @@ -507,6 +507,70 @@ impl GameController { Ok(()) } } + + /// Start a rumble effect in the game controller's triggers. + #[doc(alias = "SDL_GameControllerRumbleTriggers")] + pub fn set_rumble_triggers( + &mut self, + left_rumble: u16, + right_rumble: u16, + duration_ms: u32, + ) -> Result<(), IntegerOrSdlError> { + let result = unsafe { + sys::SDL_GameControllerRumbleTriggers(self.raw, left_rumble, right_rumble, duration_ms) + }; + + if result != 0 { + Err(IntegerOrSdlError::SdlError(get_error())) + } else { + Ok(()) + } + } + + /// Query whether a game controller has an LED. + #[doc(alias = "SDL_GameControllerHasLED")] + pub fn has_led(&self) -> bool { + let result = unsafe { sys::SDL_GameControllerHasLED(self.raw) }; + + match result { + sys::SDL_bool::SDL_FALSE => false, + sys::SDL_bool::SDL_TRUE => true, + } + } + + /// Query whether a game controller has rumble support. + #[doc(alias = "SDL_GameControllerHasRumble")] + pub fn has_rumble(&self) -> bool { + let result = unsafe { sys::SDL_GameControllerHasRumble(self.raw) }; + + match result { + sys::SDL_bool::SDL_FALSE => false, + sys::SDL_bool::SDL_TRUE => true, + } + } + + /// Query whether a game controller has rumble support on triggers. + #[doc(alias = "SDL_GameControllerHasRumbleTriggers")] + pub fn has_rumble_triggers(&self) -> bool { + let result = unsafe { sys::SDL_GameControllerHasRumbleTriggers(self.raw) }; + + match result { + sys::SDL_bool::SDL_FALSE => false, + sys::SDL_bool::SDL_TRUE => true, + } + } + + /// Update a game controller's LED color. + #[doc(alias = "SDL_GameControllerSetLED")] + pub fn set_led(&mut self, red: u8, green: u8, blue: u8) -> Result<(), IntegerOrSdlError> { + let result = unsafe { sys::SDL_GameControllerSetLED(self.raw, red, green, blue) }; + + if result != 0 { + Err(IntegerOrSdlError::SdlError(get_error())) + } else { + Ok(()) + } + } } #[cfg(feature = "hidapi")] @@ -532,7 +596,7 @@ impl GameController { } } - #[doc(alias = "SDL_GameControllerHasSensor")] + #[doc(alias = "SDL_GameControllerSetSensorEnabled")] pub fn sensor_set_enabled( &self, sensor_type: crate::sensor::SensorType, @@ -557,6 +621,15 @@ impl GameController { } } + /// Get the data rate (number of events per second) of a game controller sensor. + #[doc(alias = "SDL_GameControllerGetSensorDataRate")] + pub fn sensor_get_data_rate(&self, sensor_type: SensorType) -> f32 { + let result = + unsafe { sys::SDL_GameControllerGetSensorDataRate(self.raw, sensor_type.into()) }; + + Ok(result) + } + /// Get data from a sensor. /// /// The number of data points depends on the sensor. Both Gyroscope and diff --git a/src/sdl2/joystick.rs b/src/sdl2/joystick.rs index fdff31d349..053826dd64 100644 --- a/src/sdl2/joystick.rs +++ b/src/sdl2/joystick.rs @@ -400,6 +400,70 @@ impl Joystick { Ok(()) } } + + /// Start a rumble effect in the joystick's triggers. + #[doc(alias = "SDL_JoystickRumbleTriggers")] + pub fn set_rumble_triggers( + &mut self, + left_rumble: u16, + right_rumble: u16, + duration_ms: u32, + ) -> Result<(), IntegerOrSdlError> { + let result = unsafe { + sys::SDL_JoystickRumbleTriggers(self.raw, left_rumble, right_rumble, duration_ms) + }; + + if result != 0 { + Err(IntegerOrSdlError::SdlError(get_error())) + } else { + Ok(()) + } + } + + /// Query whether a joystick has an LED. + #[doc(alias = "SDL_JoystickHasLED")] + pub fn has_led(&self) -> bool { + let result = unsafe { sys::SDL_JoystickHasLED(self.raw) }; + + match result { + sys::SDL_bool::SDL_FALSE => false, + sys::SDL_bool::SDL_TRUE => true, + } + } + + /// Query whether a joystick has rumble support. + #[doc(alias = "SDL_JoystickHasRumble")] + pub fn has_rumble(&self) -> bool { + let result = unsafe { sys::SDL_JoystickHasRumble(self.raw) }; + + match result { + sys::SDL_bool::SDL_FALSE => false, + sys::SDL_bool::SDL_TRUE => true, + } + } + + /// Query whether a joystick has rumble support on triggers. + #[doc(alias = "SDL_JoystickHasRumbleTriggers")] + pub fn has_rumble_triggers(&self) -> bool { + let result = unsafe { sys::SDL_JoystickHasRumbleTriggers(self.raw) }; + + match result { + sys::SDL_bool::SDL_FALSE => false, + sys::SDL_bool::SDL_TRUE => true, + } + } + + /// Update a joystick's LED color. + #[doc(alias = "SDL_JoystickSetLED")] + pub fn set_led(&mut self, red: u8, green: u8, blue: u8) -> Result<(), IntegerOrSdlError> { + let result = unsafe { sys::SDL_JoystickSetLED(self.raw, red, green, blue) }; + + if result != 0 { + Err(IntegerOrSdlError::SdlError(get_error())) + } else { + Ok(()) + } + } } impl Drop for Joystick { From 086f5db85ad9cfe4d98551a81a355bdd7e709754 Mon Sep 17 00:00:00 2001 From: Scott Percival Date: Mon, 7 Mar 2022 10:14:38 +0800 Subject: [PATCH 06/13] Implement new WindowEvents --- src/sdl2/event.rs | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/src/sdl2/event.rs b/src/sdl2/event.rs index 71d2480913..18ea2227b8 100644 --- a/src/sdl2/event.rs +++ b/src/sdl2/event.rs @@ -487,6 +487,8 @@ pub enum WindowEvent { Close, TakeFocus, HitTest, + ICCProfChanged, + DisplayChanged(i32), } impl WindowEvent { @@ -510,6 +512,8 @@ impl WindowEvent { 14 => WindowEvent::Close, 15 => WindowEvent::TakeFocus, 16 => WindowEvent::HitTest, + 17 => WindowEvent::ICCProfChanged, + 18 => WindowEvent::DisplayChanged(data1), _ => WindowEvent::None, } } @@ -533,6 +537,8 @@ impl WindowEvent { WindowEvent::Close => (14, 0, 0), WindowEvent::TakeFocus => (15, 0, 0), WindowEvent::HitTest => (16, 0, 0), + WindowEvent::ICCProfChanged => (17, 0, 0), + WindowEvent::DisplayChanged(d1) => (18, d1, 0), } } @@ -554,7 +560,9 @@ impl WindowEvent { | (Self::FocusLost, Self::FocusLost) | (Self::Close, Self::Close) | (Self::TakeFocus, Self::TakeFocus) - | (Self::HitTest, Self::HitTest) => true, + | (Self::HitTest, Self::HitTest) + | (Self::ICCProfChanged, Self::ICCProfChanged) + | (Self::DisplayChanged(_), Self::DisplayChanged(_)) => true, _ => false, } } From f97f8b7552ebffa787f1feafa67f27c724e3866c Mon Sep 17 00:00:00 2001 From: Scott Percival Date: Mon, 7 Mar 2022 14:50:26 +0800 Subject: [PATCH 07/13] Implement window grabbing features --- src/sdl2/video.rs | 75 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 75 insertions(+) diff --git a/src/sdl2/video.rs b/src/sdl2/video.rs index f354c4f233..5ac4ac6bac 100644 --- a/src/sdl2/video.rs +++ b/src/sdl2/video.rs @@ -1688,11 +1688,86 @@ impl Window { } } + #[doc(alias = "SDL_SetWindowKeyboardGrab")] + pub fn set_keyboard_grab(&mut self, grabbed: bool) { + unsafe { + sys::SDL_SetWindowKeyboardGrab( + self.context.raw, + if grabbed { + sys::SDL_bool::SDL_TRUE + } else { + sys::SDL_bool::SDL_FALSE + }, + ) + } + } + + #[doc(alias = "SDL_SetWindowMouseGrab")] + pub fn set_mouse_grab(&mut self, grabbed: bool) { + unsafe { + sys::SDL_SetWindowMouseGrab( + self.context.raw, + if grabbed { + sys::SDL_bool::SDL_TRUE + } else { + sys::SDL_bool::SDL_FALSE + }, + ) + } + } + #[doc(alias = "SDL_GetWindowGrab")] pub fn grab(&self) -> bool { unsafe { sys::SDL_GetWindowGrab(self.context.raw) == sys::SDL_bool::SDL_TRUE } } + #[doc(alias = "SDL_GetWindowKeyboardGrab")] + pub fn keyboard_grab(&self) -> bool { + unsafe { sys::SDL_GetWindowKeyboardGrab(self.context.raw) == sys::SDL_bool::SDL_TRUE } + } + + #[doc(alias = "SDL_GetWindowMouseGrab")] + pub fn mouse_grab(&self) -> bool { + unsafe { sys::SDL_GetWindowMouseGrab(self.context.raw) == sys::SDL_bool::SDL_TRUE } + } + + #[doc(alias = "SDL_SetWindowMouseRect")] + pub fn set_mouse_rect(&self, rect: R) -> Result<(), String> + where + R: Into>, + { + let rect = rect.into(); + let rect_raw_ptr = match rect { + Some(ref rect) => rect.raw(), + None => ptr::null(), + }; + + unsafe { + if sys::SDL_SetWindowMouseRect(self.context.raw, rect_raw_ptr) == 0 { + Ok(()) + } else { + Err(get_error()) + } + } + } + + #[doc(alias = "SDL_GetWindowMouseRect")] + pub fn mouse_rect(&self) -> Option { + unsafe { + let raw_rect = sys::SDL_GetWindowMouseRect(self.context.raw); + if raw_rect.is_null() { + None + } else { + Some(Rect::new( + (*raw_rect).x, + (*raw_rect).y, + (*raw_rect).w as u32, + (*raw_rect).h as u32, + )) + } + } + } + #[doc(alias = "SDL_SetWindowBrightness")] pub fn set_brightness(&mut self, brightness: f64) -> Result<(), String> { unsafe { From fb769060df0316abd4356909966dee3b0ba4a5c6 Mon Sep 17 00:00:00 2001 From: Scott Percival Date: Mon, 7 Mar 2022 18:36:54 +0800 Subject: [PATCH 08/13] Implement SDL_GetAudioDeviceSpec --- src/sdl2/audio.rs | 43 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) diff --git a/src/sdl2/audio.rs b/src/sdl2/audio.rs index 4f40c9c9f9..752dfd8a04 100644 --- a/src/sdl2/audio.rs +++ b/src/sdl2/audio.rs @@ -180,6 +180,49 @@ impl AudioSubsystem { } } } + + #[doc(alias = "SDL_GetAudioDeviceSpec")] + pub fn audio_playback_device_spec(&self, index: u32) -> Result { + let mut spec = sys::SDL_AudioSpec { + freq: 0, + format: 0, + channels: 0, + silence: 0, + samples: 0, + padding: 0, + size: 0, + callback: None, + userdata: ptr::null_mut(), + }; + + let result = unsafe { sys::SDL_GetAudioDeviceSpec(index as c_int, 0, &mut spec) }; + if result != 0 { + Err(get_error()) + } else { + Ok(AudioSpec::convert_from_ll(spec)) + } + } + #[doc(alias = "SDL_GetAudioDeviceSpec")] + pub fn audio_capture_device_spec(&self, index: u32) -> Result { + let mut spec = sys::SDL_AudioSpec { + freq: 0, + format: 0, + channels: 0, + silence: 0, + samples: 0, + padding: 0, + size: 0, + callback: None, + userdata: ptr::null_mut(), + }; + + let result = unsafe { sys::SDL_GetAudioDeviceSpec(index as c_int, 1, &mut spec) }; + if result != 0 { + Err(get_error()) + } else { + Ok(AudioSpec::convert_from_ll(spec)) + } + } } #[repr(i32)] From 8700fdf028c124ef9576a338d55bdb0852a99ec8 Mon Sep 17 00:00:00 2001 From: Scott Percival Date: Tue, 8 Mar 2022 00:50:48 +0800 Subject: [PATCH 09/13] Implement SDL_JoystickSendEffect and SDL_GameControllerSendEffect --- src/sdl2/controller.rs | 18 ++++++++++++++++++ src/sdl2/joystick.rs | 18 ++++++++++++++++++ 2 files changed, 36 insertions(+) diff --git a/src/sdl2/controller.rs b/src/sdl2/controller.rs index 212d9ed00e..94a3f79c56 100644 --- a/src/sdl2/controller.rs +++ b/src/sdl2/controller.rs @@ -571,6 +571,24 @@ impl GameController { Ok(()) } } + + /// Send a controller specific effect packet. + #[doc(alias = "SDL_GameControllerSendEffect")] + pub fn send_effect(&mut self, data: &[u8]) -> Result<(), IntegerOrSdlError> { + let result = unsafe { + sys::SDL_GameControllerSendEffect( + self.raw, + data.as_ptr() as *const libc::c_void, + data.len() as i32, + ) + }; + + if result != 0 { + Err(IntegerOrSdlError::SdlError(get_error())) + } else { + Ok(()) + } + } } #[cfg(feature = "hidapi")] diff --git a/src/sdl2/joystick.rs b/src/sdl2/joystick.rs index 053826dd64..222a0c4dea 100644 --- a/src/sdl2/joystick.rs +++ b/src/sdl2/joystick.rs @@ -464,6 +464,24 @@ impl Joystick { Ok(()) } } + + /// Send a joystick specific effect packet. + #[doc(alias = "SDL_JoystickSendEffect")] + pub fn send_effect(&mut self, data: &[u8]) -> Result<(), IntegerOrSdlError> { + let result = unsafe { + sys::SDL_JoystickSendEffect( + self.raw, + data.as_ptr() as *const libc::c_void, + data.len() as i32, + ) + }; + + if result != 0 { + Err(IntegerOrSdlError::SdlError(get_error())) + } else { + Ok(()) + } + } } impl Drop for Joystick { From 1c27890e3a2223f1e8ffe2eb3e917802cab7cec2 Mon Sep 17 00:00:00 2001 From: Scott Percival Date: Tue, 8 Mar 2022 01:17:29 +0800 Subject: [PATCH 10/13] Implement SDL_GetWindowICCProfile --- src/sdl2/video.rs | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/src/sdl2/video.rs b/src/sdl2/video.rs index 5ac4ac6bac..1c526bb835 100644 --- a/src/sdl2/video.rs +++ b/src/sdl2/video.rs @@ -1429,6 +1429,24 @@ impl Window { } } + #[doc(alias = "SDL_GetWindowICCProfile")] + pub fn icc_profile(&self) -> Result, String> { + unsafe { + let mut size: sys::size_t = 0; + let data = sys::SDL_GetWindowICCProfile( + self.context.raw, + &mut size as *const sys::size_t as *mut _, + ); + if data.is_null() { + return Err(get_error()); + } + let mut result = vec![0; size as usize]; + result.copy_from_slice(std::slice::from_raw_parts(data as *const u8, size as usize)); + sys::SDL_free(data); + Ok(result) + } + } + #[doc(alias = "SDL_GetWindowPixelFormat")] pub fn window_pixel_format(&self) -> PixelFormatEnum { unsafe { From fffd2b455ca5aa7333a0b6efff24aa825cfde709 Mon Sep 17 00:00:00 2001 From: Scott Percival Date: Tue, 29 Mar 2022 18:44:35 +0800 Subject: [PATCH 11/13] Fix println formatting for touchpad tests --- examples/game-controller.rs | 33 ++++++++++++++++++++++++++++++--- 1 file changed, 30 insertions(+), 3 deletions(-) diff --git a/examples/game-controller.rs b/examples/game-controller.rs index 67cfd1e640..0ded8b6c07 100644 --- a/examples/game-controller.rs +++ b/examples/game-controller.rs @@ -87,9 +87,36 @@ fn main() -> Result<(), String> { } Event::ControllerButtonDown { button, .. } => println!("Button {:?} down", button), Event::ControllerButtonUp { button, .. } => println!("Button {:?} up", button), - Event::ControllerTouchpadDown { touchpad, finger, x, y, ..} => println!("Touchpad {touchpad} down finger:{finger} x:{x} y:{y}"), - Event::ControllerTouchpadMotion { touchpad, finger, x, y, ..} => println!("Touchpad {touchpad} move finger:{finger} x:{x} y:{y}"), - Event::ControllerTouchpadUp { touchpad, finger, x, y, ..} => println!("Touchpad {touchpad} up finger:{finger} x:{x} y:{y}"), + Event::ControllerTouchpadDown { + touchpad, + finger, + x, + y, + .. + } => println!( + "Touchpad {} down finger:{} x:{} y:{}", + touchpad, finger, x, y + ), + Event::ControllerTouchpadMotion { + touchpad, + finger, + x, + y, + .. + } => println!( + "Touchpad {} move finger:{} x:{} y:{}", + touchpad, finger, x, y + ), + Event::ControllerTouchpadUp { + touchpad, + finger, + x, + y, + .. + } => println!( + "Touchpad {} up finger:{} x:{} y:{}", + touchpad, finger, x, y + ), Event::Quit { .. } => break, _ => (), } From 39b05d53ab350c985309a4b08a7dd5b959d590cf Mon Sep 17 00:00:00 2001 From: Scott Percival Date: Wed, 13 Apr 2022 11:35:12 +0800 Subject: [PATCH 12/13] Corrections based on code review --- src/sdl2/controller.rs | 4 ++-- src/sdl2/video.rs | 5 +---- 2 files changed, 3 insertions(+), 6 deletions(-) diff --git a/src/sdl2/controller.rs b/src/sdl2/controller.rs index 94a3f79c56..4e658aefd9 100644 --- a/src/sdl2/controller.rs +++ b/src/sdl2/controller.rs @@ -574,7 +574,7 @@ impl GameController { /// Send a controller specific effect packet. #[doc(alias = "SDL_GameControllerSendEffect")] - pub fn send_effect(&mut self, data: &[u8]) -> Result<(), IntegerOrSdlError> { + pub fn send_effect(&mut self, data: &[u8]) -> Result<(), String> { let result = unsafe { sys::SDL_GameControllerSendEffect( self.raw, @@ -584,7 +584,7 @@ impl GameController { }; if result != 0 { - Err(IntegerOrSdlError::SdlError(get_error())) + Err(get_error()) } else { Ok(()) } diff --git a/src/sdl2/video.rs b/src/sdl2/video.rs index 1c526bb835..5c2752f98e 100644 --- a/src/sdl2/video.rs +++ b/src/sdl2/video.rs @@ -1433,10 +1433,7 @@ impl Window { pub fn icc_profile(&self) -> Result, String> { unsafe { let mut size: sys::size_t = 0; - let data = sys::SDL_GetWindowICCProfile( - self.context.raw, - &mut size as *const sys::size_t as *mut _, - ); + let data = sys::SDL_GetWindowICCProfile(self.context.raw, &mut size as *mut _); if data.is_null() { return Err(get_error()); } From a5cc934cd708012aa8e2f97f25c31c6109fa6186 Mon Sep 17 00:00:00 2001 From: Cobrand Date: Mon, 25 Apr 2022 15:59:57 +0200 Subject: [PATCH 13/13] fix doc test is_mouse failing --- sdl2-sys/SDL | 2 +- src/sdl2/event.rs | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/sdl2-sys/SDL b/sdl2-sys/SDL index b424665e08..a1e992b110 160000 --- a/sdl2-sys/SDL +++ b/sdl2-sys/SDL @@ -1 +1 @@ -Subproject commit b424665e0899769b200231ba943353a5fee1b6b6 +Subproject commit a1e992b110b9adf3305a5ebb5514f0e970f7911e diff --git a/src/sdl2/event.rs b/src/sdl2/event.rs index 18ea2227b8..1af80dd94e 100644 --- a/src/sdl2/event.rs +++ b/src/sdl2/event.rs @@ -2352,6 +2352,8 @@ impl Event { /// timestamp: 0, /// window_id: 0, /// which: 0, + /// precise_x: 0.0, + /// precise_y: 0.0, /// x: 0, /// y: 0, /// direction: MouseWheelDirection::Normal,