icculus · December 9, 2024 21:10
diff --git a/all-sdl3-documented-macros.h b/all-sdl3-documented-macros.h
 #define SDL_HINT_ALLOW_ALT_TAB_WHILE_GRABBED ...                                               // Specify the behavior of Alt+Tab while the keyboard is grabbed.
 #define SDL_HINT_ANDROID_ALLOW_RECREATE_ACTIVITY ...                                           // A variable to control whether the SDL activity is allowed to be re-created.
 #define SDL_HINT_ANDROID_BLOCK_ON_PAUSE ...                                                    // A variable to control whether the event loop will block itself when the app is paused.
 #define SDL_HINT_ANDROID_LOW_LATENCY_AUDIO ...                                                 // A variable to control whether low latency audio should be enabled.
 #define SDL_HINT_ANDROID_TRAP_BACK_BUTTON ...                                                  // A variable to control whether we trap the Android back button to handle it manually.
 #define SDL_HINT_APP_ID ...                                                                    // A variable setting the app ID string.
 #define SDL_HINT_APP_NAME ...                                                                  // A variable setting the application name.
 #define SDL_HINT_APPLE_TV_CONTROLLER_UI_EVENTS ...                                             // A variable controlling whether controllers used with the Apple TV generate UI events.
 #define SDL_HINT_APPLE_TV_REMOTE_ALLOW_ROTATION ...                                            // A variable controlling whether the Apple TV remote's joystick axes will automatically match the rotation of the remote.
 #define SDL_HINT_AUDIO_ALSA_DEFAULT_DEVICE ...                                                 // Specify the default ALSA audio device name.
 #define SDL_HINT_AUDIO_CATEGORY ...                                                            // A variable controlling the audio category on iOS and macOS.
 #define SDL_HINT_AUDIO_CHANNELS ...                                                            // A variable controlling the default audio channel count.
 #define SDL_HINT_AUDIO_DEVICE_APP_ICON_NAME ...                                                // Specify an application icon name for an audio device.
 #define SDL_HINT_AUDIO_DEVICE_SAMPLE_FRAMES ...                                                // A variable controlling device buffer size.
 #define SDL_HINT_AUDIO_DEVICE_STREAM_NAME ...                                                  // Specify an audio stream name for an audio device.
 #define SDL_HINT_AUDIO_DEVICE_STREAM_ROLE ...                                                  // Specify an application role for an audio device.
 #define SDL_HINT_AUDIO_DISK_INPUT_FILE ...                                                     // Specify the input file when recording audio using the disk audio driver.
 #define SDL_HINT_AUDIO_DISK_OUTPUT_FILE ...                                                    // Specify the output file when playing audio using the disk audio driver.
 #define SDL_HINT_AUDIO_DISK_TIMESCALE ...                                                      // A variable controlling the audio rate when using the disk audio driver.
 #define SDL_HINT_AUDIO_DRIVER ...                                                              // A variable that specifies an audio backend to use.
 #define SDL_HINT_AUDIO_DUMMY_TIMESCALE ...                                                     // A variable controlling the audio rate when using the dummy audio driver.
 #define SDL_HINT_AUDIO_FORMAT ...                                                              // A variable controlling the default audio format.
 #define SDL_HINT_AUDIO_FREQUENCY ...                                                           // A variable controlling the default audio frequency.
 #define SDL_HINT_AUDIO_INCLUDE_MONITORS ...                                                    // A variable that causes SDL to not ignore audio "monitors".
 #define SDL_HINT_AUTO_UPDATE_JOYSTICKS ...                                                     // A variable controlling whether SDL updates joystick state when getting input events.
 #define SDL_HINT_AUTO_UPDATE_SENSORS ...                                                       // A variable controlling whether SDL updates sensor state when getting input events.
 #define SDL_HINT_BMP_SAVE_LEGACY_FORMAT ...                                                    // Prevent SDL from using version 4 of the bitmap header when saving BMPs.
 #define SDL_HINT_CAMERA_DRIVER ...                                                             // A variable that decides what camera backend to use.
 #define SDL_HINT_CPU_FEATURE_MASK ...                                                          // A variable that limits what CPU features are available.
 #define SDL_HINT_JOYSTICK_DIRECTINPUT ...                                                      // A variable controlling whether DirectInput should be used for controllers.
 #define SDL_HINT_FILE_DIALOG_DRIVER ...                                                        // A variable that specifies a dialog backend to use.
 #define SDL_HINT_DISPLAY_USABLE_BOUNDS ...                                                     // Override for SDL_GetDisplayUsableBounds().
 #define SDL_HINT_EMSCRIPTEN_ASYNCIFY ...                                                       // Disable giving back control to the browser automatically when running with asyncify.
 #define SDL_HINT_EMSCRIPTEN_CANVAS_SELECTOR ...                                                // Specify the CSS selector used for the "default" window/canvas.
 #define SDL_HINT_EMSCRIPTEN_KEYBOARD_ELEMENT ...                                               // Override the binding element for keyboard inputs for Emscripten builds.
 #define SDL_HINT_ENABLE_SCREEN_KEYBOARD ...                                                    // A variable that controls whether the on-screen keyboard should be shown when text input is active.
 #define SDL_HINT_EVDEV_DEVICES ...                                                             // A variable containing a list of evdev devices to use if udev is not available.
 #define SDL_HINT_EVENT_LOGGING ...                                                             // A variable controlling verbosity of the logging of SDL events pushed onto the internal queue.
 #define SDL_HINT_FORCE_RAISEWINDOW ...                                                         // A variable controlling whether raising the window should be done more forcefully.
 #define SDL_HINT_FRAMEBUFFER_ACCELERATION ...                                                  // A variable controlling how 3D acceleration is used to accelerate the SDL screen surface.
 #define SDL_HINT_GAMECONTROLLERCONFIG ...                                                      // A variable that lets you manually hint extra gamecontroller db entries.
 #define SDL_HINT_GAMECONTROLLERCONFIG_FILE ...                                                 // A variable that lets you provide a file with extra gamecontroller db entries.
 #define SDL_HINT_GAMECONTROLLERTYPE ...                                                        // A variable that overrides the automatic controller type detection.
 #define SDL_HINT_GAMECONTROLLER_IGNORE_DEVICES ...                                             // A variable containing a list of devices to skip when scanning for game controllers.
 #define SDL_HINT_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT ...                                      // If set, all devices will be skipped when scanning for game controllers except for the ones listed in this variable.
 #define SDL_HINT_GAMECONTROLLER_SENSOR_FUSION ...                                              // A variable that controls whether the device's built-in accelerometer and gyro should be used as sensors for gamepads.
 #define SDL_HINT_GDK_TEXTINPUT_DEFAULT_TEXT ...                                                // This variable sets the default text of the TextInput window on GDK platforms.
 #define SDL_HINT_GDK_TEXTINPUT_DESCRIPTION ...                                                 // This variable sets the description of the TextInput window on GDK platforms.
 #define SDL_HINT_GDK_TEXTINPUT_MAX_LENGTH ...                                                  // This variable sets the maximum input length of the TextInput window on GDK platforms.
 #define SDL_HINT_GDK_TEXTINPUT_SCOPE ...                                                       // This variable sets the input scope of the TextInput window on GDK platforms.
 #define SDL_HINT_GDK_TEXTINPUT_TITLE ...                                                       // This variable sets the title of the TextInput window on GDK platforms.
 #define SDL_HINT_HIDAPI_LIBUSB ...                                                             // A variable to control whether HIDAPI uses libusb for device access.
 #define SDL_HINT_HIDAPI_LIBUSB_WHITELIST ...                                                   // A variable to control whether HIDAPI uses libusb only for whitelisted devices.
 #define SDL_HINT_HIDAPI_UDEV ...                                                               // A variable to control whether HIDAPI uses udev for device detection.
 #define SDL_HINT_GPU_DRIVER ...                                                                // A variable that specifies a GPU backend to use.
 #define SDL_HINT_HIDAPI_ENUMERATE_ONLY_CONTROLLERS ...                                         // A variable to control whether SDL_hid_enumerate() enumerates all HID devices or only controllers.
 #define SDL_HINT_HIDAPI_IGNORE_DEVICES ...                                                     // A variable containing a list of devices to ignore in SDL_hid_enumerate().
 #define SDL_HINT_IME_IMPLEMENTED_UI ...                                                        // A variable describing what IME UI elements the application can display.
 #define SDL_HINT_IOS_HIDE_HOME_INDICATOR ...                                                   // A variable controlling whether the home indicator bar on iPhone X should be hidden.
 #define SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS ...                                          // A variable that lets you enable joystick (and gamecontroller) events even when your app is in the background.
 #define SDL_HINT_JOYSTICK_ARCADESTICK_DEVICES ...                                              // A variable containing a list of arcade stick style controllers.
 #define SDL_HINT_JOYSTICK_ARCADESTICK_DEVICES_EXCLUDED ...                                     // A variable containing a list of devices that are not arcade stick style controllers.
 #define SDL_HINT_JOYSTICK_BLACKLIST_DEVICES ...                                                // A variable containing a list of devices that should not be considered joysticks.
 #define SDL_HINT_JOYSTICK_BLACKLIST_DEVICES_EXCLUDED ...                                       // A variable containing a list of devices that should be considered joysticks.
 #define SDL_HINT_JOYSTICK_DEVICE ...                                                           // A variable containing a comma separated list of devices to open as joysticks.
 #define SDL_HINT_JOYSTICK_FLIGHTSTICK_DEVICES ...                                              // A variable containing a list of flightstick style controllers.
 #define SDL_HINT_JOYSTICK_FLIGHTSTICK_DEVICES_EXCLUDED ...                                     // A variable containing a list of devices that are not flightstick style controllers.
 #define SDL_HINT_JOYSTICK_GAMEINPUT ...                                                        // A variable controlling whether GameInput should be used for controller handling on Windows.
 #define SDL_HINT_JOYSTICK_GAMECUBE_DEVICES ...                                                 // A variable containing a list of devices known to have a GameCube form factor.
 #define SDL_HINT_JOYSTICK_GAMECUBE_DEVICES_EXCLUDED ...                                        // A variable containing a list of devices known not to have a GameCube form factor.
 #define SDL_HINT_JOYSTICK_HIDAPI ...                                                           // A variable controlling whether the HIDAPI joystick drivers should be used.
 #define SDL_HINT_JOYSTICK_HIDAPI_COMBINE_JOY_CONS ...                                          // A variable controlling whether Nintendo Switch Joy-Con controllers will be combined into a single Pro-like controller when using the HIDAPI driver.
 #define SDL_HINT_JOYSTICK_HIDAPI_GAMECUBE ...                                                  // A variable controlling whether the HIDAPI driver for Nintendo GameCube controllers should be used.
 #define SDL_HINT_JOYSTICK_HIDAPI_GAMECUBE_RUMBLE_BRAKE ...                                     // A variable controlling whether rumble is used to implement the GameCube controller's 3 rumble modes, Stop(0), Rumble(1), and StopHard(2).
 #define SDL_HINT_JOYSTICK_HIDAPI_JOY_CONS ...                                                  // A variable controlling whether the HIDAPI driver for Nintendo Switch Joy-Cons should be used.
 #define SDL_HINT_JOYSTICK_HIDAPI_JOYCON_HOME_LED ...                                           // A variable controlling whether the Home button LED should be turned on when a Nintendo Switch Joy-Con controller is opened.
 #define SDL_HINT_JOYSTICK_HIDAPI_LUNA ...                                                      // A variable controlling whether the HIDAPI driver for Amazon Luna controllers connected via Bluetooth should be used.
 #define SDL_HINT_JOYSTICK_HIDAPI_NINTENDO_CLASSIC ...                                          // A variable controlling whether the HIDAPI driver for Nintendo Online classic controllers should be used.
 #define SDL_HINT_JOYSTICK_HIDAPI_PS3 ...                                                       // A variable controlling whether the HIDAPI driver for PS3 controllers should be used.
 #define SDL_HINT_JOYSTICK_HIDAPI_PS3_SIXAXIS_DRIVER ...                                        // A variable controlling whether the Sony driver (sixaxis.sys) for PS3 controllers (Sixaxis/DualShock 3) should be used.
 #define SDL_HINT_JOYSTICK_HIDAPI_PS4 ...                                                       // A variable controlling whether the HIDAPI driver for PS4 controllers should be used.
 #define SDL_HINT_JOYSTICK_HIDAPI_PS4_REPORT_INTERVAL ...                                       // A variable controlling the update rate of the PS4 controller over Bluetooth when using the HIDAPI driver.
 #define SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE ...                                                // A variable controlling whether extended input reports should be used for PS4 controllers when using the HIDAPI driver.
 #define SDL_HINT_JOYSTICK_HIDAPI_PS5 ...                                                       // A variable controlling whether the HIDAPI driver for PS5 controllers should be used.
 #define SDL_HINT_JOYSTICK_HIDAPI_PS5_PLAYER_LED ...                                            // A variable controlling whether the player LEDs should be lit to indicate which player is associated with a PS5 controller.
 #define SDL_HINT_JOYSTICK_HIDAPI_PS5_RUMBLE ...                                                // A variable controlling whether extended input reports should be used for PS5 controllers when using the HIDAPI driver.
 #define SDL_HINT_JOYSTICK_HIDAPI_SHIELD ...                                                    // A variable controlling whether the HIDAPI driver for NVIDIA SHIELD controllers should be used.
 #define SDL_HINT_JOYSTICK_HIDAPI_STADIA ...                                                    // A variable controlling whether the HIDAPI driver for Google Stadia controllers should be used.
 #define SDL_HINT_JOYSTICK_HIDAPI_STEAM ...                                                     // A variable controlling whether the HIDAPI driver for Bluetooth Steam Controllers should be used.
 #define SDL_HINT_JOYSTICK_HIDAPI_STEAM_HOME_LED ...                                            // A variable controlling whether the Steam button LED should be turned on when a Steam controller is opened.
 #define SDL_HINT_JOYSTICK_HIDAPI_STEAMDECK ...                                                 // A variable controlling whether the HIDAPI driver for the Steam Deck builtin controller should be used.
 #define SDL_HINT_JOYSTICK_HIDAPI_STEAM_HORI ...                                                // A variable controlling whether the HIDAPI driver for HORI licensed Steam controllers should be used.
 #define SDL_HINT_JOYSTICK_HIDAPI_SWITCH ...                                                    // A variable controlling whether the HIDAPI driver for Nintendo Switch controllers should be used.
 #define SDL_HINT_JOYSTICK_HIDAPI_SWITCH_HOME_LED ...                                           // A variable controlling whether the Home button LED should be turned on when a Nintendo Switch Pro controller is opened.
 #define SDL_HINT_JOYSTICK_HIDAPI_SWITCH_PLAYER_LED ...                                         // A variable controlling whether the player LEDs should be lit to indicate which player is associated with a Nintendo Switch controller.
 #define SDL_HINT_JOYSTICK_HIDAPI_VERTICAL_JOY_CONS ...                                         // A variable controlling whether Nintendo Switch Joy-Con controllers will be in vertical mode when using the HIDAPI driver.
 #define SDL_HINT_JOYSTICK_HIDAPI_WII ...                                                       // A variable controlling whether the HIDAPI driver for Nintendo Wii and Wii U controllers should be used.
 #define SDL_HINT_JOYSTICK_HIDAPI_WII_PLAYER_LED ...                                            // A variable controlling whether the player LEDs should be lit to indicate which player is associated with a Wii controller.
 #define SDL_HINT_JOYSTICK_HIDAPI_XBOX ...                                                      // A variable controlling whether the HIDAPI driver for XBox controllers should be used.
 #define SDL_HINT_JOYSTICK_HIDAPI_XBOX_360 ...                                                  // A variable controlling whether the HIDAPI driver for XBox 360 controllers should be used.
 #define SDL_HINT_JOYSTICK_HIDAPI_XBOX_360_PLAYER_LED ...                                       // A variable controlling whether the player LEDs should be lit to indicate which player is associated with an Xbox 360 controller.
 #define SDL_HINT_JOYSTICK_HIDAPI_XBOX_360_WIRELESS ...                                         // A variable controlling whether the HIDAPI driver for XBox 360 wireless controllers should be used.
 #define SDL_HINT_JOYSTICK_HIDAPI_XBOX_ONE ...                                                  // A variable controlling whether the HIDAPI driver for XBox One controllers should be used.
 #define SDL_HINT_JOYSTICK_HIDAPI_XBOX_ONE_HOME_LED ...                                         // A variable controlling whether the Home button LED should be turned on when an Xbox One controller is opened.
 #define SDL_HINT_JOYSTICK_IOKIT ...                                                            // A variable controlling whether IOKit should be used for controller handling.
 #define SDL_HINT_JOYSTICK_LINUX_CLASSIC ...                                                    // A variable controlling whether to use the classic /dev/input/js* joystick interface or the newer /dev/input/event* joystick interface on Linux.
 #define SDL_HINT_JOYSTICK_LINUX_DEADZONES ...                                                  // A variable controlling whether joysticks on Linux adhere to their HID-defined deadzones or return unfiltered values.
 #define SDL_HINT_JOYSTICK_LINUX_DIGITAL_HATS ...                                               // A variable controlling whether joysticks on Linux will always treat 'hat' axis inputs (ABS_HAT0X - ABS_HAT3Y) as 8-way digital hats without checking whether they may be analog.
 #define SDL_HINT_JOYSTICK_LINUX_HAT_DEADZONES ...                                              // A variable controlling whether digital hats on Linux will apply deadzones to their underlying input axes or use unfiltered values.
 #define SDL_HINT_JOYSTICK_MFI ...                                                              // A variable controlling whether GCController should be used for controller handling.
 #define SDL_HINT_JOYSTICK_RAWINPUT ...                                                         // A variable controlling whether the RAWINPUT joystick drivers should be used for better handling XInput-capable devices.
 #define SDL_HINT_JOYSTICK_RAWINPUT_CORRELATE_XINPUT ...                                        // A variable controlling whether the RAWINPUT driver should pull correlated data from XInput.
 #define SDL_HINT_JOYSTICK_ROG_CHAKRAM ...                                                      // A variable controlling whether the ROG Chakram mice should show up as joysticks.
 #define SDL_HINT_JOYSTICK_THREAD ...                                                           // A variable controlling whether a separate thread should be used for handling joystick detection and raw input messages on Windows.
 #define SDL_HINT_JOYSTICK_THROTTLE_DEVICES ...                                                 // A variable containing a list of throttle style controllers.
 #define SDL_HINT_JOYSTICK_THROTTLE_DEVICES_EXCLUDED ...                                        // A variable containing a list of devices that are not throttle style controllers.
 #define SDL_HINT_JOYSTICK_WGI ...                                                              // A variable controlling whether Windows.Gaming.Input should be used for controller handling.
 #define SDL_HINT_JOYSTICK_WHEEL_DEVICES ...                                                    // A variable containing a list of wheel style controllers.
 #define SDL_HINT_JOYSTICK_WHEEL_DEVICES_EXCLUDED ...                                           // A variable containing a list of devices that are not wheel style controllers.
 #define SDL_HINT_JOYSTICK_ZERO_CENTERED_DEVICES ...                                            // A variable containing a list of devices known to have all axes centered at zero.
 #define SDL_HINT_KEYCODE_OPTIONS ...                                                           // A variable that controls keycode representation in keyboard events.
 #define SDL_HINT_KMSDRM_DEVICE_INDEX ...                                                       // A variable that controls what KMSDRM device to use.
 #define SDL_HINT_KMSDRM_REQUIRE_DRM_MASTER ...                                                 // A variable that controls whether SDL requires DRM master access in order to initialize the KMSDRM video backend.
 #define SDL_HINT_LOGGING ...                                                                   // A variable controlling the default SDL log levels.
 #define SDL_HINT_MAC_BACKGROUND_APP ...                                                        // A variable controlling whether to force the application to become the foreground process when launched on macOS.
 #define SDL_HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK ...                                        // A variable that determines whether Ctrl+Click should generate a right-click event on macOS.
 #define SDL_HINT_MAC_OPENGL_ASYNC_DISPATCH ...                                                 // A variable controlling whether dispatching OpenGL context updates should block the dispatching thread until the main thread finishes processing on macOS.
 #define SDL_HINT_MAC_SCROLL_MOMENTUM ...                                                       // A variable controlling whether SDL_EVENT_MOUSE_WHEEL event values will have momentum on macOS.
 #define SDL_HINT_MAIN_CALLBACK_RATE ...                                                        // Request SDL_AppIterate() be called at a specific rate.
 #define SDL_HINT_MOUSE_AUTO_CAPTURE ...                                                        // A variable controlling whether the mouse is captured while mouse buttons are pressed.
 #define SDL_HINT_MOUSE_DOUBLE_CLICK_RADIUS ...                                                 // A variable setting the double click radius, in pixels.
 #define SDL_HINT_MOUSE_DOUBLE_CLICK_TIME ...                                                   // A variable setting the double click time, in milliseconds.
 #define SDL_HINT_MOUSE_DEFAULT_SYSTEM_CURSOR ...                                               // A variable setting which system cursor to use as the default cursor.
 #define SDL_HINT_MOUSE_EMULATE_WARP_WITH_RELATIVE ...                                          // A variable controlling whether warping a hidden mouse cursor will activate relative mouse mode.
 #define SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH ...                                                  // Allow mouse click events when clicking to focus an SDL window.
 #define SDL_HINT_MOUSE_NORMAL_SPEED_SCALE ...                                                  // A variable setting the speed scale for mouse motion, in floating point, when the mouse is not in relative mode.
 #define SDL_HINT_MOUSE_RELATIVE_MODE_CENTER ...                                                // A variable controlling whether relative mouse mode constrains the mouse to the center of the window.
 #define SDL_HINT_MOUSE_RELATIVE_MODE_WARP ...                                                  // A variable controlling whether relative mouse mode is implemented using mouse warping.
 #define SDL_HINT_MOUSE_RELATIVE_SPEED_SCALE ...                                                // A variable setting the scale for mouse motion, in floating point, when the mouse is in relative mode.
 #define SDL_HINT_MOUSE_RELATIVE_SYSTEM_SCALE ...                                               // A variable controlling whether the system mouse acceleration curve is used for relative mouse motion.
 #define SDL_HINT_MOUSE_RELATIVE_WARP_MOTION ...                                                // A variable controlling whether a motion event should be generated for mouse warping in relative mode.
 #define SDL_HINT_MOUSE_RELATIVE_CURSOR_VISIBLE ...                                             // A variable controlling whether the hardware cursor stays visible when relative mode is active.
 #define SDL_HINT_MOUSE_RELATIVE_CLIP_INTERVAL ...                                              // Controls how often SDL issues cursor confinement commands to the operating system while relative mode is active, in case the desired confinement state became out-of-sync due to interference from other running programs.
 #define SDL_HINT_MOUSE_TOUCH_EVENTS ...                                                        // A variable controlling whether mouse events should generate synthetic touch events.
 #define SDL_HINT_MUTE_CONSOLE_KEYBOARD ...                                                     // A variable controlling whether the keyboard should be muted on the console.
 #define SDL_HINT_NO_SIGNAL_HANDLERS ...                                                        // Tell SDL not to catch the SIGINT or SIGTERM signals on POSIX platforms.
 #define SDL_HINT_OPENGL_LIBRARY ...                                                            // Specify the OpenGL library to load.
 #define SDL_HINT_OPENGL_ES_DRIVER ...                                                          // A variable controlling what driver to use for OpenGL ES contexts.
 #define SDL_HINT_OPENVR_LIBRARY ...                                                            // Mechanism to specify openvr_api library location
 #define SDL_HINT_ORIENTATIONS ...                                                              // A variable controlling which orientations are allowed on iOS/Android.
 #define SDL_HINT_POLL_SENTINEL ...                                                             // A variable controlling the use of a sentinel event when polling the event queue.
 #define SDL_HINT_PREFERRED_LOCALES ...                                                         // Override for SDL_GetPreferredLocales().
 #define SDL_HINT_QUIT_ON_LAST_WINDOW_CLOSE ...                                                 // A variable that decides whether to send SDL_EVENT_QUIT when closing the last window.
 #define SDL_HINT_RENDER_DIRECT3D_THREADSAFE ...                                                // A variable controlling whether the Direct3D device is initialized for thread-safe operations.
 #define SDL_HINT_RENDER_DIRECT3D11_DEBUG ...                                                   // A variable controlling whether to enable Direct3D 11+'s Debug Layer.
 #define SDL_HINT_RENDER_VULKAN_DEBUG ...                                                       // A variable controlling whether to enable Vulkan Validation Layers.
 #define SDL_HINT_RENDER_GPU_DEBUG ...                                                          // A variable controlling whether to create the GPU device in debug mode.
 #define SDL_HINT_RENDER_GPU_LOW_POWER ...                                                      // A variable controlling whether to prefer a low-power GPU on multi-GPU systems.
 #define SDL_HINT_RENDER_DRIVER ...                                                             // A variable specifying which render driver to use.
 #define SDL_HINT_RENDER_LINE_METHOD ...                                                        // A variable controlling how the 2D render API renders lines.
 #define SDL_HINT_RENDER_METAL_PREFER_LOW_POWER_DEVICE ...                                      // A variable controlling whether the Metal render driver select low power device over default one.
 #define SDL_HINT_RENDER_VSYNC ...                                                              // A variable controlling whether updates to the SDL screen surface should be synchronized with the vertical refresh, to avoid tearing.
 #define SDL_HINT_RETURN_KEY_HIDES_IME ...                                                      // A variable to control whether the return key on the soft keyboard should hide the soft keyboard on Android and iOS.
 #define SDL_HINT_ROG_GAMEPAD_MICE ...                                                          // A variable containing a list of ROG gamepad capable mice.
 #define SDL_HINT_ROG_GAMEPAD_MICE_EXCLUDED ...                                                 // A variable containing a list of devices that are not ROG gamepad capable mice.
 #define SDL_HINT_RPI_VIDEO_LAYER ...                                                           // A variable controlling which Dispmanx layer to use on a Raspberry PI.
 #define SDL_HINT_SCREENSAVER_INHIBIT_ACTIVITY_NAME ...                                         // Specify an "activity name" for screensaver inhibition.
 #define SDL_HINT_SHUTDOWN_DBUS_ON_QUIT ...                                                     // A variable controlling whether SDL calls dbus_shutdown() on quit.
 #define SDL_HINT_STORAGE_TITLE_DRIVER ...                                                      // A variable that specifies a backend to use for title storage.
 #define SDL_HINT_STORAGE_USER_DRIVER ...                                                       // A variable that specifies a backend to use for user storage.
 #define SDL_HINT_THREAD_FORCE_REALTIME_TIME_CRITICAL ...                                       // Specifies whether SDL_THREAD_PRIORITY_TIME_CRITICAL should be treated as realtime.
 #define SDL_HINT_THREAD_PRIORITY_POLICY ...                                                    // A string specifying additional information to use with SDL_SetCurrentThreadPriority.
 #define SDL_HINT_TIMER_RESOLUTION ...                                                          // A variable that controls the timer resolution, in milliseconds.
 #define SDL_HINT_TOUCH_MOUSE_EVENTS ...                                                        // A variable controlling whether touch events should generate synthetic mouse events.
 #define SDL_HINT_TRACKPAD_IS_TOUCH_ONLY ...                                                    // A variable controlling whether trackpads should be treated as touch devices.
 #define SDL_HINT_TV_REMOTE_AS_JOYSTICK ...                                                     // A variable controlling whether the Android / tvOS remotes should be listed as joystick devices, instead of sending keyboard events.
 #define SDL_HINT_VIDEO_ALLOW_SCREENSAVER ...                                                   // A variable controlling whether the screensaver is enabled.
 #define SDL_HINT_VIDEO_DISPLAY_PRIORITY ...                                                    // A comma separated list containing the names of the displays that SDL should sort to the front of the display list.
 #define SDL_HINT_VIDEO_DOUBLE_BUFFER ...                                                       // Tell the video driver that we only want a double buffer.
 #define SDL_HINT_VIDEO_DRIVER ...                                                              // A variable that specifies a video backend to use.
 #define SDL_HINT_VIDEO_DUMMY_SAVE_FRAMES ...                                                   // A variable controlling whether the dummy video driver saves output frames.
 #define SDL_HINT_VIDEO_EGL_ALLOW_GETDISPLAY_FALLBACK ...                                       // If eglGetPlatformDisplay fails, fall back to calling eglGetDisplay.
 #define SDL_HINT_VIDEO_FORCE_EGL ...                                                           // A variable controlling whether the OpenGL context should be created with EGL.
 #define SDL_HINT_VIDEO_MAC_FULLSCREEN_SPACES ...                                               // A variable that specifies the policy for fullscreen Spaces on macOS.
 #define SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS ...                                              // A variable controlling whether fullscreen windows are minimized when they lose focus.
 #define SDL_HINT_VIDEO_OFFSCREEN_SAVE_FRAMES ...                                               // A variable controlling whether the offscreen video driver saves output frames.
 #define SDL_HINT_VIDEO_SYNC_WINDOW_OPERATIONS ...                                              // A variable controlling whether all window operations will block until complete.
 #define SDL_HINT_VIDEO_WAYLAND_ALLOW_LIBDECOR ...                                              // A variable controlling whether the libdecor Wayland backend is allowed to be used.
 #define SDL_HINT_VIDEO_WAYLAND_MODE_EMULATION ...                                              // A variable controlling whether video mode emulation is enabled under Wayland.
 #define SDL_HINT_VIDEO_WAYLAND_MODE_SCALING ...                                                // A variable controlling how modes with a non-native aspect ratio are displayed under Wayland.
 #define SDL_HINT_VIDEO_WAYLAND_PREFER_LIBDECOR ...                                             // A variable controlling whether the libdecor Wayland backend is preferred over native decorations.
 #define SDL_HINT_VIDEO_WAYLAND_SCALE_TO_DISPLAY ...                                            // A variable forcing non-DPI-aware Wayland windows to output at 1:1 scaling.
 #define SDL_HINT_VIDEO_WIN_D3DCOMPILER ...                                                     // A variable specifying which shader compiler to preload when using the Chrome ANGLE binaries.
 #define SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR ...                                        // A variable controlling whether the X11 _NET_WM_BYPASS_COMPOSITOR hint should be used.
 #define SDL_HINT_VIDEO_X11_NET_WM_PING ...                                                     // A variable controlling whether the X11 _NET_WM_PING protocol should be supported.
 #define SDL_HINT_VIDEO_X11_NODIRECTCOLOR ...                                                   // A variable controlling whether SDL uses DirectColor visuals.
 #define SDL_HINT_VIDEO_X11_SCALING_FACTOR ...                                                  // A variable forcing the content scaling factor for X11 displays.
 #define SDL_HINT_VIDEO_X11_VISUALID ...                                                        // A variable forcing the visual ID used for X11 display modes.
 #define SDL_HINT_VIDEO_X11_WINDOW_VISUALID ...                                                 // A variable forcing the visual ID chosen for new X11 windows.
 #define SDL_HINT_VIDEO_X11_XRANDR ...                                                          // A variable controlling whether the X11 XRandR extension should be used.
 #define SDL_HINT_VITA_ENABLE_BACK_TOUCH ...                                                    // A variable controlling whether touch should be enabled on the back panel of the PlayStation Vita.
 #define SDL_HINT_VITA_ENABLE_FRONT_TOUCH ...                                                   // A variable controlling whether touch should be enabled on the front panel of the PlayStation Vita.
 #define SDL_HINT_VITA_MODULE_PATH ...                                                          // A variable controlling the module path on the PlayStation Vita.
 #define SDL_HINT_VITA_PVR_INIT ...                                                             // A variable controlling whether to perform PVR initialization on the PlayStation Vita.
 #define SDL_HINT_VITA_RESOLUTION ...                                                           // A variable overriding the resolution reported on the PlayStation Vita.
 #define SDL_HINT_VITA_PVR_OPENGL ...                                                           // A variable controlling whether OpenGL should be used instead of OpenGL ES on the PlayStation Vita.
 #define SDL_HINT_VITA_TOUCH_MOUSE_DEVICE ...                                                   // A variable controlling which touchpad should generate synthetic mouse events.
 #define SDL_HINT_VULKAN_DISPLAY ...                                                            // A variable overriding the display index used in SDL_Vulkan_CreateSurface()
 #define SDL_HINT_VULKAN_LIBRARY ...                                                            // Specify the Vulkan library to load.
 #define SDL_HINT_WAVE_FACT_CHUNK ...                                                           // A variable controlling how the fact chunk affects the loading of a WAVE file.
 #define SDL_HINT_WAVE_CHUNK_LIMIT ...                                                          // A variable controlling the maximum number of chunks in a WAVE file.
 #define SDL_HINT_WAVE_RIFF_CHUNK_SIZE ...                                                      // A variable controlling how the size of the RIFF chunk affects the loading of a WAVE file.
 #define SDL_HINT_WAVE_TRUNCATION ...                                                           // A variable controlling how a truncated WAVE file is handled.
 #define SDL_HINT_WINDOW_ACTIVATE_WHEN_RAISED ...                                               // A variable controlling whether the window is activated when the SDL_RaiseWindow function is called.
 #define SDL_HINT_WINDOW_ACTIVATE_WHEN_SHOWN ...                                                // A variable controlling whether the window is activated when the SDL_ShowWindow function is called.
 #define SDL_HINT_WINDOW_ALLOW_TOPMOST ...                                                      // If set to "0" then never set the top-most flag on an SDL Window even if the application requests it.
 #define SDL_HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN ...                                   // A variable controlling whether the window frame and title bar are interactive when the cursor is hidden.
 #define SDL_HINT_WINDOWS_CLOSE_ON_ALT_F4 ...                                                   // A variable controlling whether SDL generates window-close events for Alt+F4 on Windows.
 #define SDL_HINT_WINDOWS_ENABLE_MENU_MNEMONICS ...                                             // A variable controlling whether menus can be opened with their keyboard shortcut (Alt+mnemonic).
 #define SDL_HINT_WINDOWS_ENABLE_MESSAGELOOP ...                                                // A variable controlling whether the windows message loop is processed by SDL.
 #define SDL_HINT_WINDOWS_GAMEINPUT ...                                                         // A variable controlling whether GameInput is used for raw keyboard and mouse on Windows.
 #define SDL_HINT_WINDOWS_RAW_KEYBOARD ...                                                      // A variable controlling whether raw keyboard events are used on Windows.
 #define SDL_HINT_WINDOWS_FORCE_SEMAPHORE_KERNEL ...                                            // A variable controlling whether SDL uses Kernel Semaphores on Windows.
 #define SDL_HINT_WINDOWS_INTRESOURCE_ICON ...                                                  // A variable to specify custom icon resource id from RC file on Windows platform.
 #define SDL_HINT_WINDOWS_USE_D3D9EX ...                                                        // A variable controlling whether SDL uses the D3D9Ex API introduced in Windows Vista, instead of normal D3D9.
 #define SDL_HINT_WINDOWS_ERASE_BACKGROUND_MODE ...                                             // A variable controlling whether SDL will clear the window contents when the WM_ERASEBKGND message is received.
 #define SDL_HINT_X11_FORCE_OVERRIDE_REDIRECT ...                                               // A variable controlling whether X11 windows are marked as override-redirect.
 #define SDL_HINT_X11_WINDOW_TYPE ...                                                           // A variable specifying the type of an X11 window.
 #define SDL_HINT_X11_XCB_LIBRARY ...                                                           // Specify the XCB library to load for the X11 driver.
 #define SDL_HINT_XINPUT_ENABLED ...                                                            // A variable controlling whether XInput should be used for controller handling.
 #define SDL_HINT_ASSERT ...                                                                    // A variable controlling response to SDL_assert failures.
 #define SDL_REVISION ...  // This macro is a string describing the source at a particular point in development.
 #define SDL_PROP_GLOBAL_VIDEO_WAYLAND_WL_DISPLAY_POINTER ...                                                                                                                                          // The pointer to the global `wl_display` object used by the Wayland video backend.
 #define SDL_WINDOWPOS_UNDEFINED_MASK ...                                                                                                                                                              // Used to indicate that you don't care what the window position is.
 #define SDL_WINDOWPOS_CENTERED_MASK ...                                                                                                                                                               // Used to indicate that the window position should be centered.
 #define SDL_JOYSTICK_AXIS_MAX ...                                                                                                                 // The largest value an SDL_Joystick's axis can report.
 #define SDL_JOYSTICK_AXIS_MIN ...                                                                                                                 // The smallest value an SDL_Joystick's axis can report.
 #define SDL_HAPTIC_CONSTANT ...                                                             // Constant effect supported.
 #define SDL_HAPTIC_SINE ...                                                                 // Sine wave effect supported.
 #define SDL_HAPTIC_SQUARE ...                                                               // Square wave effect supported.
 #define SDL_HAPTIC_TRIANGLE ...                                                             // Triangle wave effect supported.
 #define SDL_HAPTIC_SAWTOOTHUP ...                                                           // Sawtoothup wave effect supported.
 #define SDL_HAPTIC_SAWTOOTHDOWN ...                                                         // Sawtoothdown wave effect supported.
 #define SDL_HAPTIC_RAMP ...                                                                 // Ramp effect supported.
 #define SDL_HAPTIC_SPRING ...                                                               // Spring effect supported - uses axes position.
 #define SDL_HAPTIC_DAMPER ...                                                               // Damper effect supported - uses axes velocity.
 #define SDL_HAPTIC_INERTIA ...                                                              // Inertia effect supported - uses axes acceleration.
 #define SDL_HAPTIC_FRICTION ...                                                             // Friction effect supported - uses axes movement.
 #define SDL_HAPTIC_LEFTRIGHT ...                                                            // Left/Right effect supported.
 #define SDL_HAPTIC_RESERVED1 ...                                                            // Reserved for future use
 #define SDL_HAPTIC_CUSTOM ...                                                               // Custom effect is supported.
 #define SDL_HAPTIC_GAIN ...                                                                 // Device can set global gain.
 #define SDL_HAPTIC_AUTOCENTER ...                                                           // Device can set autocenter.
 #define SDL_HAPTIC_STATUS ...                                                               // Device can be queried for effect status.
 #define SDL_HAPTIC_PAUSE ...                                                                // Device can be paused.
 #define SDL_HAPTIC_POLAR ...                                                                // Uses polar coordinates for the direction.
 #define SDL_HAPTIC_CARTESIAN ...                                                            // Uses cartesian coordinates for the direction.
 #define SDL_HAPTIC_SPHERICAL ...                                                            // Uses spherical coordinates for the direction.
 #define SDL_HAPTIC_STEERING_AXIS ...                                                        // Use this value to play an effect on the steering wheel axis.
 #define SDL_HAPTIC_INFINITY ...                                                             // Used to play a device an infinite number of times.
 #define SDL_AUDIO_BITSIZE ...                                                                                                                                    // Retrieve the size, in bits, from an SDL_AudioFormat.
 #define SDL_AUDIO_BYTESIZE ...                                                                                                                                   // Retrieve the size, in bytes, from an SDL_AudioFormat.
 #define SDL_AUDIO_ISFLOAT ...                                                                                                                                    // Determine if an SDL_AudioFormat represents floating point data.
 #define SDL_AUDIO_ISBIGENDIAN ...                                                                                                                                // Determine if an SDL_AudioFormat represents bigendian data.
 #define SDL_AUDIO_ISLITTLEENDIAN ...                                                                                                                             // Determine if an SDL_AudioFormat represents littleendian data.
 #define SDL_AUDIO_ISSIGNED ...                                                                                                                                   // Determine if an SDL_AudioFormat represents signed data.
 #define SDL_AUDIO_ISINT ...                                                                                                                                      // Determine if an SDL_AudioFormat represents integer data.
 #define SDL_AUDIO_ISUNSIGNED ...                                                                                                                                 // Determine if an SDL_AudioFormat represents unsigned data.
 #define SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK ...                                                                                                                    // A value used to request a default playback audio device.
 #define SDL_AUDIO_DEVICE_DEFAULT_RECORDING ...                                                                                                                   // A value used to request a default recording audio device.
 #define SDL_AUDIO_FRAMESIZE ...                                                                                                                                  // Calculate the size of each audio frame (in bytes) from an SDL_AudioSpec.
 #define SDL_SOFTWARE_RENDERER ...                                                                                                                                                                                                                               // The name of the software renderer.
 #define SDL_DEBUG_TEXT_FONT_CHARACTER_SIZE ...                                                                                                                                                                                                                  // The size, in pixels, of a single SDL_RenderDebugText() character.
 #define SDL_CompilerBarrier ...                                                    // Mark a compiler barrier.
 #define SDL_CPUPauseInstruction ...                                                // A macro to insert a CPU-specific "pause" instruction into the program.
 #define SDL_AtomicIncRef ...                                                       // Increment an atomic variable used as a reference count.
 #define SDL_AtomicDecRef ...                                                       // Decrement an atomic variable used as a reference count.
 #define SDL_ALPHA_OPAQUE ...                                                                                                               // A fully opaque 8-bit alpha value.
 #define SDL_ALPHA_OPAQUE_FLOAT ...                                                                                                         // A fully opaque floating point alpha value.
 #define SDL_ALPHA_TRANSPARENT ...                                                                                                          // A fully transparent 8-bit alpha value.
 #define SDL_ALPHA_TRANSPARENT_FLOAT ...                                                                                                    // A fully transparent floating point alpha value.
 #define SDL_MUSTLOCK ...                                                                                                                                                                                                                                                                                       // Evaluates to true if the surface needs to be locked before access.
 #define SDL_PLATFORM_AIX ...         // A preprocessor macro that is only defined if compiling for AIX.
 #define SDL_PLATFORM_HAIKU ...       // A preprocessor macro that is only defined if compiling for Haiku OS.
 #define SDL_PLATFORM_BSDI ...        // A preprocessor macro that is only defined if compiling for BSDi
 #define SDL_PLATFORM_FREEBSD ...     // A preprocessor macro that is only defined if compiling for FreeBSD.
 #define SDL_PLATFORM_HPUX ...        // A preprocessor macro that is only defined if compiling for HP-UX.
 #define SDL_PLATFORM_IRIX ...        // A preprocessor macro that is only defined if compiling for IRIX.
 #define SDL_PLATFORM_LINUX ...       // A preprocessor macro that is only defined if compiling for Linux.
 #define SDL_PLATFORM_ANDROID ...     // A preprocessor macro that is only defined if compiling for Android.
 #define SDL_PLATFORM_NGAGE ...       // A preprocessor macro that is only defined if compiling for Nokia N-Gage.
 #define SDL_PLATFORM_UNIX ...        // A preprocessor macro that is only defined if compiling for a Unix-like system.
 #define SDL_PLATFORM_APPLE ...       // A preprocessor macro that is only defined if compiling for Apple platforms.
 #define SDL_PLATFORM_TVOS ...        // A preprocessor macro that is only defined if compiling for tvOS.
 #define SDL_PLATFORM_VISIONOS ...    // A preprocessor macro that is only defined if compiling for VisionOS.
 #define SDL_PLATFORM_IOS ...         // A preprocessor macro that is only defined if compiling for iOS.
 #define SDL_PLATFORM_MACOS ...       // A preprocessor macro that is only defined if compiling for macOS.
 #define SDL_PLATFORM_EMSCRIPTEN ...  // A preprocessor macro that is only defined if compiling for Emscripten.
 #define SDL_PLATFORM_NETBSD ...      // A preprocessor macro that is only defined if compiling for NetBSD.
 #define SDL_PLATFORM_OPENBSD ...     // A preprocessor macro that is only defined if compiling for OpenBSD.
 #define SDL_PLATFORM_OS2 ...         // A preprocessor macro that is only defined if compiling for OS/2.
 #define SDL_PLATFORM_OSF ...         // A preprocessor macro that is only defined if compiling for Tru64 (OSF/1).
 #define SDL_PLATFORM_QNXNTO ...      // A preprocessor macro that is only defined if compiling for QNX Neutrino.
 #define SDL_PLATFORM_RISCOS ...      // A preprocessor macro that is only defined if compiling for RISC OS.
 #define SDL_PLATFORM_SOLARIS ...     // A preprocessor macro that is only defined if compiling for SunOS/Solaris.
 #define SDL_PLATFORM_CYGWIN ...      // A preprocessor macro that is only defined if compiling for Cygwin.
 #define SDL_PLATFORM_WINDOWS ...     // A preprocessor macro that is only defined if compiling for Windows.
 #define SDL_PLATFORM_WINGDK ...      // A preprocessor macro that is only defined if compiling for Microsoft GDK for Windows.
 #define SDL_PLATFORM_XBOXONE ...     // A preprocessor macro that is only defined if compiling for Xbox One.
 #define SDL_PLATFORM_XBOXSERIES ...  // A preprocessor macro that is only defined if compiling for Xbox Series.
 #define SDL_PLATFORM_WIN32 ...       // A preprocessor macro that is only defined if compiling for desktop Windows.
 #define SDL_PLATFORM_GDK ...         // A preprocessor macro that is only defined if compiling for Microsoft GDK on any platform.
 #define SDL_PLATFORM_PSP ...         // A preprocessor macro that is only defined if compiling for Sony PSP.
 #define SDL_PLATFORM_PS2 ...         // A preprocessor macro that is only defined if compiling for Sony PlayStation 2.
 #define SDL_PLATFORM_VITA ...        // A preprocessor macro that is only defined if compiling for Sony Vita.
 #define SDL_PLATFORM_3DS ...         // A preprocessor macro that is only defined if compiling for Nintendo 3DS.
 #define SDL_STANDARD_GRAVITY ...                                          // A constant to represent standard gravity for accelerometer sensors.
 #define SDL_Swap16LE ...       // Swap a 16-bit value from littleendian to native byte order.
 #define SDL_Swap32LE ...       // Swap a 32-bit value from littleendian to native byte order.
 #define SDL_Swap64LE ...       // Swap a 64-bit value from littleendian to native byte order.
 #define SDL_SwapFloatLE ...    // Swap a floating point value from littleendian to native byte order.
 #define SDL_Swap16BE ...       // Swap a 16-bit value from bigendian to native byte order.
 #define SDL_Swap32BE ...       // Swap a 32-bit value from bigendian to native byte order.
 #define SDL_Swap64BE ...       // Swap a 64-bit value from bigendian to native byte order.
 #define SDL_SwapFloatBE ...    // Swap a floating point value from bigendian to native byte order.
 #define SDL_ASSERT_LEVEL ...                                                                              // The level of assertion aggressiveness.
 #define SDL_TriggerBreakpoint ...                                                                         // Attempt to tell an attached debugger to pause.
 #define SDL_assert ...                                                                                    // An assertion test that is normally performed only in debug builds.
 #define SDL_assert_release ...                                                                            // An assertion test that is performed even in release builds.
 #define SDL_assert_paranoid ...                                                                           // An assertion test that is performed only when built with paranoid settings.
 #define SDL_assert_always ...                                                                             // An assertion test that is always performed.
 #define SDL_CACHELINE_SIZE ...        // A guess for the cacheline size used for padding.
 #define SDL_ANDROID_EXTERNAL_STORAGE_READ ...                                                                                // See the official Android developer guide for more information: http://developer.android.com/guide/topics/data/data-storage.html
 #define SDL_MAIN_USE_CALLBACKS ...                                                                                                                                  // Inform SDL to use the main callbacks instead of main.
 #define SDL_arraysize ...                                                                                                                                   // The number of elements in an array.
 #define SDL_STRINGIFY_ARG ...                                                                                                                               // Macro useful for building other macros with strings in them.
 #define SDL_reinterpret_cast ...                                                                                                                            // Handle a Reinterpret Cast properly whether using C or C++.
 #define SDL_static_cast ...                                                                                                                                 // Handle a Static Cast properly whether using C or C++.
 #define SDL_const_cast ...                                                                                                                                  // Handle a Const Cast properly whether using C or C++.
 #define SDL_FOURCC ...                                                                                                                                      // Define a four character code as a Uint32.
 #define SDL_SINT64_C ...                                                                                                                                    // Append the 64 bit integer suffix to a signed integer literal.
 #define SDL_UINT64_C ...                                                                                                                                    // Append the 64 bit integer suffix to an unsigned integer literal.
 #define SDL_FLT_EPSILON ...                                                                                                                                 // Epsilon constant, used for comparing floating-point numbers.
 #define SDL_INIT_INTERFACE ...                                                                                                                              // A macro to initialize an SDL interface.
 #define SDL_INVALID_UNICODE_CODEPOINT ...                                                                                                                   // The Unicode REPLACEMENT CHARACTER codepoint.