From 5a079a2d114f96d4847d1ee305d5b7c16eeec50e Mon Sep 17 00:00:00 2001 From: 3gg <3gg@shellblade.net> Date: Sat, 27 Dec 2025 12:03:39 -0800 Subject: Initial commit --- contrib/SDL-3.2.8/src/dynapi/SDL_dynapi.c | 611 ++++++++++ contrib/SDL-3.2.8/src/dynapi/SDL_dynapi.h | 75 ++ contrib/SDL-3.2.8/src/dynapi/SDL_dynapi.sym | 1239 +++++++++++++++++++ .../SDL-3.2.8/src/dynapi/SDL_dynapi_overrides.h | 1261 +++++++++++++++++++ contrib/SDL-3.2.8/src/dynapi/SDL_dynapi_procs.h | 1269 ++++++++++++++++++++ .../SDL-3.2.8/src/dynapi/SDL_dynapi_unsupported.h | 52 + contrib/SDL-3.2.8/src/dynapi/gendynapi.py | 547 +++++++++ 7 files changed, 5054 insertions(+) create mode 100644 contrib/SDL-3.2.8/src/dynapi/SDL_dynapi.c create mode 100644 contrib/SDL-3.2.8/src/dynapi/SDL_dynapi.h create mode 100644 contrib/SDL-3.2.8/src/dynapi/SDL_dynapi.sym create mode 100644 contrib/SDL-3.2.8/src/dynapi/SDL_dynapi_overrides.h create mode 100644 contrib/SDL-3.2.8/src/dynapi/SDL_dynapi_procs.h create mode 100644 contrib/SDL-3.2.8/src/dynapi/SDL_dynapi_unsupported.h create mode 100755 contrib/SDL-3.2.8/src/dynapi/gendynapi.py (limited to 'contrib/SDL-3.2.8/src/dynapi') diff --git a/contrib/SDL-3.2.8/src/dynapi/SDL_dynapi.c b/contrib/SDL-3.2.8/src/dynapi/SDL_dynapi.c new file mode 100644 index 0000000..a7b51af --- /dev/null +++ b/contrib/SDL-3.2.8/src/dynapi/SDL_dynapi.c @@ -0,0 +1,611 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +#include "SDL_build_config.h" +#include "SDL_dynapi.h" +#include "SDL_dynapi_unsupported.h" + +#if SDL_DYNAMIC_API + +#define SDL_DYNAMIC_API_ENVVAR "SDL3_DYNAMIC_API" +#define SDL_SLOW_MEMCPY +#define SDL_SLOW_MEMMOVE +#define SDL_SLOW_MEMSET + +#ifdef HAVE_STDIO_H +#include +#endif +#ifdef HAVE_STDLIB_H +#include +#endif + +#include +#define SDL_MAIN_NOIMPL // don't drag in header-only implementation of SDL_main +#include + + +// These headers have system specific definitions, so aren't included above +#include + +#if defined(WIN32) || defined(_WIN32) || defined(SDL_PLATFORM_CYGWIN) +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN 1 +#endif +#include +#endif + +/* This is the version of the dynamic API. This doesn't match the SDL version + and should not change until there's been a major revamp in API/ABI. + So 2.0.5 adds functions over 2.0.4? This number doesn't change; + the sizeof(jump_table) changes instead. But 2.1.0 changes how a function + works in an incompatible way or removes a function? This number changes, + since sizeof(jump_table) isn't sufficient anymore. It's likely + we'll forget to bump every time we add a function, so this is the + failsafe switch for major API change decisions. Respect it and use it + sparingly. */ +#define SDL_DYNAPI_VERSION 2 + +#ifdef __cplusplus +extern "C" { +#endif + +static void SDL_InitDynamicAPI(void); + +/* BE CAREFUL CALLING ANY SDL CODE IN HERE, IT WILL BLOW UP. + Even self-contained stuff might call SDL_SetError() and break everything. */ + +// behold, the macro salsa! + +// Can't use the macro for varargs nonsense. This is atrocious. +#define SDL_DYNAPI_VARARGS_LOGFN(_static, name, initcall, logname, prio) \ + _static void SDLCALL SDL_Log##logname##name(int category, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) \ + { \ + va_list ap; \ + initcall; \ + va_start(ap, fmt); \ + jump_table.SDL_LogMessageV(category, SDL_LOG_PRIORITY_##prio, fmt, ap); \ + va_end(ap); \ + } + +#define SDL_DYNAPI_VARARGS(_static, name, initcall) \ + _static bool SDLCALL SDL_SetError##name(SDL_PRINTF_FORMAT_STRING const char *fmt, ...) \ + { \ + char buf[128], *str = buf; \ + int result; \ + va_list ap; \ + initcall; \ + va_start(ap, fmt); \ + result = jump_table.SDL_vsnprintf(buf, sizeof(buf), fmt, ap); \ + va_end(ap); \ + if (result >= 0 && (size_t)result >= sizeof(buf)) { \ + str = NULL; \ + va_start(ap, fmt); \ + result = jump_table.SDL_vasprintf(&str, fmt, ap); \ + va_end(ap); \ + } \ + if (result >= 0) { \ + jump_table.SDL_SetError("%s", str); \ + } \ + if (str != buf) { \ + jump_table.SDL_free(str); \ + } \ + return false; \ + } \ + _static int SDLCALL SDL_sscanf##name(const char *buf, SDL_SCANF_FORMAT_STRING const char *fmt, ...) \ + { \ + int result; \ + va_list ap; \ + initcall; \ + va_start(ap, fmt); \ + result = jump_table.SDL_vsscanf(buf, fmt, ap); \ + va_end(ap); \ + return result; \ + } \ + _static int SDLCALL SDL_snprintf##name(SDL_OUT_Z_CAP(maxlen) char *buf, size_t maxlen, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) \ + { \ + int result; \ + va_list ap; \ + initcall; \ + va_start(ap, fmt); \ + result = jump_table.SDL_vsnprintf(buf, maxlen, fmt, ap); \ + va_end(ap); \ + return result; \ + } \ + _static int SDLCALL SDL_swprintf##name(SDL_OUT_Z_CAP(maxlen) wchar_t *buf, size_t maxlen, SDL_PRINTF_FORMAT_STRING const wchar_t *fmt, ...) \ + { \ + int result; \ + va_list ap; \ + initcall; \ + va_start(ap, fmt); \ + result = jump_table.SDL_vswprintf(buf, maxlen, fmt, ap); \ + va_end(ap); \ + return result; \ + } \ + _static int SDLCALL SDL_asprintf##name(char **strp, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) \ + { \ + int result; \ + va_list ap; \ + initcall; \ + va_start(ap, fmt); \ + result = jump_table.SDL_vasprintf(strp, fmt, ap); \ + va_end(ap); \ + return result; \ + } \ + _static size_t SDLCALL SDL_IOprintf##name(SDL_IOStream *context, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) \ + { \ + size_t result; \ + va_list ap; \ + initcall; \ + va_start(ap, fmt); \ + result = jump_table.SDL_IOvprintf(context, fmt, ap); \ + va_end(ap); \ + return result; \ + } \ + _static bool SDLCALL SDL_RenderDebugTextFormat##name(SDL_Renderer *renderer, float x, float y, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) \ + { \ + char buf[128], *str = buf; \ + int result; \ + va_list ap; \ + initcall; \ + va_start(ap, fmt); \ + result = jump_table.SDL_vsnprintf(buf, sizeof(buf), fmt, ap); \ + va_end(ap); \ + if (result >= 0 && (size_t)result >= sizeof(buf)) { \ + str = NULL; \ + va_start(ap, fmt); \ + result = jump_table.SDL_vasprintf(&str, fmt, ap); \ + va_end(ap); \ + } \ + bool retval = false; \ + if (result >= 0) { \ + retval = jump_table.SDL_RenderDebugTextFormat(renderer, x, y, "%s", str); \ + } \ + if (str != buf) { \ + jump_table.SDL_free(str); \ + } \ + return retval; \ + } \ + _static void SDLCALL SDL_Log##name(SDL_PRINTF_FORMAT_STRING const char *fmt, ...) \ + { \ + va_list ap; \ + initcall; \ + va_start(ap, fmt); \ + jump_table.SDL_LogMessageV(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO, fmt, ap); \ + va_end(ap); \ + } \ + _static void SDLCALL SDL_LogMessage##name(int category, SDL_LogPriority priority, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) \ + { \ + va_list ap; \ + initcall; \ + va_start(ap, fmt); \ + jump_table.SDL_LogMessageV(category, priority, fmt, ap); \ + va_end(ap); \ + } \ + SDL_DYNAPI_VARARGS_LOGFN(_static, name, initcall, Trace, TRACE) \ + SDL_DYNAPI_VARARGS_LOGFN(_static, name, initcall, Verbose, VERBOSE) \ + SDL_DYNAPI_VARARGS_LOGFN(_static, name, initcall, Debug, DEBUG) \ + SDL_DYNAPI_VARARGS_LOGFN(_static, name, initcall, Info, INFO) \ + SDL_DYNAPI_VARARGS_LOGFN(_static, name, initcall, Warn, WARN) \ + SDL_DYNAPI_VARARGS_LOGFN(_static, name, initcall, Error, ERROR) \ + SDL_DYNAPI_VARARGS_LOGFN(_static, name, initcall, Critical, CRITICAL) + +// Typedefs for function pointers for jump table, and predeclare funcs +// The DEFAULT funcs will init jump table and then call real function. +// The REAL funcs are the actual functions, name-mangled to not clash. +#define SDL_DYNAPI_PROC(rc, fn, params, args, ret) \ + typedef rc (SDLCALL *SDL_DYNAPIFN_##fn) params;\ + static rc SDLCALL fn##_DEFAULT params; \ + extern rc SDLCALL fn##_REAL params; +#include "SDL_dynapi_procs.h" +#undef SDL_DYNAPI_PROC + +// The jump table! +typedef struct +{ +#define SDL_DYNAPI_PROC(rc, fn, params, args, ret) SDL_DYNAPIFN_##fn fn; +#include "SDL_dynapi_procs.h" +#undef SDL_DYNAPI_PROC +} SDL_DYNAPI_jump_table; + +// The actual jump table. +static SDL_DYNAPI_jump_table jump_table = { +#define SDL_DYNAPI_PROC(rc, fn, params, args, ret) fn##_DEFAULT, +#include "SDL_dynapi_procs.h" +#undef SDL_DYNAPI_PROC +}; + +// Default functions init the function table then call right thing. +#define SDL_DYNAPI_PROC(rc, fn, params, args, ret) \ + static rc SDLCALL fn##_DEFAULT params \ + { \ + SDL_InitDynamicAPI(); \ + ret jump_table.fn args; \ + } +#define SDL_DYNAPI_PROC_NO_VARARGS 1 +#include "SDL_dynapi_procs.h" +#undef SDL_DYNAPI_PROC +#undef SDL_DYNAPI_PROC_NO_VARARGS +SDL_DYNAPI_VARARGS(static, _DEFAULT, SDL_InitDynamicAPI()) + +// Public API functions to jump into the jump table. +#define SDL_DYNAPI_PROC(rc, fn, params, args, ret) \ + rc SDLCALL fn params \ + { \ + ret jump_table.fn args; \ + } +#define SDL_DYNAPI_PROC_NO_VARARGS 1 +#include "SDL_dynapi_procs.h" +#undef SDL_DYNAPI_PROC +#undef SDL_DYNAPI_PROC_NO_VARARGS +SDL_DYNAPI_VARARGS(, , ) + +#define ENABLE_SDL_CALL_LOGGING 0 +#if ENABLE_SDL_CALL_LOGGING +static bool SDLCALL SDL_SetError_LOGSDLCALLS(SDL_PRINTF_FORMAT_STRING const char *fmt, ...) +{ + char buf[512]; // !!! FIXME: dynamic allocation + va_list ap; + SDL_Log_REAL("SDL3CALL SDL_SetError"); + va_start(ap, fmt); + SDL_vsnprintf_REAL(buf, sizeof(buf), fmt, ap); + va_end(ap); + return SDL_SetError_REAL("%s", buf); +} +static int SDLCALL SDL_sscanf_LOGSDLCALLS(const char *buf, SDL_SCANF_FORMAT_STRING const char *fmt, ...) +{ + int result; + va_list ap; + SDL_Log_REAL("SDL3CALL SDL_sscanf"); + va_start(ap, fmt); + result = SDL_vsscanf_REAL(buf, fmt, ap); + va_end(ap); + return result; +} +static int SDLCALL SDL_snprintf_LOGSDLCALLS(SDL_OUT_Z_CAP(maxlen) char *buf, size_t maxlen, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) +{ + int result; + va_list ap; + SDL_Log_REAL("SDL3CALL SDL_snprintf"); + va_start(ap, fmt); + result = SDL_vsnprintf_REAL(buf, maxlen, fmt, ap); + va_end(ap); + return result; +} +static int SDLCALL SDL_asprintf_LOGSDLCALLS(char **strp, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) +{ + int result; + va_list ap; + SDL_Log_REAL("SDL3CALL SDL_asprintf"); + va_start(ap, fmt); + result = SDL_vasprintf_REAL(strp, fmt, ap); + va_end(ap); + return result; +} +static int SDLCALL SDL_swprintf_LOGSDLCALLS(SDL_OUT_Z_CAP(maxlen) wchar_t *buf, size_t maxlen, SDL_PRINTF_FORMAT_STRING const wchar_t *fmt, ...) +{ + int result; + va_list ap; + SDL_Log_REAL("SDL3CALL SDL_swprintf"); + va_start(ap, fmt); + result = SDL_vswprintf_REAL(buf, maxlen, fmt, ap); + va_end(ap); + return result; +} +static size_t SDLCALL SDL_IOprintf_LOGSDLCALLS(SDL_IOStream *context, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) +{ + size_t result; + va_list ap; + SDL_Log_REAL("SDL3CALL SDL_IOprintf"); + va_start(ap, fmt); + result = SDL_IOvprintf_REAL(context, fmt, ap); + va_end(ap); + return result; +} +static bool SDLCALL SDL_RenderDebugTextFormat_LOGSDLCALLS(SDL_Renderer *renderer, float x, float y, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) +{ + char buf[128], *str = buf; + int result; + va_list ap; + SDL_Log_REAL("SDL3CALL SDL_RenderDebugTextFormat"); + va_start(ap, fmt); + result = jump_table.SDL_vsnprintf(buf, sizeof(buf), fmt, ap); + va_end(ap); + if (result >= 0 && (size_t)result >= sizeof(buf)) { + str = NULL; + va_start(ap, fmt); + result = SDL_vasprintf_REAL(&str, fmt, ap); + va_end(ap); + } + bool retval = false; + if (result >= 0) { + retval = SDL_RenderDebugTextFormat_REAL(renderer, x, y, "%s", str); + } + if (str != buf) { + jump_table.SDL_free(str); + } + return retval; +} +static void SDLCALL SDL_Log_LOGSDLCALLS(SDL_PRINTF_FORMAT_STRING const char *fmt, ...) +{ + va_list ap; + SDL_Log_REAL("SDL3CALL SDL_Log"); + va_start(ap, fmt); + SDL_LogMessageV_REAL(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO, fmt, ap); + va_end(ap); +} +static void SDLCALL SDL_LogMessage_LOGSDLCALLS(int category, SDL_LogPriority priority, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) +{ + va_list ap; + SDL_Log_REAL("SDL3CALL SDL_LogMessage"); + va_start(ap, fmt); + SDL_LogMessageV_REAL(category, priority, fmt, ap); + va_end(ap); +} +#define SDL_DYNAPI_VARARGS_LOGFN_LOGSDLCALLS(logname, prio) \ + static void SDLCALL SDL_Log##logname##_LOGSDLCALLS(int category, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) \ + { \ + va_list ap; \ + va_start(ap, fmt); \ + SDL_Log_REAL("SDL3CALL SDL_Log%s", #logname); \ + SDL_LogMessageV_REAL(category, SDL_LOG_PRIORITY_##prio, fmt, ap); \ + va_end(ap); \ + } +SDL_DYNAPI_VARARGS_LOGFN_LOGSDLCALLS(Trace, TRACE) +SDL_DYNAPI_VARARGS_LOGFN_LOGSDLCALLS(Verbose, VERBOSE) +SDL_DYNAPI_VARARGS_LOGFN_LOGSDLCALLS(Debug, DEBUG) +SDL_DYNAPI_VARARGS_LOGFN_LOGSDLCALLS(Info, INFO) +SDL_DYNAPI_VARARGS_LOGFN_LOGSDLCALLS(Warn, WARN) +SDL_DYNAPI_VARARGS_LOGFN_LOGSDLCALLS(Error, ERROR) +SDL_DYNAPI_VARARGS_LOGFN_LOGSDLCALLS(Critical, CRITICAL) +#define SDL_DYNAPI_PROC(rc, fn, params, args, ret) \ + rc SDLCALL fn##_LOGSDLCALLS params \ + { \ + SDL_Log_REAL("SDL3CALL %s", #fn); \ + ret fn##_REAL args; \ + } +#define SDL_DYNAPI_PROC_NO_VARARGS 1 +#include "SDL_dynapi_procs.h" +#undef SDL_DYNAPI_PROC +#undef SDL_DYNAPI_PROC_NO_VARARGS +#endif + +/* we make this a static function so we can call the correct one without the + system's dynamic linker resolving to the wrong version of this. */ +static Sint32 initialize_jumptable(Uint32 apiver, void *table, Uint32 tablesize) +{ + SDL_DYNAPI_jump_table *output_jump_table = (SDL_DYNAPI_jump_table *)table; + + if (apiver != SDL_DYNAPI_VERSION) { + // !!! FIXME: can maybe handle older versions? + return -1; // not compatible. + } else if (tablesize > sizeof(jump_table)) { + return -1; // newer version of SDL with functions we can't provide. + } + +// Init our jump table first. +#if ENABLE_SDL_CALL_LOGGING + { + const char *env = SDL_getenv_unsafe_REAL("SDL_DYNAPI_LOG_CALLS"); + const bool log_calls = (env && SDL_atoi_REAL(env)); + if (log_calls) { +#define SDL_DYNAPI_PROC(rc, fn, params, args, ret) jump_table.fn = fn##_LOGSDLCALLS; +#include "SDL_dynapi_procs.h" +#undef SDL_DYNAPI_PROC + } else { +#define SDL_DYNAPI_PROC(rc, fn, params, args, ret) jump_table.fn = fn##_REAL; +#include "SDL_dynapi_procs.h" +#undef SDL_DYNAPI_PROC + } + } +#else +#define SDL_DYNAPI_PROC(rc, fn, params, args, ret) jump_table.fn = fn##_REAL; +#include "SDL_dynapi_procs.h" +#undef SDL_DYNAPI_PROC +#endif + + // Then the external table... + if (output_jump_table != &jump_table) { + jump_table.SDL_memcpy(output_jump_table, &jump_table, tablesize); + } + + // Safe to call SDL functions now; jump table is initialized! + + return 0; // success! +} + +// Here's the exported entry point that fills in the jump table. +// Use specific types when an "int" might suffice to keep this sane. +typedef Sint32 (SDLCALL *SDL_DYNAPI_ENTRYFN)(Uint32 apiver, void *table, Uint32 tablesize); +extern SDL_DECLSPEC Sint32 SDLCALL SDL_DYNAPI_entry(Uint32, void *, Uint32); + +Sint32 SDL_DYNAPI_entry(Uint32 apiver, void *table, Uint32 tablesize) +{ + return initialize_jumptable(apiver, table, tablesize); +} + +#ifdef __cplusplus +} +#endif + +// Obviously we can't use SDL_LoadObject() to load SDL. :) +// Also obviously, we never close the loaded library. +#if defined(WIN32) || defined(_WIN32) || defined(SDL_PLATFORM_CYGWIN) +static SDL_INLINE void *get_sdlapi_entry(const char *fname, const char *sym) +{ + HMODULE lib = LoadLibraryA(fname); + void *result = NULL; + if (lib) { + result = (void *) GetProcAddress(lib, sym); + if (!result) { + FreeLibrary(lib); + } + } + return result; +} + +#elif defined(SDL_PLATFORM_UNIX) || defined(SDL_PLATFORM_APPLE) || defined(SDL_PLATFORM_HAIKU) +#include +static SDL_INLINE void *get_sdlapi_entry(const char *fname, const char *sym) +{ + void *lib = dlopen(fname, RTLD_NOW | RTLD_LOCAL); + void *result = NULL; + if (lib) { + result = dlsym(lib, sym); + if (!result) { + dlclose(lib); + } + } + return result; +} + +#else +#error Please define your platform. +#endif + +static void dynapi_warn(const char *msg) +{ + const char *caption = "SDL Dynamic API Failure!"; + (void)caption; +// SDL_ShowSimpleMessageBox() is a too heavy for here. +#if (defined(WIN32) || defined(_WIN32) || defined(SDL_PLATFORM_CYGWIN)) && !defined(SDL_PLATFORM_XBOXONE) && !defined(SDL_PLATFORM_XBOXSERIES) + MessageBoxA(NULL, msg, caption, MB_OK | MB_ICONERROR); +#elif defined(HAVE_STDIO_H) + fprintf(stderr, "\n\n%s\n%s\n\n", caption, msg); + fflush(stderr); +#endif +} + +/* This is not declared in any header, although it is shared between some + parts of SDL, because we don't want anything calling it without an + extremely good reason. */ +#ifdef __cplusplus +extern "C" { +#endif +extern SDL_NORETURN void SDL_ExitProcess(int exitcode); +#ifdef __WATCOMC__ +#pragma aux SDL_ExitProcess aborts; +#endif +#ifdef __cplusplus +} +#endif + +static void SDL_InitDynamicAPILocked(void) +{ + // this can't use SDL_getenv_unsafe_REAL, because it might allocate memory before the app can set their allocator. +#if defined(WIN32) || defined(_WIN32) || defined(__CYGWIN__) + // We've always used LoadLibraryA for this, so this has never worked with Unicode paths on Windows. Sorry. + char envbuf[512]; // overflows will just report as environment variable being unset, but LoadLibraryA has a MAX_PATH of 260 anyhow, apparently. + const DWORD rc = GetEnvironmentVariableA(SDL_DYNAMIC_API_ENVVAR, envbuf, (DWORD) sizeof (envbuf)); + char *libname = ((rc != 0) && (rc < sizeof (envbuf))) ? envbuf : NULL; +#else + char *libname = getenv(SDL_DYNAMIC_API_ENVVAR); +#endif + + SDL_DYNAPI_ENTRYFN entry = NULL; // funcs from here by default. + bool use_internal = true; + + if (libname) { + while (*libname && !entry) { + // This is evil, but we're not making any permanent changes... + char *ptr = (char *)libname; + while (true) { + char ch = *ptr; + if ((ch == ',') || (ch == '\0')) { + *ptr = '\0'; + entry = (SDL_DYNAPI_ENTRYFN)get_sdlapi_entry(libname, "SDL_DYNAPI_entry"); + *ptr = ch; + libname = (ch == '\0') ? ptr : (ptr + 1); + break; + } else { + ptr++; + } + } + } + if (!entry) { + dynapi_warn("Couldn't load an overriding SDL library. Please fix or remove the " SDL_DYNAMIC_API_ENVVAR " environment variable. Using the default SDL."); + // Just fill in the function pointers from this library, later. + } + } + + if (entry) { + if (entry(SDL_DYNAPI_VERSION, &jump_table, sizeof(jump_table)) < 0) { + dynapi_warn("Couldn't override SDL library. Using a newer SDL build might help. Please fix or remove the " SDL_DYNAMIC_API_ENVVAR " environment variable. Using the default SDL."); + // Just fill in the function pointers from this library, later. + } else { + use_internal = false; // We overrode SDL! Don't use the internal version! + } + } + + // Just fill in the function pointers from this library. + if (use_internal) { + if (initialize_jumptable(SDL_DYNAPI_VERSION, &jump_table, sizeof(jump_table)) < 0) { + // Now we're screwed. Should definitely abort now. + dynapi_warn("Failed to initialize internal SDL dynapi. As this would otherwise crash, we have to abort now."); +#ifndef NDEBUG + SDL_TriggerBreakpoint(); +#endif + SDL_ExitProcess(86); + } + } + + // we intentionally never close the newly-loaded lib, of course. +} + +static void SDL_InitDynamicAPI(void) +{ + /* So the theory is that every function in the jump table defaults to + * calling this function, and then replaces itself with a version that + * doesn't call this function anymore. But it's possible that, in an + * extreme corner case, you can have a second thread hit this function + * while the jump table is being initialized by the first. + * In this case, a spinlock is really painful compared to what spinlocks + * _should_ be used for, but this would only happen once, and should be + * insanely rare, as you would have to spin a thread outside of SDL (as + * SDL_CreateThread() would also call this function before building the + * new thread). + */ + static bool already_initialized = false; + + static SDL_SpinLock lock = 0; + SDL_LockSpinlock_REAL(&lock); + + if (!already_initialized) { + SDL_InitDynamicAPILocked(); + already_initialized = true; + } + + SDL_UnlockSpinlock_REAL(&lock); +} + +#else // SDL_DYNAMIC_API + +#include + +Sint32 SDL_DYNAPI_entry(Uint32 apiver, void *table, Uint32 tablesize); +Sint32 SDL_DYNAPI_entry(Uint32 apiver, void *table, Uint32 tablesize) +{ + (void)apiver; + (void)table; + (void)tablesize; + return -1; // not compatible. +} + +#endif // SDL_DYNAMIC_API diff --git a/contrib/SDL-3.2.8/src/dynapi/SDL_dynapi.h b/contrib/SDL-3.2.8/src/dynapi/SDL_dynapi.h new file mode 100644 index 0000000..99ef9a9 --- /dev/null +++ b/contrib/SDL-3.2.8/src/dynapi/SDL_dynapi.h @@ -0,0 +1,75 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef SDL_dynapi_h_ +#define SDL_dynapi_h_ + +/* IMPORTANT: + This is the master switch to disabling the dynamic API. We made it so you + have to hand-edit an internal source file in SDL to turn it off; you + can do it if you want it badly enough, but hopefully you won't want to. + You should understand the ramifications of turning this off: it makes it + hard to update your SDL in the field, and impossible if you've statically + linked SDL into your app. Understand that platforms change, and if we can't + drop in an updated SDL, your application can definitely break some time + in the future, even if it's fine today. + To be sure, as new system-level video and audio APIs are introduced, an + updated SDL can transparently take advantage of them, but your program will + not without this feature. Think hard before turning it off. +*/ +#ifdef SDL_DYNAMIC_API // Tried to force it on the command line? +#error Nope, you have to edit this file to force this off. +#endif + +#ifdef SDL_PLATFORM_APPLE +#include "TargetConditionals.h" +#endif + +#if defined(SDL_PLATFORM_PRIVATE) // probably not useful on private platforms. +#define SDL_DYNAMIC_API 0 +#elif defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE // probably not useful on iOS. +#define SDL_DYNAMIC_API 0 +#elif defined(SDL_PLATFORM_ANDROID) // probably not useful on Android. +#define SDL_DYNAMIC_API 0 +#elif defined(SDL_PLATFORM_EMSCRIPTEN) // probably not useful on Emscripten. +#define SDL_DYNAMIC_API 0 +#elif defined(SDL_PLATFORM_PS2) && SDL_PLATFORM_PS2 +#define SDL_DYNAMIC_API 0 +#elif defined(SDL_PLATFORM_PSP) && SDL_PLATFORM_PSP +#define SDL_DYNAMIC_API 0 +#elif defined(SDL_PLATFORM_RISCOS) // probably not useful on RISC OS, since dlopen() can't be used when using static linking. +#define SDL_DYNAMIC_API 0 +#elif defined(__clang_analyzer__) || defined(__INTELLISENSE__) || defined(SDL_THREAD_SAFETY_ANALYSIS) +#define SDL_DYNAMIC_API 0 // Turn off for static analysis, so reports are more clear. +#elif defined(SDL_PLATFORM_VITA) +#define SDL_DYNAMIC_API 0 // vitasdk doesn't support dynamic linking +#elif defined(SDL_PLATFORM_3DS) +#define SDL_DYNAMIC_API 0 // devkitARM doesn't support dynamic linking +#elif defined(DYNAPI_NEEDS_DLOPEN) && !defined(HAVE_DLOPEN) +#define SDL_DYNAMIC_API 0 // we need dlopen(), but don't have it.... +#endif + +// everyone else. This is where we turn on the API if nothing forced it off. +#ifndef SDL_DYNAMIC_API +#define SDL_DYNAMIC_API 1 +#endif + +#endif diff --git a/contrib/SDL-3.2.8/src/dynapi/SDL_dynapi.sym b/contrib/SDL-3.2.8/src/dynapi/SDL_dynapi.sym new file mode 100644 index 0000000..73f3484 --- /dev/null +++ b/contrib/SDL-3.2.8/src/dynapi/SDL_dynapi.sym @@ -0,0 +1,1239 @@ +SDL3_0.0.0 { + global: + JNI_OnLoad; + SDL_DYNAPI_entry; + SDL_AcquireCameraFrame; + SDL_AcquireGPUCommandBuffer; + SDL_AcquireGPUSwapchainTexture; + SDL_AddAtomicInt; + SDL_AddEventWatch; + SDL_AddGamepadMapping; + SDL_AddGamepadMappingsFromFile; + SDL_AddGamepadMappingsFromIO; + SDL_AddHintCallback; + SDL_AddSurfaceAlternateImage; + SDL_AddTimer; + SDL_AddTimerNS; + SDL_AddVulkanRenderSemaphores; + SDL_AttachVirtualJoystick; + SDL_AudioDevicePaused; + SDL_BeginGPUComputePass; + SDL_BeginGPUCopyPass; + SDL_BeginGPURenderPass; + SDL_BindAudioStream; + SDL_BindAudioStreams; + SDL_BindGPUComputePipeline; + SDL_BindGPUComputeSamplers; + SDL_BindGPUComputeStorageBuffers; + SDL_BindGPUComputeStorageTextures; + SDL_BindGPUFragmentSamplers; + SDL_BindGPUFragmentStorageBuffers; + SDL_BindGPUFragmentStorageTextures; + SDL_BindGPUGraphicsPipeline; + SDL_BindGPUIndexBuffer; + SDL_BindGPUVertexBuffers; + SDL_BindGPUVertexSamplers; + SDL_BindGPUVertexStorageBuffers; + SDL_BindGPUVertexStorageTextures; + SDL_BlitGPUTexture; + SDL_BlitSurface9Grid; + SDL_BlitSurface; + SDL_BlitSurfaceScaled; + SDL_BlitSurfaceTiled; + SDL_BlitSurfaceTiledWithScale; + SDL_BlitSurfaceUnchecked; + SDL_BlitSurfaceUncheckedScaled; + SDL_BroadcastCondition; + SDL_CaptureMouse; + SDL_ClaimWindowForGPUDevice; + SDL_CleanupTLS; + SDL_ClearAudioStream; + SDL_ClearClipboardData; + SDL_ClearComposition; + SDL_ClearError; + SDL_ClearProperty; + SDL_ClearSurface; + SDL_CloseAudioDevice; + SDL_CloseCamera; + SDL_CloseGamepad; + SDL_CloseHaptic; + SDL_CloseIO; + SDL_CloseJoystick; + SDL_CloseSensor; + SDL_CloseStorage; + SDL_CompareAndSwapAtomicInt; + SDL_CompareAndSwapAtomicPointer; + SDL_CompareAndSwapAtomicU32; + SDL_ComposeCustomBlendMode; + SDL_ConvertAudioSamples; + SDL_ConvertEventToRenderCoordinates; + SDL_ConvertPixels; + SDL_ConvertPixelsAndColorspace; + SDL_ConvertSurface; + SDL_ConvertSurfaceAndColorspace; + SDL_CopyFile; + SDL_CopyGPUBufferToBuffer; + SDL_CopyGPUTextureToTexture; + SDL_CopyProperties; + SDL_CopyStorageFile; + SDL_CreateAudioStream; + SDL_CreateColorCursor; + SDL_CreateCondition; + SDL_CreateCursor; + SDL_CreateDirectory; + SDL_CreateEnvironment; + SDL_CreateGPUBuffer; + SDL_CreateGPUComputePipeline; + SDL_CreateGPUDevice; + SDL_CreateGPUDeviceWithProperties; + SDL_CreateGPUGraphicsPipeline; + SDL_CreateGPUSampler; + SDL_CreateGPUShader; + SDL_CreateGPUTexture; + SDL_CreateGPUTransferBuffer; + SDL_CreateHapticEffect; + SDL_CreateMutex; + SDL_CreatePalette; + SDL_CreatePopupWindow; + SDL_CreateProcess; + SDL_CreateProcessWithProperties; + SDL_CreateProperties; + SDL_CreateRWLock; + SDL_CreateRenderer; + SDL_CreateRendererWithProperties; + SDL_CreateSemaphore; + SDL_CreateSoftwareRenderer; + SDL_CreateStorageDirectory; + SDL_CreateSurface; + SDL_CreateSurfaceFrom; + SDL_CreateSurfacePalette; + SDL_CreateSystemCursor; + SDL_CreateTexture; + SDL_CreateTextureFromSurface; + SDL_CreateTextureWithProperties; + SDL_CreateThreadRuntime; + SDL_CreateThreadWithPropertiesRuntime; + SDL_CreateWindow; + SDL_CreateWindowAndRenderer; + SDL_CreateWindowWithProperties; + SDL_CursorVisible; + SDL_DateTimeToTime; + SDL_Delay; + SDL_DelayNS; + SDL_DestroyAudioStream; + SDL_DestroyCondition; + SDL_DestroyCursor; + SDL_DestroyEnvironment; + SDL_DestroyGPUDevice; + SDL_DestroyHapticEffect; + SDL_DestroyMutex; + SDL_DestroyPalette; + SDL_DestroyProcess; + SDL_DestroyProperties; + SDL_DestroyRWLock; + SDL_DestroyRenderer; + SDL_DestroySemaphore; + SDL_DestroySurface; + SDL_DestroyTexture; + SDL_DestroyWindow; + SDL_DestroyWindowSurface; + SDL_DetachThread; + SDL_DetachVirtualJoystick; + SDL_DisableScreenSaver; + SDL_DispatchGPUCompute; + SDL_DispatchGPUComputeIndirect; + SDL_DownloadFromGPUBuffer; + SDL_DownloadFromGPUTexture; + SDL_DrawGPUIndexedPrimitives; + SDL_DrawGPUIndexedPrimitivesIndirect; + SDL_DrawGPUPrimitives; + SDL_DrawGPUPrimitivesIndirect; + SDL_DuplicateSurface; + SDL_EGL_GetCurrentConfig; + SDL_EGL_GetCurrentDisplay; + SDL_EGL_GetProcAddress; + SDL_EGL_GetWindowSurface; + SDL_EGL_SetAttributeCallbacks; + SDL_EnableScreenSaver; + SDL_EndGPUComputePass; + SDL_EndGPUCopyPass; + SDL_EndGPURenderPass; + SDL_EnterAppMainCallbacks; + SDL_EnumerateDirectory; + SDL_EnumerateProperties; + SDL_EnumerateStorageDirectory; + SDL_EventEnabled; + SDL_FillSurfaceRect; + SDL_FillSurfaceRects; + SDL_FilterEvents; + SDL_FlashWindow; + SDL_FlipSurface; + SDL_FlushAudioStream; + SDL_FlushEvent; + SDL_FlushEvents; + SDL_FlushIO; + SDL_FlushRenderer; + SDL_GDKResumeGPU; + SDL_GDKSuspendComplete; + SDL_GDKSuspendGPU; + SDL_GL_CreateContext; + SDL_GL_DestroyContext; + SDL_GL_ExtensionSupported; + SDL_GL_GetAttribute; + SDL_GL_GetCurrentContext; + SDL_GL_GetCurrentWindow; + SDL_GL_GetProcAddress; + SDL_GL_GetSwapInterval; + SDL_GL_LoadLibrary; + SDL_GL_MakeCurrent; + SDL_GL_ResetAttributes; + SDL_GL_SetAttribute; + SDL_GL_SetSwapInterval; + SDL_GL_SwapWindow; + SDL_GL_UnloadLibrary; + SDL_GPUSupportsProperties; + SDL_GPUSupportsShaderFormats; + SDL_GPUTextureFormatTexelBlockSize; + SDL_GPUTextureSupportsFormat; + SDL_GPUTextureSupportsSampleCount; + SDL_GUIDToString; + SDL_GamepadConnected; + SDL_GamepadEventsEnabled; + SDL_GamepadHasAxis; + SDL_GamepadHasButton; + SDL_GamepadHasSensor; + SDL_GamepadSensorEnabled; + SDL_GenerateMipmapsForGPUTexture; + SDL_GetAndroidActivity; + SDL_GetAndroidCachePath; + SDL_GetAndroidExternalStoragePath; + SDL_GetAndroidExternalStorageState; + SDL_GetAndroidInternalStoragePath; + SDL_GetAndroidJNIEnv; + SDL_GetAndroidSDKVersion; + SDL_GetAppMetadataProperty; + SDL_GetAssertionHandler; + SDL_GetAssertionReport; + SDL_GetAtomicInt; + SDL_GetAtomicPointer; + SDL_GetAtomicU32; + SDL_GetAudioDeviceChannelMap; + SDL_GetAudioDeviceFormat; + SDL_GetAudioDeviceGain; + SDL_GetAudioDeviceName; + SDL_GetAudioDriver; + SDL_GetAudioFormatName; + SDL_GetAudioPlaybackDevices; + SDL_GetAudioRecordingDevices; + SDL_GetAudioStreamAvailable; + SDL_GetAudioStreamData; + SDL_GetAudioStreamDevice; + SDL_GetAudioStreamFormat; + SDL_GetAudioStreamFrequencyRatio; + SDL_GetAudioStreamGain; + SDL_GetAudioStreamInputChannelMap; + SDL_GetAudioStreamOutputChannelMap; + SDL_GetAudioStreamProperties; + SDL_GetAudioStreamQueued; + SDL_GetBasePath; + SDL_GetBooleanProperty; + SDL_GetCPUCacheLineSize; + SDL_GetCameraDriver; + SDL_GetCameraFormat; + SDL_GetCameraID; + SDL_GetCameraName; + SDL_GetCameraPermissionState; + SDL_GetCameraPosition; + SDL_GetCameraProperties; + SDL_GetCameraSupportedFormats; + SDL_GetCameras; + SDL_GetClipboardData; + SDL_GetClipboardMimeTypes; + SDL_GetClipboardText; + SDL_GetClosestFullscreenDisplayMode; + SDL_GetCurrentAudioDriver; + SDL_GetCurrentCameraDriver; + SDL_GetCurrentDisplayMode; + SDL_GetCurrentDisplayOrientation; + SDL_GetCurrentRenderOutputSize; + SDL_GetCurrentThreadID; + SDL_GetCurrentTime; + SDL_GetCurrentVideoDriver; + SDL_GetCursor; + SDL_GetDXGIOutputInfo; + SDL_GetDateTimeLocalePreferences; + SDL_GetDayOfWeek; + SDL_GetDayOfYear; + SDL_GetDaysInMonth; + SDL_GetDefaultAssertionHandler; + SDL_GetDefaultCursor; + SDL_GetDesktopDisplayMode; + SDL_GetDirect3D9AdapterIndex; + SDL_GetDisplayBounds; + SDL_GetDisplayContentScale; + SDL_GetDisplayForPoint; + SDL_GetDisplayForRect; + SDL_GetDisplayForWindow; + SDL_GetDisplayName; + SDL_GetDisplayProperties; + SDL_GetDisplayUsableBounds; + SDL_GetDisplays; + SDL_GetEnvironment; + SDL_GetEnvironmentVariable; + SDL_GetEnvironmentVariables; + SDL_GetError; + SDL_GetEventFilter; + SDL_GetFloatProperty; + SDL_GetFullscreenDisplayModes; + SDL_GetGDKDefaultUser; + SDL_GetGDKTaskQueue; + SDL_GetGPUDeviceDriver; + SDL_GetGPUDriver; + SDL_GetGPUShaderFormats; + SDL_GetGPUSwapchainTextureFormat; + SDL_GetGamepadAppleSFSymbolsNameForAxis; + SDL_GetGamepadAppleSFSymbolsNameForButton; + SDL_GetGamepadAxis; + SDL_GetGamepadAxisFromString; + SDL_GetGamepadBindings; + SDL_GetGamepadButton; + SDL_GetGamepadButtonFromString; + SDL_GetGamepadButtonLabel; + SDL_GetGamepadButtonLabelForType; + SDL_GetGamepadConnectionState; + SDL_GetGamepadFirmwareVersion; + SDL_GetGamepadFromID; + SDL_GetGamepadFromPlayerIndex; + SDL_GetGamepadGUIDForID; + SDL_GetGamepadID; + SDL_GetGamepadJoystick; + SDL_GetGamepadMapping; + SDL_GetGamepadMappingForGUID; + SDL_GetGamepadMappingForID; + SDL_GetGamepadMappings; + SDL_GetGamepadName; + SDL_GetGamepadNameForID; + SDL_GetGamepadPath; + SDL_GetGamepadPathForID; + SDL_GetGamepadPlayerIndex; + SDL_GetGamepadPlayerIndexForID; + SDL_GetGamepadPowerInfo; + SDL_GetGamepadProduct; + SDL_GetGamepadProductForID; + SDL_GetGamepadProductVersion; + SDL_GetGamepadProductVersionForID; + SDL_GetGamepadProperties; + SDL_GetGamepadSensorData; + SDL_GetGamepadSensorDataRate; + SDL_GetGamepadSerial; + SDL_GetGamepadSteamHandle; + SDL_GetGamepadStringForAxis; + SDL_GetGamepadStringForButton; + SDL_GetGamepadStringForType; + SDL_GetGamepadTouchpadFinger; + SDL_GetGamepadType; + SDL_GetGamepadTypeForID; + SDL_GetGamepadTypeFromString; + SDL_GetGamepadVendor; + SDL_GetGamepadVendorForID; + SDL_GetGamepads; + SDL_GetGlobalMouseState; + SDL_GetGlobalProperties; + SDL_GetGrabbedWindow; + SDL_GetHapticEffectStatus; + SDL_GetHapticFeatures; + SDL_GetHapticFromID; + SDL_GetHapticID; + SDL_GetHapticName; + SDL_GetHapticNameForID; + SDL_GetHaptics; + SDL_GetHint; + SDL_GetHintBoolean; + SDL_GetIOProperties; + SDL_GetIOSize; + SDL_GetIOStatus; + SDL_GetJoystickAxis; + SDL_GetJoystickAxisInitialState; + SDL_GetJoystickBall; + SDL_GetJoystickButton; + SDL_GetJoystickConnectionState; + SDL_GetJoystickFirmwareVersion; + SDL_GetJoystickFromID; + SDL_GetJoystickFromPlayerIndex; + SDL_GetJoystickGUID; + SDL_GetJoystickGUIDForID; + SDL_GetJoystickGUIDInfo; + SDL_GetJoystickHat; + SDL_GetJoystickID; + SDL_GetJoystickName; + SDL_GetJoystickNameForID; + SDL_GetJoystickPath; + SDL_GetJoystickPathForID; + SDL_GetJoystickPlayerIndex; + SDL_GetJoystickPlayerIndexForID; + SDL_GetJoystickPowerInfo; + SDL_GetJoystickProduct; + SDL_GetJoystickProductForID; + SDL_GetJoystickProductVersion; + SDL_GetJoystickProductVersionForID; + SDL_GetJoystickProperties; + SDL_GetJoystickSerial; + SDL_GetJoystickType; + SDL_GetJoystickTypeForID; + SDL_GetJoystickVendor; + SDL_GetJoystickVendorForID; + SDL_GetJoysticks; + SDL_GetKeyFromName; + SDL_GetKeyFromScancode; + SDL_GetKeyName; + SDL_GetKeyboardFocus; + SDL_GetKeyboardNameForID; + SDL_GetKeyboardState; + SDL_GetKeyboards; + SDL_GetLogOutputFunction; + SDL_GetLogPriority; + SDL_GetMasksForPixelFormat; + SDL_GetMaxHapticEffects; + SDL_GetMaxHapticEffectsPlaying; + SDL_GetMemoryFunctions; + SDL_GetMice; + SDL_GetModState; + SDL_GetMouseFocus; + SDL_GetMouseNameForID; + SDL_GetMouseState; + SDL_GetNaturalDisplayOrientation; + SDL_GetNumAllocations; + SDL_GetNumAudioDrivers; + SDL_GetNumCameraDrivers; + SDL_GetNumGPUDrivers; + SDL_GetNumGamepadTouchpadFingers; + SDL_GetNumGamepadTouchpads; + SDL_GetNumHapticAxes; + SDL_GetNumJoystickAxes; + SDL_GetNumJoystickBalls; + SDL_GetNumJoystickButtons; + SDL_GetNumJoystickHats; + SDL_GetNumLogicalCPUCores; + SDL_GetNumRenderDrivers; + SDL_GetNumVideoDrivers; + SDL_GetNumberProperty; + SDL_GetOriginalMemoryFunctions; + SDL_GetPathInfo; + SDL_GetPerformanceCounter; + SDL_GetPerformanceFrequency; + SDL_GetPixelFormatDetails; + SDL_GetPixelFormatForMasks; + SDL_GetPixelFormatName; + SDL_GetPlatform; + SDL_GetPointerProperty; + SDL_GetPowerInfo; + SDL_GetPrefPath; + SDL_GetPreferredLocales; + SDL_GetPrimaryDisplay; + SDL_GetPrimarySelectionText; + SDL_GetProcessInput; + SDL_GetProcessOutput; + SDL_GetProcessProperties; + SDL_GetPropertyType; + SDL_GetRGB; + SDL_GetRGBA; + SDL_GetRealGamepadType; + SDL_GetRealGamepadTypeForID; + SDL_GetRectAndLineIntersection; + SDL_GetRectAndLineIntersectionFloat; + SDL_GetRectEnclosingPoints; + SDL_GetRectEnclosingPointsFloat; + SDL_GetRectIntersection; + SDL_GetRectIntersectionFloat; + SDL_GetRectUnion; + SDL_GetRectUnionFloat; + SDL_GetRelativeMouseState; + SDL_GetRenderClipRect; + SDL_GetRenderColorScale; + SDL_GetRenderDrawBlendMode; + SDL_GetRenderDrawColor; + SDL_GetRenderDrawColorFloat; + SDL_GetRenderDriver; + SDL_GetRenderLogicalPresentation; + SDL_GetRenderLogicalPresentationRect; + SDL_GetRenderMetalCommandEncoder; + SDL_GetRenderMetalLayer; + SDL_GetRenderOutputSize; + SDL_GetRenderSafeArea; + SDL_GetRenderScale; + SDL_GetRenderTarget; + SDL_GetRenderVSync; + SDL_GetRenderViewport; + SDL_GetRenderWindow; + SDL_GetRenderer; + SDL_GetRendererFromTexture; + SDL_GetRendererName; + SDL_GetRendererProperties; + SDL_GetRevision; + SDL_GetSIMDAlignment; + SDL_GetScancodeFromKey; + SDL_GetScancodeFromName; + SDL_GetScancodeName; + SDL_GetSemaphoreValue; + SDL_GetSensorData; + SDL_GetSensorFromID; + SDL_GetSensorID; + SDL_GetSensorName; + SDL_GetSensorNameForID; + SDL_GetSensorNonPortableType; + SDL_GetSensorNonPortableTypeForID; + SDL_GetSensorProperties; + SDL_GetSensorType; + SDL_GetSensorTypeForID; + SDL_GetSensors; + SDL_GetSilenceValueForFormat; + SDL_GetStorageFileSize; + SDL_GetStoragePathInfo; + SDL_GetStorageSpaceRemaining; + SDL_GetStringProperty; + SDL_GetSurfaceAlphaMod; + SDL_GetSurfaceBlendMode; + SDL_GetSurfaceClipRect; + SDL_GetSurfaceColorKey; + SDL_GetSurfaceColorMod; + SDL_GetSurfaceColorspace; + SDL_GetSurfaceImages; + SDL_GetSurfacePalette; + SDL_GetSurfaceProperties; + SDL_GetSystemRAM; + SDL_GetSystemTheme; + SDL_GetTLS; + SDL_GetTextInputArea; + SDL_GetTextureAlphaMod; + SDL_GetTextureAlphaModFloat; + SDL_GetTextureBlendMode; + SDL_GetTextureColorMod; + SDL_GetTextureColorModFloat; + SDL_GetTextureProperties; + SDL_GetTextureScaleMode; + SDL_GetTextureSize; + SDL_GetThreadID; + SDL_GetThreadName; + SDL_GetTicks; + SDL_GetTicksNS; + SDL_GetTouchDeviceName; + SDL_GetTouchDeviceType; + SDL_GetTouchDevices; + SDL_GetTouchFingers; + SDL_GetUserFolder; + SDL_GetVersion; + SDL_GetVideoDriver; + SDL_GetWindowAspectRatio; + SDL_GetWindowBordersSize; + SDL_GetWindowDisplayScale; + SDL_GetWindowFlags; + SDL_GetWindowFromEvent; + SDL_GetWindowFromID; + SDL_GetWindowFullscreenMode; + SDL_GetWindowICCProfile; + SDL_GetWindowID; + SDL_GetWindowKeyboardGrab; + SDL_GetWindowMaximumSize; + SDL_GetWindowMinimumSize; + SDL_GetWindowMouseGrab; + SDL_GetWindowMouseRect; + SDL_GetWindowOpacity; + SDL_GetWindowParent; + SDL_GetWindowPixelDensity; + SDL_GetWindowPixelFormat; + SDL_GetWindowPosition; + SDL_GetWindowProperties; + SDL_GetWindowRelativeMouseMode; + SDL_GetWindowSafeArea; + SDL_GetWindowSize; + SDL_GetWindowSizeInPixels; + SDL_GetWindowSurface; + SDL_GetWindowSurfaceVSync; + SDL_GetWindowTitle; + SDL_GetWindows; + SDL_GlobDirectory; + SDL_GlobStorageDirectory; + SDL_HapticEffectSupported; + SDL_HapticRumbleSupported; + SDL_HasARMSIMD; + SDL_HasAVX2; + SDL_HasAVX512F; + SDL_HasAVX; + SDL_HasAltiVec; + SDL_HasClipboardData; + SDL_HasClipboardText; + SDL_HasEvent; + SDL_HasEvents; + SDL_HasGamepad; + SDL_HasJoystick; + SDL_HasKeyboard; + SDL_HasLASX; + SDL_HasLSX; + SDL_HasMMX; + SDL_HasMouse; + SDL_HasNEON; + SDL_HasPrimarySelectionText; + SDL_HasProperty; + SDL_HasRectIntersection; + SDL_HasRectIntersectionFloat; + SDL_HasSSE2; + SDL_HasSSE3; + SDL_HasSSE41; + SDL_HasSSE42; + SDL_HasSSE; + SDL_HasScreenKeyboardSupport; + SDL_HideCursor; + SDL_HideWindow; + SDL_IOFromConstMem; + SDL_IOFromDynamicMem; + SDL_IOFromFile; + SDL_IOFromMem; + SDL_IOprintf; + SDL_IOvprintf; + SDL_Init; + SDL_InitHapticRumble; + SDL_InitSubSystem; + SDL_InsertGPUDebugLabel; + SDL_IsChromebook; + SDL_IsDeXMode; + SDL_IsGamepad; + SDL_IsJoystickHaptic; + SDL_IsJoystickVirtual; + SDL_IsMouseHaptic; + SDL_IsTV; + SDL_IsTablet; + SDL_JoystickConnected; + SDL_JoystickEventsEnabled; + SDL_KillProcess; + SDL_LoadBMP; + SDL_LoadBMP_IO; + SDL_LoadFile; + SDL_LoadFile_IO; + SDL_LoadFunction; + SDL_LoadObject; + SDL_LoadWAV; + SDL_LoadWAV_IO; + SDL_LockAudioStream; + SDL_LockJoysticks; + SDL_LockMutex; + SDL_LockProperties; + SDL_LockRWLockForReading; + SDL_LockRWLockForWriting; + SDL_LockSpinlock; + SDL_LockSurface; + SDL_LockTexture; + SDL_LockTextureToSurface; + SDL_Log; + SDL_LogCritical; + SDL_LogDebug; + SDL_LogError; + SDL_LogInfo; + SDL_LogMessage; + SDL_LogMessageV; + SDL_LogTrace; + SDL_LogVerbose; + SDL_LogWarn; + SDL_MapGPUTransferBuffer; + SDL_MapRGB; + SDL_MapRGBA; + SDL_MapSurfaceRGB; + SDL_MapSurfaceRGBA; + SDL_MaximizeWindow; + SDL_MemoryBarrierAcquireFunction; + SDL_MemoryBarrierReleaseFunction; + SDL_Metal_CreateView; + SDL_Metal_DestroyView; + SDL_Metal_GetLayer; + SDL_MinimizeWindow; + SDL_MixAudio; + SDL_OnApplicationDidChangeStatusBarOrientation; + SDL_OnApplicationDidEnterBackground; + SDL_OnApplicationDidEnterForeground; + SDL_OnApplicationDidReceiveMemoryWarning; + SDL_OnApplicationWillEnterBackground; + SDL_OnApplicationWillEnterForeground; + SDL_OnApplicationWillTerminate; + SDL_OpenAudioDevice; + SDL_OpenAudioDeviceStream; + SDL_OpenCamera; + SDL_OpenFileStorage; + SDL_OpenGamepad; + SDL_OpenHaptic; + SDL_OpenHapticFromJoystick; + SDL_OpenHapticFromMouse; + SDL_OpenIO; + SDL_OpenJoystick; + SDL_OpenSensor; + SDL_OpenStorage; + SDL_OpenTitleStorage; + SDL_OpenURL; + SDL_OpenUserStorage; + SDL_OutOfMemory; + SDL_PauseAudioDevice; + SDL_PauseAudioStreamDevice; + SDL_PauseHaptic; + SDL_PeepEvents; + SDL_PlayHapticRumble; + SDL_PollEvent; + SDL_PopGPUDebugGroup; + SDL_PremultiplyAlpha; + SDL_PremultiplySurfaceAlpha; + SDL_PumpEvents; + SDL_PushEvent; + SDL_PushGPUComputeUniformData; + SDL_PushGPUDebugGroup; + SDL_PushGPUFragmentUniformData; + SDL_PushGPUVertexUniformData; + SDL_PutAudioStreamData; + SDL_QueryGPUFence; + SDL_Quit; + SDL_QuitSubSystem; + SDL_RaiseWindow; + SDL_ReadIO; + SDL_ReadProcess; + SDL_ReadS16BE; + SDL_ReadS16LE; + SDL_ReadS32BE; + SDL_ReadS32LE; + SDL_ReadS64BE; + SDL_ReadS64LE; + SDL_ReadS8; + SDL_ReadStorageFile; + SDL_ReadSurfacePixel; + SDL_ReadSurfacePixelFloat; + SDL_ReadU16BE; + SDL_ReadU16LE; + SDL_ReadU32BE; + SDL_ReadU32LE; + SDL_ReadU64BE; + SDL_ReadU64LE; + SDL_ReadU8; + SDL_RegisterApp; + SDL_RegisterEvents; + SDL_ReleaseCameraFrame; + SDL_ReleaseGPUBuffer; + SDL_ReleaseGPUComputePipeline; + SDL_ReleaseGPUFence; + SDL_ReleaseGPUGraphicsPipeline; + SDL_ReleaseGPUSampler; + SDL_ReleaseGPUShader; + SDL_ReleaseGPUTexture; + SDL_ReleaseGPUTransferBuffer; + SDL_ReleaseWindowFromGPUDevice; + SDL_ReloadGamepadMappings; + SDL_RemoveEventWatch; + SDL_RemoveHintCallback; + SDL_RemovePath; + SDL_RemoveStoragePath; + SDL_RemoveSurfaceAlternateImages; + SDL_RemoveTimer; + SDL_RenamePath; + SDL_RenameStoragePath; + SDL_RenderClear; + SDL_RenderClipEnabled; + SDL_RenderCoordinatesFromWindow; + SDL_RenderCoordinatesToWindow; + SDL_RenderFillRect; + SDL_RenderFillRects; + SDL_RenderGeometry; + SDL_RenderGeometryRaw; + SDL_RenderLine; + SDL_RenderLines; + SDL_RenderPoint; + SDL_RenderPoints; + SDL_RenderPresent; + SDL_RenderReadPixels; + SDL_RenderRect; + SDL_RenderRects; + SDL_RenderTexture9Grid; + SDL_RenderTexture; + SDL_RenderTextureRotated; + SDL_RenderTextureTiled; + SDL_RenderViewportSet; + SDL_ReportAssertion; + SDL_RequestAndroidPermission; + SDL_ResetAssertionReport; + SDL_ResetHint; + SDL_ResetHints; + SDL_ResetKeyboard; + SDL_ResetLogPriorities; + SDL_RestoreWindow; + SDL_ResumeAudioDevice; + SDL_ResumeAudioStreamDevice; + SDL_ResumeHaptic; + SDL_RumbleGamepad; + SDL_RumbleGamepadTriggers; + SDL_RumbleJoystick; + SDL_RumbleJoystickTriggers; + SDL_RunApp; + SDL_RunHapticEffect; + SDL_SaveBMP; + SDL_SaveBMP_IO; + SDL_ScaleSurface; + SDL_ScreenKeyboardShown; + SDL_ScreenSaverEnabled; + SDL_SeekIO; + SDL_SendAndroidBackButton; + SDL_SendAndroidMessage; + SDL_SendGamepadEffect; + SDL_SendJoystickEffect; + SDL_SendJoystickVirtualSensorData; + SDL_SetAppMetadata; + SDL_SetAppMetadataProperty; + SDL_SetAssertionHandler; + SDL_SetAtomicInt; + SDL_SetAtomicPointer; + SDL_SetAtomicU32; + SDL_SetAudioDeviceGain; + SDL_SetAudioPostmixCallback; + SDL_SetAudioStreamFormat; + SDL_SetAudioStreamFrequencyRatio; + SDL_SetAudioStreamGain; + SDL_SetAudioStreamGetCallback; + SDL_SetAudioStreamInputChannelMap; + SDL_SetAudioStreamOutputChannelMap; + SDL_SetAudioStreamPutCallback; + SDL_SetBooleanProperty; + SDL_SetClipboardData; + SDL_SetClipboardText; + SDL_SetCurrentThreadPriority; + SDL_SetCursor; + SDL_SetEnvironmentVariable; + SDL_SetError; + SDL_SetEventEnabled; + SDL_SetEventFilter; + SDL_SetFloatProperty; + SDL_SetGPUBlendConstants; + SDL_SetGPUBufferName; + SDL_SetGPUScissor; + SDL_SetGPUStencilReference; + SDL_SetGPUSwapchainParameters; + SDL_SetGPUTextureName; + SDL_SetGPUViewport; + SDL_SetGamepadEventsEnabled; + SDL_SetGamepadLED; + SDL_SetGamepadMapping; + SDL_SetGamepadPlayerIndex; + SDL_SetGamepadSensorEnabled; + SDL_SetHapticAutocenter; + SDL_SetHapticGain; + SDL_SetHint; + SDL_SetHintWithPriority; + SDL_SetInitialized; + SDL_SetJoystickEventsEnabled; + SDL_SetJoystickLED; + SDL_SetJoystickPlayerIndex; + SDL_SetJoystickVirtualAxis; + SDL_SetJoystickVirtualBall; + SDL_SetJoystickVirtualButton; + SDL_SetJoystickVirtualHat; + SDL_SetJoystickVirtualTouchpad; + SDL_SetLinuxThreadPriority; + SDL_SetLinuxThreadPriorityAndPolicy; + SDL_SetLogOutputFunction; + SDL_SetLogPriorities; + SDL_SetLogPriority; + SDL_SetLogPriorityPrefix; + SDL_SetMainReady; + SDL_SetMemoryFunctions; + SDL_SetModState; + SDL_SetNumberProperty; + SDL_SetPaletteColors; + SDL_SetPointerProperty; + SDL_SetPointerPropertyWithCleanup; + SDL_SetPrimarySelectionText; + SDL_SetRenderClipRect; + SDL_SetRenderColorScale; + SDL_SetRenderDrawBlendMode; + SDL_SetRenderDrawColor; + SDL_SetRenderDrawColorFloat; + SDL_SetRenderLogicalPresentation; + SDL_SetRenderScale; + SDL_SetRenderTarget; + SDL_SetRenderVSync; + SDL_SetRenderViewport; + SDL_SetScancodeName; + SDL_SetStringProperty; + SDL_SetSurfaceAlphaMod; + SDL_SetSurfaceBlendMode; + SDL_SetSurfaceClipRect; + SDL_SetSurfaceColorKey; + SDL_SetSurfaceColorMod; + SDL_SetSurfaceColorspace; + SDL_SetSurfacePalette; + SDL_SetSurfaceRLE; + SDL_SetTLS; + SDL_SetTextInputArea; + SDL_SetTextureAlphaMod; + SDL_SetTextureAlphaModFloat; + SDL_SetTextureBlendMode; + SDL_SetTextureColorMod; + SDL_SetTextureColorModFloat; + SDL_SetTextureScaleMode; + SDL_SetWindowAlwaysOnTop; + SDL_SetWindowAspectRatio; + SDL_SetWindowBordered; + SDL_SetWindowFocusable; + SDL_SetWindowFullscreen; + SDL_SetWindowFullscreenMode; + SDL_SetWindowHitTest; + SDL_SetWindowIcon; + SDL_SetWindowKeyboardGrab; + SDL_SetWindowMaximumSize; + SDL_SetWindowMinimumSize; + SDL_SetWindowModal; + SDL_SetWindowMouseGrab; + SDL_SetWindowMouseRect; + SDL_SetWindowOpacity; + SDL_SetWindowParent; + SDL_SetWindowPosition; + SDL_SetWindowRelativeMouseMode; + SDL_SetWindowResizable; + SDL_SetWindowShape; + SDL_SetWindowSize; + SDL_SetWindowSurfaceVSync; + SDL_SetWindowTitle; + SDL_SetWindowsMessageHook; + SDL_SetX11EventHook; + SDL_SetiOSAnimationCallback; + SDL_SetiOSEventPump; + SDL_ShouldInit; + SDL_ShouldQuit; + SDL_ShowAndroidToast; + SDL_ShowCursor; + SDL_ShowMessageBox; + SDL_ShowOpenFileDialog; + SDL_ShowOpenFolderDialog; + SDL_ShowSaveFileDialog; + SDL_ShowSimpleMessageBox; + SDL_ShowWindow; + SDL_ShowWindowSystemMenu; + SDL_SignalCondition; + SDL_SignalSemaphore; + SDL_StartTextInput; + SDL_StartTextInputWithProperties; + SDL_StepUTF8; + SDL_StopHapticEffect; + SDL_StopHapticEffects; + SDL_StopHapticRumble; + SDL_StopTextInput; + SDL_StorageReady; + SDL_StringToGUID; + SDL_SubmitGPUCommandBuffer; + SDL_SubmitGPUCommandBufferAndAcquireFence; + SDL_SurfaceHasAlternateImages; + SDL_SurfaceHasColorKey; + SDL_SurfaceHasRLE; + SDL_SyncWindow; + SDL_TellIO; + SDL_TextInputActive; + SDL_TimeFromWindows; + SDL_TimeToDateTime; + SDL_TimeToWindows; + SDL_TryLockMutex; + SDL_TryLockRWLockForReading; + SDL_TryLockRWLockForWriting; + SDL_TryLockSpinlock; + SDL_TryWaitSemaphore; + SDL_UCS4ToUTF8; + SDL_UnbindAudioStream; + SDL_UnbindAudioStreams; + SDL_UnloadObject; + SDL_UnlockAudioStream; + SDL_UnlockJoysticks; + SDL_UnlockMutex; + SDL_UnlockProperties; + SDL_UnlockRWLock; + SDL_UnlockSpinlock; + SDL_UnlockSurface; + SDL_UnlockTexture; + SDL_UnmapGPUTransferBuffer; + SDL_UnregisterApp; + SDL_UnsetEnvironmentVariable; + SDL_UpdateGamepads; + SDL_UpdateHapticEffect; + SDL_UpdateJoysticks; + SDL_UpdateNVTexture; + SDL_UpdateSensors; + SDL_UpdateTexture; + SDL_UpdateWindowSurface; + SDL_UpdateWindowSurfaceRects; + SDL_UpdateYUVTexture; + SDL_UploadToGPUBuffer; + SDL_UploadToGPUTexture; + SDL_Vulkan_CreateSurface; + SDL_Vulkan_DestroySurface; + SDL_Vulkan_GetInstanceExtensions; + SDL_Vulkan_GetPresentationSupport; + SDL_Vulkan_GetVkGetInstanceProcAddr; + SDL_Vulkan_LoadLibrary; + SDL_Vulkan_UnloadLibrary; + SDL_WaitCondition; + SDL_WaitConditionTimeout; + SDL_WaitEvent; + SDL_WaitEventTimeout; + SDL_WaitForGPUFences; + SDL_WaitForGPUIdle; + SDL_WaitProcess; + SDL_WaitSemaphore; + SDL_WaitSemaphoreTimeout; + SDL_WaitThread; + SDL_WarpMouseGlobal; + SDL_WarpMouseInWindow; + SDL_WasInit; + SDL_WindowHasSurface; + SDL_WindowSupportsGPUPresentMode; + SDL_WindowSupportsGPUSwapchainComposition; + SDL_WriteIO; + SDL_WriteS16BE; + SDL_WriteS16LE; + SDL_WriteS32BE; + SDL_WriteS32LE; + SDL_WriteS64BE; + SDL_WriteS64LE; + SDL_WriteS8; + SDL_WriteStorageFile; + SDL_WriteSurfacePixel; + SDL_WriteSurfacePixelFloat; + SDL_WriteU16BE; + SDL_WriteU16LE; + SDL_WriteU32BE; + SDL_WriteU32LE; + SDL_WriteU64BE; + SDL_WriteU64LE; + SDL_WriteU8; + SDL_abs; + SDL_acos; + SDL_acosf; + SDL_aligned_alloc; + SDL_aligned_free; + SDL_asin; + SDL_asinf; + SDL_asprintf; + SDL_atan2; + SDL_atan2f; + SDL_atan; + SDL_atanf; + SDL_atof; + SDL_atoi; + SDL_bsearch; + SDL_bsearch_r; + SDL_calloc; + SDL_ceil; + SDL_ceilf; + SDL_copysign; + SDL_copysignf; + SDL_cos; + SDL_cosf; + SDL_crc16; + SDL_crc32; + SDL_exp; + SDL_expf; + SDL_fabs; + SDL_fabsf; + SDL_floor; + SDL_floorf; + SDL_fmod; + SDL_fmodf; + SDL_free; + SDL_getenv; + SDL_getenv_unsafe; + SDL_hid_ble_scan; + SDL_hid_close; + SDL_hid_device_change_count; + SDL_hid_enumerate; + SDL_hid_exit; + SDL_hid_free_enumeration; + SDL_hid_get_device_info; + SDL_hid_get_feature_report; + SDL_hid_get_indexed_string; + SDL_hid_get_input_report; + SDL_hid_get_manufacturer_string; + SDL_hid_get_product_string; + SDL_hid_get_report_descriptor; + SDL_hid_get_serial_number_string; + SDL_hid_init; + SDL_hid_open; + SDL_hid_open_path; + SDL_hid_read; + SDL_hid_read_timeout; + SDL_hid_send_feature_report; + SDL_hid_set_nonblocking; + SDL_hid_write; + SDL_iconv; + SDL_iconv_close; + SDL_iconv_open; + SDL_iconv_string; + SDL_isalnum; + SDL_isalpha; + SDL_isblank; + SDL_iscntrl; + SDL_isdigit; + SDL_isgraph; + SDL_isinf; + SDL_isinff; + SDL_islower; + SDL_isnan; + SDL_isnanf; + SDL_isprint; + SDL_ispunct; + SDL_isspace; + SDL_isupper; + SDL_isxdigit; + SDL_itoa; + SDL_lltoa; + SDL_log10; + SDL_log10f; + SDL_log; + SDL_logf; + SDL_lround; + SDL_lroundf; + SDL_ltoa; + SDL_malloc; + SDL_memcmp; + SDL_memcpy; + SDL_memmove; + SDL_memset4; + SDL_memset; + SDL_modf; + SDL_modff; + SDL_murmur3_32; + SDL_pow; + SDL_powf; + SDL_qsort; + SDL_qsort_r; + SDL_rand; + SDL_rand_bits; + SDL_rand_bits_r; + SDL_rand_r; + SDL_randf; + SDL_randf_r; + SDL_realloc; + SDL_round; + SDL_roundf; + SDL_scalbn; + SDL_scalbnf; + SDL_setenv_unsafe; + SDL_sin; + SDL_sinf; + SDL_snprintf; + SDL_sqrt; + SDL_sqrtf; + SDL_srand; + SDL_sscanf; + SDL_strcasecmp; + SDL_strcasestr; + SDL_strchr; + SDL_strcmp; + SDL_strdup; + SDL_strlcat; + SDL_strlcpy; + SDL_strlen; + SDL_strlwr; + SDL_strncasecmp; + SDL_strncmp; + SDL_strndup; + SDL_strnlen; + SDL_strnstr; + SDL_strpbrk; + SDL_strrchr; + SDL_strrev; + SDL_strstr; + SDL_strtod; + SDL_strtok_r; + SDL_strtol; + SDL_strtoll; + SDL_strtoul; + SDL_strtoull; + SDL_strupr; + SDL_swprintf; + SDL_tan; + SDL_tanf; + SDL_tolower; + SDL_toupper; + SDL_trunc; + SDL_truncf; + SDL_uitoa; + SDL_ulltoa; + SDL_ultoa; + SDL_unsetenv_unsafe; + SDL_utf8strlcpy; + SDL_utf8strlen; + SDL_utf8strnlen; + SDL_vasprintf; + SDL_vsnprintf; + SDL_vsscanf; + SDL_vswprintf; + SDL_wcscasecmp; + SDL_wcscmp; + SDL_wcsdup; + SDL_wcslcat; + SDL_wcslcpy; + SDL_wcslen; + SDL_wcsncasecmp; + SDL_wcsncmp; + SDL_wcsnlen; + SDL_wcsnstr; + SDL_wcsstr; + SDL_wcstol; + SDL_StepBackUTF8; + SDL_DelayPrecise; + SDL_CalculateGPUTextureFormatSize; + SDL_SetErrorV; + SDL_GetDefaultLogOutputFunction; + SDL_RenderDebugText; + SDL_GetSandbox; + SDL_CancelGPUCommandBuffer; + SDL_SaveFile_IO; + SDL_SaveFile; + SDL_GetCurrentDirectory; + SDL_IsAudioDevicePhysical; + SDL_IsAudioDevicePlayback; + SDL_AsyncIOFromFile; + SDL_GetAsyncIOSize; + SDL_ReadAsyncIO; + SDL_WriteAsyncIO; + SDL_CloseAsyncIO; + SDL_CreateAsyncIOQueue; + SDL_DestroyAsyncIOQueue; + SDL_GetAsyncIOResult; + SDL_WaitAsyncIOResult; + SDL_SignalAsyncIOQueue; + SDL_LoadFileAsync; + SDL_ShowFileDialogWithProperties; + SDL_IsMainThread; + SDL_RunOnMainThread; + SDL_SetGPUAllowedFramesInFlight; + SDL_RenderTextureAffine; + SDL_WaitForGPUSwapchain; + SDL_WaitAndAcquireGPUSwapchainTexture; + SDL_RenderDebugTextFormat; + SDL_CreateTray; + SDL_SetTrayIcon; + SDL_SetTrayTooltip; + SDL_CreateTrayMenu; + SDL_CreateTraySubmenu; + SDL_GetTrayMenu; + SDL_GetTraySubmenu; + SDL_GetTrayEntries; + SDL_RemoveTrayEntry; + SDL_InsertTrayEntryAt; + SDL_SetTrayEntryLabel; + SDL_GetTrayEntryLabel; + SDL_SetTrayEntryChecked; + SDL_GetTrayEntryChecked; + SDL_SetTrayEntryEnabled; + SDL_GetTrayEntryEnabled; + SDL_SetTrayEntryCallback; + SDL_DestroyTray; + SDL_GetTrayEntryParent; + SDL_GetTrayMenuParentEntry; + SDL_GetTrayMenuParentTray; + SDL_GetThreadState; + SDL_AudioStreamDevicePaused; + SDL_ClickTrayEntry; + SDL_UpdateTrays; + SDL_StretchSurface; + # extra symbols go here (don't modify this line) + local: *; +}; diff --git a/contrib/SDL-3.2.8/src/dynapi/SDL_dynapi_overrides.h b/contrib/SDL-3.2.8/src/dynapi/SDL_dynapi_overrides.h new file mode 100644 index 0000000..77fd553 --- /dev/null +++ b/contrib/SDL-3.2.8/src/dynapi/SDL_dynapi_overrides.h @@ -0,0 +1,1261 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + + +// DO NOT EDIT THIS FILE BY HAND. It is autogenerated by gendynapi.py. + +#if !SDL_DYNAMIC_API +#error You should not be here. +#endif + +// New API symbols are added at the end +#define SDL_AcquireCameraFrame SDL_AcquireCameraFrame_REAL +#define SDL_AcquireGPUCommandBuffer SDL_AcquireGPUCommandBuffer_REAL +#define SDL_AcquireGPUSwapchainTexture SDL_AcquireGPUSwapchainTexture_REAL +#define SDL_AddAtomicInt SDL_AddAtomicInt_REAL +#define SDL_AddEventWatch SDL_AddEventWatch_REAL +#define SDL_AddGamepadMapping SDL_AddGamepadMapping_REAL +#define SDL_AddGamepadMappingsFromFile SDL_AddGamepadMappingsFromFile_REAL +#define SDL_AddGamepadMappingsFromIO SDL_AddGamepadMappingsFromIO_REAL +#define SDL_AddHintCallback SDL_AddHintCallback_REAL +#define SDL_AddSurfaceAlternateImage SDL_AddSurfaceAlternateImage_REAL +#define SDL_AddTimer SDL_AddTimer_REAL +#define SDL_AddTimerNS SDL_AddTimerNS_REAL +#define SDL_AddVulkanRenderSemaphores SDL_AddVulkanRenderSemaphores_REAL +#define SDL_AttachVirtualJoystick SDL_AttachVirtualJoystick_REAL +#define SDL_AudioDevicePaused SDL_AudioDevicePaused_REAL +#define SDL_BeginGPUComputePass SDL_BeginGPUComputePass_REAL +#define SDL_BeginGPUCopyPass SDL_BeginGPUCopyPass_REAL +#define SDL_BeginGPURenderPass SDL_BeginGPURenderPass_REAL +#define SDL_BindAudioStream SDL_BindAudioStream_REAL +#define SDL_BindAudioStreams SDL_BindAudioStreams_REAL +#define SDL_BindGPUComputePipeline SDL_BindGPUComputePipeline_REAL +#define SDL_BindGPUComputeSamplers SDL_BindGPUComputeSamplers_REAL +#define SDL_BindGPUComputeStorageBuffers SDL_BindGPUComputeStorageBuffers_REAL +#define SDL_BindGPUComputeStorageTextures SDL_BindGPUComputeStorageTextures_REAL +#define SDL_BindGPUFragmentSamplers SDL_BindGPUFragmentSamplers_REAL +#define SDL_BindGPUFragmentStorageBuffers SDL_BindGPUFragmentStorageBuffers_REAL +#define SDL_BindGPUFragmentStorageTextures SDL_BindGPUFragmentStorageTextures_REAL +#define SDL_BindGPUGraphicsPipeline SDL_BindGPUGraphicsPipeline_REAL +#define SDL_BindGPUIndexBuffer SDL_BindGPUIndexBuffer_REAL +#define SDL_BindGPUVertexBuffers SDL_BindGPUVertexBuffers_REAL +#define SDL_BindGPUVertexSamplers SDL_BindGPUVertexSamplers_REAL +#define SDL_BindGPUVertexStorageBuffers SDL_BindGPUVertexStorageBuffers_REAL +#define SDL_BindGPUVertexStorageTextures SDL_BindGPUVertexStorageTextures_REAL +#define SDL_BlitGPUTexture SDL_BlitGPUTexture_REAL +#define SDL_BlitSurface SDL_BlitSurface_REAL +#define SDL_BlitSurface9Grid SDL_BlitSurface9Grid_REAL +#define SDL_BlitSurfaceScaled SDL_BlitSurfaceScaled_REAL +#define SDL_BlitSurfaceTiled SDL_BlitSurfaceTiled_REAL +#define SDL_BlitSurfaceTiledWithScale SDL_BlitSurfaceTiledWithScale_REAL +#define SDL_BlitSurfaceUnchecked SDL_BlitSurfaceUnchecked_REAL +#define SDL_BlitSurfaceUncheckedScaled SDL_BlitSurfaceUncheckedScaled_REAL +#define SDL_BroadcastCondition SDL_BroadcastCondition_REAL +#define SDL_CaptureMouse SDL_CaptureMouse_REAL +#define SDL_ClaimWindowForGPUDevice SDL_ClaimWindowForGPUDevice_REAL +#define SDL_CleanupTLS SDL_CleanupTLS_REAL +#define SDL_ClearAudioStream SDL_ClearAudioStream_REAL +#define SDL_ClearClipboardData SDL_ClearClipboardData_REAL +#define SDL_ClearComposition SDL_ClearComposition_REAL +#define SDL_ClearError SDL_ClearError_REAL +#define SDL_ClearProperty SDL_ClearProperty_REAL +#define SDL_ClearSurface SDL_ClearSurface_REAL +#define SDL_CloseAudioDevice SDL_CloseAudioDevice_REAL +#define SDL_CloseCamera SDL_CloseCamera_REAL +#define SDL_CloseGamepad SDL_CloseGamepad_REAL +#define SDL_CloseHaptic SDL_CloseHaptic_REAL +#define SDL_CloseIO SDL_CloseIO_REAL +#define SDL_CloseJoystick SDL_CloseJoystick_REAL +#define SDL_CloseSensor SDL_CloseSensor_REAL +#define SDL_CloseStorage SDL_CloseStorage_REAL +#define SDL_CompareAndSwapAtomicInt SDL_CompareAndSwapAtomicInt_REAL +#define SDL_CompareAndSwapAtomicPointer SDL_CompareAndSwapAtomicPointer_REAL +#define SDL_CompareAndSwapAtomicU32 SDL_CompareAndSwapAtomicU32_REAL +#define SDL_ComposeCustomBlendMode SDL_ComposeCustomBlendMode_REAL +#define SDL_ConvertAudioSamples SDL_ConvertAudioSamples_REAL +#define SDL_ConvertEventToRenderCoordinates SDL_ConvertEventToRenderCoordinates_REAL +#define SDL_ConvertPixels SDL_ConvertPixels_REAL +#define SDL_ConvertPixelsAndColorspace SDL_ConvertPixelsAndColorspace_REAL +#define SDL_ConvertSurface SDL_ConvertSurface_REAL +#define SDL_ConvertSurfaceAndColorspace SDL_ConvertSurfaceAndColorspace_REAL +#define SDL_CopyFile SDL_CopyFile_REAL +#define SDL_CopyGPUBufferToBuffer SDL_CopyGPUBufferToBuffer_REAL +#define SDL_CopyGPUTextureToTexture SDL_CopyGPUTextureToTexture_REAL +#define SDL_CopyProperties SDL_CopyProperties_REAL +#define SDL_CopyStorageFile SDL_CopyStorageFile_REAL +#define SDL_CreateAudioStream SDL_CreateAudioStream_REAL +#define SDL_CreateColorCursor SDL_CreateColorCursor_REAL +#define SDL_CreateCondition SDL_CreateCondition_REAL +#define SDL_CreateCursor SDL_CreateCursor_REAL +#define SDL_CreateDirectory SDL_CreateDirectory_REAL +#define SDL_CreateEnvironment SDL_CreateEnvironment_REAL +#define SDL_CreateGPUBuffer SDL_CreateGPUBuffer_REAL +#define SDL_CreateGPUComputePipeline SDL_CreateGPUComputePipeline_REAL +#define SDL_CreateGPUDevice SDL_CreateGPUDevice_REAL +#define SDL_CreateGPUDeviceWithProperties SDL_CreateGPUDeviceWithProperties_REAL +#define SDL_CreateGPUGraphicsPipeline SDL_CreateGPUGraphicsPipeline_REAL +#define SDL_CreateGPUSampler SDL_CreateGPUSampler_REAL +#define SDL_CreateGPUShader SDL_CreateGPUShader_REAL +#define SDL_CreateGPUTexture SDL_CreateGPUTexture_REAL +#define SDL_CreateGPUTransferBuffer SDL_CreateGPUTransferBuffer_REAL +#define SDL_CreateHapticEffect SDL_CreateHapticEffect_REAL +#define SDL_CreateMutex SDL_CreateMutex_REAL +#define SDL_CreatePalette SDL_CreatePalette_REAL +#define SDL_CreatePopupWindow SDL_CreatePopupWindow_REAL +#define SDL_CreateProcess SDL_CreateProcess_REAL +#define SDL_CreateProcessWithProperties SDL_CreateProcessWithProperties_REAL +#define SDL_CreateProperties SDL_CreateProperties_REAL +#define SDL_CreateRWLock SDL_CreateRWLock_REAL +#define SDL_CreateRenderer SDL_CreateRenderer_REAL +#define SDL_CreateRendererWithProperties SDL_CreateRendererWithProperties_REAL +#define SDL_CreateSemaphore SDL_CreateSemaphore_REAL +#define SDL_CreateSoftwareRenderer SDL_CreateSoftwareRenderer_REAL +#define SDL_CreateStorageDirectory SDL_CreateStorageDirectory_REAL +#define SDL_CreateSurface SDL_CreateSurface_REAL +#define SDL_CreateSurfaceFrom SDL_CreateSurfaceFrom_REAL +#define SDL_CreateSurfacePalette SDL_CreateSurfacePalette_REAL +#define SDL_CreateSystemCursor SDL_CreateSystemCursor_REAL +#define SDL_CreateTexture SDL_CreateTexture_REAL +#define SDL_CreateTextureFromSurface SDL_CreateTextureFromSurface_REAL +#define SDL_CreateTextureWithProperties SDL_CreateTextureWithProperties_REAL +#define SDL_CreateThreadRuntime SDL_CreateThreadRuntime_REAL +#define SDL_CreateThreadWithPropertiesRuntime SDL_CreateThreadWithPropertiesRuntime_REAL +#define SDL_CreateWindow SDL_CreateWindow_REAL +#define SDL_CreateWindowAndRenderer SDL_CreateWindowAndRenderer_REAL +#define SDL_CreateWindowWithProperties SDL_CreateWindowWithProperties_REAL +#define SDL_CursorVisible SDL_CursorVisible_REAL +#define SDL_DateTimeToTime SDL_DateTimeToTime_REAL +#define SDL_Delay SDL_Delay_REAL +#define SDL_DelayNS SDL_DelayNS_REAL +#define SDL_DestroyAudioStream SDL_DestroyAudioStream_REAL +#define SDL_DestroyCondition SDL_DestroyCondition_REAL +#define SDL_DestroyCursor SDL_DestroyCursor_REAL +#define SDL_DestroyEnvironment SDL_DestroyEnvironment_REAL +#define SDL_DestroyGPUDevice SDL_DestroyGPUDevice_REAL +#define SDL_DestroyHapticEffect SDL_DestroyHapticEffect_REAL +#define SDL_DestroyMutex SDL_DestroyMutex_REAL +#define SDL_DestroyPalette SDL_DestroyPalette_REAL +#define SDL_DestroyProcess SDL_DestroyProcess_REAL +#define SDL_DestroyProperties SDL_DestroyProperties_REAL +#define SDL_DestroyRWLock SDL_DestroyRWLock_REAL +#define SDL_DestroyRenderer SDL_DestroyRenderer_REAL +#define SDL_DestroySemaphore SDL_DestroySemaphore_REAL +#define SDL_DestroySurface SDL_DestroySurface_REAL +#define SDL_DestroyTexture SDL_DestroyTexture_REAL +#define SDL_DestroyWindow SDL_DestroyWindow_REAL +#define SDL_DestroyWindowSurface SDL_DestroyWindowSurface_REAL +#define SDL_DetachThread SDL_DetachThread_REAL +#define SDL_DetachVirtualJoystick SDL_DetachVirtualJoystick_REAL +#define SDL_DisableScreenSaver SDL_DisableScreenSaver_REAL +#define SDL_DispatchGPUCompute SDL_DispatchGPUCompute_REAL +#define SDL_DispatchGPUComputeIndirect SDL_DispatchGPUComputeIndirect_REAL +#define SDL_DownloadFromGPUBuffer SDL_DownloadFromGPUBuffer_REAL +#define SDL_DownloadFromGPUTexture SDL_DownloadFromGPUTexture_REAL +#define SDL_DrawGPUIndexedPrimitives SDL_DrawGPUIndexedPrimitives_REAL +#define SDL_DrawGPUIndexedPrimitivesIndirect SDL_DrawGPUIndexedPrimitivesIndirect_REAL +#define SDL_DrawGPUPrimitives SDL_DrawGPUPrimitives_REAL +#define SDL_DrawGPUPrimitivesIndirect SDL_DrawGPUPrimitivesIndirect_REAL +#define SDL_DuplicateSurface SDL_DuplicateSurface_REAL +#define SDL_EGL_GetCurrentConfig SDL_EGL_GetCurrentConfig_REAL +#define SDL_EGL_GetCurrentDisplay SDL_EGL_GetCurrentDisplay_REAL +#define SDL_EGL_GetProcAddress SDL_EGL_GetProcAddress_REAL +#define SDL_EGL_GetWindowSurface SDL_EGL_GetWindowSurface_REAL +#define SDL_EGL_SetAttributeCallbacks SDL_EGL_SetAttributeCallbacks_REAL +#define SDL_EnableScreenSaver SDL_EnableScreenSaver_REAL +#define SDL_EndGPUComputePass SDL_EndGPUComputePass_REAL +#define SDL_EndGPUCopyPass SDL_EndGPUCopyPass_REAL +#define SDL_EndGPURenderPass SDL_EndGPURenderPass_REAL +#define SDL_EnterAppMainCallbacks SDL_EnterAppMainCallbacks_REAL +#define SDL_EnumerateDirectory SDL_EnumerateDirectory_REAL +#define SDL_EnumerateProperties SDL_EnumerateProperties_REAL +#define SDL_EnumerateStorageDirectory SDL_EnumerateStorageDirectory_REAL +#define SDL_EventEnabled SDL_EventEnabled_REAL +#define SDL_FillSurfaceRect SDL_FillSurfaceRect_REAL +#define SDL_FillSurfaceRects SDL_FillSurfaceRects_REAL +#define SDL_FilterEvents SDL_FilterEvents_REAL +#define SDL_FlashWindow SDL_FlashWindow_REAL +#define SDL_FlipSurface SDL_FlipSurface_REAL +#define SDL_FlushAudioStream SDL_FlushAudioStream_REAL +#define SDL_FlushEvent SDL_FlushEvent_REAL +#define SDL_FlushEvents SDL_FlushEvents_REAL +#define SDL_FlushIO SDL_FlushIO_REAL +#define SDL_FlushRenderer SDL_FlushRenderer_REAL +#define SDL_GDKResumeGPU SDL_GDKResumeGPU_REAL +#define SDL_GDKSuspendComplete SDL_GDKSuspendComplete_REAL +#define SDL_GDKSuspendGPU SDL_GDKSuspendGPU_REAL +#define SDL_GL_CreateContext SDL_GL_CreateContext_REAL +#define SDL_GL_DestroyContext SDL_GL_DestroyContext_REAL +#define SDL_GL_ExtensionSupported SDL_GL_ExtensionSupported_REAL +#define SDL_GL_GetAttribute SDL_GL_GetAttribute_REAL +#define SDL_GL_GetCurrentContext SDL_GL_GetCurrentContext_REAL +#define SDL_GL_GetCurrentWindow SDL_GL_GetCurrentWindow_REAL +#define SDL_GL_GetProcAddress SDL_GL_GetProcAddress_REAL +#define SDL_GL_GetSwapInterval SDL_GL_GetSwapInterval_REAL +#define SDL_GL_LoadLibrary SDL_GL_LoadLibrary_REAL +#define SDL_GL_MakeCurrent SDL_GL_MakeCurrent_REAL +#define SDL_GL_ResetAttributes SDL_GL_ResetAttributes_REAL +#define SDL_GL_SetAttribute SDL_GL_SetAttribute_REAL +#define SDL_GL_SetSwapInterval SDL_GL_SetSwapInterval_REAL +#define SDL_GL_SwapWindow SDL_GL_SwapWindow_REAL +#define SDL_GL_UnloadLibrary SDL_GL_UnloadLibrary_REAL +#define SDL_GPUSupportsProperties SDL_GPUSupportsProperties_REAL +#define SDL_GPUSupportsShaderFormats SDL_GPUSupportsShaderFormats_REAL +#define SDL_GPUTextureFormatTexelBlockSize SDL_GPUTextureFormatTexelBlockSize_REAL +#define SDL_GPUTextureSupportsFormat SDL_GPUTextureSupportsFormat_REAL +#define SDL_GPUTextureSupportsSampleCount SDL_GPUTextureSupportsSampleCount_REAL +#define SDL_GUIDToString SDL_GUIDToString_REAL +#define SDL_GamepadConnected SDL_GamepadConnected_REAL +#define SDL_GamepadEventsEnabled SDL_GamepadEventsEnabled_REAL +#define SDL_GamepadHasAxis SDL_GamepadHasAxis_REAL +#define SDL_GamepadHasButton SDL_GamepadHasButton_REAL +#define SDL_GamepadHasSensor SDL_GamepadHasSensor_REAL +#define SDL_GamepadSensorEnabled SDL_GamepadSensorEnabled_REAL +#define SDL_GenerateMipmapsForGPUTexture SDL_GenerateMipmapsForGPUTexture_REAL +#define SDL_GetAndroidActivity SDL_GetAndroidActivity_REAL +#define SDL_GetAndroidCachePath SDL_GetAndroidCachePath_REAL +#define SDL_GetAndroidExternalStoragePath SDL_GetAndroidExternalStoragePath_REAL +#define SDL_GetAndroidExternalStorageState SDL_GetAndroidExternalStorageState_REAL +#define SDL_GetAndroidInternalStoragePath SDL_GetAndroidInternalStoragePath_REAL +#define SDL_GetAndroidJNIEnv SDL_GetAndroidJNIEnv_REAL +#define SDL_GetAndroidSDKVersion SDL_GetAndroidSDKVersion_REAL +#define SDL_GetAppMetadataProperty SDL_GetAppMetadataProperty_REAL +#define SDL_GetAssertionHandler SDL_GetAssertionHandler_REAL +#define SDL_GetAssertionReport SDL_GetAssertionReport_REAL +#define SDL_GetAtomicInt SDL_GetAtomicInt_REAL +#define SDL_GetAtomicPointer SDL_GetAtomicPointer_REAL +#define SDL_GetAtomicU32 SDL_GetAtomicU32_REAL +#define SDL_GetAudioDeviceChannelMap SDL_GetAudioDeviceChannelMap_REAL +#define SDL_GetAudioDeviceFormat SDL_GetAudioDeviceFormat_REAL +#define SDL_GetAudioDeviceGain SDL_GetAudioDeviceGain_REAL +#define SDL_GetAudioDeviceName SDL_GetAudioDeviceName_REAL +#define SDL_GetAudioDriver SDL_GetAudioDriver_REAL +#define SDL_GetAudioFormatName SDL_GetAudioFormatName_REAL +#define SDL_GetAudioPlaybackDevices SDL_GetAudioPlaybackDevices_REAL +#define SDL_GetAudioRecordingDevices SDL_GetAudioRecordingDevices_REAL +#define SDL_GetAudioStreamAvailable SDL_GetAudioStreamAvailable_REAL +#define SDL_GetAudioStreamData SDL_GetAudioStreamData_REAL +#define SDL_GetAudioStreamDevice SDL_GetAudioStreamDevice_REAL +#define SDL_GetAudioStreamFormat SDL_GetAudioStreamFormat_REAL +#define SDL_GetAudioStreamFrequencyRatio SDL_GetAudioStreamFrequencyRatio_REAL +#define SDL_GetAudioStreamGain SDL_GetAudioStreamGain_REAL +#define SDL_GetAudioStreamInputChannelMap SDL_GetAudioStreamInputChannelMap_REAL +#define SDL_GetAudioStreamOutputChannelMap SDL_GetAudioStreamOutputChannelMap_REAL +#define SDL_GetAudioStreamProperties SDL_GetAudioStreamProperties_REAL +#define SDL_GetAudioStreamQueued SDL_GetAudioStreamQueued_REAL +#define SDL_GetBasePath SDL_GetBasePath_REAL +#define SDL_GetBooleanProperty SDL_GetBooleanProperty_REAL +#define SDL_GetCPUCacheLineSize SDL_GetCPUCacheLineSize_REAL +#define SDL_GetCameraDriver SDL_GetCameraDriver_REAL +#define SDL_GetCameraFormat SDL_GetCameraFormat_REAL +#define SDL_GetCameraID SDL_GetCameraID_REAL +#define SDL_GetCameraName SDL_GetCameraName_REAL +#define SDL_GetCameraPermissionState SDL_GetCameraPermissionState_REAL +#define SDL_GetCameraPosition SDL_GetCameraPosition_REAL +#define SDL_GetCameraProperties SDL_GetCameraProperties_REAL +#define SDL_GetCameraSupportedFormats SDL_GetCameraSupportedFormats_REAL +#define SDL_GetCameras SDL_GetCameras_REAL +#define SDL_GetClipboardData SDL_GetClipboardData_REAL +#define SDL_GetClipboardMimeTypes SDL_GetClipboardMimeTypes_REAL +#define SDL_GetClipboardText SDL_GetClipboardText_REAL +#define SDL_GetClosestFullscreenDisplayMode SDL_GetClosestFullscreenDisplayMode_REAL +#define SDL_GetCurrentAudioDriver SDL_GetCurrentAudioDriver_REAL +#define SDL_GetCurrentCameraDriver SDL_GetCurrentCameraDriver_REAL +#define SDL_GetCurrentDisplayMode SDL_GetCurrentDisplayMode_REAL +#define SDL_GetCurrentDisplayOrientation SDL_GetCurrentDisplayOrientation_REAL +#define SDL_GetCurrentRenderOutputSize SDL_GetCurrentRenderOutputSize_REAL +#define SDL_GetCurrentThreadID SDL_GetCurrentThreadID_REAL +#define SDL_GetCurrentTime SDL_GetCurrentTime_REAL +#define SDL_GetCurrentVideoDriver SDL_GetCurrentVideoDriver_REAL +#define SDL_GetCursor SDL_GetCursor_REAL +#define SDL_GetDXGIOutputInfo SDL_GetDXGIOutputInfo_REAL +#define SDL_GetDateTimeLocalePreferences SDL_GetDateTimeLocalePreferences_REAL +#define SDL_GetDayOfWeek SDL_GetDayOfWeek_REAL +#define SDL_GetDayOfYear SDL_GetDayOfYear_REAL +#define SDL_GetDaysInMonth SDL_GetDaysInMonth_REAL +#define SDL_GetDefaultAssertionHandler SDL_GetDefaultAssertionHandler_REAL +#define SDL_GetDefaultCursor SDL_GetDefaultCursor_REAL +#define SDL_GetDesktopDisplayMode SDL_GetDesktopDisplayMode_REAL +#define SDL_GetDirect3D9AdapterIndex SDL_GetDirect3D9AdapterIndex_REAL +#define SDL_GetDisplayBounds SDL_GetDisplayBounds_REAL +#define SDL_GetDisplayContentScale SDL_GetDisplayContentScale_REAL +#define SDL_GetDisplayForPoint SDL_GetDisplayForPoint_REAL +#define SDL_GetDisplayForRect SDL_GetDisplayForRect_REAL +#define SDL_GetDisplayForWindow SDL_GetDisplayForWindow_REAL +#define SDL_GetDisplayName SDL_GetDisplayName_REAL +#define SDL_GetDisplayProperties SDL_GetDisplayProperties_REAL +#define SDL_GetDisplayUsableBounds SDL_GetDisplayUsableBounds_REAL +#define SDL_GetDisplays SDL_GetDisplays_REAL +#define SDL_GetEnvironment SDL_GetEnvironment_REAL +#define SDL_GetEnvironmentVariable SDL_GetEnvironmentVariable_REAL +#define SDL_GetEnvironmentVariables SDL_GetEnvironmentVariables_REAL +#define SDL_GetError SDL_GetError_REAL +#define SDL_GetEventFilter SDL_GetEventFilter_REAL +#define SDL_GetFloatProperty SDL_GetFloatProperty_REAL +#define SDL_GetFullscreenDisplayModes SDL_GetFullscreenDisplayModes_REAL +#define SDL_GetGDKDefaultUser SDL_GetGDKDefaultUser_REAL +#define SDL_GetGDKTaskQueue SDL_GetGDKTaskQueue_REAL +#define SDL_GetGPUDeviceDriver SDL_GetGPUDeviceDriver_REAL +#define SDL_GetGPUDriver SDL_GetGPUDriver_REAL +#define SDL_GetGPUShaderFormats SDL_GetGPUShaderFormats_REAL +#define SDL_GetGPUSwapchainTextureFormat SDL_GetGPUSwapchainTextureFormat_REAL +#define SDL_GetGamepadAppleSFSymbolsNameForAxis SDL_GetGamepadAppleSFSymbolsNameForAxis_REAL +#define SDL_GetGamepadAppleSFSymbolsNameForButton SDL_GetGamepadAppleSFSymbolsNameForButton_REAL +#define SDL_GetGamepadAxis SDL_GetGamepadAxis_REAL +#define SDL_GetGamepadAxisFromString SDL_GetGamepadAxisFromString_REAL +#define SDL_GetGamepadBindings SDL_GetGamepadBindings_REAL +#define SDL_GetGamepadButton SDL_GetGamepadButton_REAL +#define SDL_GetGamepadButtonFromString SDL_GetGamepadButtonFromString_REAL +#define SDL_GetGamepadButtonLabel SDL_GetGamepadButtonLabel_REAL +#define SDL_GetGamepadButtonLabelForType SDL_GetGamepadButtonLabelForType_REAL +#define SDL_GetGamepadConnectionState SDL_GetGamepadConnectionState_REAL +#define SDL_GetGamepadFirmwareVersion SDL_GetGamepadFirmwareVersion_REAL +#define SDL_GetGamepadFromID SDL_GetGamepadFromID_REAL +#define SDL_GetGamepadFromPlayerIndex SDL_GetGamepadFromPlayerIndex_REAL +#define SDL_GetGamepadGUIDForID SDL_GetGamepadGUIDForID_REAL +#define SDL_GetGamepadID SDL_GetGamepadID_REAL +#define SDL_GetGamepadJoystick SDL_GetGamepadJoystick_REAL +#define SDL_GetGamepadMapping SDL_GetGamepadMapping_REAL +#define SDL_GetGamepadMappingForGUID SDL_GetGamepadMappingForGUID_REAL +#define SDL_GetGamepadMappingForID SDL_GetGamepadMappingForID_REAL +#define SDL_GetGamepadMappings SDL_GetGamepadMappings_REAL +#define SDL_GetGamepadName SDL_GetGamepadName_REAL +#define SDL_GetGamepadNameForID SDL_GetGamepadNameForID_REAL +#define SDL_GetGamepadPath SDL_GetGamepadPath_REAL +#define SDL_GetGamepadPathForID SDL_GetGamepadPathForID_REAL +#define SDL_GetGamepadPlayerIndex SDL_GetGamepadPlayerIndex_REAL +#define SDL_GetGamepadPlayerIndexForID SDL_GetGamepadPlayerIndexForID_REAL +#define SDL_GetGamepadPowerInfo SDL_GetGamepadPowerInfo_REAL +#define SDL_GetGamepadProduct SDL_GetGamepadProduct_REAL +#define SDL_GetGamepadProductForID SDL_GetGamepadProductForID_REAL +#define SDL_GetGamepadProductVersion SDL_GetGamepadProductVersion_REAL +#define SDL_GetGamepadProductVersionForID SDL_GetGamepadProductVersionForID_REAL +#define SDL_GetGamepadProperties SDL_GetGamepadProperties_REAL +#define SDL_GetGamepadSensorData SDL_GetGamepadSensorData_REAL +#define SDL_GetGamepadSensorDataRate SDL_GetGamepadSensorDataRate_REAL +#define SDL_GetGamepadSerial SDL_GetGamepadSerial_REAL +#define SDL_GetGamepadSteamHandle SDL_GetGamepadSteamHandle_REAL +#define SDL_GetGamepadStringForAxis SDL_GetGamepadStringForAxis_REAL +#define SDL_GetGamepadStringForButton SDL_GetGamepadStringForButton_REAL +#define SDL_GetGamepadStringForType SDL_GetGamepadStringForType_REAL +#define SDL_GetGamepadTouchpadFinger SDL_GetGamepadTouchpadFinger_REAL +#define SDL_GetGamepadType SDL_GetGamepadType_REAL +#define SDL_GetGamepadTypeForID SDL_GetGamepadTypeForID_REAL +#define SDL_GetGamepadTypeFromString SDL_GetGamepadTypeFromString_REAL +#define SDL_GetGamepadVendor SDL_GetGamepadVendor_REAL +#define SDL_GetGamepadVendorForID SDL_GetGamepadVendorForID_REAL +#define SDL_GetGamepads SDL_GetGamepads_REAL +#define SDL_GetGlobalMouseState SDL_GetGlobalMouseState_REAL +#define SDL_GetGlobalProperties SDL_GetGlobalProperties_REAL +#define SDL_GetGrabbedWindow SDL_GetGrabbedWindow_REAL +#define SDL_GetHapticEffectStatus SDL_GetHapticEffectStatus_REAL +#define SDL_GetHapticFeatures SDL_GetHapticFeatures_REAL +#define SDL_GetHapticFromID SDL_GetHapticFromID_REAL +#define SDL_GetHapticID SDL_GetHapticID_REAL +#define SDL_GetHapticName SDL_GetHapticName_REAL +#define SDL_GetHapticNameForID SDL_GetHapticNameForID_REAL +#define SDL_GetHaptics SDL_GetHaptics_REAL +#define SDL_GetHint SDL_GetHint_REAL +#define SDL_GetHintBoolean SDL_GetHintBoolean_REAL +#define SDL_GetIOProperties SDL_GetIOProperties_REAL +#define SDL_GetIOSize SDL_GetIOSize_REAL +#define SDL_GetIOStatus SDL_GetIOStatus_REAL +#define SDL_GetJoystickAxis SDL_GetJoystickAxis_REAL +#define SDL_GetJoystickAxisInitialState SDL_GetJoystickAxisInitialState_REAL +#define SDL_GetJoystickBall SDL_GetJoystickBall_REAL +#define SDL_GetJoystickButton SDL_GetJoystickButton_REAL +#define SDL_GetJoystickConnectionState SDL_GetJoystickConnectionState_REAL +#define SDL_GetJoystickFirmwareVersion SDL_GetJoystickFirmwareVersion_REAL +#define SDL_GetJoystickFromID SDL_GetJoystickFromID_REAL +#define SDL_GetJoystickFromPlayerIndex SDL_GetJoystickFromPlayerIndex_REAL +#define SDL_GetJoystickGUID SDL_GetJoystickGUID_REAL +#define SDL_GetJoystickGUIDForID SDL_GetJoystickGUIDForID_REAL +#define SDL_GetJoystickGUIDInfo SDL_GetJoystickGUIDInfo_REAL +#define SDL_GetJoystickHat SDL_GetJoystickHat_REAL +#define SDL_GetJoystickID SDL_GetJoystickID_REAL +#define SDL_GetJoystickName SDL_GetJoystickName_REAL +#define SDL_GetJoystickNameForID SDL_GetJoystickNameForID_REAL +#define SDL_GetJoystickPath SDL_GetJoystickPath_REAL +#define SDL_GetJoystickPathForID SDL_GetJoystickPathForID_REAL +#define SDL_GetJoystickPlayerIndex SDL_GetJoystickPlayerIndex_REAL +#define SDL_GetJoystickPlayerIndexForID SDL_GetJoystickPlayerIndexForID_REAL +#define SDL_GetJoystickPowerInfo SDL_GetJoystickPowerInfo_REAL +#define SDL_GetJoystickProduct SDL_GetJoystickProduct_REAL +#define SDL_GetJoystickProductForID SDL_GetJoystickProductForID_REAL +#define SDL_GetJoystickProductVersion SDL_GetJoystickProductVersion_REAL +#define SDL_GetJoystickProductVersionForID SDL_GetJoystickProductVersionForID_REAL +#define SDL_GetJoystickProperties SDL_GetJoystickProperties_REAL +#define SDL_GetJoystickSerial SDL_GetJoystickSerial_REAL +#define SDL_GetJoystickType SDL_GetJoystickType_REAL +#define SDL_GetJoystickTypeForID SDL_GetJoystickTypeForID_REAL +#define SDL_GetJoystickVendor SDL_GetJoystickVendor_REAL +#define SDL_GetJoystickVendorForID SDL_GetJoystickVendorForID_REAL +#define SDL_GetJoysticks SDL_GetJoysticks_REAL +#define SDL_GetKeyFromName SDL_GetKeyFromName_REAL +#define SDL_GetKeyFromScancode SDL_GetKeyFromScancode_REAL +#define SDL_GetKeyName SDL_GetKeyName_REAL +#define SDL_GetKeyboardFocus SDL_GetKeyboardFocus_REAL +#define SDL_GetKeyboardNameForID SDL_GetKeyboardNameForID_REAL +#define SDL_GetKeyboardState SDL_GetKeyboardState_REAL +#define SDL_GetKeyboards SDL_GetKeyboards_REAL +#define SDL_GetLogOutputFunction SDL_GetLogOutputFunction_REAL +#define SDL_GetLogPriority SDL_GetLogPriority_REAL +#define SDL_GetMasksForPixelFormat SDL_GetMasksForPixelFormat_REAL +#define SDL_GetMaxHapticEffects SDL_GetMaxHapticEffects_REAL +#define SDL_GetMaxHapticEffectsPlaying SDL_GetMaxHapticEffectsPlaying_REAL +#define SDL_GetMemoryFunctions SDL_GetMemoryFunctions_REAL +#define SDL_GetMice SDL_GetMice_REAL +#define SDL_GetModState SDL_GetModState_REAL +#define SDL_GetMouseFocus SDL_GetMouseFocus_REAL +#define SDL_GetMouseNameForID SDL_GetMouseNameForID_REAL +#define SDL_GetMouseState SDL_GetMouseState_REAL +#define SDL_GetNaturalDisplayOrientation SDL_GetNaturalDisplayOrientation_REAL +#define SDL_GetNumAllocations SDL_GetNumAllocations_REAL +#define SDL_GetNumAudioDrivers SDL_GetNumAudioDrivers_REAL +#define SDL_GetNumCameraDrivers SDL_GetNumCameraDrivers_REAL +#define SDL_GetNumGPUDrivers SDL_GetNumGPUDrivers_REAL +#define SDL_GetNumGamepadTouchpadFingers SDL_GetNumGamepadTouchpadFingers_REAL +#define SDL_GetNumGamepadTouchpads SDL_GetNumGamepadTouchpads_REAL +#define SDL_GetNumHapticAxes SDL_GetNumHapticAxes_REAL +#define SDL_GetNumJoystickAxes SDL_GetNumJoystickAxes_REAL +#define SDL_GetNumJoystickBalls SDL_GetNumJoystickBalls_REAL +#define SDL_GetNumJoystickButtons SDL_GetNumJoystickButtons_REAL +#define SDL_GetNumJoystickHats SDL_GetNumJoystickHats_REAL +#define SDL_GetNumLogicalCPUCores SDL_GetNumLogicalCPUCores_REAL +#define SDL_GetNumRenderDrivers SDL_GetNumRenderDrivers_REAL +#define SDL_GetNumVideoDrivers SDL_GetNumVideoDrivers_REAL +#define SDL_GetNumberProperty SDL_GetNumberProperty_REAL +#define SDL_GetOriginalMemoryFunctions SDL_GetOriginalMemoryFunctions_REAL +#define SDL_GetPathInfo SDL_GetPathInfo_REAL +#define SDL_GetPerformanceCounter SDL_GetPerformanceCounter_REAL +#define SDL_GetPerformanceFrequency SDL_GetPerformanceFrequency_REAL +#define SDL_GetPixelFormatDetails SDL_GetPixelFormatDetails_REAL +#define SDL_GetPixelFormatForMasks SDL_GetPixelFormatForMasks_REAL +#define SDL_GetPixelFormatName SDL_GetPixelFormatName_REAL +#define SDL_GetPlatform SDL_GetPlatform_REAL +#define SDL_GetPointerProperty SDL_GetPointerProperty_REAL +#define SDL_GetPowerInfo SDL_GetPowerInfo_REAL +#define SDL_GetPrefPath SDL_GetPrefPath_REAL +#define SDL_GetPreferredLocales SDL_GetPreferredLocales_REAL +#define SDL_GetPrimaryDisplay SDL_GetPrimaryDisplay_REAL +#define SDL_GetPrimarySelectionText SDL_GetPrimarySelectionText_REAL +#define SDL_GetProcessInput SDL_GetProcessInput_REAL +#define SDL_GetProcessOutput SDL_GetProcessOutput_REAL +#define SDL_GetProcessProperties SDL_GetProcessProperties_REAL +#define SDL_GetPropertyType SDL_GetPropertyType_REAL +#define SDL_GetRGB SDL_GetRGB_REAL +#define SDL_GetRGBA SDL_GetRGBA_REAL +#define SDL_GetRealGamepadType SDL_GetRealGamepadType_REAL +#define SDL_GetRealGamepadTypeForID SDL_GetRealGamepadTypeForID_REAL +#define SDL_GetRectAndLineIntersection SDL_GetRectAndLineIntersection_REAL +#define SDL_GetRectAndLineIntersectionFloat SDL_GetRectAndLineIntersectionFloat_REAL +#define SDL_GetRectEnclosingPoints SDL_GetRectEnclosingPoints_REAL +#define SDL_GetRectEnclosingPointsFloat SDL_GetRectEnclosingPointsFloat_REAL +#define SDL_GetRectIntersection SDL_GetRectIntersection_REAL +#define SDL_GetRectIntersectionFloat SDL_GetRectIntersectionFloat_REAL +#define SDL_GetRectUnion SDL_GetRectUnion_REAL +#define SDL_GetRectUnionFloat SDL_GetRectUnionFloat_REAL +#define SDL_GetRelativeMouseState SDL_GetRelativeMouseState_REAL +#define SDL_GetRenderClipRect SDL_GetRenderClipRect_REAL +#define SDL_GetRenderColorScale SDL_GetRenderColorScale_REAL +#define SDL_GetRenderDrawBlendMode SDL_GetRenderDrawBlendMode_REAL +#define SDL_GetRenderDrawColor SDL_GetRenderDrawColor_REAL +#define SDL_GetRenderDrawColorFloat SDL_GetRenderDrawColorFloat_REAL +#define SDL_GetRenderDriver SDL_GetRenderDriver_REAL +#define SDL_GetRenderLogicalPresentation SDL_GetRenderLogicalPresentation_REAL +#define SDL_GetRenderLogicalPresentationRect SDL_GetRenderLogicalPresentationRect_REAL +#define SDL_GetRenderMetalCommandEncoder SDL_GetRenderMetalCommandEncoder_REAL +#define SDL_GetRenderMetalLayer SDL_GetRenderMetalLayer_REAL +#define SDL_GetRenderOutputSize SDL_GetRenderOutputSize_REAL +#define SDL_GetRenderSafeArea SDL_GetRenderSafeArea_REAL +#define SDL_GetRenderScale SDL_GetRenderScale_REAL +#define SDL_GetRenderTarget SDL_GetRenderTarget_REAL +#define SDL_GetRenderVSync SDL_GetRenderVSync_REAL +#define SDL_GetRenderViewport SDL_GetRenderViewport_REAL +#define SDL_GetRenderWindow SDL_GetRenderWindow_REAL +#define SDL_GetRenderer SDL_GetRenderer_REAL +#define SDL_GetRendererFromTexture SDL_GetRendererFromTexture_REAL +#define SDL_GetRendererName SDL_GetRendererName_REAL +#define SDL_GetRendererProperties SDL_GetRendererProperties_REAL +#define SDL_GetRevision SDL_GetRevision_REAL +#define SDL_GetSIMDAlignment SDL_GetSIMDAlignment_REAL +#define SDL_GetScancodeFromKey SDL_GetScancodeFromKey_REAL +#define SDL_GetScancodeFromName SDL_GetScancodeFromName_REAL +#define SDL_GetScancodeName SDL_GetScancodeName_REAL +#define SDL_GetSemaphoreValue SDL_GetSemaphoreValue_REAL +#define SDL_GetSensorData SDL_GetSensorData_REAL +#define SDL_GetSensorFromID SDL_GetSensorFromID_REAL +#define SDL_GetSensorID SDL_GetSensorID_REAL +#define SDL_GetSensorName SDL_GetSensorName_REAL +#define SDL_GetSensorNameForID SDL_GetSensorNameForID_REAL +#define SDL_GetSensorNonPortableType SDL_GetSensorNonPortableType_REAL +#define SDL_GetSensorNonPortableTypeForID SDL_GetSensorNonPortableTypeForID_REAL +#define SDL_GetSensorProperties SDL_GetSensorProperties_REAL +#define SDL_GetSensorType SDL_GetSensorType_REAL +#define SDL_GetSensorTypeForID SDL_GetSensorTypeForID_REAL +#define SDL_GetSensors SDL_GetSensors_REAL +#define SDL_GetSilenceValueForFormat SDL_GetSilenceValueForFormat_REAL +#define SDL_GetStorageFileSize SDL_GetStorageFileSize_REAL +#define SDL_GetStoragePathInfo SDL_GetStoragePathInfo_REAL +#define SDL_GetStorageSpaceRemaining SDL_GetStorageSpaceRemaining_REAL +#define SDL_GetStringProperty SDL_GetStringProperty_REAL +#define SDL_GetSurfaceAlphaMod SDL_GetSurfaceAlphaMod_REAL +#define SDL_GetSurfaceBlendMode SDL_GetSurfaceBlendMode_REAL +#define SDL_GetSurfaceClipRect SDL_GetSurfaceClipRect_REAL +#define SDL_GetSurfaceColorKey SDL_GetSurfaceColorKey_REAL +#define SDL_GetSurfaceColorMod SDL_GetSurfaceColorMod_REAL +#define SDL_GetSurfaceColorspace SDL_GetSurfaceColorspace_REAL +#define SDL_GetSurfaceImages SDL_GetSurfaceImages_REAL +#define SDL_GetSurfacePalette SDL_GetSurfacePalette_REAL +#define SDL_GetSurfaceProperties SDL_GetSurfaceProperties_REAL +#define SDL_GetSystemRAM SDL_GetSystemRAM_REAL +#define SDL_GetSystemTheme SDL_GetSystemTheme_REAL +#define SDL_GetTLS SDL_GetTLS_REAL +#define SDL_GetTextInputArea SDL_GetTextInputArea_REAL +#define SDL_GetTextureAlphaMod SDL_GetTextureAlphaMod_REAL +#define SDL_GetTextureAlphaModFloat SDL_GetTextureAlphaModFloat_REAL +#define SDL_GetTextureBlendMode SDL_GetTextureBlendMode_REAL +#define SDL_GetTextureColorMod SDL_GetTextureColorMod_REAL +#define SDL_GetTextureColorModFloat SDL_GetTextureColorModFloat_REAL +#define SDL_GetTextureProperties SDL_GetTextureProperties_REAL +#define SDL_GetTextureScaleMode SDL_GetTextureScaleMode_REAL +#define SDL_GetTextureSize SDL_GetTextureSize_REAL +#define SDL_GetThreadID SDL_GetThreadID_REAL +#define SDL_GetThreadName SDL_GetThreadName_REAL +#define SDL_GetTicks SDL_GetTicks_REAL +#define SDL_GetTicksNS SDL_GetTicksNS_REAL +#define SDL_GetTouchDeviceName SDL_GetTouchDeviceName_REAL +#define SDL_GetTouchDeviceType SDL_GetTouchDeviceType_REAL +#define SDL_GetTouchDevices SDL_GetTouchDevices_REAL +#define SDL_GetTouchFingers SDL_GetTouchFingers_REAL +#define SDL_GetUserFolder SDL_GetUserFolder_REAL +#define SDL_GetVersion SDL_GetVersion_REAL +#define SDL_GetVideoDriver SDL_GetVideoDriver_REAL +#define SDL_GetWindowAspectRatio SDL_GetWindowAspectRatio_REAL +#define SDL_GetWindowBordersSize SDL_GetWindowBordersSize_REAL +#define SDL_GetWindowDisplayScale SDL_GetWindowDisplayScale_REAL +#define SDL_GetWindowFlags SDL_GetWindowFlags_REAL +#define SDL_GetWindowFromEvent SDL_GetWindowFromEvent_REAL +#define SDL_GetWindowFromID SDL_GetWindowFromID_REAL +#define SDL_GetWindowFullscreenMode SDL_GetWindowFullscreenMode_REAL +#define SDL_GetWindowICCProfile SDL_GetWindowICCProfile_REAL +#define SDL_GetWindowID SDL_GetWindowID_REAL +#define SDL_GetWindowKeyboardGrab SDL_GetWindowKeyboardGrab_REAL +#define SDL_GetWindowMaximumSize SDL_GetWindowMaximumSize_REAL +#define SDL_GetWindowMinimumSize SDL_GetWindowMinimumSize_REAL +#define SDL_GetWindowMouseGrab SDL_GetWindowMouseGrab_REAL +#define SDL_GetWindowMouseRect SDL_GetWindowMouseRect_REAL +#define SDL_GetWindowOpacity SDL_GetWindowOpacity_REAL +#define SDL_GetWindowParent SDL_GetWindowParent_REAL +#define SDL_GetWindowPixelDensity SDL_GetWindowPixelDensity_REAL +#define SDL_GetWindowPixelFormat SDL_GetWindowPixelFormat_REAL +#define SDL_GetWindowPosition SDL_GetWindowPosition_REAL +#define SDL_GetWindowProperties SDL_GetWindowProperties_REAL +#define SDL_GetWindowRelativeMouseMode SDL_GetWindowRelativeMouseMode_REAL +#define SDL_GetWindowSafeArea SDL_GetWindowSafeArea_REAL +#define SDL_GetWindowSize SDL_GetWindowSize_REAL +#define SDL_GetWindowSizeInPixels SDL_GetWindowSizeInPixels_REAL +#define SDL_GetWindowSurface SDL_GetWindowSurface_REAL +#define SDL_GetWindowSurfaceVSync SDL_GetWindowSurfaceVSync_REAL +#define SDL_GetWindowTitle SDL_GetWindowTitle_REAL +#define SDL_GetWindows SDL_GetWindows_REAL +#define SDL_GlobDirectory SDL_GlobDirectory_REAL +#define SDL_GlobStorageDirectory SDL_GlobStorageDirectory_REAL +#define SDL_HapticEffectSupported SDL_HapticEffectSupported_REAL +#define SDL_HapticRumbleSupported SDL_HapticRumbleSupported_REAL +#define SDL_HasARMSIMD SDL_HasARMSIMD_REAL +#define SDL_HasAVX SDL_HasAVX_REAL +#define SDL_HasAVX2 SDL_HasAVX2_REAL +#define SDL_HasAVX512F SDL_HasAVX512F_REAL +#define SDL_HasAltiVec SDL_HasAltiVec_REAL +#define SDL_HasClipboardData SDL_HasClipboardData_REAL +#define SDL_HasClipboardText SDL_HasClipboardText_REAL +#define SDL_HasEvent SDL_HasEvent_REAL +#define SDL_HasEvents SDL_HasEvents_REAL +#define SDL_HasGamepad SDL_HasGamepad_REAL +#define SDL_HasJoystick SDL_HasJoystick_REAL +#define SDL_HasKeyboard SDL_HasKeyboard_REAL +#define SDL_HasLASX SDL_HasLASX_REAL +#define SDL_HasLSX SDL_HasLSX_REAL +#define SDL_HasMMX SDL_HasMMX_REAL +#define SDL_HasMouse SDL_HasMouse_REAL +#define SDL_HasNEON SDL_HasNEON_REAL +#define SDL_HasPrimarySelectionText SDL_HasPrimarySelectionText_REAL +#define SDL_HasProperty SDL_HasProperty_REAL +#define SDL_HasRectIntersection SDL_HasRectIntersection_REAL +#define SDL_HasRectIntersectionFloat SDL_HasRectIntersectionFloat_REAL +#define SDL_HasSSE SDL_HasSSE_REAL +#define SDL_HasSSE2 SDL_HasSSE2_REAL +#define SDL_HasSSE3 SDL_HasSSE3_REAL +#define SDL_HasSSE41 SDL_HasSSE41_REAL +#define SDL_HasSSE42 SDL_HasSSE42_REAL +#define SDL_HasScreenKeyboardSupport SDL_HasScreenKeyboardSupport_REAL +#define SDL_HideCursor SDL_HideCursor_REAL +#define SDL_HideWindow SDL_HideWindow_REAL +#define SDL_IOFromConstMem SDL_IOFromConstMem_REAL +#define SDL_IOFromDynamicMem SDL_IOFromDynamicMem_REAL +#define SDL_IOFromFile SDL_IOFromFile_REAL +#define SDL_IOFromMem SDL_IOFromMem_REAL +#define SDL_IOprintf SDL_IOprintf_REAL +#define SDL_IOvprintf SDL_IOvprintf_REAL +#define SDL_Init SDL_Init_REAL +#define SDL_InitHapticRumble SDL_InitHapticRumble_REAL +#define SDL_InitSubSystem SDL_InitSubSystem_REAL +#define SDL_InsertGPUDebugLabel SDL_InsertGPUDebugLabel_REAL +#define SDL_IsChromebook SDL_IsChromebook_REAL +#define SDL_IsDeXMode SDL_IsDeXMode_REAL +#define SDL_IsGamepad SDL_IsGamepad_REAL +#define SDL_IsJoystickHaptic SDL_IsJoystickHaptic_REAL +#define SDL_IsJoystickVirtual SDL_IsJoystickVirtual_REAL +#define SDL_IsMouseHaptic SDL_IsMouseHaptic_REAL +#define SDL_IsTV SDL_IsTV_REAL +#define SDL_IsTablet SDL_IsTablet_REAL +#define SDL_JoystickConnected SDL_JoystickConnected_REAL +#define SDL_JoystickEventsEnabled SDL_JoystickEventsEnabled_REAL +#define SDL_KillProcess SDL_KillProcess_REAL +#define SDL_LoadBMP SDL_LoadBMP_REAL +#define SDL_LoadBMP_IO SDL_LoadBMP_IO_REAL +#define SDL_LoadFile SDL_LoadFile_REAL +#define SDL_LoadFile_IO SDL_LoadFile_IO_REAL +#define SDL_LoadFunction SDL_LoadFunction_REAL +#define SDL_LoadObject SDL_LoadObject_REAL +#define SDL_LoadWAV SDL_LoadWAV_REAL +#define SDL_LoadWAV_IO SDL_LoadWAV_IO_REAL +#define SDL_LockAudioStream SDL_LockAudioStream_REAL +#define SDL_LockJoysticks SDL_LockJoysticks_REAL +#define SDL_LockMutex SDL_LockMutex_REAL +#define SDL_LockProperties SDL_LockProperties_REAL +#define SDL_LockRWLockForReading SDL_LockRWLockForReading_REAL +#define SDL_LockRWLockForWriting SDL_LockRWLockForWriting_REAL +#define SDL_LockSpinlock SDL_LockSpinlock_REAL +#define SDL_LockSurface SDL_LockSurface_REAL +#define SDL_LockTexture SDL_LockTexture_REAL +#define SDL_LockTextureToSurface SDL_LockTextureToSurface_REAL +#define SDL_Log SDL_Log_REAL +#define SDL_LogCritical SDL_LogCritical_REAL +#define SDL_LogDebug SDL_LogDebug_REAL +#define SDL_LogError SDL_LogError_REAL +#define SDL_LogInfo SDL_LogInfo_REAL +#define SDL_LogMessage SDL_LogMessage_REAL +#define SDL_LogMessageV SDL_LogMessageV_REAL +#define SDL_LogTrace SDL_LogTrace_REAL +#define SDL_LogVerbose SDL_LogVerbose_REAL +#define SDL_LogWarn SDL_LogWarn_REAL +#define SDL_MapGPUTransferBuffer SDL_MapGPUTransferBuffer_REAL +#define SDL_MapRGB SDL_MapRGB_REAL +#define SDL_MapRGBA SDL_MapRGBA_REAL +#define SDL_MapSurfaceRGB SDL_MapSurfaceRGB_REAL +#define SDL_MapSurfaceRGBA SDL_MapSurfaceRGBA_REAL +#define SDL_MaximizeWindow SDL_MaximizeWindow_REAL +#define SDL_MemoryBarrierAcquireFunction SDL_MemoryBarrierAcquireFunction_REAL +#define SDL_MemoryBarrierReleaseFunction SDL_MemoryBarrierReleaseFunction_REAL +#define SDL_Metal_CreateView SDL_Metal_CreateView_REAL +#define SDL_Metal_DestroyView SDL_Metal_DestroyView_REAL +#define SDL_Metal_GetLayer SDL_Metal_GetLayer_REAL +#define SDL_MinimizeWindow SDL_MinimizeWindow_REAL +#define SDL_MixAudio SDL_MixAudio_REAL +#define SDL_OnApplicationDidChangeStatusBarOrientation SDL_OnApplicationDidChangeStatusBarOrientation_REAL +#define SDL_OnApplicationDidEnterBackground SDL_OnApplicationDidEnterBackground_REAL +#define SDL_OnApplicationDidEnterForeground SDL_OnApplicationDidEnterForeground_REAL +#define SDL_OnApplicationDidReceiveMemoryWarning SDL_OnApplicationDidReceiveMemoryWarning_REAL +#define SDL_OnApplicationWillEnterBackground SDL_OnApplicationWillEnterBackground_REAL +#define SDL_OnApplicationWillEnterForeground SDL_OnApplicationWillEnterForeground_REAL +#define SDL_OnApplicationWillTerminate SDL_OnApplicationWillTerminate_REAL +#define SDL_OpenAudioDevice SDL_OpenAudioDevice_REAL +#define SDL_OpenAudioDeviceStream SDL_OpenAudioDeviceStream_REAL +#define SDL_OpenCamera SDL_OpenCamera_REAL +#define SDL_OpenFileStorage SDL_OpenFileStorage_REAL +#define SDL_OpenGamepad SDL_OpenGamepad_REAL +#define SDL_OpenHaptic SDL_OpenHaptic_REAL +#define SDL_OpenHapticFromJoystick SDL_OpenHapticFromJoystick_REAL +#define SDL_OpenHapticFromMouse SDL_OpenHapticFromMouse_REAL +#define SDL_OpenIO SDL_OpenIO_REAL +#define SDL_OpenJoystick SDL_OpenJoystick_REAL +#define SDL_OpenSensor SDL_OpenSensor_REAL +#define SDL_OpenStorage SDL_OpenStorage_REAL +#define SDL_OpenTitleStorage SDL_OpenTitleStorage_REAL +#define SDL_OpenURL SDL_OpenURL_REAL +#define SDL_OpenUserStorage SDL_OpenUserStorage_REAL +#define SDL_OutOfMemory SDL_OutOfMemory_REAL +#define SDL_PauseAudioDevice SDL_PauseAudioDevice_REAL +#define SDL_PauseAudioStreamDevice SDL_PauseAudioStreamDevice_REAL +#define SDL_PauseHaptic SDL_PauseHaptic_REAL +#define SDL_PeepEvents SDL_PeepEvents_REAL +#define SDL_PlayHapticRumble SDL_PlayHapticRumble_REAL +#define SDL_PollEvent SDL_PollEvent_REAL +#define SDL_PopGPUDebugGroup SDL_PopGPUDebugGroup_REAL +#define SDL_PremultiplyAlpha SDL_PremultiplyAlpha_REAL +#define SDL_PremultiplySurfaceAlpha SDL_PremultiplySurfaceAlpha_REAL +#define SDL_PumpEvents SDL_PumpEvents_REAL +#define SDL_PushEvent SDL_PushEvent_REAL +#define SDL_PushGPUComputeUniformData SDL_PushGPUComputeUniformData_REAL +#define SDL_PushGPUDebugGroup SDL_PushGPUDebugGroup_REAL +#define SDL_PushGPUFragmentUniformData SDL_PushGPUFragmentUniformData_REAL +#define SDL_PushGPUVertexUniformData SDL_PushGPUVertexUniformData_REAL +#define SDL_PutAudioStreamData SDL_PutAudioStreamData_REAL +#define SDL_QueryGPUFence SDL_QueryGPUFence_REAL +#define SDL_Quit SDL_Quit_REAL +#define SDL_QuitSubSystem SDL_QuitSubSystem_REAL +#define SDL_RaiseWindow SDL_RaiseWindow_REAL +#define SDL_ReadIO SDL_ReadIO_REAL +#define SDL_ReadProcess SDL_ReadProcess_REAL +#define SDL_ReadS16BE SDL_ReadS16BE_REAL +#define SDL_ReadS16LE SDL_ReadS16LE_REAL +#define SDL_ReadS32BE SDL_ReadS32BE_REAL +#define SDL_ReadS32LE SDL_ReadS32LE_REAL +#define SDL_ReadS64BE SDL_ReadS64BE_REAL +#define SDL_ReadS64LE SDL_ReadS64LE_REAL +#define SDL_ReadS8 SDL_ReadS8_REAL +#define SDL_ReadStorageFile SDL_ReadStorageFile_REAL +#define SDL_ReadSurfacePixel SDL_ReadSurfacePixel_REAL +#define SDL_ReadSurfacePixelFloat SDL_ReadSurfacePixelFloat_REAL +#define SDL_ReadU16BE SDL_ReadU16BE_REAL +#define SDL_ReadU16LE SDL_ReadU16LE_REAL +#define SDL_ReadU32BE SDL_ReadU32BE_REAL +#define SDL_ReadU32LE SDL_ReadU32LE_REAL +#define SDL_ReadU64BE SDL_ReadU64BE_REAL +#define SDL_ReadU64LE SDL_ReadU64LE_REAL +#define SDL_ReadU8 SDL_ReadU8_REAL +#define SDL_RegisterApp SDL_RegisterApp_REAL +#define SDL_RegisterEvents SDL_RegisterEvents_REAL +#define SDL_ReleaseCameraFrame SDL_ReleaseCameraFrame_REAL +#define SDL_ReleaseGPUBuffer SDL_ReleaseGPUBuffer_REAL +#define SDL_ReleaseGPUComputePipeline SDL_ReleaseGPUComputePipeline_REAL +#define SDL_ReleaseGPUFence SDL_ReleaseGPUFence_REAL +#define SDL_ReleaseGPUGraphicsPipeline SDL_ReleaseGPUGraphicsPipeline_REAL +#define SDL_ReleaseGPUSampler SDL_ReleaseGPUSampler_REAL +#define SDL_ReleaseGPUShader SDL_ReleaseGPUShader_REAL +#define SDL_ReleaseGPUTexture SDL_ReleaseGPUTexture_REAL +#define SDL_ReleaseGPUTransferBuffer SDL_ReleaseGPUTransferBuffer_REAL +#define SDL_ReleaseWindowFromGPUDevice SDL_ReleaseWindowFromGPUDevice_REAL +#define SDL_ReloadGamepadMappings SDL_ReloadGamepadMappings_REAL +#define SDL_RemoveEventWatch SDL_RemoveEventWatch_REAL +#define SDL_RemoveHintCallback SDL_RemoveHintCallback_REAL +#define SDL_RemovePath SDL_RemovePath_REAL +#define SDL_RemoveStoragePath SDL_RemoveStoragePath_REAL +#define SDL_RemoveSurfaceAlternateImages SDL_RemoveSurfaceAlternateImages_REAL +#define SDL_RemoveTimer SDL_RemoveTimer_REAL +#define SDL_RenamePath SDL_RenamePath_REAL +#define SDL_RenameStoragePath SDL_RenameStoragePath_REAL +#define SDL_RenderClear SDL_RenderClear_REAL +#define SDL_RenderClipEnabled SDL_RenderClipEnabled_REAL +#define SDL_RenderCoordinatesFromWindow SDL_RenderCoordinatesFromWindow_REAL +#define SDL_RenderCoordinatesToWindow SDL_RenderCoordinatesToWindow_REAL +#define SDL_RenderFillRect SDL_RenderFillRect_REAL +#define SDL_RenderFillRects SDL_RenderFillRects_REAL +#define SDL_RenderGeometry SDL_RenderGeometry_REAL +#define SDL_RenderGeometryRaw SDL_RenderGeometryRaw_REAL +#define SDL_RenderLine SDL_RenderLine_REAL +#define SDL_RenderLines SDL_RenderLines_REAL +#define SDL_RenderPoint SDL_RenderPoint_REAL +#define SDL_RenderPoints SDL_RenderPoints_REAL +#define SDL_RenderPresent SDL_RenderPresent_REAL +#define SDL_RenderReadPixels SDL_RenderReadPixels_REAL +#define SDL_RenderRect SDL_RenderRect_REAL +#define SDL_RenderRects SDL_RenderRects_REAL +#define SDL_RenderTexture SDL_RenderTexture_REAL +#define SDL_RenderTexture9Grid SDL_RenderTexture9Grid_REAL +#define SDL_RenderTextureRotated SDL_RenderTextureRotated_REAL +#define SDL_RenderTextureTiled SDL_RenderTextureTiled_REAL +#define SDL_RenderViewportSet SDL_RenderViewportSet_REAL +#define SDL_ReportAssertion SDL_ReportAssertion_REAL +#define SDL_RequestAndroidPermission SDL_RequestAndroidPermission_REAL +#define SDL_ResetAssertionReport SDL_ResetAssertionReport_REAL +#define SDL_ResetHint SDL_ResetHint_REAL +#define SDL_ResetHints SDL_ResetHints_REAL +#define SDL_ResetKeyboard SDL_ResetKeyboard_REAL +#define SDL_ResetLogPriorities SDL_ResetLogPriorities_REAL +#define SDL_RestoreWindow SDL_RestoreWindow_REAL +#define SDL_ResumeAudioDevice SDL_ResumeAudioDevice_REAL +#define SDL_ResumeAudioStreamDevice SDL_ResumeAudioStreamDevice_REAL +#define SDL_ResumeHaptic SDL_ResumeHaptic_REAL +#define SDL_RumbleGamepad SDL_RumbleGamepad_REAL +#define SDL_RumbleGamepadTriggers SDL_RumbleGamepadTriggers_REAL +#define SDL_RumbleJoystick SDL_RumbleJoystick_REAL +#define SDL_RumbleJoystickTriggers SDL_RumbleJoystickTriggers_REAL +#define SDL_RunApp SDL_RunApp_REAL +#define SDL_RunHapticEffect SDL_RunHapticEffect_REAL +#define SDL_SaveBMP SDL_SaveBMP_REAL +#define SDL_SaveBMP_IO SDL_SaveBMP_IO_REAL +#define SDL_ScaleSurface SDL_ScaleSurface_REAL +#define SDL_ScreenKeyboardShown SDL_ScreenKeyboardShown_REAL +#define SDL_ScreenSaverEnabled SDL_ScreenSaverEnabled_REAL +#define SDL_SeekIO SDL_SeekIO_REAL +#define SDL_SendAndroidBackButton SDL_SendAndroidBackButton_REAL +#define SDL_SendAndroidMessage SDL_SendAndroidMessage_REAL +#define SDL_SendGamepadEffect SDL_SendGamepadEffect_REAL +#define SDL_SendJoystickEffect SDL_SendJoystickEffect_REAL +#define SDL_SendJoystickVirtualSensorData SDL_SendJoystickVirtualSensorData_REAL +#define SDL_SetAppMetadata SDL_SetAppMetadata_REAL +#define SDL_SetAppMetadataProperty SDL_SetAppMetadataProperty_REAL +#define SDL_SetAssertionHandler SDL_SetAssertionHandler_REAL +#define SDL_SetAtomicInt SDL_SetAtomicInt_REAL +#define SDL_SetAtomicPointer SDL_SetAtomicPointer_REAL +#define SDL_SetAtomicU32 SDL_SetAtomicU32_REAL +#define SDL_SetAudioDeviceGain SDL_SetAudioDeviceGain_REAL +#define SDL_SetAudioPostmixCallback SDL_SetAudioPostmixCallback_REAL +#define SDL_SetAudioStreamFormat SDL_SetAudioStreamFormat_REAL +#define SDL_SetAudioStreamFrequencyRatio SDL_SetAudioStreamFrequencyRatio_REAL +#define SDL_SetAudioStreamGain SDL_SetAudioStreamGain_REAL +#define SDL_SetAudioStreamGetCallback SDL_SetAudioStreamGetCallback_REAL +#define SDL_SetAudioStreamInputChannelMap SDL_SetAudioStreamInputChannelMap_REAL +#define SDL_SetAudioStreamOutputChannelMap SDL_SetAudioStreamOutputChannelMap_REAL +#define SDL_SetAudioStreamPutCallback SDL_SetAudioStreamPutCallback_REAL +#define SDL_SetBooleanProperty SDL_SetBooleanProperty_REAL +#define SDL_SetClipboardData SDL_SetClipboardData_REAL +#define SDL_SetClipboardText SDL_SetClipboardText_REAL +#define SDL_SetCurrentThreadPriority SDL_SetCurrentThreadPriority_REAL +#define SDL_SetCursor SDL_SetCursor_REAL +#define SDL_SetEnvironmentVariable SDL_SetEnvironmentVariable_REAL +#define SDL_SetError SDL_SetError_REAL +#define SDL_SetEventEnabled SDL_SetEventEnabled_REAL +#define SDL_SetEventFilter SDL_SetEventFilter_REAL +#define SDL_SetFloatProperty SDL_SetFloatProperty_REAL +#define SDL_SetGPUBlendConstants SDL_SetGPUBlendConstants_REAL +#define SDL_SetGPUBufferName SDL_SetGPUBufferName_REAL +#define SDL_SetGPUScissor SDL_SetGPUScissor_REAL +#define SDL_SetGPUStencilReference SDL_SetGPUStencilReference_REAL +#define SDL_SetGPUSwapchainParameters SDL_SetGPUSwapchainParameters_REAL +#define SDL_SetGPUTextureName SDL_SetGPUTextureName_REAL +#define SDL_SetGPUViewport SDL_SetGPUViewport_REAL +#define SDL_SetGamepadEventsEnabled SDL_SetGamepadEventsEnabled_REAL +#define SDL_SetGamepadLED SDL_SetGamepadLED_REAL +#define SDL_SetGamepadMapping SDL_SetGamepadMapping_REAL +#define SDL_SetGamepadPlayerIndex SDL_SetGamepadPlayerIndex_REAL +#define SDL_SetGamepadSensorEnabled SDL_SetGamepadSensorEnabled_REAL +#define SDL_SetHapticAutocenter SDL_SetHapticAutocenter_REAL +#define SDL_SetHapticGain SDL_SetHapticGain_REAL +#define SDL_SetHint SDL_SetHint_REAL +#define SDL_SetHintWithPriority SDL_SetHintWithPriority_REAL +#define SDL_SetInitialized SDL_SetInitialized_REAL +#define SDL_SetJoystickEventsEnabled SDL_SetJoystickEventsEnabled_REAL +#define SDL_SetJoystickLED SDL_SetJoystickLED_REAL +#define SDL_SetJoystickPlayerIndex SDL_SetJoystickPlayerIndex_REAL +#define SDL_SetJoystickVirtualAxis SDL_SetJoystickVirtualAxis_REAL +#define SDL_SetJoystickVirtualBall SDL_SetJoystickVirtualBall_REAL +#define SDL_SetJoystickVirtualButton SDL_SetJoystickVirtualButton_REAL +#define SDL_SetJoystickVirtualHat SDL_SetJoystickVirtualHat_REAL +#define SDL_SetJoystickVirtualTouchpad SDL_SetJoystickVirtualTouchpad_REAL +#define SDL_SetLinuxThreadPriority SDL_SetLinuxThreadPriority_REAL +#define SDL_SetLinuxThreadPriorityAndPolicy SDL_SetLinuxThreadPriorityAndPolicy_REAL +#define SDL_SetLogOutputFunction SDL_SetLogOutputFunction_REAL +#define SDL_SetLogPriorities SDL_SetLogPriorities_REAL +#define SDL_SetLogPriority SDL_SetLogPriority_REAL +#define SDL_SetLogPriorityPrefix SDL_SetLogPriorityPrefix_REAL +#define SDL_SetMainReady SDL_SetMainReady_REAL +#define SDL_SetMemoryFunctions SDL_SetMemoryFunctions_REAL +#define SDL_SetModState SDL_SetModState_REAL +#define SDL_SetNumberProperty SDL_SetNumberProperty_REAL +#define SDL_SetPaletteColors SDL_SetPaletteColors_REAL +#define SDL_SetPointerProperty SDL_SetPointerProperty_REAL +#define SDL_SetPointerPropertyWithCleanup SDL_SetPointerPropertyWithCleanup_REAL +#define SDL_SetPrimarySelectionText SDL_SetPrimarySelectionText_REAL +#define SDL_SetRenderClipRect SDL_SetRenderClipRect_REAL +#define SDL_SetRenderColorScale SDL_SetRenderColorScale_REAL +#define SDL_SetRenderDrawBlendMode SDL_SetRenderDrawBlendMode_REAL +#define SDL_SetRenderDrawColor SDL_SetRenderDrawColor_REAL +#define SDL_SetRenderDrawColorFloat SDL_SetRenderDrawColorFloat_REAL +#define SDL_SetRenderLogicalPresentation SDL_SetRenderLogicalPresentation_REAL +#define SDL_SetRenderScale SDL_SetRenderScale_REAL +#define SDL_SetRenderTarget SDL_SetRenderTarget_REAL +#define SDL_SetRenderVSync SDL_SetRenderVSync_REAL +#define SDL_SetRenderViewport SDL_SetRenderViewport_REAL +#define SDL_SetScancodeName SDL_SetScancodeName_REAL +#define SDL_SetStringProperty SDL_SetStringProperty_REAL +#define SDL_SetSurfaceAlphaMod SDL_SetSurfaceAlphaMod_REAL +#define SDL_SetSurfaceBlendMode SDL_SetSurfaceBlendMode_REAL +#define SDL_SetSurfaceClipRect SDL_SetSurfaceClipRect_REAL +#define SDL_SetSurfaceColorKey SDL_SetSurfaceColorKey_REAL +#define SDL_SetSurfaceColorMod SDL_SetSurfaceColorMod_REAL +#define SDL_SetSurfaceColorspace SDL_SetSurfaceColorspace_REAL +#define SDL_SetSurfacePalette SDL_SetSurfacePalette_REAL +#define SDL_SetSurfaceRLE SDL_SetSurfaceRLE_REAL +#define SDL_SetTLS SDL_SetTLS_REAL +#define SDL_SetTextInputArea SDL_SetTextInputArea_REAL +#define SDL_SetTextureAlphaMod SDL_SetTextureAlphaMod_REAL +#define SDL_SetTextureAlphaModFloat SDL_SetTextureAlphaModFloat_REAL +#define SDL_SetTextureBlendMode SDL_SetTextureBlendMode_REAL +#define SDL_SetTextureColorMod SDL_SetTextureColorMod_REAL +#define SDL_SetTextureColorModFloat SDL_SetTextureColorModFloat_REAL +#define SDL_SetTextureScaleMode SDL_SetTextureScaleMode_REAL +#define SDL_SetWindowAlwaysOnTop SDL_SetWindowAlwaysOnTop_REAL +#define SDL_SetWindowAspectRatio SDL_SetWindowAspectRatio_REAL +#define SDL_SetWindowBordered SDL_SetWindowBordered_REAL +#define SDL_SetWindowFocusable SDL_SetWindowFocusable_REAL +#define SDL_SetWindowFullscreen SDL_SetWindowFullscreen_REAL +#define SDL_SetWindowFullscreenMode SDL_SetWindowFullscreenMode_REAL +#define SDL_SetWindowHitTest SDL_SetWindowHitTest_REAL +#define SDL_SetWindowIcon SDL_SetWindowIcon_REAL +#define SDL_SetWindowKeyboardGrab SDL_SetWindowKeyboardGrab_REAL +#define SDL_SetWindowMaximumSize SDL_SetWindowMaximumSize_REAL +#define SDL_SetWindowMinimumSize SDL_SetWindowMinimumSize_REAL +#define SDL_SetWindowModal SDL_SetWindowModal_REAL +#define SDL_SetWindowMouseGrab SDL_SetWindowMouseGrab_REAL +#define SDL_SetWindowMouseRect SDL_SetWindowMouseRect_REAL +#define SDL_SetWindowOpacity SDL_SetWindowOpacity_REAL +#define SDL_SetWindowParent SDL_SetWindowParent_REAL +#define SDL_SetWindowPosition SDL_SetWindowPosition_REAL +#define SDL_SetWindowRelativeMouseMode SDL_SetWindowRelativeMouseMode_REAL +#define SDL_SetWindowResizable SDL_SetWindowResizable_REAL +#define SDL_SetWindowShape SDL_SetWindowShape_REAL +#define SDL_SetWindowSize SDL_SetWindowSize_REAL +#define SDL_SetWindowSurfaceVSync SDL_SetWindowSurfaceVSync_REAL +#define SDL_SetWindowTitle SDL_SetWindowTitle_REAL +#define SDL_SetWindowsMessageHook SDL_SetWindowsMessageHook_REAL +#define SDL_SetX11EventHook SDL_SetX11EventHook_REAL +#define SDL_SetiOSAnimationCallback SDL_SetiOSAnimationCallback_REAL +#define SDL_SetiOSEventPump SDL_SetiOSEventPump_REAL +#define SDL_ShouldInit SDL_ShouldInit_REAL +#define SDL_ShouldQuit SDL_ShouldQuit_REAL +#define SDL_ShowAndroidToast SDL_ShowAndroidToast_REAL +#define SDL_ShowCursor SDL_ShowCursor_REAL +#define SDL_ShowMessageBox SDL_ShowMessageBox_REAL +#define SDL_ShowOpenFileDialog SDL_ShowOpenFileDialog_REAL +#define SDL_ShowOpenFolderDialog SDL_ShowOpenFolderDialog_REAL +#define SDL_ShowSaveFileDialog SDL_ShowSaveFileDialog_REAL +#define SDL_ShowSimpleMessageBox SDL_ShowSimpleMessageBox_REAL +#define SDL_ShowWindow SDL_ShowWindow_REAL +#define SDL_ShowWindowSystemMenu SDL_ShowWindowSystemMenu_REAL +#define SDL_SignalCondition SDL_SignalCondition_REAL +#define SDL_SignalSemaphore SDL_SignalSemaphore_REAL +#define SDL_StartTextInput SDL_StartTextInput_REAL +#define SDL_StartTextInputWithProperties SDL_StartTextInputWithProperties_REAL +#define SDL_StepUTF8 SDL_StepUTF8_REAL +#define SDL_StopHapticEffect SDL_StopHapticEffect_REAL +#define SDL_StopHapticEffects SDL_StopHapticEffects_REAL +#define SDL_StopHapticRumble SDL_StopHapticRumble_REAL +#define SDL_StopTextInput SDL_StopTextInput_REAL +#define SDL_StorageReady SDL_StorageReady_REAL +#define SDL_StringToGUID SDL_StringToGUID_REAL +#define SDL_SubmitGPUCommandBuffer SDL_SubmitGPUCommandBuffer_REAL +#define SDL_SubmitGPUCommandBufferAndAcquireFence SDL_SubmitGPUCommandBufferAndAcquireFence_REAL +#define SDL_SurfaceHasAlternateImages SDL_SurfaceHasAlternateImages_REAL +#define SDL_SurfaceHasColorKey SDL_SurfaceHasColorKey_REAL +#define SDL_SurfaceHasRLE SDL_SurfaceHasRLE_REAL +#define SDL_SyncWindow SDL_SyncWindow_REAL +#define SDL_TellIO SDL_TellIO_REAL +#define SDL_TextInputActive SDL_TextInputActive_REAL +#define SDL_TimeFromWindows SDL_TimeFromWindows_REAL +#define SDL_TimeToDateTime SDL_TimeToDateTime_REAL +#define SDL_TimeToWindows SDL_TimeToWindows_REAL +#define SDL_TryLockMutex SDL_TryLockMutex_REAL +#define SDL_TryLockRWLockForReading SDL_TryLockRWLockForReading_REAL +#define SDL_TryLockRWLockForWriting SDL_TryLockRWLockForWriting_REAL +#define SDL_TryLockSpinlock SDL_TryLockSpinlock_REAL +#define SDL_TryWaitSemaphore SDL_TryWaitSemaphore_REAL +#define SDL_UCS4ToUTF8 SDL_UCS4ToUTF8_REAL +#define SDL_UnbindAudioStream SDL_UnbindAudioStream_REAL +#define SDL_UnbindAudioStreams SDL_UnbindAudioStreams_REAL +#define SDL_UnloadObject SDL_UnloadObject_REAL +#define SDL_UnlockAudioStream SDL_UnlockAudioStream_REAL +#define SDL_UnlockJoysticks SDL_UnlockJoysticks_REAL +#define SDL_UnlockMutex SDL_UnlockMutex_REAL +#define SDL_UnlockProperties SDL_UnlockProperties_REAL +#define SDL_UnlockRWLock SDL_UnlockRWLock_REAL +#define SDL_UnlockSpinlock SDL_UnlockSpinlock_REAL +#define SDL_UnlockSurface SDL_UnlockSurface_REAL +#define SDL_UnlockTexture SDL_UnlockTexture_REAL +#define SDL_UnmapGPUTransferBuffer SDL_UnmapGPUTransferBuffer_REAL +#define SDL_UnregisterApp SDL_UnregisterApp_REAL +#define SDL_UnsetEnvironmentVariable SDL_UnsetEnvironmentVariable_REAL +#define SDL_UpdateGamepads SDL_UpdateGamepads_REAL +#define SDL_UpdateHapticEffect SDL_UpdateHapticEffect_REAL +#define SDL_UpdateJoysticks SDL_UpdateJoysticks_REAL +#define SDL_UpdateNVTexture SDL_UpdateNVTexture_REAL +#define SDL_UpdateSensors SDL_UpdateSensors_REAL +#define SDL_UpdateTexture SDL_UpdateTexture_REAL +#define SDL_UpdateWindowSurface SDL_UpdateWindowSurface_REAL +#define SDL_UpdateWindowSurfaceRects SDL_UpdateWindowSurfaceRects_REAL +#define SDL_UpdateYUVTexture SDL_UpdateYUVTexture_REAL +#define SDL_UploadToGPUBuffer SDL_UploadToGPUBuffer_REAL +#define SDL_UploadToGPUTexture SDL_UploadToGPUTexture_REAL +#define SDL_Vulkan_CreateSurface SDL_Vulkan_CreateSurface_REAL +#define SDL_Vulkan_DestroySurface SDL_Vulkan_DestroySurface_REAL +#define SDL_Vulkan_GetInstanceExtensions SDL_Vulkan_GetInstanceExtensions_REAL +#define SDL_Vulkan_GetPresentationSupport SDL_Vulkan_GetPresentationSupport_REAL +#define SDL_Vulkan_GetVkGetInstanceProcAddr SDL_Vulkan_GetVkGetInstanceProcAddr_REAL +#define SDL_Vulkan_LoadLibrary SDL_Vulkan_LoadLibrary_REAL +#define SDL_Vulkan_UnloadLibrary SDL_Vulkan_UnloadLibrary_REAL +#define SDL_WaitCondition SDL_WaitCondition_REAL +#define SDL_WaitConditionTimeout SDL_WaitConditionTimeout_REAL +#define SDL_WaitEvent SDL_WaitEvent_REAL +#define SDL_WaitEventTimeout SDL_WaitEventTimeout_REAL +#define SDL_WaitForGPUFences SDL_WaitForGPUFences_REAL +#define SDL_WaitForGPUIdle SDL_WaitForGPUIdle_REAL +#define SDL_WaitProcess SDL_WaitProcess_REAL +#define SDL_WaitSemaphore SDL_WaitSemaphore_REAL +#define SDL_WaitSemaphoreTimeout SDL_WaitSemaphoreTimeout_REAL +#define SDL_WaitThread SDL_WaitThread_REAL +#define SDL_WarpMouseGlobal SDL_WarpMouseGlobal_REAL +#define SDL_WarpMouseInWindow SDL_WarpMouseInWindow_REAL +#define SDL_WasInit SDL_WasInit_REAL +#define SDL_WindowHasSurface SDL_WindowHasSurface_REAL +#define SDL_WindowSupportsGPUPresentMode SDL_WindowSupportsGPUPresentMode_REAL +#define SDL_WindowSupportsGPUSwapchainComposition SDL_WindowSupportsGPUSwapchainComposition_REAL +#define SDL_WriteIO SDL_WriteIO_REAL +#define SDL_WriteS16BE SDL_WriteS16BE_REAL +#define SDL_WriteS16LE SDL_WriteS16LE_REAL +#define SDL_WriteS32BE SDL_WriteS32BE_REAL +#define SDL_WriteS32LE SDL_WriteS32LE_REAL +#define SDL_WriteS64BE SDL_WriteS64BE_REAL +#define SDL_WriteS64LE SDL_WriteS64LE_REAL +#define SDL_WriteS8 SDL_WriteS8_REAL +#define SDL_WriteStorageFile SDL_WriteStorageFile_REAL +#define SDL_WriteSurfacePixel SDL_WriteSurfacePixel_REAL +#define SDL_WriteSurfacePixelFloat SDL_WriteSurfacePixelFloat_REAL +#define SDL_WriteU16BE SDL_WriteU16BE_REAL +#define SDL_WriteU16LE SDL_WriteU16LE_REAL +#define SDL_WriteU32BE SDL_WriteU32BE_REAL +#define SDL_WriteU32LE SDL_WriteU32LE_REAL +#define SDL_WriteU64BE SDL_WriteU64BE_REAL +#define SDL_WriteU64LE SDL_WriteU64LE_REAL +#define SDL_WriteU8 SDL_WriteU8_REAL +#define SDL_abs SDL_abs_REAL +#define SDL_acos SDL_acos_REAL +#define SDL_acosf SDL_acosf_REAL +#define SDL_aligned_alloc SDL_aligned_alloc_REAL +#define SDL_aligned_free SDL_aligned_free_REAL +#define SDL_asin SDL_asin_REAL +#define SDL_asinf SDL_asinf_REAL +#define SDL_asprintf SDL_asprintf_REAL +#define SDL_atan SDL_atan_REAL +#define SDL_atan2 SDL_atan2_REAL +#define SDL_atan2f SDL_atan2f_REAL +#define SDL_atanf SDL_atanf_REAL +#define SDL_atof SDL_atof_REAL +#define SDL_atoi SDL_atoi_REAL +#define SDL_bsearch SDL_bsearch_REAL +#define SDL_bsearch_r SDL_bsearch_r_REAL +#define SDL_calloc SDL_calloc_REAL +#define SDL_ceil SDL_ceil_REAL +#define SDL_ceilf SDL_ceilf_REAL +#define SDL_copysign SDL_copysign_REAL +#define SDL_copysignf SDL_copysignf_REAL +#define SDL_cos SDL_cos_REAL +#define SDL_cosf SDL_cosf_REAL +#define SDL_crc16 SDL_crc16_REAL +#define SDL_crc32 SDL_crc32_REAL +#define SDL_exp SDL_exp_REAL +#define SDL_expf SDL_expf_REAL +#define SDL_fabs SDL_fabs_REAL +#define SDL_fabsf SDL_fabsf_REAL +#define SDL_floor SDL_floor_REAL +#define SDL_floorf SDL_floorf_REAL +#define SDL_fmod SDL_fmod_REAL +#define SDL_fmodf SDL_fmodf_REAL +#define SDL_free SDL_free_REAL +#define SDL_getenv SDL_getenv_REAL +#define SDL_getenv_unsafe SDL_getenv_unsafe_REAL +#define SDL_hid_ble_scan SDL_hid_ble_scan_REAL +#define SDL_hid_close SDL_hid_close_REAL +#define SDL_hid_device_change_count SDL_hid_device_change_count_REAL +#define SDL_hid_enumerate SDL_hid_enumerate_REAL +#define SDL_hid_exit SDL_hid_exit_REAL +#define SDL_hid_free_enumeration SDL_hid_free_enumeration_REAL +#define SDL_hid_get_device_info SDL_hid_get_device_info_REAL +#define SDL_hid_get_feature_report SDL_hid_get_feature_report_REAL +#define SDL_hid_get_indexed_string SDL_hid_get_indexed_string_REAL +#define SDL_hid_get_input_report SDL_hid_get_input_report_REAL +#define SDL_hid_get_manufacturer_string SDL_hid_get_manufacturer_string_REAL +#define SDL_hid_get_product_string SDL_hid_get_product_string_REAL +#define SDL_hid_get_report_descriptor SDL_hid_get_report_descriptor_REAL +#define SDL_hid_get_serial_number_string SDL_hid_get_serial_number_string_REAL +#define SDL_hid_init SDL_hid_init_REAL +#define SDL_hid_open SDL_hid_open_REAL +#define SDL_hid_open_path SDL_hid_open_path_REAL +#define SDL_hid_read SDL_hid_read_REAL +#define SDL_hid_read_timeout SDL_hid_read_timeout_REAL +#define SDL_hid_send_feature_report SDL_hid_send_feature_report_REAL +#define SDL_hid_set_nonblocking SDL_hid_set_nonblocking_REAL +#define SDL_hid_write SDL_hid_write_REAL +#define SDL_iconv SDL_iconv_REAL +#define SDL_iconv_close SDL_iconv_close_REAL +#define SDL_iconv_open SDL_iconv_open_REAL +#define SDL_iconv_string SDL_iconv_string_REAL +#define SDL_isalnum SDL_isalnum_REAL +#define SDL_isalpha SDL_isalpha_REAL +#define SDL_isblank SDL_isblank_REAL +#define SDL_iscntrl SDL_iscntrl_REAL +#define SDL_isdigit SDL_isdigit_REAL +#define SDL_isgraph SDL_isgraph_REAL +#define SDL_isinf SDL_isinf_REAL +#define SDL_isinff SDL_isinff_REAL +#define SDL_islower SDL_islower_REAL +#define SDL_isnan SDL_isnan_REAL +#define SDL_isnanf SDL_isnanf_REAL +#define SDL_isprint SDL_isprint_REAL +#define SDL_ispunct SDL_ispunct_REAL +#define SDL_isspace SDL_isspace_REAL +#define SDL_isupper SDL_isupper_REAL +#define SDL_isxdigit SDL_isxdigit_REAL +#define SDL_itoa SDL_itoa_REAL +#define SDL_lltoa SDL_lltoa_REAL +#define SDL_log SDL_log_REAL +#define SDL_log10 SDL_log10_REAL +#define SDL_log10f SDL_log10f_REAL +#define SDL_logf SDL_logf_REAL +#define SDL_lround SDL_lround_REAL +#define SDL_lroundf SDL_lroundf_REAL +#define SDL_ltoa SDL_ltoa_REAL +#define SDL_malloc SDL_malloc_REAL +#define SDL_memcmp SDL_memcmp_REAL +#define SDL_memcpy SDL_memcpy_REAL +#define SDL_memmove SDL_memmove_REAL +#define SDL_memset SDL_memset_REAL +#define SDL_memset4 SDL_memset4_REAL +#define SDL_modf SDL_modf_REAL +#define SDL_modff SDL_modff_REAL +#define SDL_murmur3_32 SDL_murmur3_32_REAL +#define SDL_pow SDL_pow_REAL +#define SDL_powf SDL_powf_REAL +#define SDL_qsort SDL_qsort_REAL +#define SDL_qsort_r SDL_qsort_r_REAL +#define SDL_rand SDL_rand_REAL +#define SDL_rand_bits SDL_rand_bits_REAL +#define SDL_rand_bits_r SDL_rand_bits_r_REAL +#define SDL_rand_r SDL_rand_r_REAL +#define SDL_randf SDL_randf_REAL +#define SDL_randf_r SDL_randf_r_REAL +#define SDL_realloc SDL_realloc_REAL +#define SDL_round SDL_round_REAL +#define SDL_roundf SDL_roundf_REAL +#define SDL_scalbn SDL_scalbn_REAL +#define SDL_scalbnf SDL_scalbnf_REAL +#define SDL_setenv_unsafe SDL_setenv_unsafe_REAL +#define SDL_sin SDL_sin_REAL +#define SDL_sinf SDL_sinf_REAL +#define SDL_snprintf SDL_snprintf_REAL +#define SDL_sqrt SDL_sqrt_REAL +#define SDL_sqrtf SDL_sqrtf_REAL +#define SDL_srand SDL_srand_REAL +#define SDL_sscanf SDL_sscanf_REAL +#define SDL_strcasecmp SDL_strcasecmp_REAL +#define SDL_strcasestr SDL_strcasestr_REAL +#define SDL_strchr SDL_strchr_REAL +#define SDL_strcmp SDL_strcmp_REAL +#define SDL_strdup SDL_strdup_REAL +#define SDL_strlcat SDL_strlcat_REAL +#define SDL_strlcpy SDL_strlcpy_REAL +#define SDL_strlen SDL_strlen_REAL +#define SDL_strlwr SDL_strlwr_REAL +#define SDL_strncasecmp SDL_strncasecmp_REAL +#define SDL_strncmp SDL_strncmp_REAL +#define SDL_strndup SDL_strndup_REAL +#define SDL_strnlen SDL_strnlen_REAL +#define SDL_strnstr SDL_strnstr_REAL +#define SDL_strpbrk SDL_strpbrk_REAL +#define SDL_strrchr SDL_strrchr_REAL +#define SDL_strrev SDL_strrev_REAL +#define SDL_strstr SDL_strstr_REAL +#define SDL_strtod SDL_strtod_REAL +#define SDL_strtok_r SDL_strtok_r_REAL +#define SDL_strtol SDL_strtol_REAL +#define SDL_strtoll SDL_strtoll_REAL +#define SDL_strtoul SDL_strtoul_REAL +#define SDL_strtoull SDL_strtoull_REAL +#define SDL_strupr SDL_strupr_REAL +#define SDL_swprintf SDL_swprintf_REAL +#define SDL_tan SDL_tan_REAL +#define SDL_tanf SDL_tanf_REAL +#define SDL_tolower SDL_tolower_REAL +#define SDL_toupper SDL_toupper_REAL +#define SDL_trunc SDL_trunc_REAL +#define SDL_truncf SDL_truncf_REAL +#define SDL_uitoa SDL_uitoa_REAL +#define SDL_ulltoa SDL_ulltoa_REAL +#define SDL_ultoa SDL_ultoa_REAL +#define SDL_unsetenv_unsafe SDL_unsetenv_unsafe_REAL +#define SDL_utf8strlcpy SDL_utf8strlcpy_REAL +#define SDL_utf8strlen SDL_utf8strlen_REAL +#define SDL_utf8strnlen SDL_utf8strnlen_REAL +#define SDL_vasprintf SDL_vasprintf_REAL +#define SDL_vsnprintf SDL_vsnprintf_REAL +#define SDL_vsscanf SDL_vsscanf_REAL +#define SDL_vswprintf SDL_vswprintf_REAL +#define SDL_wcscasecmp SDL_wcscasecmp_REAL +#define SDL_wcscmp SDL_wcscmp_REAL +#define SDL_wcsdup SDL_wcsdup_REAL +#define SDL_wcslcat SDL_wcslcat_REAL +#define SDL_wcslcpy SDL_wcslcpy_REAL +#define SDL_wcslen SDL_wcslen_REAL +#define SDL_wcsncasecmp SDL_wcsncasecmp_REAL +#define SDL_wcsncmp SDL_wcsncmp_REAL +#define SDL_wcsnlen SDL_wcsnlen_REAL +#define SDL_wcsnstr SDL_wcsnstr_REAL +#define SDL_wcsstr SDL_wcsstr_REAL +#define SDL_wcstol SDL_wcstol_REAL +#define SDL_StepBackUTF8 SDL_StepBackUTF8_REAL +#define SDL_DelayPrecise SDL_DelayPrecise_REAL +#define SDL_CalculateGPUTextureFormatSize SDL_CalculateGPUTextureFormatSize_REAL +#define SDL_SetErrorV SDL_SetErrorV_REAL +#define SDL_GetDefaultLogOutputFunction SDL_GetDefaultLogOutputFunction_REAL +#define SDL_RenderDebugText SDL_RenderDebugText_REAL +#define SDL_GetSandbox SDL_GetSandbox_REAL +#define SDL_CancelGPUCommandBuffer SDL_CancelGPUCommandBuffer_REAL +#define SDL_SaveFile_IO SDL_SaveFile_IO_REAL +#define SDL_SaveFile SDL_SaveFile_REAL +#define SDL_GetCurrentDirectory SDL_GetCurrentDirectory_REAL +#define SDL_IsAudioDevicePhysical SDL_IsAudioDevicePhysical_REAL +#define SDL_IsAudioDevicePlayback SDL_IsAudioDevicePlayback_REAL +#define SDL_AsyncIOFromFile SDL_AsyncIOFromFile_REAL +#define SDL_GetAsyncIOSize SDL_GetAsyncIOSize_REAL +#define SDL_ReadAsyncIO SDL_ReadAsyncIO_REAL +#define SDL_WriteAsyncIO SDL_WriteAsyncIO_REAL +#define SDL_CloseAsyncIO SDL_CloseAsyncIO_REAL +#define SDL_CreateAsyncIOQueue SDL_CreateAsyncIOQueue_REAL +#define SDL_DestroyAsyncIOQueue SDL_DestroyAsyncIOQueue_REAL +#define SDL_GetAsyncIOResult SDL_GetAsyncIOResult_REAL +#define SDL_WaitAsyncIOResult SDL_WaitAsyncIOResult_REAL +#define SDL_SignalAsyncIOQueue SDL_SignalAsyncIOQueue_REAL +#define SDL_LoadFileAsync SDL_LoadFileAsync_REAL +#define SDL_ShowFileDialogWithProperties SDL_ShowFileDialogWithProperties_REAL +#define SDL_IsMainThread SDL_IsMainThread_REAL +#define SDL_RunOnMainThread SDL_RunOnMainThread_REAL +#define SDL_SetGPUAllowedFramesInFlight SDL_SetGPUAllowedFramesInFlight_REAL +#define SDL_RenderTextureAffine SDL_RenderTextureAffine_REAL +#define SDL_WaitForGPUSwapchain SDL_WaitForGPUSwapchain_REAL +#define SDL_WaitAndAcquireGPUSwapchainTexture SDL_WaitAndAcquireGPUSwapchainTexture_REAL +#define SDL_RenderDebugTextFormat SDL_RenderDebugTextFormat_REAL +#define SDL_CreateTray SDL_CreateTray_REAL +#define SDL_SetTrayIcon SDL_SetTrayIcon_REAL +#define SDL_SetTrayTooltip SDL_SetTrayTooltip_REAL +#define SDL_CreateTrayMenu SDL_CreateTrayMenu_REAL +#define SDL_CreateTraySubmenu SDL_CreateTraySubmenu_REAL +#define SDL_GetTrayMenu SDL_GetTrayMenu_REAL +#define SDL_GetTraySubmenu SDL_GetTraySubmenu_REAL +#define SDL_GetTrayEntries SDL_GetTrayEntries_REAL +#define SDL_RemoveTrayEntry SDL_RemoveTrayEntry_REAL +#define SDL_InsertTrayEntryAt SDL_InsertTrayEntryAt_REAL +#define SDL_SetTrayEntryLabel SDL_SetTrayEntryLabel_REAL +#define SDL_GetTrayEntryLabel SDL_GetTrayEntryLabel_REAL +#define SDL_SetTrayEntryChecked SDL_SetTrayEntryChecked_REAL +#define SDL_GetTrayEntryChecked SDL_GetTrayEntryChecked_REAL +#define SDL_SetTrayEntryEnabled SDL_SetTrayEntryEnabled_REAL +#define SDL_GetTrayEntryEnabled SDL_GetTrayEntryEnabled_REAL +#define SDL_SetTrayEntryCallback SDL_SetTrayEntryCallback_REAL +#define SDL_DestroyTray SDL_DestroyTray_REAL +#define SDL_GetTrayEntryParent SDL_GetTrayEntryParent_REAL +#define SDL_GetTrayMenuParentEntry SDL_GetTrayMenuParentEntry_REAL +#define SDL_GetTrayMenuParentTray SDL_GetTrayMenuParentTray_REAL +#define SDL_GetThreadState SDL_GetThreadState_REAL +#define SDL_AudioStreamDevicePaused SDL_AudioStreamDevicePaused_REAL +#define SDL_ClickTrayEntry SDL_ClickTrayEntry_REAL +#define SDL_UpdateTrays SDL_UpdateTrays_REAL +#define SDL_StretchSurface SDL_StretchSurface_REAL diff --git a/contrib/SDL-3.2.8/src/dynapi/SDL_dynapi_procs.h b/contrib/SDL-3.2.8/src/dynapi/SDL_dynapi_procs.h new file mode 100644 index 0000000..e86ac2a --- /dev/null +++ b/contrib/SDL-3.2.8/src/dynapi/SDL_dynapi_procs.h @@ -0,0 +1,1269 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + + +/* + DO NOT EDIT THIS FILE BY HAND. It is autogenerated by gendynapi.py. + NEVER REARRANGE THIS FILE, THE ORDER IS ABI LAW. + Changing this file means bumping SDL_DYNAPI_VERSION. You can safely add + new items to the end of the file, though. + Also, this file gets included multiple times, don't add #pragma once, etc. +*/ + +// direct jump magic can use these, the rest needs special code. +#ifndef SDL_DYNAPI_PROC_NO_VARARGS +SDL_DYNAPI_PROC(size_t,SDL_IOprintf,(SDL_IOStream *a, SDL_PRINTF_FORMAT_STRING const char *b, ...),(a,b),return) +SDL_DYNAPI_PROC(void,SDL_Log,(SDL_PRINTF_FORMAT_STRING const char *a, ...),(a),) +SDL_DYNAPI_PROC(void,SDL_LogCritical,(int a, SDL_PRINTF_FORMAT_STRING const char *b, ...),(a,b),) +SDL_DYNAPI_PROC(void,SDL_LogDebug,(int a, SDL_PRINTF_FORMAT_STRING const char *b, ...),(a,b),) +SDL_DYNAPI_PROC(void,SDL_LogError,(int a, SDL_PRINTF_FORMAT_STRING const char *b, ...),(a,b),) +SDL_DYNAPI_PROC(void,SDL_LogInfo,(int a, SDL_PRINTF_FORMAT_STRING const char *b, ...),(a,b),) +SDL_DYNAPI_PROC(void,SDL_LogMessage,(int a, SDL_LogPriority b, SDL_PRINTF_FORMAT_STRING const char *c, ...),(a,b,c),) +SDL_DYNAPI_PROC(void,SDL_LogTrace,(int a, SDL_PRINTF_FORMAT_STRING const char *b, ...),(a,b),) +SDL_DYNAPI_PROC(void,SDL_LogVerbose,(int a, SDL_PRINTF_FORMAT_STRING const char *b, ...),(a,b),) +SDL_DYNAPI_PROC(void,SDL_LogWarn,(int a, SDL_PRINTF_FORMAT_STRING const char *b, ...),(a,b),) +SDL_DYNAPI_PROC(bool,SDL_SetError,(SDL_PRINTF_FORMAT_STRING const char *a, ...),(a),return) +SDL_DYNAPI_PROC(int,SDL_asprintf,(char **a, SDL_PRINTF_FORMAT_STRING const char *b, ...),(a,b),return) +SDL_DYNAPI_PROC(int,SDL_snprintf,(SDL_OUT_Z_CAP(b) char *a, size_t b, SDL_PRINTF_FORMAT_STRING const char *c, ...),(a,b,c),return) +SDL_DYNAPI_PROC(int,SDL_sscanf,(const char *a, SDL_SCANF_FORMAT_STRING const char *b, ...),(a,b),return) +SDL_DYNAPI_PROC(int,SDL_swprintf,(SDL_OUT_Z_CAP(b) wchar_t *a, size_t b, SDL_PRINTF_FORMAT_STRING const wchar_t *c, ...),(a,b,c),return) +#endif + +// New API symbols are added at the end +SDL_DYNAPI_PROC(SDL_Surface*,SDL_AcquireCameraFrame,(SDL_Camera *a, Uint64 *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_GPUCommandBuffer*,SDL_AcquireGPUCommandBuffer,(SDL_GPUDevice *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_AcquireGPUSwapchainTexture,(SDL_GPUCommandBuffer *a, SDL_Window *b, SDL_GPUTexture **c, Uint32 *d, Uint32 *e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(int,SDL_AddAtomicInt,(SDL_AtomicInt *a, int b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_AddEventWatch,(SDL_EventFilter a, void *b),(a,b),return) +SDL_DYNAPI_PROC(int,SDL_AddGamepadMapping,(const char *a),(a),return) +SDL_DYNAPI_PROC(int,SDL_AddGamepadMappingsFromFile,(const char *a),(a),return) +SDL_DYNAPI_PROC(int,SDL_AddGamepadMappingsFromIO,(SDL_IOStream *a, bool b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_AddHintCallback,(const char *a, SDL_HintCallback b, void *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_AddSurfaceAlternateImage,(SDL_Surface *a, SDL_Surface *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_TimerID,SDL_AddTimer,(Uint32 a, SDL_TimerCallback b, void *c),(a,b,c),return) +SDL_DYNAPI_PROC(SDL_TimerID,SDL_AddTimerNS,(Uint64 a, SDL_NSTimerCallback b, void *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_AddVulkanRenderSemaphores,(SDL_Renderer *a, Uint32 b, Sint64 c, Sint64 d),(a,b,c,d),return) +SDL_DYNAPI_PROC(SDL_JoystickID,SDL_AttachVirtualJoystick,(const SDL_VirtualJoystickDesc *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_AudioDevicePaused,(SDL_AudioDeviceID a),(a),return) +SDL_DYNAPI_PROC(SDL_GPUComputePass*,SDL_BeginGPUComputePass,(SDL_GPUCommandBuffer *a, const SDL_GPUStorageTextureReadWriteBinding *b, Uint32 c, const SDL_GPUStorageBufferReadWriteBinding *d, Uint32 e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(SDL_GPUCopyPass*,SDL_BeginGPUCopyPass,(SDL_GPUCommandBuffer *a),(a),return) +SDL_DYNAPI_PROC(SDL_GPURenderPass*,SDL_BeginGPURenderPass,(SDL_GPUCommandBuffer *a, const SDL_GPUColorTargetInfo *b, Uint32 c, const SDL_GPUDepthStencilTargetInfo *d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_BindAudioStream,(SDL_AudioDeviceID a, SDL_AudioStream *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_BindAudioStreams,(SDL_AudioDeviceID a, SDL_AudioStream * const *b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(void,SDL_BindGPUComputePipeline,(SDL_GPUComputePass *a, SDL_GPUComputePipeline *b),(a,b),) +SDL_DYNAPI_PROC(void,SDL_BindGPUComputeSamplers,(SDL_GPUComputePass *a, Uint32 b, const SDL_GPUTextureSamplerBinding *c, Uint32 d),(a,b,c,d),) +SDL_DYNAPI_PROC(void,SDL_BindGPUComputeStorageBuffers,(SDL_GPUComputePass *a, Uint32 b, SDL_GPUBuffer *const *c, Uint32 d),(a,b,c,d),) +SDL_DYNAPI_PROC(void,SDL_BindGPUComputeStorageTextures,(SDL_GPUComputePass *a, Uint32 b, SDL_GPUTexture *const *c, Uint32 d),(a,b,c,d),) +SDL_DYNAPI_PROC(void,SDL_BindGPUFragmentSamplers,(SDL_GPURenderPass *a, Uint32 b, const SDL_GPUTextureSamplerBinding *c, Uint32 d),(a,b,c,d),) +SDL_DYNAPI_PROC(void,SDL_BindGPUFragmentStorageBuffers,(SDL_GPURenderPass *a, Uint32 b, SDL_GPUBuffer *const *c, Uint32 d),(a,b,c,d),) +SDL_DYNAPI_PROC(void,SDL_BindGPUFragmentStorageTextures,(SDL_GPURenderPass *a, Uint32 b, SDL_GPUTexture *const *c, Uint32 d),(a,b,c,d),) +SDL_DYNAPI_PROC(void,SDL_BindGPUGraphicsPipeline,(SDL_GPURenderPass *a, SDL_GPUGraphicsPipeline *b),(a,b),) +SDL_DYNAPI_PROC(void,SDL_BindGPUIndexBuffer,(SDL_GPURenderPass *a, const SDL_GPUBufferBinding *b, SDL_GPUIndexElementSize c),(a,b,c),) +SDL_DYNAPI_PROC(void,SDL_BindGPUVertexBuffers,(SDL_GPURenderPass *a, Uint32 b, const SDL_GPUBufferBinding *c, Uint32 d),(a,b,c,d),) +SDL_DYNAPI_PROC(void,SDL_BindGPUVertexSamplers,(SDL_GPURenderPass *a, Uint32 b, const SDL_GPUTextureSamplerBinding *c, Uint32 d),(a,b,c,d),) +SDL_DYNAPI_PROC(void,SDL_BindGPUVertexStorageBuffers,(SDL_GPURenderPass *a, Uint32 b, SDL_GPUBuffer *const *c, Uint32 d),(a,b,c,d),) +SDL_DYNAPI_PROC(void,SDL_BindGPUVertexStorageTextures,(SDL_GPURenderPass *a, Uint32 b, SDL_GPUTexture *const *c, Uint32 d),(a,b,c,d),) +SDL_DYNAPI_PROC(void,SDL_BlitGPUTexture,(SDL_GPUCommandBuffer *a, const SDL_GPUBlitInfo *b),(a,b),) +SDL_DYNAPI_PROC(bool,SDL_BlitSurface,(SDL_Surface *a, const SDL_Rect *b, SDL_Surface *c, const SDL_Rect *d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_BlitSurface9Grid,(SDL_Surface *a, const SDL_Rect *b, int c, int d, int e, int f, float g, SDL_ScaleMode h, SDL_Surface *i, const SDL_Rect *j),(a,b,c,d,e,f,g,h,i,j),return) +SDL_DYNAPI_PROC(bool,SDL_BlitSurfaceScaled,(SDL_Surface *a, const SDL_Rect *b, SDL_Surface *c, const SDL_Rect *d, SDL_ScaleMode e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(bool,SDL_BlitSurfaceTiled,(SDL_Surface *a, const SDL_Rect *b, SDL_Surface *c, const SDL_Rect *d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_BlitSurfaceTiledWithScale,(SDL_Surface *a, const SDL_Rect *b, float c, SDL_ScaleMode d, SDL_Surface *e, const SDL_Rect *f),(a,b,c,d,e,f),return) +SDL_DYNAPI_PROC(bool,SDL_BlitSurfaceUnchecked,(SDL_Surface *a, const SDL_Rect *b, SDL_Surface *c, const SDL_Rect *d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_BlitSurfaceUncheckedScaled,(SDL_Surface *a, const SDL_Rect *b, SDL_Surface *c, const SDL_Rect *d, SDL_ScaleMode e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(void,SDL_BroadcastCondition,(SDL_Condition *a),(a),) +SDL_DYNAPI_PROC(bool,SDL_CaptureMouse,(bool a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_ClaimWindowForGPUDevice,(SDL_GPUDevice *a, SDL_Window *b),(a,b),return) +SDL_DYNAPI_PROC(void,SDL_CleanupTLS,(void),(),) +SDL_DYNAPI_PROC(bool,SDL_ClearAudioStream,(SDL_AudioStream *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_ClearClipboardData,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_ClearComposition,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_ClearError,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_ClearProperty,(SDL_PropertiesID a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_ClearSurface,(SDL_Surface *a, float b, float c, float d, float e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(void,SDL_CloseAudioDevice,(SDL_AudioDeviceID a),(a),) +SDL_DYNAPI_PROC(void,SDL_CloseCamera,(SDL_Camera *a),(a),) +SDL_DYNAPI_PROC(void,SDL_CloseGamepad,(SDL_Gamepad *a),(a),) +SDL_DYNAPI_PROC(void,SDL_CloseHaptic,(SDL_Haptic *a),(a),) +SDL_DYNAPI_PROC(bool,SDL_CloseIO,(SDL_IOStream *a),(a),return) +SDL_DYNAPI_PROC(void,SDL_CloseJoystick,(SDL_Joystick *a),(a),) +SDL_DYNAPI_PROC(void,SDL_CloseSensor,(SDL_Sensor *a),(a),) +SDL_DYNAPI_PROC(bool,SDL_CloseStorage,(SDL_Storage *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_CompareAndSwapAtomicInt,(SDL_AtomicInt *a, int b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_CompareAndSwapAtomicPointer,(void **a, void *b, void *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_CompareAndSwapAtomicU32,(SDL_AtomicU32 *a, Uint32 b, Uint32 c),(a,b,c),return) +SDL_DYNAPI_PROC(SDL_BlendMode,SDL_ComposeCustomBlendMode,(SDL_BlendFactor a, SDL_BlendFactor b, SDL_BlendOperation c, SDL_BlendFactor d, SDL_BlendFactor e, SDL_BlendOperation f),(a,b,c,d,e,f),return) +SDL_DYNAPI_PROC(bool,SDL_ConvertAudioSamples,(const SDL_AudioSpec *a, const Uint8 *b, int c, const SDL_AudioSpec *d, Uint8 **e, int *f),(a,b,c,d,e,f),return) +SDL_DYNAPI_PROC(bool,SDL_ConvertEventToRenderCoordinates,(SDL_Renderer *a, SDL_Event *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_ConvertPixels,(int a, int b, SDL_PixelFormat c, const void *d, int e, SDL_PixelFormat f, void *g, int h),(a,b,c,d,e,f,g,h),return) +SDL_DYNAPI_PROC(bool,SDL_ConvertPixelsAndColorspace,(int a, int b, SDL_PixelFormat c, SDL_Colorspace d, SDL_PropertiesID e, const void *f, int g, SDL_PixelFormat h, SDL_Colorspace i, SDL_PropertiesID j, void *k, int l),(a,b,c,d,e,f,g,h,i,j,k,l),return) +SDL_DYNAPI_PROC(SDL_Surface*,SDL_ConvertSurface,(SDL_Surface *a, SDL_PixelFormat b),(a,b),return) +SDL_DYNAPI_PROC(SDL_Surface*,SDL_ConvertSurfaceAndColorspace,(SDL_Surface *a, SDL_PixelFormat b, SDL_Palette *c, SDL_Colorspace d, SDL_PropertiesID e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(bool,SDL_CopyFile,(const char *a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(void,SDL_CopyGPUBufferToBuffer,(SDL_GPUCopyPass *a, const SDL_GPUBufferLocation *b, const SDL_GPUBufferLocation *c, Uint32 d, bool e),(a,b,c,d,e),) +SDL_DYNAPI_PROC(void,SDL_CopyGPUTextureToTexture,(SDL_GPUCopyPass *a, const SDL_GPUTextureLocation *b, const SDL_GPUTextureLocation *c, Uint32 d, Uint32 e, Uint32 f, bool g),(a,b,c,d,e,f,g),) +SDL_DYNAPI_PROC(bool,SDL_CopyProperties,(SDL_PropertiesID a, SDL_PropertiesID b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_CopyStorageFile,(SDL_Storage *a, const char *b, const char *c),(a,b,c),return) +SDL_DYNAPI_PROC(SDL_AudioStream*,SDL_CreateAudioStream,(const SDL_AudioSpec *a, const SDL_AudioSpec *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_Cursor*,SDL_CreateColorCursor,(SDL_Surface *a, int b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(SDL_Condition*,SDL_CreateCondition,(void),(),return) +SDL_DYNAPI_PROC(SDL_Cursor*,SDL_CreateCursor,(const Uint8 *a, const Uint8 *b, int c, int d, int e, int f),(a,b,c,d,e,f),return) +SDL_DYNAPI_PROC(bool,SDL_CreateDirectory,(const char *a),(a),return) +SDL_DYNAPI_PROC(SDL_Environment*,SDL_CreateEnvironment,(bool a),(a),return) +SDL_DYNAPI_PROC(SDL_GPUBuffer*,SDL_CreateGPUBuffer,(SDL_GPUDevice *a, const SDL_GPUBufferCreateInfo* b),(a,b),return) +SDL_DYNAPI_PROC(SDL_GPUComputePipeline*,SDL_CreateGPUComputePipeline,(SDL_GPUDevice *a, const SDL_GPUComputePipelineCreateInfo *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_GPUDevice*,SDL_CreateGPUDevice,(SDL_GPUShaderFormat a, bool b, const char *c),(a,b,c),return) +SDL_DYNAPI_PROC(SDL_GPUDevice*,SDL_CreateGPUDeviceWithProperties,(SDL_PropertiesID a),(a),return) +SDL_DYNAPI_PROC(SDL_GPUGraphicsPipeline*,SDL_CreateGPUGraphicsPipeline,(SDL_GPUDevice *a, const SDL_GPUGraphicsPipelineCreateInfo *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_GPUSampler*,SDL_CreateGPUSampler,(SDL_GPUDevice *a, const SDL_GPUSamplerCreateInfo *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_GPUShader*,SDL_CreateGPUShader,(SDL_GPUDevice *a, const SDL_GPUShaderCreateInfo *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_GPUTexture*,SDL_CreateGPUTexture,(SDL_GPUDevice *a, const SDL_GPUTextureCreateInfo *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_GPUTransferBuffer*,SDL_CreateGPUTransferBuffer,(SDL_GPUDevice *a, const SDL_GPUTransferBufferCreateInfo *b),(a,b),return) +SDL_DYNAPI_PROC(int,SDL_CreateHapticEffect,(SDL_Haptic *a, const SDL_HapticEffect *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_Mutex*,SDL_CreateMutex,(void),(),return) +SDL_DYNAPI_PROC(SDL_Palette*,SDL_CreatePalette,(int a),(a),return) +SDL_DYNAPI_PROC(SDL_Window*,SDL_CreatePopupWindow,(SDL_Window *a, int b, int c, int d, int e, SDL_WindowFlags f),(a,b,c,d,e,f),return) +SDL_DYNAPI_PROC(SDL_Process*,SDL_CreateProcess,(const char * const *a, bool b),(a,b),return) +SDL_DYNAPI_PROC(SDL_Process*,SDL_CreateProcessWithProperties,(SDL_PropertiesID a),(a),return) +SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_CreateProperties,(void),(),return) +SDL_DYNAPI_PROC(SDL_RWLock*,SDL_CreateRWLock,(void),(),return) +SDL_DYNAPI_PROC(SDL_Renderer*,SDL_CreateRenderer,(SDL_Window *a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_Renderer*,SDL_CreateRendererWithProperties,(SDL_PropertiesID a),(a),return) +SDL_DYNAPI_PROC(SDL_Semaphore*,SDL_CreateSemaphore,(Uint32 a),(a),return) +SDL_DYNAPI_PROC(SDL_Renderer*,SDL_CreateSoftwareRenderer,(SDL_Surface *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_CreateStorageDirectory,(SDL_Storage *a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_Surface*,SDL_CreateSurface,(int a, int b, SDL_PixelFormat c),(a,b,c),return) +SDL_DYNAPI_PROC(SDL_Surface*,SDL_CreateSurfaceFrom,(int a, int b, SDL_PixelFormat c, void *d, int e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(SDL_Palette*,SDL_CreateSurfacePalette,(SDL_Surface *a),(a),return) +SDL_DYNAPI_PROC(SDL_Cursor*,SDL_CreateSystemCursor,(SDL_SystemCursor a),(a),return) +SDL_DYNAPI_PROC(SDL_Texture*,SDL_CreateTexture,(SDL_Renderer *a, SDL_PixelFormat b, SDL_TextureAccess c, int d, int e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(SDL_Texture*,SDL_CreateTextureFromSurface,(SDL_Renderer *a, SDL_Surface *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_Texture*,SDL_CreateTextureWithProperties,(SDL_Renderer *a, SDL_PropertiesID b),(a,b),return) +SDL_DYNAPI_PROC(SDL_Thread*,SDL_CreateThreadRuntime,(SDL_ThreadFunction a, const char *b, void *c, SDL_FunctionPointer d, SDL_FunctionPointer e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(SDL_Thread*,SDL_CreateThreadWithPropertiesRuntime,(SDL_PropertiesID a, SDL_FunctionPointer b, SDL_FunctionPointer c),(a,b,c),return) +SDL_DYNAPI_PROC(SDL_Window*,SDL_CreateWindow,(const char *a, int b, int c, SDL_WindowFlags d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_CreateWindowAndRenderer,(const char *a, int b, int c, SDL_WindowFlags d, SDL_Window **e, SDL_Renderer **f),(a,b,c,d,e,f),return) +SDL_DYNAPI_PROC(SDL_Window*,SDL_CreateWindowWithProperties,(SDL_PropertiesID a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_CursorVisible,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_DateTimeToTime,(const SDL_DateTime *a, SDL_Time *b),(a,b),return) +SDL_DYNAPI_PROC(void,SDL_Delay,(Uint32 a),(a),) +SDL_DYNAPI_PROC(void,SDL_DelayNS,(Uint64 a),(a),) +SDL_DYNAPI_PROC(void,SDL_DestroyAudioStream,(SDL_AudioStream *a),(a),) +SDL_DYNAPI_PROC(void,SDL_DestroyCondition,(SDL_Condition *a),(a),) +SDL_DYNAPI_PROC(void,SDL_DestroyCursor,(SDL_Cursor *a),(a),) +SDL_DYNAPI_PROC(void,SDL_DestroyEnvironment,(SDL_Environment *a),(a),) +SDL_DYNAPI_PROC(void,SDL_DestroyGPUDevice,(SDL_GPUDevice *a),(a),) +SDL_DYNAPI_PROC(void,SDL_DestroyHapticEffect,(SDL_Haptic *a, int b),(a,b),) +SDL_DYNAPI_PROC(void,SDL_DestroyMutex,(SDL_Mutex *a),(a),) +SDL_DYNAPI_PROC(void,SDL_DestroyPalette,(SDL_Palette *a),(a),) +SDL_DYNAPI_PROC(void,SDL_DestroyProcess,(SDL_Process *a),(a),) +SDL_DYNAPI_PROC(void,SDL_DestroyProperties,(SDL_PropertiesID a),(a),) +SDL_DYNAPI_PROC(void,SDL_DestroyRWLock,(SDL_RWLock *a),(a),) +SDL_DYNAPI_PROC(void,SDL_DestroyRenderer,(SDL_Renderer *a),(a),) +SDL_DYNAPI_PROC(void,SDL_DestroySemaphore,(SDL_Semaphore *a),(a),) +SDL_DYNAPI_PROC(void,SDL_DestroySurface,(SDL_Surface *a),(a),) +SDL_DYNAPI_PROC(void,SDL_DestroyTexture,(SDL_Texture *a),(a),) +SDL_DYNAPI_PROC(void,SDL_DestroyWindow,(SDL_Window *a),(a),) +SDL_DYNAPI_PROC(bool,SDL_DestroyWindowSurface,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(void,SDL_DetachThread,(SDL_Thread *a),(a),) +SDL_DYNAPI_PROC(bool,SDL_DetachVirtualJoystick,(SDL_JoystickID a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_DisableScreenSaver,(void),(),return) +SDL_DYNAPI_PROC(void,SDL_DispatchGPUCompute,(SDL_GPUComputePass *a, Uint32 b, Uint32 c, Uint32 d),(a,b,c,d),) +SDL_DYNAPI_PROC(void,SDL_DispatchGPUComputeIndirect,(SDL_GPUComputePass *a, SDL_GPUBuffer *b, Uint32 c),(a,b,c),) +SDL_DYNAPI_PROC(void,SDL_DownloadFromGPUBuffer,(SDL_GPUCopyPass *a, const SDL_GPUBufferRegion *b, const SDL_GPUTransferBufferLocation *c),(a,b,c),) +SDL_DYNAPI_PROC(void,SDL_DownloadFromGPUTexture,(SDL_GPUCopyPass *a, const SDL_GPUTextureRegion *b, const SDL_GPUTextureTransferInfo *c),(a,b,c),) +SDL_DYNAPI_PROC(void,SDL_DrawGPUIndexedPrimitives,(SDL_GPURenderPass *a, Uint32 b, Uint32 c, Uint32 d, Sint32 e, Uint32 f),(a,b,c,d,e,f),) +SDL_DYNAPI_PROC(void,SDL_DrawGPUIndexedPrimitivesIndirect,(SDL_GPURenderPass *a, SDL_GPUBuffer *b, Uint32 c, Uint32 d),(a,b,c,d),) +SDL_DYNAPI_PROC(void,SDL_DrawGPUPrimitives,(SDL_GPURenderPass *a, Uint32 b, Uint32 c, Uint32 d, Uint32 e),(a,b,c,d,e),) +SDL_DYNAPI_PROC(void,SDL_DrawGPUPrimitivesIndirect,(SDL_GPURenderPass *a, SDL_GPUBuffer *b, Uint32 c, Uint32 d),(a,b,c,d),) +SDL_DYNAPI_PROC(SDL_Surface*,SDL_DuplicateSurface,(SDL_Surface *a),(a),return) +SDL_DYNAPI_PROC(SDL_EGLConfig,SDL_EGL_GetCurrentConfig,(void),(),return) +SDL_DYNAPI_PROC(SDL_EGLDisplay,SDL_EGL_GetCurrentDisplay,(void),(),return) +SDL_DYNAPI_PROC(SDL_FunctionPointer,SDL_EGL_GetProcAddress,(const char *a),(a),return) +SDL_DYNAPI_PROC(SDL_EGLSurface,SDL_EGL_GetWindowSurface,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(void,SDL_EGL_SetAttributeCallbacks,(SDL_EGLAttribArrayCallback a, SDL_EGLIntArrayCallback b, SDL_EGLIntArrayCallback c, void *d),(a,b,c,d),) +SDL_DYNAPI_PROC(bool,SDL_EnableScreenSaver,(void),(),return) +SDL_DYNAPI_PROC(void,SDL_EndGPUComputePass,(SDL_GPUComputePass *a),(a),) +SDL_DYNAPI_PROC(void,SDL_EndGPUCopyPass,(SDL_GPUCopyPass *a),(a),) +SDL_DYNAPI_PROC(void,SDL_EndGPURenderPass,(SDL_GPURenderPass *a),(a),) +SDL_DYNAPI_PROC(int,SDL_EnterAppMainCallbacks,(int a, char *b[], SDL_AppInit_func c, SDL_AppIterate_func d, SDL_AppEvent_func e, SDL_AppQuit_func f),(a,b,c,d,e,f),return) +SDL_DYNAPI_PROC(bool,SDL_EnumerateDirectory,(const char *a, SDL_EnumerateDirectoryCallback b, void *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_EnumerateProperties,(SDL_PropertiesID a, SDL_EnumeratePropertiesCallback b, void *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_EnumerateStorageDirectory,(SDL_Storage *a, const char *b, SDL_EnumerateDirectoryCallback c, void *d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_EventEnabled,(Uint32 a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_FillSurfaceRect,(SDL_Surface *a, const SDL_Rect *b, Uint32 c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_FillSurfaceRects,(SDL_Surface *a, const SDL_Rect *b, int c, Uint32 d),(a,b,c,d),return) +SDL_DYNAPI_PROC(void,SDL_FilterEvents,(SDL_EventFilter a, void *b),(a,b),) +SDL_DYNAPI_PROC(bool,SDL_FlashWindow,(SDL_Window *a, SDL_FlashOperation b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_FlipSurface,(SDL_Surface *a, SDL_FlipMode b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_FlushAudioStream,(SDL_AudioStream *a),(a),return) +SDL_DYNAPI_PROC(void,SDL_FlushEvent,(Uint32 a),(a),) +SDL_DYNAPI_PROC(void,SDL_FlushEvents,(Uint32 a, Uint32 b),(a,b),) +SDL_DYNAPI_PROC(bool,SDL_FlushIO,(SDL_IOStream *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_FlushRenderer,(SDL_Renderer *a),(a),return) +SDL_DYNAPI_PROC(void,SDL_GDKResumeGPU,(SDL_GPUDevice *a),(a),) +SDL_DYNAPI_PROC(void,SDL_GDKSuspendComplete,(void),(),) +SDL_DYNAPI_PROC(void,SDL_GDKSuspendGPU,(SDL_GPUDevice *a),(a),) +SDL_DYNAPI_PROC(SDL_GLContext,SDL_GL_CreateContext,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GL_DestroyContext,(SDL_GLContext a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GL_ExtensionSupported,(const char *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GL_GetAttribute,(SDL_GLAttr a, int *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_GLContext,SDL_GL_GetCurrentContext,(void),(),return) +SDL_DYNAPI_PROC(SDL_Window*,SDL_GL_GetCurrentWindow,(void),(),return) +SDL_DYNAPI_PROC(SDL_FunctionPointer,SDL_GL_GetProcAddress,(const char *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GL_GetSwapInterval,(int *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GL_LoadLibrary,(const char *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GL_MakeCurrent,(SDL_Window *a, SDL_GLContext b),(a,b),return) +SDL_DYNAPI_PROC(void,SDL_GL_ResetAttributes,(void),(),) +SDL_DYNAPI_PROC(bool,SDL_GL_SetAttribute,(SDL_GLAttr a, int b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_GL_SetSwapInterval,(int a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GL_SwapWindow,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(void,SDL_GL_UnloadLibrary,(void),(),) +SDL_DYNAPI_PROC(bool,SDL_GPUSupportsProperties,(SDL_PropertiesID a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GPUSupportsShaderFormats,(SDL_GPUShaderFormat a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(Uint32,SDL_GPUTextureFormatTexelBlockSize,(SDL_GPUTextureFormat a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GPUTextureSupportsFormat,(SDL_GPUDevice *a, SDL_GPUTextureFormat b, SDL_GPUTextureType c, SDL_GPUTextureUsageFlags d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_GPUTextureSupportsSampleCount,(SDL_GPUDevice *a, SDL_GPUTextureFormat b, SDL_GPUSampleCount c),(a,b,c),return) +SDL_DYNAPI_PROC(void,SDL_GUIDToString,(SDL_GUID a, char *b, int c),(a,b,c),) +SDL_DYNAPI_PROC(bool,SDL_GamepadConnected,(SDL_Gamepad *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GamepadEventsEnabled,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_GamepadHasAxis,(SDL_Gamepad *a, SDL_GamepadAxis b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_GamepadHasButton,(SDL_Gamepad *a, SDL_GamepadButton b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_GamepadHasSensor,(SDL_Gamepad *a, SDL_SensorType b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_GamepadSensorEnabled,(SDL_Gamepad *a, SDL_SensorType b),(a,b),return) +SDL_DYNAPI_PROC(void,SDL_GenerateMipmapsForGPUTexture,(SDL_GPUCommandBuffer *a, SDL_GPUTexture *b),(a,b),) +SDL_DYNAPI_PROC(void*,SDL_GetAndroidActivity,(void),(),return) +SDL_DYNAPI_PROC(const char*,SDL_GetAndroidCachePath,(void),(),return) +SDL_DYNAPI_PROC(const char*,SDL_GetAndroidExternalStoragePath,(void),(),return) +SDL_DYNAPI_PROC(Uint32,SDL_GetAndroidExternalStorageState,(void),(),return) +SDL_DYNAPI_PROC(const char*,SDL_GetAndroidInternalStoragePath,(void),(),return) +SDL_DYNAPI_PROC(void*,SDL_GetAndroidJNIEnv,(void),(),return) +SDL_DYNAPI_PROC(int,SDL_GetAndroidSDKVersion,(void),(),return) +SDL_DYNAPI_PROC(const char*,SDL_GetAppMetadataProperty,(const char *a),(a),return) +SDL_DYNAPI_PROC(SDL_AssertionHandler,SDL_GetAssertionHandler,(void **a),(a),return) +SDL_DYNAPI_PROC(const SDL_AssertData*,SDL_GetAssertionReport,(void),(),return) +SDL_DYNAPI_PROC(int,SDL_GetAtomicInt,(SDL_AtomicInt *a),(a),return) +SDL_DYNAPI_PROC(void*,SDL_GetAtomicPointer,(void **a),(a),return) +SDL_DYNAPI_PROC(Uint32,SDL_GetAtomicU32,(SDL_AtomicU32 *a),(a),return) +SDL_DYNAPI_PROC(int*,SDL_GetAudioDeviceChannelMap,(SDL_AudioDeviceID a, int *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_GetAudioDeviceFormat,(SDL_AudioDeviceID a, SDL_AudioSpec *b, int *c),(a,b,c),return) +SDL_DYNAPI_PROC(float,SDL_GetAudioDeviceGain,(SDL_AudioDeviceID a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetAudioDeviceName,(SDL_AudioDeviceID a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetAudioDriver,(int a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetAudioFormatName,(SDL_AudioFormat a),(a),return) +SDL_DYNAPI_PROC(SDL_AudioDeviceID*,SDL_GetAudioPlaybackDevices,(int *a),(a),return) +SDL_DYNAPI_PROC(SDL_AudioDeviceID*,SDL_GetAudioRecordingDevices,(int *a),(a),return) +SDL_DYNAPI_PROC(int,SDL_GetAudioStreamAvailable,(SDL_AudioStream *a),(a),return) +SDL_DYNAPI_PROC(int,SDL_GetAudioStreamData,(SDL_AudioStream *a, void *b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(SDL_AudioDeviceID,SDL_GetAudioStreamDevice,(SDL_AudioStream *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GetAudioStreamFormat,(SDL_AudioStream *a, SDL_AudioSpec *b, SDL_AudioSpec *c),(a,b,c),return) +SDL_DYNAPI_PROC(float,SDL_GetAudioStreamFrequencyRatio,(SDL_AudioStream *a),(a),return) +SDL_DYNAPI_PROC(float,SDL_GetAudioStreamGain,(SDL_AudioStream *a),(a),return) +SDL_DYNAPI_PROC(int*,SDL_GetAudioStreamInputChannelMap,(SDL_AudioStream *a, int *b),(a,b),return) +SDL_DYNAPI_PROC(int*,SDL_GetAudioStreamOutputChannelMap,(SDL_AudioStream *a, int *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetAudioStreamProperties,(SDL_AudioStream *a),(a),return) +SDL_DYNAPI_PROC(int,SDL_GetAudioStreamQueued,(SDL_AudioStream *a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetBasePath,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_GetBooleanProperty,(SDL_PropertiesID a, const char *b, bool c),(a,b,c),return) +SDL_DYNAPI_PROC(int,SDL_GetCPUCacheLineSize,(void),(),return) +SDL_DYNAPI_PROC(const char*,SDL_GetCameraDriver,(int a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GetCameraFormat,(SDL_Camera *a, SDL_CameraSpec *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_CameraID,SDL_GetCameraID,(SDL_Camera *a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetCameraName,(SDL_CameraID a),(a),return) +SDL_DYNAPI_PROC(int,SDL_GetCameraPermissionState,(SDL_Camera *a),(a),return) +SDL_DYNAPI_PROC(SDL_CameraPosition,SDL_GetCameraPosition,(SDL_CameraID a),(a),return) +SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetCameraProperties,(SDL_Camera *a),(a),return) +SDL_DYNAPI_PROC(SDL_CameraSpec**,SDL_GetCameraSupportedFormats,(SDL_CameraID a, int *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_CameraID*,SDL_GetCameras,(int *a),(a),return) +SDL_DYNAPI_PROC(void*,SDL_GetClipboardData,(const char *a, size_t *b),(a,b),return) +SDL_DYNAPI_PROC(char **,SDL_GetClipboardMimeTypes,(size_t *a),(a),return) +SDL_DYNAPI_PROC(char*,SDL_GetClipboardText,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_GetClosestFullscreenDisplayMode,(SDL_DisplayID a, int b, int c, float d, bool e, SDL_DisplayMode *f),(a,b,c,d,e,f),return) +SDL_DYNAPI_PROC(const char*,SDL_GetCurrentAudioDriver,(void),(),return) +SDL_DYNAPI_PROC(const char*,SDL_GetCurrentCameraDriver,(void),(),return) +SDL_DYNAPI_PROC(const SDL_DisplayMode*,SDL_GetCurrentDisplayMode,(SDL_DisplayID a),(a),return) +SDL_DYNAPI_PROC(SDL_DisplayOrientation,SDL_GetCurrentDisplayOrientation,(SDL_DisplayID a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GetCurrentRenderOutputSize,(SDL_Renderer *a, int *b, int *c),(a,b,c),return) +SDL_DYNAPI_PROC(SDL_ThreadID,SDL_GetCurrentThreadID,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_GetCurrentTime,(SDL_Time *a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetCurrentVideoDriver,(void),(),return) +SDL_DYNAPI_PROC(SDL_Cursor*,SDL_GetCursor,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_GetDXGIOutputInfo,(SDL_DisplayID a, int *b, int *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_GetDateTimeLocalePreferences,(SDL_DateFormat *a, SDL_TimeFormat *b),(a,b),return) +SDL_DYNAPI_PROC(int,SDL_GetDayOfWeek,(int a, int b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(int,SDL_GetDayOfYear,(int a, int b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(int,SDL_GetDaysInMonth,(int a, int b),(a,b),return) +SDL_DYNAPI_PROC(SDL_AssertionHandler,SDL_GetDefaultAssertionHandler,(void),(),return) +SDL_DYNAPI_PROC(SDL_Cursor*,SDL_GetDefaultCursor,(void),(),return) +SDL_DYNAPI_PROC(const SDL_DisplayMode*,SDL_GetDesktopDisplayMode,(SDL_DisplayID a),(a),return) +SDL_DYNAPI_PROC(int,SDL_GetDirect3D9AdapterIndex,(SDL_DisplayID a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GetDisplayBounds,(SDL_DisplayID a, SDL_Rect *b),(a,b),return) +SDL_DYNAPI_PROC(float,SDL_GetDisplayContentScale,(SDL_DisplayID a),(a),return) +SDL_DYNAPI_PROC(SDL_DisplayID,SDL_GetDisplayForPoint,(const SDL_Point *a),(a),return) +SDL_DYNAPI_PROC(SDL_DisplayID,SDL_GetDisplayForRect,(const SDL_Rect *a),(a),return) +SDL_DYNAPI_PROC(SDL_DisplayID,SDL_GetDisplayForWindow,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetDisplayName,(SDL_DisplayID a),(a),return) +SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetDisplayProperties,(SDL_DisplayID a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GetDisplayUsableBounds,(SDL_DisplayID a, SDL_Rect *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_DisplayID*,SDL_GetDisplays,(int *a),(a),return) +SDL_DYNAPI_PROC(SDL_Environment*,SDL_GetEnvironment,(void),(),return) +SDL_DYNAPI_PROC(const char*,SDL_GetEnvironmentVariable,(SDL_Environment *a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(char**,SDL_GetEnvironmentVariables,(SDL_Environment *a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetError,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_GetEventFilter,(SDL_EventFilter *a, void **b),(a,b),return) +SDL_DYNAPI_PROC(float,SDL_GetFloatProperty,(SDL_PropertiesID a, const char *b, float c),(a,b,c),return) +SDL_DYNAPI_PROC(SDL_DisplayMode**,SDL_GetFullscreenDisplayModes,(SDL_DisplayID a, int *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_GetGDKDefaultUser,(XUserHandle *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GetGDKTaskQueue,(XTaskQueueHandle *a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetGPUDeviceDriver,(SDL_GPUDevice *a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetGPUDriver,(int a),(a),return) +SDL_DYNAPI_PROC(SDL_GPUShaderFormat,SDL_GetGPUShaderFormats,(SDL_GPUDevice *a),(a),return) +SDL_DYNAPI_PROC(SDL_GPUTextureFormat,SDL_GetGPUSwapchainTextureFormat,(SDL_GPUDevice *a, SDL_Window *b),(a,b),return) +SDL_DYNAPI_PROC(const char*,SDL_GetGamepadAppleSFSymbolsNameForAxis,(SDL_Gamepad *a, SDL_GamepadAxis b),(a,b),return) +SDL_DYNAPI_PROC(const char*,SDL_GetGamepadAppleSFSymbolsNameForButton,(SDL_Gamepad *a, SDL_GamepadButton b),(a,b),return) +SDL_DYNAPI_PROC(Sint16,SDL_GetGamepadAxis,(SDL_Gamepad *a, SDL_GamepadAxis b),(a,b),return) +SDL_DYNAPI_PROC(SDL_GamepadAxis,SDL_GetGamepadAxisFromString,(const char *a),(a),return) +SDL_DYNAPI_PROC(SDL_GamepadBinding**,SDL_GetGamepadBindings,(SDL_Gamepad *a, int *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_GetGamepadButton,(SDL_Gamepad *a, SDL_GamepadButton b),(a,b),return) +SDL_DYNAPI_PROC(SDL_GamepadButton,SDL_GetGamepadButtonFromString,(const char *a),(a),return) +SDL_DYNAPI_PROC(SDL_GamepadButtonLabel,SDL_GetGamepadButtonLabel,(SDL_Gamepad *a, SDL_GamepadButton b),(a,b),return) +SDL_DYNAPI_PROC(SDL_GamepadButtonLabel,SDL_GetGamepadButtonLabelForType,(SDL_GamepadType a, SDL_GamepadButton b),(a,b),return) +SDL_DYNAPI_PROC(SDL_JoystickConnectionState,SDL_GetGamepadConnectionState,(SDL_Gamepad *a),(a),return) +SDL_DYNAPI_PROC(Uint16,SDL_GetGamepadFirmwareVersion,(SDL_Gamepad *a),(a),return) +SDL_DYNAPI_PROC(SDL_Gamepad*,SDL_GetGamepadFromID,(SDL_JoystickID a),(a),return) +SDL_DYNAPI_PROC(SDL_Gamepad*,SDL_GetGamepadFromPlayerIndex,(int a),(a),return) +SDL_DYNAPI_PROC(SDL_GUID,SDL_GetGamepadGUIDForID,(SDL_JoystickID a),(a),return) +SDL_DYNAPI_PROC(SDL_JoystickID,SDL_GetGamepadID,(SDL_Gamepad *a),(a),return) +SDL_DYNAPI_PROC(SDL_Joystick*,SDL_GetGamepadJoystick,(SDL_Gamepad *a),(a),return) +SDL_DYNAPI_PROC(char*,SDL_GetGamepadMapping,(SDL_Gamepad *a),(a),return) +SDL_DYNAPI_PROC(char*,SDL_GetGamepadMappingForGUID,(SDL_GUID a),(a),return) +SDL_DYNAPI_PROC(char*,SDL_GetGamepadMappingForID,(SDL_JoystickID a),(a),return) +SDL_DYNAPI_PROC(char **,SDL_GetGamepadMappings,(int *a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetGamepadName,(SDL_Gamepad *a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetGamepadNameForID,(SDL_JoystickID a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetGamepadPath,(SDL_Gamepad *a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetGamepadPathForID,(SDL_JoystickID a),(a),return) +SDL_DYNAPI_PROC(int,SDL_GetGamepadPlayerIndex,(SDL_Gamepad *a),(a),return) +SDL_DYNAPI_PROC(int,SDL_GetGamepadPlayerIndexForID,(SDL_JoystickID a),(a),return) +SDL_DYNAPI_PROC(SDL_PowerState,SDL_GetGamepadPowerInfo,(SDL_Gamepad *a, int *b),(a,b),return) +SDL_DYNAPI_PROC(Uint16,SDL_GetGamepadProduct,(SDL_Gamepad *a),(a),return) +SDL_DYNAPI_PROC(Uint16,SDL_GetGamepadProductForID,(SDL_JoystickID a),(a),return) +SDL_DYNAPI_PROC(Uint16,SDL_GetGamepadProductVersion,(SDL_Gamepad *a),(a),return) +SDL_DYNAPI_PROC(Uint16,SDL_GetGamepadProductVersionForID,(SDL_JoystickID a),(a),return) +SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetGamepadProperties,(SDL_Gamepad *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GetGamepadSensorData,(SDL_Gamepad *a, SDL_SensorType b, float *c, int d),(a,b,c,d),return) +SDL_DYNAPI_PROC(float,SDL_GetGamepadSensorDataRate,(SDL_Gamepad *a, SDL_SensorType b),(a,b),return) +SDL_DYNAPI_PROC(const char*,SDL_GetGamepadSerial,(SDL_Gamepad *a),(a),return) +SDL_DYNAPI_PROC(Uint64,SDL_GetGamepadSteamHandle,(SDL_Gamepad *a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetGamepadStringForAxis,(SDL_GamepadAxis a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetGamepadStringForButton,(SDL_GamepadButton a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetGamepadStringForType,(SDL_GamepadType a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GetGamepadTouchpadFinger,(SDL_Gamepad *a, int b, int c, bool *d, float *e, float *f, float *g),(a,b,c,d,e,f,g),return) +SDL_DYNAPI_PROC(SDL_GamepadType,SDL_GetGamepadType,(SDL_Gamepad *a),(a),return) +SDL_DYNAPI_PROC(SDL_GamepadType,SDL_GetGamepadTypeForID,(SDL_JoystickID a),(a),return) +SDL_DYNAPI_PROC(SDL_GamepadType,SDL_GetGamepadTypeFromString,(const char *a),(a),return) +SDL_DYNAPI_PROC(Uint16,SDL_GetGamepadVendor,(SDL_Gamepad *a),(a),return) +SDL_DYNAPI_PROC(Uint16,SDL_GetGamepadVendorForID,(SDL_JoystickID a),(a),return) +SDL_DYNAPI_PROC(SDL_JoystickID*,SDL_GetGamepads,(int *a),(a),return) +SDL_DYNAPI_PROC(SDL_MouseButtonFlags,SDL_GetGlobalMouseState,(float *a, float *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetGlobalProperties,(void),(),return) +SDL_DYNAPI_PROC(SDL_Window*,SDL_GetGrabbedWindow,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_GetHapticEffectStatus,(SDL_Haptic *a, int b),(a,b),return) +SDL_DYNAPI_PROC(Uint32,SDL_GetHapticFeatures,(SDL_Haptic *a),(a),return) +SDL_DYNAPI_PROC(SDL_Haptic*,SDL_GetHapticFromID,(SDL_HapticID a),(a),return) +SDL_DYNAPI_PROC(SDL_HapticID,SDL_GetHapticID,(SDL_Haptic *a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetHapticName,(SDL_Haptic *a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetHapticNameForID,(SDL_HapticID a),(a),return) +SDL_DYNAPI_PROC(SDL_HapticID*,SDL_GetHaptics,(int *a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetHint,(const char *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GetHintBoolean,(const char *a, bool b),(a,b),return) +SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetIOProperties,(SDL_IOStream *a),(a),return) +SDL_DYNAPI_PROC(Sint64,SDL_GetIOSize,(SDL_IOStream *a),(a),return) +SDL_DYNAPI_PROC(SDL_IOStatus,SDL_GetIOStatus,(SDL_IOStream *a),(a),return) +SDL_DYNAPI_PROC(Sint16,SDL_GetJoystickAxis,(SDL_Joystick *a, int b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_GetJoystickAxisInitialState,(SDL_Joystick *a, int b, Sint16 *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_GetJoystickBall,(SDL_Joystick *a, int b, int *c, int *d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_GetJoystickButton,(SDL_Joystick *a, int b),(a,b),return) +SDL_DYNAPI_PROC(SDL_JoystickConnectionState,SDL_GetJoystickConnectionState,(SDL_Joystick *a),(a),return) +SDL_DYNAPI_PROC(Uint16,SDL_GetJoystickFirmwareVersion,(SDL_Joystick *a),(a),return) +SDL_DYNAPI_PROC(SDL_Joystick*,SDL_GetJoystickFromID,(SDL_JoystickID a),(a),return) +SDL_DYNAPI_PROC(SDL_Joystick*,SDL_GetJoystickFromPlayerIndex,(int a),(a),return) +SDL_DYNAPI_PROC(SDL_GUID,SDL_GetJoystickGUID,(SDL_Joystick *a),(a),return) +SDL_DYNAPI_PROC(SDL_GUID,SDL_GetJoystickGUIDForID,(SDL_JoystickID a),(a),return) +SDL_DYNAPI_PROC(void,SDL_GetJoystickGUIDInfo,(SDL_GUID a, Uint16 *b, Uint16 *c, Uint16 *d, Uint16 *e),(a,b,c,d,e),) +SDL_DYNAPI_PROC(Uint8,SDL_GetJoystickHat,(SDL_Joystick *a, int b),(a,b),return) +SDL_DYNAPI_PROC(SDL_JoystickID,SDL_GetJoystickID,(SDL_Joystick *a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetJoystickName,(SDL_Joystick *a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetJoystickNameForID,(SDL_JoystickID a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetJoystickPath,(SDL_Joystick *a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetJoystickPathForID,(SDL_JoystickID a),(a),return) +SDL_DYNAPI_PROC(int,SDL_GetJoystickPlayerIndex,(SDL_Joystick *a),(a),return) +SDL_DYNAPI_PROC(int,SDL_GetJoystickPlayerIndexForID,(SDL_JoystickID a),(a),return) +SDL_DYNAPI_PROC(SDL_PowerState,SDL_GetJoystickPowerInfo,(SDL_Joystick *a, int *b),(a,b),return) +SDL_DYNAPI_PROC(Uint16,SDL_GetJoystickProduct,(SDL_Joystick *a),(a),return) +SDL_DYNAPI_PROC(Uint16,SDL_GetJoystickProductForID,(SDL_JoystickID a),(a),return) +SDL_DYNAPI_PROC(Uint16,SDL_GetJoystickProductVersion,(SDL_Joystick *a),(a),return) +SDL_DYNAPI_PROC(Uint16,SDL_GetJoystickProductVersionForID,(SDL_JoystickID a),(a),return) +SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetJoystickProperties,(SDL_Joystick *a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetJoystickSerial,(SDL_Joystick *a),(a),return) +SDL_DYNAPI_PROC(SDL_JoystickType,SDL_GetJoystickType,(SDL_Joystick *a),(a),return) +SDL_DYNAPI_PROC(SDL_JoystickType,SDL_GetJoystickTypeForID,(SDL_JoystickID a),(a),return) +SDL_DYNAPI_PROC(Uint16,SDL_GetJoystickVendor,(SDL_Joystick *a),(a),return) +SDL_DYNAPI_PROC(Uint16,SDL_GetJoystickVendorForID,(SDL_JoystickID a),(a),return) +SDL_DYNAPI_PROC(SDL_JoystickID*,SDL_GetJoysticks,(int *a),(a),return) +SDL_DYNAPI_PROC(SDL_Keycode,SDL_GetKeyFromName,(const char *a),(a),return) +SDL_DYNAPI_PROC(SDL_Keycode,SDL_GetKeyFromScancode,(SDL_Scancode a, SDL_Keymod b, bool c),(a,b,c),return) +SDL_DYNAPI_PROC(const char*,SDL_GetKeyName,(SDL_Keycode a),(a),return) +SDL_DYNAPI_PROC(SDL_Window*,SDL_GetKeyboardFocus,(void),(),return) +SDL_DYNAPI_PROC(const char*,SDL_GetKeyboardNameForID,(SDL_KeyboardID a),(a),return) +SDL_DYNAPI_PROC(const bool*,SDL_GetKeyboardState,(int *a),(a),return) +SDL_DYNAPI_PROC(SDL_KeyboardID*,SDL_GetKeyboards,(int *a),(a),return) +SDL_DYNAPI_PROC(void,SDL_GetLogOutputFunction,(SDL_LogOutputFunction *a, void **b),(a,b),) +SDL_DYNAPI_PROC(SDL_LogPriority,SDL_GetLogPriority,(int a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GetMasksForPixelFormat,(SDL_PixelFormat a, int *b, Uint32 *c, Uint32 *d, Uint32 *e, Uint32 *f),(a,b,c,d,e,f),return) +SDL_DYNAPI_PROC(int,SDL_GetMaxHapticEffects,(SDL_Haptic *a),(a),return) +SDL_DYNAPI_PROC(int,SDL_GetMaxHapticEffectsPlaying,(SDL_Haptic *a),(a),return) +SDL_DYNAPI_PROC(void,SDL_GetMemoryFunctions,(SDL_malloc_func *a, SDL_calloc_func *b, SDL_realloc_func *c, SDL_free_func *d),(a,b,c,d),) +SDL_DYNAPI_PROC(SDL_MouseID*,SDL_GetMice,(int *a),(a),return) +SDL_DYNAPI_PROC(SDL_Keymod,SDL_GetModState,(void),(),return) +SDL_DYNAPI_PROC(SDL_Window*,SDL_GetMouseFocus,(void),(),return) +SDL_DYNAPI_PROC(const char*,SDL_GetMouseNameForID,(SDL_MouseID a),(a),return) +SDL_DYNAPI_PROC(SDL_MouseButtonFlags,SDL_GetMouseState,(float *a, float *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_DisplayOrientation,SDL_GetNaturalDisplayOrientation,(SDL_DisplayID a),(a),return) +SDL_DYNAPI_PROC(int,SDL_GetNumAllocations,(void),(),return) +SDL_DYNAPI_PROC(int,SDL_GetNumAudioDrivers,(void),(),return) +SDL_DYNAPI_PROC(int,SDL_GetNumCameraDrivers,(void),(),return) +SDL_DYNAPI_PROC(int,SDL_GetNumGPUDrivers,(void),(),return) +SDL_DYNAPI_PROC(int,SDL_GetNumGamepadTouchpadFingers,(SDL_Gamepad *a, int b),(a,b),return) +SDL_DYNAPI_PROC(int,SDL_GetNumGamepadTouchpads,(SDL_Gamepad *a),(a),return) +SDL_DYNAPI_PROC(int,SDL_GetNumHapticAxes,(SDL_Haptic *a),(a),return) +SDL_DYNAPI_PROC(int,SDL_GetNumJoystickAxes,(SDL_Joystick *a),(a),return) +SDL_DYNAPI_PROC(int,SDL_GetNumJoystickBalls,(SDL_Joystick *a),(a),return) +SDL_DYNAPI_PROC(int,SDL_GetNumJoystickButtons,(SDL_Joystick *a),(a),return) +SDL_DYNAPI_PROC(int,SDL_GetNumJoystickHats,(SDL_Joystick *a),(a),return) +SDL_DYNAPI_PROC(int,SDL_GetNumLogicalCPUCores,(void),(),return) +SDL_DYNAPI_PROC(int,SDL_GetNumRenderDrivers,(void),(),return) +SDL_DYNAPI_PROC(int,SDL_GetNumVideoDrivers,(void),(),return) +SDL_DYNAPI_PROC(Sint64,SDL_GetNumberProperty,(SDL_PropertiesID a, const char *b, Sint64 c),(a,b,c),return) +SDL_DYNAPI_PROC(void,SDL_GetOriginalMemoryFunctions,(SDL_malloc_func *a, SDL_calloc_func *b, SDL_realloc_func *c, SDL_free_func *d),(a,b,c,d),) +SDL_DYNAPI_PROC(bool,SDL_GetPathInfo,(const char *a, SDL_PathInfo *b),(a,b),return) +SDL_DYNAPI_PROC(Uint64,SDL_GetPerformanceCounter,(void),(),return) +SDL_DYNAPI_PROC(Uint64,SDL_GetPerformanceFrequency,(void),(),return) +SDL_DYNAPI_PROC(const SDL_PixelFormatDetails*,SDL_GetPixelFormatDetails,(SDL_PixelFormat a),(a),return) +SDL_DYNAPI_PROC(SDL_PixelFormat,SDL_GetPixelFormatForMasks,(int a, Uint32 b, Uint32 c, Uint32 d, Uint32 e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(const char*,SDL_GetPixelFormatName,(SDL_PixelFormat a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetPlatform,(void),(),return) +SDL_DYNAPI_PROC(void*,SDL_GetPointerProperty,(SDL_PropertiesID a, const char *b, void *c),(a,b,c),return) +SDL_DYNAPI_PROC(SDL_PowerState,SDL_GetPowerInfo,(int *a, int *b),(a,b),return) +SDL_DYNAPI_PROC(char*,SDL_GetPrefPath,(const char *a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_Locale**,SDL_GetPreferredLocales,(int *a),(a),return) +SDL_DYNAPI_PROC(SDL_DisplayID,SDL_GetPrimaryDisplay,(void),(),return) +SDL_DYNAPI_PROC(char*,SDL_GetPrimarySelectionText,(void),(),return) +SDL_DYNAPI_PROC(SDL_IOStream*,SDL_GetProcessInput,(SDL_Process *a),(a),return) +SDL_DYNAPI_PROC(SDL_IOStream*,SDL_GetProcessOutput,(SDL_Process *a),(a),return) +SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetProcessProperties,(SDL_Process *a),(a),return) +SDL_DYNAPI_PROC(SDL_PropertyType,SDL_GetPropertyType,(SDL_PropertiesID a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(void,SDL_GetRGB,(Uint32 a, const SDL_PixelFormatDetails *b, const SDL_Palette *c, Uint8 *d, Uint8 *e, Uint8 *f),(a,b,c,d,e,f),) +SDL_DYNAPI_PROC(void,SDL_GetRGBA,(Uint32 a, const SDL_PixelFormatDetails *b, const SDL_Palette *c, Uint8 *d, Uint8 *e, Uint8 *f, Uint8 *g),(a,b,c,d,e,f,g),) +SDL_DYNAPI_PROC(SDL_GamepadType,SDL_GetRealGamepadType,(SDL_Gamepad *a),(a),return) +SDL_DYNAPI_PROC(SDL_GamepadType,SDL_GetRealGamepadTypeForID,(SDL_JoystickID a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GetRectAndLineIntersection,(const SDL_Rect *a, int *b, int *c, int *d, int *e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(bool,SDL_GetRectAndLineIntersectionFloat,(const SDL_FRect *a, float *b, float *c, float *d, float *e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(bool,SDL_GetRectEnclosingPoints,(const SDL_Point *a, int b, const SDL_Rect *c, SDL_Rect *d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_GetRectEnclosingPointsFloat,(const SDL_FPoint *a, int b, const SDL_FRect *c, SDL_FRect *d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_GetRectIntersection,(const SDL_Rect *a, const SDL_Rect *b, SDL_Rect *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_GetRectIntersectionFloat,(const SDL_FRect *a, const SDL_FRect *b, SDL_FRect *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_GetRectUnion,(const SDL_Rect *a, const SDL_Rect *b, SDL_Rect *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_GetRectUnionFloat,(const SDL_FRect *a, const SDL_FRect *b, SDL_FRect *c),(a,b,c),return) +SDL_DYNAPI_PROC(SDL_MouseButtonFlags,SDL_GetRelativeMouseState,(float *a, float *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_GetRenderClipRect,(SDL_Renderer *a, SDL_Rect *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_GetRenderColorScale,(SDL_Renderer *a, float *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_GetRenderDrawBlendMode,(SDL_Renderer *a, SDL_BlendMode *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_GetRenderDrawColor,(SDL_Renderer *a, Uint8 *b, Uint8 *c, Uint8 *d, Uint8 *e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(bool,SDL_GetRenderDrawColorFloat,(SDL_Renderer *a, float *b, float *c, float *d, float *e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(const char*,SDL_GetRenderDriver,(int a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GetRenderLogicalPresentation,(SDL_Renderer *a, int *b, int *c, SDL_RendererLogicalPresentation *d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_GetRenderLogicalPresentationRect,(SDL_Renderer *a, SDL_FRect *b),(a,b),return) +SDL_DYNAPI_PROC(void*,SDL_GetRenderMetalCommandEncoder,(SDL_Renderer *a),(a),return) +SDL_DYNAPI_PROC(void*,SDL_GetRenderMetalLayer,(SDL_Renderer *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GetRenderOutputSize,(SDL_Renderer *a, int *b, int *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_GetRenderSafeArea,(SDL_Renderer *a, SDL_Rect *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_GetRenderScale,(SDL_Renderer *a, float *b, float *c),(a,b,c),return) +SDL_DYNAPI_PROC(SDL_Texture*,SDL_GetRenderTarget,(SDL_Renderer *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GetRenderVSync,(SDL_Renderer *a, int *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_GetRenderViewport,(SDL_Renderer *a, SDL_Rect *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_Window*,SDL_GetRenderWindow,(SDL_Renderer *a),(a),return) +SDL_DYNAPI_PROC(SDL_Renderer*,SDL_GetRenderer,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(SDL_Renderer*,SDL_GetRendererFromTexture,(SDL_Texture *a),(a),return) +SDL_DYNAPI_PROC(const char *,SDL_GetRendererName,(SDL_Renderer *a),(a),return) +SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetRendererProperties,(SDL_Renderer *a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetRevision,(void),(),return) +SDL_DYNAPI_PROC(size_t,SDL_GetSIMDAlignment,(void),(),return) +SDL_DYNAPI_PROC(SDL_Scancode,SDL_GetScancodeFromKey,(SDL_Keycode a, SDL_Keymod *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_Scancode,SDL_GetScancodeFromName,(const char *a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetScancodeName,(SDL_Scancode a),(a),return) +SDL_DYNAPI_PROC(Uint32,SDL_GetSemaphoreValue,(SDL_Semaphore *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GetSensorData,(SDL_Sensor *a, float *b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(SDL_Sensor*,SDL_GetSensorFromID,(SDL_SensorID a),(a),return) +SDL_DYNAPI_PROC(SDL_SensorID,SDL_GetSensorID,(SDL_Sensor *a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetSensorName,(SDL_Sensor *a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetSensorNameForID,(SDL_SensorID a),(a),return) +SDL_DYNAPI_PROC(int,SDL_GetSensorNonPortableType,(SDL_Sensor *a),(a),return) +SDL_DYNAPI_PROC(int,SDL_GetSensorNonPortableTypeForID,(SDL_SensorID a),(a),return) +SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetSensorProperties,(SDL_Sensor *a),(a),return) +SDL_DYNAPI_PROC(SDL_SensorType,SDL_GetSensorType,(SDL_Sensor *a),(a),return) +SDL_DYNAPI_PROC(SDL_SensorType,SDL_GetSensorTypeForID,(SDL_SensorID a),(a),return) +SDL_DYNAPI_PROC(SDL_SensorID*,SDL_GetSensors,(int *a),(a),return) +SDL_DYNAPI_PROC(int,SDL_GetSilenceValueForFormat,(SDL_AudioFormat a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GetStorageFileSize,(SDL_Storage *a, const char *b, Uint64 *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_GetStoragePathInfo,(SDL_Storage *a, const char *b, SDL_PathInfo *c),(a,b,c),return) +SDL_DYNAPI_PROC(Uint64,SDL_GetStorageSpaceRemaining,(SDL_Storage *a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetStringProperty,(SDL_PropertiesID a, const char *b, const char *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_GetSurfaceAlphaMod,(SDL_Surface *a, Uint8 *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_GetSurfaceBlendMode,(SDL_Surface *a, SDL_BlendMode *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_GetSurfaceClipRect,(SDL_Surface *a, SDL_Rect *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_GetSurfaceColorKey,(SDL_Surface *a, Uint32 *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_GetSurfaceColorMod,(SDL_Surface *a, Uint8 *b, Uint8 *c, Uint8 *d),(a,b,c,d),return) +SDL_DYNAPI_PROC(SDL_Colorspace,SDL_GetSurfaceColorspace,(SDL_Surface *a),(a),return) +SDL_DYNAPI_PROC(SDL_Surface**,SDL_GetSurfaceImages,(SDL_Surface *a, int *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_Palette*,SDL_GetSurfacePalette,(SDL_Surface *a),(a),return) +SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetSurfaceProperties,(SDL_Surface *a),(a),return) +SDL_DYNAPI_PROC(int,SDL_GetSystemRAM,(void),(),return) +SDL_DYNAPI_PROC(SDL_SystemTheme,SDL_GetSystemTheme,(void),(),return) +SDL_DYNAPI_PROC(void*,SDL_GetTLS,(SDL_TLSID *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GetTextInputArea,(SDL_Window *a, SDL_Rect *b, int *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_GetTextureAlphaMod,(SDL_Texture *a, Uint8 *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_GetTextureAlphaModFloat,(SDL_Texture *a, float *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_GetTextureBlendMode,(SDL_Texture *a, SDL_BlendMode *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_GetTextureColorMod,(SDL_Texture *a, Uint8 *b, Uint8 *c, Uint8 *d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_GetTextureColorModFloat,(SDL_Texture *a, float *b, float *c, float *d),(a,b,c,d),return) +SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetTextureProperties,(SDL_Texture *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GetTextureScaleMode,(SDL_Texture *a, SDL_ScaleMode *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_GetTextureSize,(SDL_Texture *a, float *b, float *c),(a,b,c),return) +SDL_DYNAPI_PROC(SDL_ThreadID,SDL_GetThreadID,(SDL_Thread *a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_GetThreadName,(SDL_Thread *a),(a),return) +SDL_DYNAPI_PROC(Uint64,SDL_GetTicks,(void),(),return) +SDL_DYNAPI_PROC(Uint64,SDL_GetTicksNS,(void),(),return) +SDL_DYNAPI_PROC(const char*,SDL_GetTouchDeviceName,(SDL_TouchID a),(a),return) +SDL_DYNAPI_PROC(SDL_TouchDeviceType,SDL_GetTouchDeviceType,(SDL_TouchID a),(a),return) +SDL_DYNAPI_PROC(SDL_TouchID*,SDL_GetTouchDevices,(int *a),(a),return) +SDL_DYNAPI_PROC(SDL_Finger**,SDL_GetTouchFingers,(SDL_TouchID a, int *b),(a,b),return) +SDL_DYNAPI_PROC(const char*,SDL_GetUserFolder,(SDL_Folder a),(a),return) +SDL_DYNAPI_PROC(int,SDL_GetVersion,(void),(),return) +SDL_DYNAPI_PROC(const char*,SDL_GetVideoDriver,(int a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GetWindowAspectRatio,(SDL_Window *a, float *b, float *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_GetWindowBordersSize,(SDL_Window *a, int *b, int *c, int *d, int *e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(float,SDL_GetWindowDisplayScale,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(SDL_WindowFlags,SDL_GetWindowFlags,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(SDL_Window*,SDL_GetWindowFromEvent,(const SDL_Event *a),(a),return) +SDL_DYNAPI_PROC(SDL_Window*,SDL_GetWindowFromID,(SDL_WindowID a),(a),return) +SDL_DYNAPI_PROC(const SDL_DisplayMode*,SDL_GetWindowFullscreenMode,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(void*,SDL_GetWindowICCProfile,(SDL_Window *a, size_t *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_WindowID,SDL_GetWindowID,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GetWindowKeyboardGrab,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GetWindowMaximumSize,(SDL_Window *a, int *b, int *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_GetWindowMinimumSize,(SDL_Window *a, int *b, int *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_GetWindowMouseGrab,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(const SDL_Rect*,SDL_GetWindowMouseRect,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(float,SDL_GetWindowOpacity,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(SDL_Window*,SDL_GetWindowParent,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(float,SDL_GetWindowPixelDensity,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(SDL_PixelFormat,SDL_GetWindowPixelFormat,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GetWindowPosition,(SDL_Window *a, int *b, int *c),(a,b,c),return) +SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetWindowProperties,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GetWindowRelativeMouseMode,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GetWindowSafeArea,(SDL_Window *a, SDL_Rect *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_GetWindowSize,(SDL_Window *a, int *b, int *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_GetWindowSizeInPixels,(SDL_Window *a, int *b, int *c),(a,b,c),return) +SDL_DYNAPI_PROC(SDL_Surface*,SDL_GetWindowSurface,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_GetWindowSurfaceVSync,(SDL_Window *a, int *b),(a,b),return) +SDL_DYNAPI_PROC(const char*,SDL_GetWindowTitle,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(SDL_Window**,SDL_GetWindows,(int *a),(a),return) +SDL_DYNAPI_PROC(char **,SDL_GlobDirectory,(const char *a, const char *b, SDL_GlobFlags c, int *d),(a,b,c,d),return) +SDL_DYNAPI_PROC(char **,SDL_GlobStorageDirectory,(SDL_Storage *a, const char *b, const char *c, SDL_GlobFlags d, int *e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(bool,SDL_HapticEffectSupported,(SDL_Haptic *a, const SDL_HapticEffect *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_HapticRumbleSupported,(SDL_Haptic *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_HasARMSIMD,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_HasAVX,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_HasAVX2,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_HasAVX512F,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_HasAltiVec,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_HasClipboardData,(const char *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_HasClipboardText,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_HasEvent,(Uint32 a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_HasEvents,(Uint32 a, Uint32 b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_HasGamepad,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_HasJoystick,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_HasKeyboard,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_HasLASX,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_HasLSX,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_HasMMX,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_HasMouse,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_HasNEON,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_HasPrimarySelectionText,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_HasProperty,(SDL_PropertiesID a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_HasRectIntersection,(const SDL_Rect *a, const SDL_Rect *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_HasRectIntersectionFloat,(const SDL_FRect *a, const SDL_FRect *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_HasSSE,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_HasSSE2,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_HasSSE3,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_HasSSE41,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_HasSSE42,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_HasScreenKeyboardSupport,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_HideCursor,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_HideWindow,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(SDL_IOStream*,SDL_IOFromConstMem,(const void *a, size_t b),(a,b),return) +SDL_DYNAPI_PROC(SDL_IOStream*,SDL_IOFromDynamicMem,(void),(),return) +SDL_DYNAPI_PROC(SDL_IOStream*,SDL_IOFromFile,(const char *a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_IOStream*,SDL_IOFromMem,(void *a, size_t b),(a,b),return) +SDL_DYNAPI_PROC(size_t,SDL_IOvprintf,(SDL_IOStream *a, SDL_PRINTF_FORMAT_STRING const char *b, va_list c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_Init,(SDL_InitFlags a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_InitHapticRumble,(SDL_Haptic *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_InitSubSystem,(SDL_InitFlags a),(a),return) +SDL_DYNAPI_PROC(void,SDL_InsertGPUDebugLabel,(SDL_GPUCommandBuffer *a, const char *b),(a,b),) +SDL_DYNAPI_PROC(bool,SDL_IsChromebook,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_IsDeXMode,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_IsGamepad,(SDL_JoystickID a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_IsJoystickHaptic,(SDL_Joystick *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_IsJoystickVirtual,(SDL_JoystickID a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_IsMouseHaptic,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_IsTV,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_IsTablet,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_JoystickConnected,(SDL_Joystick *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_JoystickEventsEnabled,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_KillProcess,(SDL_Process *a, bool b),(a,b),return) +SDL_DYNAPI_PROC(SDL_Surface*,SDL_LoadBMP,(const char *a),(a),return) +SDL_DYNAPI_PROC(SDL_Surface*,SDL_LoadBMP_IO,(SDL_IOStream *a, bool b),(a,b),return) +SDL_DYNAPI_PROC(void*,SDL_LoadFile,(const char *a, size_t *b),(a,b),return) +SDL_DYNAPI_PROC(void*,SDL_LoadFile_IO,(SDL_IOStream *a, size_t *b, bool c),(a,b,c),return) +SDL_DYNAPI_PROC(SDL_FunctionPointer,SDL_LoadFunction,(SDL_SharedObject *a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_SharedObject*,SDL_LoadObject,(const char *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_LoadWAV,(const char *a, SDL_AudioSpec *b, Uint8 **c, Uint32 *d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_LoadWAV_IO,(SDL_IOStream *a, bool b, SDL_AudioSpec *c, Uint8 **d, Uint32 *e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(bool,SDL_LockAudioStream,(SDL_AudioStream *a),(a),return) +SDL_DYNAPI_PROC(void,SDL_LockJoysticks,(void),(),) +SDL_DYNAPI_PROC(void,SDL_LockMutex,(SDL_Mutex *a),(a),) +SDL_DYNAPI_PROC(bool,SDL_LockProperties,(SDL_PropertiesID a),(a),return) +SDL_DYNAPI_PROC(void,SDL_LockRWLockForReading,(SDL_RWLock *a),(a),) +SDL_DYNAPI_PROC(void,SDL_LockRWLockForWriting,(SDL_RWLock *a),(a),) +SDL_DYNAPI_PROC(void,SDL_LockSpinlock,(SDL_SpinLock *a),(a),) +SDL_DYNAPI_PROC(bool,SDL_LockSurface,(SDL_Surface *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_LockTexture,(SDL_Texture *a, const SDL_Rect *b, void **c, int *d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_LockTextureToSurface,(SDL_Texture *a, const SDL_Rect *b, SDL_Surface **c),(a,b,c),return) +SDL_DYNAPI_PROC(void,SDL_LogMessageV,(int a, SDL_LogPriority b, SDL_PRINTF_FORMAT_STRING const char *c, va_list d),(a,b,c,d),) +SDL_DYNAPI_PROC(void*,SDL_MapGPUTransferBuffer,(SDL_GPUDevice *a, SDL_GPUTransferBuffer *b, bool c),(a,b,c),return) +SDL_DYNAPI_PROC(Uint32,SDL_MapRGB,(const SDL_PixelFormatDetails *a, const SDL_Palette *b, Uint8 c, Uint8 d, Uint8 e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(Uint32,SDL_MapRGBA,(const SDL_PixelFormatDetails *a, const SDL_Palette *b, Uint8 c, Uint8 d, Uint8 e, Uint8 f),(a,b,c,d,e,f),return) +SDL_DYNAPI_PROC(Uint32,SDL_MapSurfaceRGB,(SDL_Surface *a, Uint8 b, Uint8 c, Uint8 d),(a,b,c,d),return) +SDL_DYNAPI_PROC(Uint32,SDL_MapSurfaceRGBA,(SDL_Surface *a, Uint8 b, Uint8 c, Uint8 d, Uint8 e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(bool,SDL_MaximizeWindow,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(void,SDL_MemoryBarrierAcquireFunction,(void),(),) +SDL_DYNAPI_PROC(void,SDL_MemoryBarrierReleaseFunction,(void),(),) +SDL_DYNAPI_PROC(SDL_MetalView,SDL_Metal_CreateView,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(void,SDL_Metal_DestroyView,(SDL_MetalView a),(a),) +SDL_DYNAPI_PROC(void*,SDL_Metal_GetLayer,(SDL_MetalView a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_MinimizeWindow,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_MixAudio,(Uint8 *a, const Uint8 *b, SDL_AudioFormat c, Uint32 d, float e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(void,SDL_OnApplicationDidChangeStatusBarOrientation,(void),(),) +SDL_DYNAPI_PROC(void,SDL_OnApplicationDidEnterBackground,(void),(),) +SDL_DYNAPI_PROC(void,SDL_OnApplicationDidEnterForeground,(void),(),) +SDL_DYNAPI_PROC(void,SDL_OnApplicationDidReceiveMemoryWarning,(void),(),) +SDL_DYNAPI_PROC(void,SDL_OnApplicationWillEnterBackground,(void),(),) +SDL_DYNAPI_PROC(void,SDL_OnApplicationWillEnterForeground,(void),(),) +SDL_DYNAPI_PROC(void,SDL_OnApplicationWillTerminate,(void),(),) +SDL_DYNAPI_PROC(SDL_AudioDeviceID,SDL_OpenAudioDevice,(SDL_AudioDeviceID a, const SDL_AudioSpec *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_AudioStream*,SDL_OpenAudioDeviceStream,(SDL_AudioDeviceID a, const SDL_AudioSpec *b, SDL_AudioStreamCallback c, void *d),(a,b,c,d),return) +SDL_DYNAPI_PROC(SDL_Camera*,SDL_OpenCamera,(SDL_CameraID a, const SDL_CameraSpec *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_Storage*,SDL_OpenFileStorage,(const char *a),(a),return) +SDL_DYNAPI_PROC(SDL_Gamepad*,SDL_OpenGamepad,(SDL_JoystickID a),(a),return) +SDL_DYNAPI_PROC(SDL_Haptic*,SDL_OpenHaptic,(SDL_HapticID a),(a),return) +SDL_DYNAPI_PROC(SDL_Haptic*,SDL_OpenHapticFromJoystick,(SDL_Joystick *a),(a),return) +SDL_DYNAPI_PROC(SDL_Haptic*,SDL_OpenHapticFromMouse,(void),(),return) +SDL_DYNAPI_PROC(SDL_IOStream*,SDL_OpenIO,(const SDL_IOStreamInterface *a, void *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_Joystick*,SDL_OpenJoystick,(SDL_JoystickID a),(a),return) +SDL_DYNAPI_PROC(SDL_Sensor*,SDL_OpenSensor,(SDL_SensorID a),(a),return) +SDL_DYNAPI_PROC(SDL_Storage*,SDL_OpenStorage,(const SDL_StorageInterface *a, void *b),(a,b),return) +SDL_DYNAPI_PROC(SDL_Storage*,SDL_OpenTitleStorage,(const char *a, SDL_PropertiesID b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_OpenURL,(const char *a),(a),return) +SDL_DYNAPI_PROC(SDL_Storage*,SDL_OpenUserStorage,(const char *a, const char *b, SDL_PropertiesID c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_OutOfMemory,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_PauseAudioDevice,(SDL_AudioDeviceID a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_PauseAudioStreamDevice,(SDL_AudioStream *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_PauseHaptic,(SDL_Haptic *a),(a),return) +SDL_DYNAPI_PROC(int,SDL_PeepEvents,(SDL_Event *a, int b, SDL_EventAction c, Uint32 d, Uint32 e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(bool,SDL_PlayHapticRumble,(SDL_Haptic *a, float b, Uint32 c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_PollEvent,(SDL_Event *a),(a),return) +SDL_DYNAPI_PROC(void,SDL_PopGPUDebugGroup,(SDL_GPUCommandBuffer *a),(a),) +SDL_DYNAPI_PROC(bool,SDL_PremultiplyAlpha,(int a, int b, SDL_PixelFormat c, const void *d, int e, SDL_PixelFormat f, void *g, int h, bool i),(a,b,c,d,e,f,g,h,i),return) +SDL_DYNAPI_PROC(bool,SDL_PremultiplySurfaceAlpha,(SDL_Surface *a, bool b),(a,b),return) +SDL_DYNAPI_PROC(void,SDL_PumpEvents,(void),(),) +SDL_DYNAPI_PROC(bool,SDL_PushEvent,(SDL_Event *a),(a),return) +SDL_DYNAPI_PROC(void,SDL_PushGPUComputeUniformData,(SDL_GPUCommandBuffer *a, Uint32 b, const void *c, Uint32 d),(a,b,c,d),) +SDL_DYNAPI_PROC(void,SDL_PushGPUDebugGroup,(SDL_GPUCommandBuffer *a, const char *b),(a,b),) +SDL_DYNAPI_PROC(void,SDL_PushGPUFragmentUniformData,(SDL_GPUCommandBuffer *a, Uint32 b, const void *c, Uint32 d),(a,b,c,d),) +SDL_DYNAPI_PROC(void,SDL_PushGPUVertexUniformData,(SDL_GPUCommandBuffer *a, Uint32 b, const void *c, Uint32 d),(a,b,c,d),) +SDL_DYNAPI_PROC(bool,SDL_PutAudioStreamData,(SDL_AudioStream *a, const void *b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_QueryGPUFence,(SDL_GPUDevice *a, SDL_GPUFence *b),(a,b),return) +SDL_DYNAPI_PROC(void,SDL_Quit,(void),(),) +SDL_DYNAPI_PROC(void,SDL_QuitSubSystem,(SDL_InitFlags a),(a),) +SDL_DYNAPI_PROC(bool,SDL_RaiseWindow,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(size_t,SDL_ReadIO,(SDL_IOStream *a, void *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(void*,SDL_ReadProcess,(SDL_Process *a, size_t *b, int *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_ReadS16BE,(SDL_IOStream *a, Sint16 *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_ReadS16LE,(SDL_IOStream *a, Sint16 *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_ReadS32BE,(SDL_IOStream *a, Sint32 *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_ReadS32LE,(SDL_IOStream *a, Sint32 *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_ReadS64BE,(SDL_IOStream *a, Sint64 *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_ReadS64LE,(SDL_IOStream *a, Sint64 *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_ReadS8,(SDL_IOStream *a, Sint8 *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_ReadStorageFile,(SDL_Storage *a, const char *b, void *c, Uint64 d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_ReadSurfacePixel,(SDL_Surface *a, int b, int c, Uint8 *d, Uint8 *e, Uint8 *f, Uint8 *g),(a,b,c,d,e,f,g),return) +SDL_DYNAPI_PROC(bool,SDL_ReadSurfacePixelFloat,(SDL_Surface *a, int b, int c, float *d, float *e, float *f, float *g),(a,b,c,d,e,f,g),return) +SDL_DYNAPI_PROC(bool,SDL_ReadU16BE,(SDL_IOStream *a, Uint16 *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_ReadU16LE,(SDL_IOStream *a, Uint16 *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_ReadU32BE,(SDL_IOStream *a, Uint32 *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_ReadU32LE,(SDL_IOStream *a, Uint32 *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_ReadU64BE,(SDL_IOStream *a, Uint64 *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_ReadU64LE,(SDL_IOStream *a, Uint64 *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_ReadU8,(SDL_IOStream *a, Uint8 *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_RegisterApp,(const char *a, Uint32 b, void *c),(a,b,c),return) +SDL_DYNAPI_PROC(Uint32,SDL_RegisterEvents,(int a),(a),return) +SDL_DYNAPI_PROC(void,SDL_ReleaseCameraFrame,(SDL_Camera *a, SDL_Surface *b),(a,b),) +SDL_DYNAPI_PROC(void,SDL_ReleaseGPUBuffer,(SDL_GPUDevice *a, SDL_GPUBuffer *b),(a,b),) +SDL_DYNAPI_PROC(void,SDL_ReleaseGPUComputePipeline,(SDL_GPUDevice *a, SDL_GPUComputePipeline *b),(a,b),) +SDL_DYNAPI_PROC(void,SDL_ReleaseGPUFence,(SDL_GPUDevice *a, SDL_GPUFence *b),(a,b),) +SDL_DYNAPI_PROC(void,SDL_ReleaseGPUGraphicsPipeline,(SDL_GPUDevice *a, SDL_GPUGraphicsPipeline *b),(a,b),) +SDL_DYNAPI_PROC(void,SDL_ReleaseGPUSampler,(SDL_GPUDevice *a, SDL_GPUSampler *b),(a,b),) +SDL_DYNAPI_PROC(void,SDL_ReleaseGPUShader,(SDL_GPUDevice *a, SDL_GPUShader *b),(a,b),) +SDL_DYNAPI_PROC(void,SDL_ReleaseGPUTexture,(SDL_GPUDevice *a, SDL_GPUTexture *b),(a,b),) +SDL_DYNAPI_PROC(void,SDL_ReleaseGPUTransferBuffer,(SDL_GPUDevice *a, SDL_GPUTransferBuffer *b),(a,b),) +SDL_DYNAPI_PROC(void,SDL_ReleaseWindowFromGPUDevice,(SDL_GPUDevice *a, SDL_Window *b),(a,b),) +SDL_DYNAPI_PROC(bool,SDL_ReloadGamepadMappings,(void),(),return) +SDL_DYNAPI_PROC(void,SDL_RemoveEventWatch,(SDL_EventFilter a, void *b),(a,b),) +SDL_DYNAPI_PROC(void,SDL_RemoveHintCallback,(const char *a, SDL_HintCallback b, void *c),(a,b,c),) +SDL_DYNAPI_PROC(bool,SDL_RemovePath,(const char *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_RemoveStoragePath,(SDL_Storage *a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(void,SDL_RemoveSurfaceAlternateImages,(SDL_Surface *a),(a),) +SDL_DYNAPI_PROC(bool,SDL_RemoveTimer,(SDL_TimerID a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_RenamePath,(const char *a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_RenameStoragePath,(SDL_Storage *a, const char *b, const char *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_RenderClear,(SDL_Renderer *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_RenderClipEnabled,(SDL_Renderer *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_RenderCoordinatesFromWindow,(SDL_Renderer *a, float b, float c, float *d, float *e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(bool,SDL_RenderCoordinatesToWindow,(SDL_Renderer *a, float b, float c, float *d, float *e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(bool,SDL_RenderFillRect,(SDL_Renderer *a, const SDL_FRect *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_RenderFillRects,(SDL_Renderer *a, const SDL_FRect *b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_RenderGeometry,(SDL_Renderer *a, SDL_Texture *b, const SDL_Vertex *c, int d, const int *e, int f),(a,b,c,d,e,f),return) +SDL_DYNAPI_PROC(bool,SDL_RenderGeometryRaw,(SDL_Renderer *a, SDL_Texture *b, const float *c, int d, const SDL_FColor *e, int f, const float *g, int h, int i, const void *j, int k, int l),(a,b,c,d,e,f,g,h,i,j,k,l),return) +SDL_DYNAPI_PROC(bool,SDL_RenderLine,(SDL_Renderer *a, float b, float c, float d, float e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(bool,SDL_RenderLines,(SDL_Renderer *a, const SDL_FPoint *b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_RenderPoint,(SDL_Renderer *a, float b, float c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_RenderPoints,(SDL_Renderer *a, const SDL_FPoint *b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_RenderPresent,(SDL_Renderer *a),(a),return) +SDL_DYNAPI_PROC(SDL_Surface*,SDL_RenderReadPixels,(SDL_Renderer *a, const SDL_Rect *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_RenderRect,(SDL_Renderer *a, const SDL_FRect *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_RenderRects,(SDL_Renderer *a, const SDL_FRect *b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_RenderTexture,(SDL_Renderer *a, SDL_Texture *b, const SDL_FRect *c, const SDL_FRect *d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_RenderTexture9Grid,(SDL_Renderer *a, SDL_Texture *b, const SDL_FRect *c, float d, float e, float f, float g, float h, const SDL_FRect *i),(a,b,c,d,e,f,g,h,i),return) +SDL_DYNAPI_PROC(bool,SDL_RenderTextureRotated,(SDL_Renderer *a, SDL_Texture *b, const SDL_FRect *c, const SDL_FRect *d, double e, const SDL_FPoint *f, SDL_FlipMode g),(a,b,c,d,e,f,g),return) +SDL_DYNAPI_PROC(bool,SDL_RenderTextureTiled,(SDL_Renderer *a, SDL_Texture *b, const SDL_FRect *c, float d, const SDL_FRect *e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(bool,SDL_RenderViewportSet,(SDL_Renderer *a),(a),return) +SDL_DYNAPI_PROC(SDL_AssertState,SDL_ReportAssertion,(SDL_AssertData *a, const char *b, const char *c, int d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_RequestAndroidPermission,(const char *a, SDL_RequestAndroidPermissionCallback b, void *c),(a,b,c),return) +SDL_DYNAPI_PROC(void,SDL_ResetAssertionReport,(void),(),) +SDL_DYNAPI_PROC(bool,SDL_ResetHint,(const char *a),(a),return) +SDL_DYNAPI_PROC(void,SDL_ResetHints,(void),(),) +SDL_DYNAPI_PROC(void,SDL_ResetKeyboard,(void),(),) +SDL_DYNAPI_PROC(void,SDL_ResetLogPriorities,(void),(),) +SDL_DYNAPI_PROC(bool,SDL_RestoreWindow,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_ResumeAudioDevice,(SDL_AudioDeviceID a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_ResumeAudioStreamDevice,(SDL_AudioStream *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_ResumeHaptic,(SDL_Haptic *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_RumbleGamepad,(SDL_Gamepad *a, Uint16 b, Uint16 c, Uint32 d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_RumbleGamepadTriggers,(SDL_Gamepad *a, Uint16 b, Uint16 c, Uint32 d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_RumbleJoystick,(SDL_Joystick *a, Uint16 b, Uint16 c, Uint32 d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_RumbleJoystickTriggers,(SDL_Joystick *a, Uint16 b, Uint16 c, Uint32 d),(a,b,c,d),return) +SDL_DYNAPI_PROC(int,SDL_RunApp,(int a, char *b[], SDL_main_func c, void *d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_RunHapticEffect,(SDL_Haptic *a, int b, Uint32 c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SaveBMP,(SDL_Surface *a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SaveBMP_IO,(SDL_Surface *a, SDL_IOStream *b, bool c),(a,b,c),return) +SDL_DYNAPI_PROC(SDL_Surface*,SDL_ScaleSurface,(SDL_Surface *a, int b, int c, SDL_ScaleMode d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_ScreenKeyboardShown,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_ScreenSaverEnabled,(void),(),return) +SDL_DYNAPI_PROC(Sint64,SDL_SeekIO,(SDL_IOStream *a, Sint64 b, SDL_IOWhence c),(a,b,c),return) +SDL_DYNAPI_PROC(void,SDL_SendAndroidBackButton,(void),(),) +SDL_DYNAPI_PROC(bool,SDL_SendAndroidMessage,(Uint32 a, int b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SendGamepadEffect,(SDL_Gamepad *a, const void *b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SendJoystickEffect,(SDL_Joystick *a, const void *b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SendJoystickVirtualSensorData,(SDL_Joystick *a, SDL_SensorType b, Uint64 c, const float *d, int e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(bool,SDL_SetAppMetadata,(const char *a, const char *b, const char *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SetAppMetadataProperty,(const char *a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(void,SDL_SetAssertionHandler,(SDL_AssertionHandler a, void *b),(a,b),) +SDL_DYNAPI_PROC(int,SDL_SetAtomicInt,(SDL_AtomicInt *a, int b),(a,b),return) +SDL_DYNAPI_PROC(void*,SDL_SetAtomicPointer,(void **a, void *b),(a,b),return) +SDL_DYNAPI_PROC(Uint32,SDL_SetAtomicU32,(SDL_AtomicU32 *a, Uint32 b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetAudioDeviceGain,(SDL_AudioDeviceID a, float b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetAudioPostmixCallback,(SDL_AudioDeviceID a, SDL_AudioPostmixCallback b, void *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SetAudioStreamFormat,(SDL_AudioStream *a, const SDL_AudioSpec *b, const SDL_AudioSpec *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SetAudioStreamFrequencyRatio,(SDL_AudioStream *a, float b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetAudioStreamGain,(SDL_AudioStream *a, float b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetAudioStreamGetCallback,(SDL_AudioStream *a, SDL_AudioStreamCallback b, void *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SetAudioStreamInputChannelMap,(SDL_AudioStream *a, const int *b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SetAudioStreamOutputChannelMap,(SDL_AudioStream *a, const int *b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SetAudioStreamPutCallback,(SDL_AudioStream *a, SDL_AudioStreamCallback b, void *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SetBooleanProperty,(SDL_PropertiesID a, const char *b, bool c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SetClipboardData,(SDL_ClipboardDataCallback a, SDL_ClipboardCleanupCallback b, void *c, const char **d, size_t e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(bool,SDL_SetClipboardText,(const char *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_SetCurrentThreadPriority,(SDL_ThreadPriority a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_SetCursor,(SDL_Cursor *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_SetEnvironmentVariable,(SDL_Environment *a, const char *b, const char *c, bool d),(a,b,c,d),return) +SDL_DYNAPI_PROC(void,SDL_SetEventEnabled,(Uint32 a, bool b),(a,b),) +SDL_DYNAPI_PROC(void,SDL_SetEventFilter,(SDL_EventFilter a, void *b),(a,b),) +SDL_DYNAPI_PROC(bool,SDL_SetFloatProperty,(SDL_PropertiesID a, const char *b, float c),(a,b,c),return) +SDL_DYNAPI_PROC(void,SDL_SetGPUBlendConstants,(SDL_GPURenderPass *a, SDL_FColor b),(a,b),) +SDL_DYNAPI_PROC(void,SDL_SetGPUBufferName,(SDL_GPUDevice *a, SDL_GPUBuffer *b, const char *c),(a,b,c),) +SDL_DYNAPI_PROC(void,SDL_SetGPUScissor,(SDL_GPURenderPass *a, const SDL_Rect *b),(a,b),) +SDL_DYNAPI_PROC(void,SDL_SetGPUStencilReference,(SDL_GPURenderPass *a, Uint8 b),(a,b),) +SDL_DYNAPI_PROC(bool,SDL_SetGPUSwapchainParameters,(SDL_GPUDevice *a, SDL_Window *b, SDL_GPUSwapchainComposition c, SDL_GPUPresentMode d),(a,b,c,d),return) +SDL_DYNAPI_PROC(void,SDL_SetGPUTextureName,(SDL_GPUDevice *a, SDL_GPUTexture *b, const char *c),(a,b,c),) +SDL_DYNAPI_PROC(void,SDL_SetGPUViewport,(SDL_GPURenderPass *a, const SDL_GPUViewport *b),(a,b),) +SDL_DYNAPI_PROC(void,SDL_SetGamepadEventsEnabled,(bool a),(a),) +SDL_DYNAPI_PROC(bool,SDL_SetGamepadLED,(SDL_Gamepad *a, Uint8 b, Uint8 c, Uint8 d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_SetGamepadMapping,(SDL_JoystickID a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetGamepadPlayerIndex,(SDL_Gamepad *a, int b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetGamepadSensorEnabled,(SDL_Gamepad *a, SDL_SensorType b, bool c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SetHapticAutocenter,(SDL_Haptic *a, int b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetHapticGain,(SDL_Haptic *a, int b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetHint,(const char *a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetHintWithPriority,(const char *a, const char *b, SDL_HintPriority c),(a,b,c),return) +SDL_DYNAPI_PROC(void,SDL_SetInitialized,(SDL_InitState *a, bool b),(a,b),) +SDL_DYNAPI_PROC(void,SDL_SetJoystickEventsEnabled,(bool a),(a),) +SDL_DYNAPI_PROC(bool,SDL_SetJoystickLED,(SDL_Joystick *a, Uint8 b, Uint8 c, Uint8 d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_SetJoystickPlayerIndex,(SDL_Joystick *a, int b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetJoystickVirtualAxis,(SDL_Joystick *a, int b, Sint16 c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SetJoystickVirtualBall,(SDL_Joystick *a, int b, Sint16 c, Sint16 d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_SetJoystickVirtualButton,(SDL_Joystick *a, int b, bool c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SetJoystickVirtualHat,(SDL_Joystick *a, int b, Uint8 c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SetJoystickVirtualTouchpad,(SDL_Joystick *a, int b, int c, bool d, float e, float f, float g),(a,b,c,d,e,f,g),return) +SDL_DYNAPI_PROC(bool,SDL_SetLinuxThreadPriority,(Sint64 a, int b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetLinuxThreadPriorityAndPolicy,(Sint64 a, int b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(void,SDL_SetLogOutputFunction,(SDL_LogOutputFunction a, void *b),(a,b),) +SDL_DYNAPI_PROC(void,SDL_SetLogPriorities,(SDL_LogPriority a),(a),) +SDL_DYNAPI_PROC(void,SDL_SetLogPriority,(int a, SDL_LogPriority b),(a,b),) +SDL_DYNAPI_PROC(bool,SDL_SetLogPriorityPrefix,(SDL_LogPriority a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(void,SDL_SetMainReady,(void),(),) +SDL_DYNAPI_PROC(bool,SDL_SetMemoryFunctions,(SDL_malloc_func a, SDL_calloc_func b, SDL_realloc_func c, SDL_free_func d),(a,b,c,d),return) +SDL_DYNAPI_PROC(void,SDL_SetModState,(SDL_Keymod a),(a),) +SDL_DYNAPI_PROC(bool,SDL_SetNumberProperty,(SDL_PropertiesID a, const char *b, Sint64 c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SetPaletteColors,(SDL_Palette *a, const SDL_Color *b, int c, int d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_SetPointerProperty,(SDL_PropertiesID a, const char *b, void *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SetPointerPropertyWithCleanup,(SDL_PropertiesID a, const char *b, void *c, SDL_CleanupPropertyCallback d, void *e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(bool,SDL_SetPrimarySelectionText,(const char *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_SetRenderClipRect,(SDL_Renderer *a, const SDL_Rect *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetRenderColorScale,(SDL_Renderer *a, float b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetRenderDrawBlendMode,(SDL_Renderer *a, SDL_BlendMode b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetRenderDrawColor,(SDL_Renderer *a, Uint8 b, Uint8 c, Uint8 d, Uint8 e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(bool,SDL_SetRenderDrawColorFloat,(SDL_Renderer *a, float b, float c, float d, float e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(bool,SDL_SetRenderLogicalPresentation,(SDL_Renderer *a, int b, int c, SDL_RendererLogicalPresentation d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_SetRenderScale,(SDL_Renderer *a, float b, float c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SetRenderTarget,(SDL_Renderer *a, SDL_Texture *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetRenderVSync,(SDL_Renderer *a, int b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetRenderViewport,(SDL_Renderer *a, const SDL_Rect *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetScancodeName,(SDL_Scancode a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetStringProperty,(SDL_PropertiesID a, const char *b, const char *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SetSurfaceAlphaMod,(SDL_Surface *a, Uint8 b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetSurfaceBlendMode,(SDL_Surface *a, SDL_BlendMode b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetSurfaceClipRect,(SDL_Surface *a, const SDL_Rect *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetSurfaceColorKey,(SDL_Surface *a, bool b, Uint32 c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SetSurfaceColorMod,(SDL_Surface *a, Uint8 b, Uint8 c, Uint8 d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_SetSurfaceColorspace,(SDL_Surface *a, SDL_Colorspace b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetSurfacePalette,(SDL_Surface *a, SDL_Palette *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetSurfaceRLE,(SDL_Surface *a, bool b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetTLS,(SDL_TLSID *a, const void *b, SDL_TLSDestructorCallback c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SetTextInputArea,(SDL_Window *a, const SDL_Rect *b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SetTextureAlphaMod,(SDL_Texture *a, Uint8 b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetTextureAlphaModFloat,(SDL_Texture *a, float b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetTextureBlendMode,(SDL_Texture *a, SDL_BlendMode b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetTextureColorMod,(SDL_Texture *a, Uint8 b, Uint8 c, Uint8 d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_SetTextureColorModFloat,(SDL_Texture *a, float b, float c, float d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_SetTextureScaleMode,(SDL_Texture *a, SDL_ScaleMode b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetWindowAlwaysOnTop,(SDL_Window *a, bool b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetWindowAspectRatio,(SDL_Window *a, float b, float c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SetWindowBordered,(SDL_Window *a, bool b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetWindowFocusable,(SDL_Window *a, bool b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetWindowFullscreen,(SDL_Window *a, bool b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetWindowFullscreenMode,(SDL_Window *a, const SDL_DisplayMode *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetWindowHitTest,(SDL_Window *a, SDL_HitTest b, void *c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SetWindowIcon,(SDL_Window *a, SDL_Surface *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetWindowKeyboardGrab,(SDL_Window *a, bool b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetWindowMaximumSize,(SDL_Window *a, int b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SetWindowMinimumSize,(SDL_Window *a, int b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SetWindowModal,(SDL_Window *a, bool b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetWindowMouseGrab,(SDL_Window *a, bool b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetWindowMouseRect,(SDL_Window *a, const SDL_Rect *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetWindowOpacity,(SDL_Window *a, float b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetWindowParent,(SDL_Window *a, SDL_Window *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetWindowPosition,(SDL_Window *a, int b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SetWindowRelativeMouseMode,(SDL_Window *a, bool b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetWindowResizable,(SDL_Window *a, bool b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetWindowShape,(SDL_Window *a, SDL_Surface *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetWindowSize,(SDL_Window *a, int b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SetWindowSurfaceVSync,(SDL_Window *a, int b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_SetWindowTitle,(SDL_Window *a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(void,SDL_SetWindowsMessageHook,(SDL_WindowsMessageHook a, void *b),(a,b),) +SDL_DYNAPI_PROC(void,SDL_SetX11EventHook,(SDL_X11EventHook a, void *b),(a,b),) +SDL_DYNAPI_PROC(bool,SDL_SetiOSAnimationCallback,(SDL_Window *a, int b, SDL_iOSAnimationCallback c, void *d),(a,b,c,d),return) +SDL_DYNAPI_PROC(void,SDL_SetiOSEventPump,(bool a),(a),) +SDL_DYNAPI_PROC(bool,SDL_ShouldInit,(SDL_InitState *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_ShouldQuit,(SDL_InitState *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_ShowAndroidToast,(const char *a, int b, int c, int d, int e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(bool,SDL_ShowCursor,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_ShowMessageBox,(const SDL_MessageBoxData *a, int *b),(a,b),return) +SDL_DYNAPI_PROC(void,SDL_ShowOpenFileDialog,(SDL_DialogFileCallback a, void *b, SDL_Window *c, const SDL_DialogFileFilter *d, int e, const char *f, bool g),(a,b,c,d,e,f,g),) +SDL_DYNAPI_PROC(void,SDL_ShowOpenFolderDialog,(SDL_DialogFileCallback a, void *b, SDL_Window *c, const char *d, bool e),(a,b,c,d,e),) +SDL_DYNAPI_PROC(void,SDL_ShowSaveFileDialog,(SDL_DialogFileCallback a, void *b, SDL_Window *c, const SDL_DialogFileFilter *d, int e, const char *f),(a,b,c,d,e,f),) +SDL_DYNAPI_PROC(bool,SDL_ShowSimpleMessageBox,(SDL_MessageBoxFlags a, const char *b, const char *c, SDL_Window *d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_ShowWindow,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_ShowWindowSystemMenu,(SDL_Window *a, int b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(void,SDL_SignalCondition,(SDL_Condition *a),(a),) +SDL_DYNAPI_PROC(void,SDL_SignalSemaphore,(SDL_Semaphore *a),(a),) +SDL_DYNAPI_PROC(bool,SDL_StartTextInput,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_StartTextInputWithProperties,(SDL_Window *a, SDL_PropertiesID b),(a,b),return) +SDL_DYNAPI_PROC(Uint32,SDL_StepUTF8,(const char **a, size_t *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_StopHapticEffect,(SDL_Haptic *a, int b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_StopHapticEffects,(SDL_Haptic *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_StopHapticRumble,(SDL_Haptic *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_StopTextInput,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_StorageReady,(SDL_Storage *a),(a),return) +SDL_DYNAPI_PROC(SDL_GUID,SDL_StringToGUID,(const char *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_SubmitGPUCommandBuffer,(SDL_GPUCommandBuffer *a),(a),return) +SDL_DYNAPI_PROC(SDL_GPUFence*,SDL_SubmitGPUCommandBufferAndAcquireFence,(SDL_GPUCommandBuffer *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_SurfaceHasAlternateImages,(SDL_Surface *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_SurfaceHasColorKey,(SDL_Surface *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_SurfaceHasRLE,(SDL_Surface *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_SyncWindow,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(Sint64,SDL_TellIO,(SDL_IOStream *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_TextInputActive,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(SDL_Time,SDL_TimeFromWindows,(Uint32 a, Uint32 b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_TimeToDateTime,(SDL_Time a, SDL_DateTime *b, bool c),(a,b,c),return) +SDL_DYNAPI_PROC(void,SDL_TimeToWindows,(SDL_Time a, Uint32 *b, Uint32 *c),(a,b,c),) +SDL_DYNAPI_PROC(bool,SDL_TryLockMutex,(SDL_Mutex *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_TryLockRWLockForReading,(SDL_RWLock *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_TryLockRWLockForWriting,(SDL_RWLock *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_TryLockSpinlock,(SDL_SpinLock *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_TryWaitSemaphore,(SDL_Semaphore *a),(a),return) +SDL_DYNAPI_PROC(char*,SDL_UCS4ToUTF8,(Uint32 a, char *b),(a,b),return) +SDL_DYNAPI_PROC(void,SDL_UnbindAudioStream,(SDL_AudioStream *a),(a),) +SDL_DYNAPI_PROC(void,SDL_UnbindAudioStreams,(SDL_AudioStream * const *a, int b),(a,b),) +SDL_DYNAPI_PROC(void,SDL_UnloadObject,(SDL_SharedObject *a),(a),) +SDL_DYNAPI_PROC(bool,SDL_UnlockAudioStream,(SDL_AudioStream *a),(a),return) +SDL_DYNAPI_PROC(void,SDL_UnlockJoysticks,(void),(),) +SDL_DYNAPI_PROC(void,SDL_UnlockMutex,(SDL_Mutex *a),(a),) +SDL_DYNAPI_PROC(void,SDL_UnlockProperties,(SDL_PropertiesID a),(a),) +SDL_DYNAPI_PROC(void,SDL_UnlockRWLock,(SDL_RWLock *a),(a),) +SDL_DYNAPI_PROC(void,SDL_UnlockSpinlock,(SDL_SpinLock *a),(a),) +SDL_DYNAPI_PROC(void,SDL_UnlockSurface,(SDL_Surface *a),(a),) +SDL_DYNAPI_PROC(void,SDL_UnlockTexture,(SDL_Texture *a),(a),) +SDL_DYNAPI_PROC(void,SDL_UnmapGPUTransferBuffer,(SDL_GPUDevice *a, SDL_GPUTransferBuffer *b),(a,b),) +SDL_DYNAPI_PROC(void,SDL_UnregisterApp,(void),(),) +SDL_DYNAPI_PROC(bool,SDL_UnsetEnvironmentVariable,(SDL_Environment *a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(void,SDL_UpdateGamepads,(void),(),) +SDL_DYNAPI_PROC(bool,SDL_UpdateHapticEffect,(SDL_Haptic *a, int b, const SDL_HapticEffect *c),(a,b,c),return) +SDL_DYNAPI_PROC(void,SDL_UpdateJoysticks,(void),(),) +SDL_DYNAPI_PROC(bool,SDL_UpdateNVTexture,(SDL_Texture *a, const SDL_Rect *b, const Uint8 *c, int d, const Uint8 *e, int f),(a,b,c,d,e,f),return) +SDL_DYNAPI_PROC(void,SDL_UpdateSensors,(void),(),) +SDL_DYNAPI_PROC(bool,SDL_UpdateTexture,(SDL_Texture *a, const SDL_Rect *b, const void *c, int d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_UpdateWindowSurface,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_UpdateWindowSurfaceRects,(SDL_Window *a, const SDL_Rect *b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_UpdateYUVTexture,(SDL_Texture *a, const SDL_Rect *b, const Uint8 *c, int d, const Uint8 *e, int f, const Uint8 *g, int h),(a,b,c,d,e,f,g,h),return) +SDL_DYNAPI_PROC(void,SDL_UploadToGPUBuffer,(SDL_GPUCopyPass *a, const SDL_GPUTransferBufferLocation *b, const SDL_GPUBufferRegion *c, bool d),(a,b,c,d),) +SDL_DYNAPI_PROC(void,SDL_UploadToGPUTexture,(SDL_GPUCopyPass *a, const SDL_GPUTextureTransferInfo *b, const SDL_GPUTextureRegion *c, bool d),(a,b,c,d),) +SDL_DYNAPI_PROC(bool,SDL_Vulkan_CreateSurface,(SDL_Window *a, VkInstance b, const struct VkAllocationCallbacks *c, VkSurfaceKHR *d),(a,b,c,d),return) +SDL_DYNAPI_PROC(void,SDL_Vulkan_DestroySurface,(VkInstance a, VkSurfaceKHR b, const struct VkAllocationCallbacks *c),(a,b,c),) +SDL_DYNAPI_PROC(char const* const*,SDL_Vulkan_GetInstanceExtensions,(Uint32 *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_Vulkan_GetPresentationSupport,(VkInstance a, VkPhysicalDevice b, Uint32 c),(a,b,c),return) +SDL_DYNAPI_PROC(SDL_FunctionPointer,SDL_Vulkan_GetVkGetInstanceProcAddr,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_Vulkan_LoadLibrary,(const char *a),(a),return) +SDL_DYNAPI_PROC(void,SDL_Vulkan_UnloadLibrary,(void),(),) +SDL_DYNAPI_PROC(void,SDL_WaitCondition,(SDL_Condition *a, SDL_Mutex *b),(a,b),) +SDL_DYNAPI_PROC(bool,SDL_WaitConditionTimeout,(SDL_Condition *a, SDL_Mutex *b, Sint32 c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_WaitEvent,(SDL_Event *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_WaitEventTimeout,(SDL_Event *a, Sint32 b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_WaitForGPUFences,(SDL_GPUDevice *a, bool b, SDL_GPUFence *const *c, Uint32 d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_WaitForGPUIdle,(SDL_GPUDevice *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_WaitProcess,(SDL_Process *a, bool b, int *c),(a,b,c),return) +SDL_DYNAPI_PROC(void,SDL_WaitSemaphore,(SDL_Semaphore *a),(a),) +SDL_DYNAPI_PROC(bool,SDL_WaitSemaphoreTimeout,(SDL_Semaphore *a, Sint32 b),(a,b),return) +SDL_DYNAPI_PROC(void,SDL_WaitThread,(SDL_Thread *a, int *b),(a,b),) +SDL_DYNAPI_PROC(bool,SDL_WarpMouseGlobal,(float a, float b),(a,b),return) +SDL_DYNAPI_PROC(void,SDL_WarpMouseInWindow,(SDL_Window *a, float b, float c),(a,b,c),) +SDL_DYNAPI_PROC(SDL_InitFlags,SDL_WasInit,(SDL_InitFlags a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_WindowHasSurface,(SDL_Window *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_WindowSupportsGPUPresentMode,(SDL_GPUDevice *a, SDL_Window *b, SDL_GPUPresentMode c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_WindowSupportsGPUSwapchainComposition,(SDL_GPUDevice *a, SDL_Window *b, SDL_GPUSwapchainComposition c),(a,b,c),return) +SDL_DYNAPI_PROC(size_t,SDL_WriteIO,(SDL_IOStream *a, const void *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_WriteS16BE,(SDL_IOStream *a, Sint16 b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_WriteS16LE,(SDL_IOStream *a, Sint16 b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_WriteS32BE,(SDL_IOStream *a, Sint32 b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_WriteS32LE,(SDL_IOStream *a, Sint32 b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_WriteS64BE,(SDL_IOStream *a, Sint64 b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_WriteS64LE,(SDL_IOStream *a, Sint64 b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_WriteS8,(SDL_IOStream *a, Sint8 b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_WriteStorageFile,(SDL_Storage *a, const char *b, const void *c, Uint64 d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_WriteSurfacePixel,(SDL_Surface *a, int b, int c, Uint8 d, Uint8 e, Uint8 f, Uint8 g),(a,b,c,d,e,f,g),return) +SDL_DYNAPI_PROC(bool,SDL_WriteSurfacePixelFloat,(SDL_Surface *a, int b, int c, float d, float e, float f, float g),(a,b,c,d,e,f,g),return) +SDL_DYNAPI_PROC(bool,SDL_WriteU16BE,(SDL_IOStream *a, Uint16 b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_WriteU16LE,(SDL_IOStream *a, Uint16 b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_WriteU32BE,(SDL_IOStream *a, Uint32 b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_WriteU32LE,(SDL_IOStream *a, Uint32 b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_WriteU64BE,(SDL_IOStream *a, Uint64 b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_WriteU64LE,(SDL_IOStream *a, Uint64 b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_WriteU8,(SDL_IOStream *a, Uint8 b),(a,b),return) +SDL_DYNAPI_PROC(int,SDL_abs,(int a),(a),return) +SDL_DYNAPI_PROC(double,SDL_acos,(double a),(a),return) +SDL_DYNAPI_PROC(float,SDL_acosf,(float a),(a),return) +SDL_DYNAPI_PROC(void*,SDL_aligned_alloc,(size_t a, size_t b),(a,b),return) +SDL_DYNAPI_PROC(void,SDL_aligned_free,(void *a),(a),) +SDL_DYNAPI_PROC(double,SDL_asin,(double a),(a),return) +SDL_DYNAPI_PROC(float,SDL_asinf,(float a),(a),return) +SDL_DYNAPI_PROC(double,SDL_atan,(double a),(a),return) +SDL_DYNAPI_PROC(double,SDL_atan2,(double a, double b),(a,b),return) +SDL_DYNAPI_PROC(float,SDL_atan2f,(float a, float b),(a,b),return) +SDL_DYNAPI_PROC(float,SDL_atanf,(float a),(a),return) +SDL_DYNAPI_PROC(double,SDL_atof,(const char *a),(a),return) +SDL_DYNAPI_PROC(int,SDL_atoi,(const char *a),(a),return) +SDL_DYNAPI_PROC(void*,SDL_bsearch,(const void *a, const void *b, size_t c, size_t d, SDL_CompareCallback e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(void*,SDL_bsearch_r,(const void *a, const void *b, size_t c, size_t d, SDL_CompareCallback_r e, void *f),(a,b,c,d,e,f),return) +SDL_DYNAPI_PROC(void*,SDL_calloc,(size_t a, size_t b),(a,b),return) +SDL_DYNAPI_PROC(double,SDL_ceil,(double a),(a),return) +SDL_DYNAPI_PROC(float,SDL_ceilf,(float a),(a),return) +SDL_DYNAPI_PROC(double,SDL_copysign,(double a, double b),(a,b),return) +SDL_DYNAPI_PROC(float,SDL_copysignf,(float a, float b),(a,b),return) +SDL_DYNAPI_PROC(double,SDL_cos,(double a),(a),return) +SDL_DYNAPI_PROC(float,SDL_cosf,(float a),(a),return) +SDL_DYNAPI_PROC(Uint16,SDL_crc16,(Uint16 a, const void *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(Uint32,SDL_crc32,(Uint32 a, const void *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(double,SDL_exp,(double a),(a),return) +SDL_DYNAPI_PROC(float,SDL_expf,(float a),(a),return) +SDL_DYNAPI_PROC(double,SDL_fabs,(double a),(a),return) +SDL_DYNAPI_PROC(float,SDL_fabsf,(float a),(a),return) +SDL_DYNAPI_PROC(double,SDL_floor,(double a),(a),return) +SDL_DYNAPI_PROC(float,SDL_floorf,(float a),(a),return) +SDL_DYNAPI_PROC(double,SDL_fmod,(double a, double b),(a,b),return) +SDL_DYNAPI_PROC(float,SDL_fmodf,(float a, float b),(a,b),return) +SDL_DYNAPI_PROC(void,SDL_free,(void *a),(a),) +SDL_DYNAPI_PROC(const char*,SDL_getenv,(const char *a),(a),return) +SDL_DYNAPI_PROC(const char*,SDL_getenv_unsafe,(const char *a),(a),return) +SDL_DYNAPI_PROC(void,SDL_hid_ble_scan,(bool a),(a),) +SDL_DYNAPI_PROC(int,SDL_hid_close,(SDL_hid_device *a),(a),return) +SDL_DYNAPI_PROC(Uint32,SDL_hid_device_change_count,(void),(),return) +SDL_DYNAPI_PROC(SDL_hid_device_info*,SDL_hid_enumerate,(unsigned short a, unsigned short b),(a,b),return) +SDL_DYNAPI_PROC(int,SDL_hid_exit,(void),(),return) +SDL_DYNAPI_PROC(void,SDL_hid_free_enumeration,(SDL_hid_device_info *a),(a),) +SDL_DYNAPI_PROC(SDL_hid_device_info*,SDL_hid_get_device_info,(SDL_hid_device *a),(a),return) +SDL_DYNAPI_PROC(int,SDL_hid_get_feature_report,(SDL_hid_device *a, unsigned char *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(int,SDL_hid_get_indexed_string,(SDL_hid_device *a, int b, wchar_t *c, size_t d),(a,b,c,d),return) +SDL_DYNAPI_PROC(int,SDL_hid_get_input_report,(SDL_hid_device *a, unsigned char *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(int,SDL_hid_get_manufacturer_string,(SDL_hid_device *a, wchar_t *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(int,SDL_hid_get_product_string,(SDL_hid_device *a, wchar_t *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(int,SDL_hid_get_report_descriptor,(SDL_hid_device *a, unsigned char *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(int,SDL_hid_get_serial_number_string,(SDL_hid_device *a, wchar_t *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(int,SDL_hid_init,(void),(),return) +SDL_DYNAPI_PROC(SDL_hid_device*,SDL_hid_open,(unsigned short a, unsigned short b, const wchar_t *c),(a,b,c),return) +SDL_DYNAPI_PROC(SDL_hid_device*,SDL_hid_open_path,(const char *a),(a),return) +SDL_DYNAPI_PROC(int,SDL_hid_read,(SDL_hid_device *a, unsigned char *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(int,SDL_hid_read_timeout,(SDL_hid_device *a, unsigned char *b, size_t c, int d),(a,b,c,d),return) +SDL_DYNAPI_PROC(int,SDL_hid_send_feature_report,(SDL_hid_device *a, const unsigned char *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(int,SDL_hid_set_nonblocking,(SDL_hid_device *a, int b),(a,b),return) +SDL_DYNAPI_PROC(int,SDL_hid_write,(SDL_hid_device *a, const unsigned char *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(size_t,SDL_iconv,(SDL_iconv_t a, const char **b, size_t *c, char **d, size_t *e),(a,b,c,d,e),return) +SDL_DYNAPI_PROC(int,SDL_iconv_close,(SDL_iconv_t a),(a),return) +SDL_DYNAPI_PROC(SDL_iconv_t,SDL_iconv_open,(const char *a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(char*,SDL_iconv_string,(const char *a, const char *b, const char *c, size_t d),(a,b,c,d),return) +SDL_DYNAPI_PROC(int,SDL_isalnum,(int a),(a),return) +SDL_DYNAPI_PROC(int,SDL_isalpha,(int a),(a),return) +SDL_DYNAPI_PROC(int,SDL_isblank,(int a),(a),return) +SDL_DYNAPI_PROC(int,SDL_iscntrl,(int a),(a),return) +SDL_DYNAPI_PROC(int,SDL_isdigit,(int a),(a),return) +SDL_DYNAPI_PROC(int,SDL_isgraph,(int a),(a),return) +SDL_DYNAPI_PROC(int,SDL_isinf,(double a),(a),return) +SDL_DYNAPI_PROC(int,SDL_isinff,(float a),(a),return) +SDL_DYNAPI_PROC(int,SDL_islower,(int a),(a),return) +SDL_DYNAPI_PROC(int,SDL_isnan,(double a),(a),return) +SDL_DYNAPI_PROC(int,SDL_isnanf,(float a),(a),return) +SDL_DYNAPI_PROC(int,SDL_isprint,(int a),(a),return) +SDL_DYNAPI_PROC(int,SDL_ispunct,(int a),(a),return) +SDL_DYNAPI_PROC(int,SDL_isspace,(int a),(a),return) +SDL_DYNAPI_PROC(int,SDL_isupper,(int a),(a),return) +SDL_DYNAPI_PROC(int,SDL_isxdigit,(int a),(a),return) +SDL_DYNAPI_PROC(char*,SDL_itoa,(int a, char *b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(char*,SDL_lltoa,(long long a, char *b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(double,SDL_log,(double a),(a),return) +SDL_DYNAPI_PROC(double,SDL_log10,(double a),(a),return) +SDL_DYNAPI_PROC(float,SDL_log10f,(float a),(a),return) +SDL_DYNAPI_PROC(float,SDL_logf,(float a),(a),return) +SDL_DYNAPI_PROC(long,SDL_lround,(double a),(a),return) +SDL_DYNAPI_PROC(long,SDL_lroundf,(float a),(a),return) +SDL_DYNAPI_PROC(char*,SDL_ltoa,(long a, char *b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(void*,SDL_malloc,(size_t a),(a),return) +SDL_DYNAPI_PROC(int,SDL_memcmp,(const void *a, const void *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(void*,SDL_memcpy,(SDL_OUT_BYTECAP(c) void *a, SDL_IN_BYTECAP(c) const void *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(void*,SDL_memmove,(SDL_OUT_BYTECAP(c) void *a, SDL_IN_BYTECAP(c) const void *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(void*,SDL_memset,(SDL_OUT_BYTECAP(c) void *a, int b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(void*,SDL_memset4,(void *a, Uint32 b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(double,SDL_modf,(double a, double *b),(a,b),return) +SDL_DYNAPI_PROC(float,SDL_modff,(float a, float *b),(a,b),return) +SDL_DYNAPI_PROC(Uint32,SDL_murmur3_32,(const void *a, size_t b, Uint32 c),(a,b,c),return) +SDL_DYNAPI_PROC(double,SDL_pow,(double a, double b),(a,b),return) +SDL_DYNAPI_PROC(float,SDL_powf,(float a, float b),(a,b),return) +SDL_DYNAPI_PROC(void,SDL_qsort,(void *a, size_t b, size_t c, SDL_CompareCallback d),(a,b,c,d),) +SDL_DYNAPI_PROC(void,SDL_qsort_r,(void *a, size_t b, size_t c, SDL_CompareCallback_r d, void *e),(a,b,c,d,e),) +SDL_DYNAPI_PROC(Sint32,SDL_rand,(Sint32 a),(a),return) +SDL_DYNAPI_PROC(Uint32,SDL_rand_bits,(void),(),return) +SDL_DYNAPI_PROC(Uint32,SDL_rand_bits_r,(Uint64 *a),(a),return) +SDL_DYNAPI_PROC(Sint32,SDL_rand_r,(Uint64 *a, Sint32 b),(a,b),return) +SDL_DYNAPI_PROC(float,SDL_randf,(void),(),return) +SDL_DYNAPI_PROC(float,SDL_randf_r,(Uint64 *a),(a),return) +SDL_DYNAPI_PROC(void*,SDL_realloc,(void *a, size_t b),(a,b),return) +SDL_DYNAPI_PROC(double,SDL_round,(double a),(a),return) +SDL_DYNAPI_PROC(float,SDL_roundf,(float a),(a),return) +SDL_DYNAPI_PROC(double,SDL_scalbn,(double a, int b),(a,b),return) +SDL_DYNAPI_PROC(float,SDL_scalbnf,(float a, int b),(a,b),return) +SDL_DYNAPI_PROC(int,SDL_setenv_unsafe,(const char *a, const char *b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(double,SDL_sin,(double a),(a),return) +SDL_DYNAPI_PROC(float,SDL_sinf,(float a),(a),return) +SDL_DYNAPI_PROC(double,SDL_sqrt,(double a),(a),return) +SDL_DYNAPI_PROC(float,SDL_sqrtf,(float a),(a),return) +SDL_DYNAPI_PROC(void,SDL_srand,(Uint64 a),(a),) +SDL_DYNAPI_PROC(int,SDL_strcasecmp,(const char *a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(char*,SDL_strcasestr,(const char *a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(char*,SDL_strchr,(const char *a, int b),(a,b),return) +SDL_DYNAPI_PROC(int,SDL_strcmp,(const char *a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(char*,SDL_strdup,(const char *a),(a),return) +SDL_DYNAPI_PROC(size_t,SDL_strlcat,(SDL_INOUT_Z_CAP(c) char *a, const char *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(size_t,SDL_strlcpy,(SDL_OUT_Z_CAP(c) char *a, const char *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(size_t,SDL_strlen,(const char *a),(a),return) +SDL_DYNAPI_PROC(char*,SDL_strlwr,(char *a),(a),return) +SDL_DYNAPI_PROC(int,SDL_strncasecmp,(const char *a, const char *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(int,SDL_strncmp,(const char *a, const char *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(char*,SDL_strndup,(const char *a, size_t b),(a,b),return) +SDL_DYNAPI_PROC(size_t,SDL_strnlen,(const char *a, size_t b),(a,b),return) +SDL_DYNAPI_PROC(char*,SDL_strnstr,(const char *a, const char *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(char*,SDL_strpbrk,(const char *a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(char*,SDL_strrchr,(const char *a, int b),(a,b),return) +SDL_DYNAPI_PROC(char*,SDL_strrev,(char *a),(a),return) +SDL_DYNAPI_PROC(char*,SDL_strstr,(const char *a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(double,SDL_strtod,(const char *a, char **b),(a,b),return) +SDL_DYNAPI_PROC(char*,SDL_strtok_r,(char *a, const char *b, char **c),(a,b,c),return) +SDL_DYNAPI_PROC(long,SDL_strtol,(const char *a, char **b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(long long,SDL_strtoll,(const char *a, char **b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(unsigned long,SDL_strtoul,(const char *a, char **b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(unsigned long long,SDL_strtoull,(const char *a, char **b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(char*,SDL_strupr,(char *a),(a),return) +SDL_DYNAPI_PROC(double,SDL_tan,(double a),(a),return) +SDL_DYNAPI_PROC(float,SDL_tanf,(float a),(a),return) +SDL_DYNAPI_PROC(int,SDL_tolower,(int a),(a),return) +SDL_DYNAPI_PROC(int,SDL_toupper,(int a),(a),return) +SDL_DYNAPI_PROC(double,SDL_trunc,(double a),(a),return) +SDL_DYNAPI_PROC(float,SDL_truncf,(float a),(a),return) +SDL_DYNAPI_PROC(char*,SDL_uitoa,(unsigned int a, char *b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(char*,SDL_ulltoa,(unsigned long long a, char *b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(char*,SDL_ultoa,(unsigned long a, char *b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(int,SDL_unsetenv_unsafe,(const char *a),(a),return) +SDL_DYNAPI_PROC(size_t,SDL_utf8strlcpy,(SDL_OUT_Z_CAP(c) char *a, const char *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(size_t,SDL_utf8strlen,(const char *a),(a),return) +SDL_DYNAPI_PROC(size_t,SDL_utf8strnlen,(const char *a, size_t b),(a,b),return) +SDL_DYNAPI_PROC(int,SDL_vasprintf,(char **a, SDL_PRINTF_FORMAT_STRING const char *b, va_list c),(a,b,c),return) +SDL_DYNAPI_PROC(int,SDL_vsnprintf,(SDL_OUT_Z_CAP(b) char *a, size_t b, SDL_PRINTF_FORMAT_STRING const char *c, va_list d),(a,b,c,d),return) +SDL_DYNAPI_PROC(int,SDL_vsscanf,(const char *a, SDL_SCANF_FORMAT_STRING const char *b, va_list c),(a,b,c),return) +SDL_DYNAPI_PROC(int,SDL_vswprintf,(SDL_OUT_Z_CAP(b) wchar_t *a, size_t b, const wchar_t *c, va_list d),(a,b,c,d),return) +SDL_DYNAPI_PROC(int,SDL_wcscasecmp,(const wchar_t *a, const wchar_t *b),(a,b),return) +SDL_DYNAPI_PROC(int,SDL_wcscmp,(const wchar_t *a, const wchar_t *b),(a,b),return) +SDL_DYNAPI_PROC(wchar_t*,SDL_wcsdup,(const wchar_t *a),(a),return) +SDL_DYNAPI_PROC(size_t,SDL_wcslcat,(SDL_INOUT_Z_CAP(c) wchar_t *a, const wchar_t *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(size_t,SDL_wcslcpy,(SDL_OUT_Z_CAP(c) wchar_t *a, const wchar_t *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(size_t,SDL_wcslen,(const wchar_t *a),(a),return) +SDL_DYNAPI_PROC(int,SDL_wcsncasecmp,(const wchar_t *a, const wchar_t *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(int,SDL_wcsncmp,(const wchar_t *a, const wchar_t *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(size_t,SDL_wcsnlen,(const wchar_t *a, size_t b),(a,b),return) +SDL_DYNAPI_PROC(wchar_t*,SDL_wcsnstr,(const wchar_t *a, const wchar_t *b, size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(wchar_t*,SDL_wcsstr,(const wchar_t *a, const wchar_t *b),(a,b),return) +SDL_DYNAPI_PROC(long,SDL_wcstol,(const wchar_t *a, wchar_t **b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(Uint32,SDL_StepBackUTF8,(const char *a, const char **b),(a,b),return) +SDL_DYNAPI_PROC(void,SDL_DelayPrecise,(Uint64 a),(a),) +SDL_DYNAPI_PROC(Uint32,SDL_CalculateGPUTextureFormatSize,(SDL_GPUTextureFormat a, Uint32 b, Uint32 c, Uint32 d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_SetErrorV,(SDL_PRINTF_FORMAT_STRING const char *a,va_list b),(a,b),return) +SDL_DYNAPI_PROC(SDL_LogOutputFunction,SDL_GetDefaultLogOutputFunction,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_RenderDebugText,(SDL_Renderer *a,float b,float c,const char *d),(a,b,c,d),return) +SDL_DYNAPI_PROC(SDL_Sandbox,SDL_GetSandbox,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_CancelGPUCommandBuffer,(SDL_GPUCommandBuffer *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_SaveFile_IO,(SDL_IOStream *a,const void *b,size_t c,bool d),(a,b,c,d),return) +SDL_DYNAPI_PROC(bool,SDL_SaveFile,(const char *a,const void *b,size_t c),(a,b,c),return) +SDL_DYNAPI_PROC(char*,SDL_GetCurrentDirectory,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_IsAudioDevicePhysical,(SDL_AudioDeviceID a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_IsAudioDevicePlayback,(SDL_AudioDeviceID a),(a),return) +SDL_DYNAPI_PROC(SDL_AsyncIO*,SDL_AsyncIOFromFile,(const char *a, const char *b),(a,b),return) +SDL_DYNAPI_PROC(Sint64,SDL_GetAsyncIOSize,(SDL_AsyncIO *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_ReadAsyncIO,(SDL_AsyncIO *a, void *b, Uint64 c, Uint64 d, SDL_AsyncIOQueue *e, void *f),(a,b,c,d,e,f),return) +SDL_DYNAPI_PROC(bool,SDL_WriteAsyncIO,(SDL_AsyncIO *a, void *b, Uint64 c, Uint64 d, SDL_AsyncIOQueue *e, void *f),(a,b,c,d,e,f),return) +SDL_DYNAPI_PROC(bool,SDL_CloseAsyncIO,(SDL_AsyncIO *a, bool b, SDL_AsyncIOQueue *c, void *d),(a,b,c,d),return) +SDL_DYNAPI_PROC(SDL_AsyncIOQueue*,SDL_CreateAsyncIOQueue,(void),(),return) +SDL_DYNAPI_PROC(void,SDL_DestroyAsyncIOQueue,(SDL_AsyncIOQueue *a),(a),) +SDL_DYNAPI_PROC(bool,SDL_GetAsyncIOResult,(SDL_AsyncIOQueue *a, SDL_AsyncIOOutcome *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_WaitAsyncIOResult,(SDL_AsyncIOQueue *a, SDL_AsyncIOOutcome *b, Sint32 c),(a,b,c),return) +SDL_DYNAPI_PROC(void,SDL_SignalAsyncIOQueue,(SDL_AsyncIOQueue *a),(a),) +SDL_DYNAPI_PROC(bool,SDL_LoadFileAsync,(const char *a, SDL_AsyncIOQueue *b, void *c),(a,b,c),return) +SDL_DYNAPI_PROC(void,SDL_ShowFileDialogWithProperties,(SDL_FileDialogType a, SDL_DialogFileCallback b, void *c, SDL_PropertiesID d),(a,b,c,d),) +SDL_DYNAPI_PROC(bool,SDL_IsMainThread,(void),(),return) +SDL_DYNAPI_PROC(bool,SDL_RunOnMainThread,(SDL_MainThreadCallback a,void *b,bool c),(a,b,c),return) +SDL_DYNAPI_PROC(bool,SDL_SetGPUAllowedFramesInFlight,(SDL_GPUDevice *a,Uint32 b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_RenderTextureAffine,(SDL_Renderer *a,SDL_Texture *b,const SDL_FRect *c,const SDL_FPoint *d,const SDL_FPoint *e,const SDL_FPoint *f),(a,b,c,d,e,f),return) +SDL_DYNAPI_PROC(bool,SDL_WaitForGPUSwapchain,(SDL_GPUDevice *a, SDL_Window *b),(a,b),return) +SDL_DYNAPI_PROC(bool,SDL_WaitAndAcquireGPUSwapchainTexture,(SDL_GPUCommandBuffer *a,SDL_Window *b,SDL_GPUTexture **c,Uint32 *d,Uint32 *e),(a,b,c,d,e),return) +#ifndef SDL_DYNAPI_PROC_NO_VARARGS +SDL_DYNAPI_PROC(bool,SDL_RenderDebugTextFormat,(SDL_Renderer *a,float b,float c,SDL_PRINTF_FORMAT_STRING const char *d,...),(a,b,c,d),return) +#endif +SDL_DYNAPI_PROC(SDL_Tray*,SDL_CreateTray,(SDL_Surface *a,const char *b),(a,b),return) +SDL_DYNAPI_PROC(void,SDL_SetTrayIcon,(SDL_Tray *a,SDL_Surface *b),(a,b),) +SDL_DYNAPI_PROC(void,SDL_SetTrayTooltip,(SDL_Tray *a,const char *b),(a,b),) +SDL_DYNAPI_PROC(SDL_TrayMenu*,SDL_CreateTrayMenu,(SDL_Tray *a),(a),return) +SDL_DYNAPI_PROC(SDL_TrayMenu*,SDL_CreateTraySubmenu,(SDL_TrayEntry *a),(a),return) +SDL_DYNAPI_PROC(SDL_TrayMenu*,SDL_GetTrayMenu,(SDL_Tray *a),(a),return) +SDL_DYNAPI_PROC(SDL_TrayMenu*,SDL_GetTraySubmenu,(SDL_TrayEntry *a),(a),return) +SDL_DYNAPI_PROC(const SDL_TrayEntry**,SDL_GetTrayEntries,(SDL_TrayMenu *a,int *b),(a,b),return) +SDL_DYNAPI_PROC(void,SDL_RemoveTrayEntry,(SDL_TrayEntry *a),(a),) +SDL_DYNAPI_PROC(SDL_TrayEntry*,SDL_InsertTrayEntryAt,(SDL_TrayMenu *a,int b,const char *c,SDL_TrayEntryFlags d),(a,b,c,d),return) +SDL_DYNAPI_PROC(void,SDL_SetTrayEntryLabel,(SDL_TrayEntry *a,const char *b),(a,b),) +SDL_DYNAPI_PROC(const char*,SDL_GetTrayEntryLabel,(SDL_TrayEntry *a),(a),return) +SDL_DYNAPI_PROC(void,SDL_SetTrayEntryChecked,(SDL_TrayEntry *a,bool b),(a,b),) +SDL_DYNAPI_PROC(bool,SDL_GetTrayEntryChecked,(SDL_TrayEntry *a),(a),return) +SDL_DYNAPI_PROC(void,SDL_SetTrayEntryEnabled,(SDL_TrayEntry *a,bool b),(a,b),) +SDL_DYNAPI_PROC(bool,SDL_GetTrayEntryEnabled,(SDL_TrayEntry *a),(a),return) +SDL_DYNAPI_PROC(void,SDL_SetTrayEntryCallback,(SDL_TrayEntry *a,SDL_TrayCallback b,void *c),(a,b,c),) +SDL_DYNAPI_PROC(void,SDL_DestroyTray,(SDL_Tray *a),(a),) +SDL_DYNAPI_PROC(SDL_TrayMenu*,SDL_GetTrayEntryParent,(SDL_TrayEntry *a),(a),return) +SDL_DYNAPI_PROC(SDL_TrayEntry*,SDL_GetTrayMenuParentEntry,(SDL_TrayMenu *a),(a),return) +SDL_DYNAPI_PROC(SDL_Tray*,SDL_GetTrayMenuParentTray,(SDL_TrayMenu *a),(a),return) +SDL_DYNAPI_PROC(SDL_ThreadState,SDL_GetThreadState,(SDL_Thread *a),(a),return) +SDL_DYNAPI_PROC(bool,SDL_AudioStreamDevicePaused,(SDL_AudioStream *a),(a),return) +SDL_DYNAPI_PROC(void,SDL_ClickTrayEntry,(SDL_TrayEntry *a),(a),) +SDL_DYNAPI_PROC(void,SDL_UpdateTrays,(void),(),) +SDL_DYNAPI_PROC(bool,SDL_StretchSurface,(SDL_Surface *a,const SDL_Rect *b,SDL_Surface *c,const SDL_Rect *d,SDL_ScaleMode e),(a,b,c,d,e),return) diff --git a/contrib/SDL-3.2.8/src/dynapi/SDL_dynapi_unsupported.h b/contrib/SDL-3.2.8/src/dynapi/SDL_dynapi_unsupported.h new file mode 100644 index 0000000..143943a --- /dev/null +++ b/contrib/SDL-3.2.8/src/dynapi/SDL_dynapi_unsupported.h @@ -0,0 +1,52 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef SDL_dynapi_unsupported_h_ +#define SDL_dynapi_unsupported_h_ + + +#if !defined(SDL_PLATFORM_WINDOWS) +typedef struct ID3D12Device ID3D12Device; +typedef void *SDL_WindowsMessageHook; +#endif + +#if !(defined(SDL_PLATFORM_WIN32) || defined(SDL_PLATFORM_WINGDK)) +typedef struct ID3D11Device ID3D11Device; +typedef struct IDirect3DDevice9 IDirect3DDevice9; +#endif + +#ifndef SDL_PLATFORM_GDK +typedef struct XTaskQueueHandle XTaskQueueHandle; +#endif + +#ifndef SDL_PLATFORM_GDK +typedef struct XUserHandle XUserHandle; +#endif + +#ifndef SDL_PLATFORM_ANDROID +typedef void *SDL_RequestAndroidPermissionCallback; +#endif + +#ifndef SDL_PLATFORM_IOS +typedef void *SDL_iOSAnimationCallback; +#endif + +#endif diff --git a/contrib/SDL-3.2.8/src/dynapi/gendynapi.py b/contrib/SDL-3.2.8/src/dynapi/gendynapi.py new file mode 100755 index 0000000..0915523 --- /dev/null +++ b/contrib/SDL-3.2.8/src/dynapi/gendynapi.py @@ -0,0 +1,547 @@ +#!/usr/bin/env python3 + +# Simple DirectMedia Layer +# Copyright (C) 1997-2025 Sam Lantinga +# +# This software is provided 'as-is', without any express or implied +# warranty. In no event will the authors be held liable for any damages +# arising from the use of this software. +# +# Permission is granted to anyone to use this software for any purpose, +# including commercial applications, and to alter it and redistribute it +# freely, subject to the following restrictions: +# +# 1. The origin of this software must not be misrepresented; you must not +# claim that you wrote the original software. If you use this software +# in a product, an acknowledgment in the product documentation would be +# appreciated but is not required. +# 2. Altered source versions must be plainly marked as such, and must not be +# misrepresented as being the original software. +# 3. This notice may not be removed or altered from any source distribution. + +# WHAT IS THIS? +# When you add a public API to SDL, please run this script, make sure the +# output looks sane (git diff, it adds to existing files), and commit it. +# It keeps the dynamic API jump table operating correctly. +# +# Platform-specific API: +# After running the script, you have to manually add #ifdef SDL_PLATFORM_WIN32 +# or similar around the function in 'SDL_dynapi_procs.h'. +# + +import argparse +import dataclasses +import json +import logging +import os +from pathlib import Path +import pprint +import re + + +SDL_ROOT = Path(__file__).resolve().parents[2] + +SDL_INCLUDE_DIR = SDL_ROOT / "include/SDL3" +SDL_DYNAPI_PROCS_H = SDL_ROOT / "src/dynapi/SDL_dynapi_procs.h" +SDL_DYNAPI_OVERRIDES_H = SDL_ROOT / "src/dynapi/SDL_dynapi_overrides.h" +SDL_DYNAPI_SYM = SDL_ROOT / "src/dynapi/SDL_dynapi.sym" + +RE_EXTERN_C = re.compile(r'.*extern[ "]*C[ "].*') +RE_COMMENT_REMOVE_CONTENT = re.compile(r'\/\*.*\*/') +RE_PARSING_FUNCTION = re.compile(r'(.*SDLCALL[^\(\)]*) ([a-zA-Z0-9_]+) *\((.*)\) *;.*') + +#eg: +# void (SDLCALL *callback)(void*, int) +# \1(\2)\3 +RE_PARSING_CALLBACK = re.compile(r'([^\(\)]*)\(([^\(\)]+)\)(.*)') + + +logger = logging.getLogger(__name__) + + +@dataclasses.dataclass(frozen=True) +class SdlProcedure: + retval: str + name: str + parameter: list[str] + parameter_name: list[str] + header: str + comment: str + + @property + def variadic(self) -> bool: + return "..." in self.parameter + + +def parse_header(header_path: Path) -> list[SdlProcedure]: + logger.debug("Parse header: %s", header_path) + + header_procedures = [] + + parsing_function = False + current_func = "" + parsing_comment = False + current_comment = "" + ignore_wiki_documentation = False + + with header_path.open() as f: + for line in f: + + # Skip lines if we're in a wiki documentation block. + if ignore_wiki_documentation: + if line.startswith("#endif"): + ignore_wiki_documentation = False + continue + + # Discard wiki documentations blocks. + if line.startswith("#ifdef SDL_WIKI_DOCUMENTATION_SECTION"): + ignore_wiki_documentation = True + continue + + # Discard pre-processor directives ^#.* + if line.startswith("#"): + continue + + # Discard "extern C" line + match = RE_EXTERN_C.match(line) + if match: + continue + + # Remove one line comment // ... + # eg: extern SDL_DECLSPEC SDL_hid_device * SDLCALL SDL_hid_open_path(const char *path, int bExclusive /* = false */) + line = RE_COMMENT_REMOVE_CONTENT.sub('', line) + + # Get the comment block /* ... */ across several lines + match_start = "/*" in line + match_end = "*/" in line + if match_start and match_end: + continue + if match_start: + parsing_comment = True + current_comment = line + continue + if match_end: + parsing_comment = False + current_comment += line + continue + if parsing_comment: + current_comment += line + continue + + # Get the function prototype across several lines + if parsing_function: + # Append to the current function + current_func += " " + current_func += line.strip() + else: + # if is contains "extern", start grabbing + if "extern" not in line: + continue + # Start grabbing the new function + current_func = line.strip() + parsing_function = True + + # If it contains ';', then the function is complete + if ";" not in current_func: + continue + + # Got function/comment, reset vars + parsing_function = False + func = current_func + comment = current_comment + current_func = "" + current_comment = "" + + # Discard if it doesn't contain 'SDLCALL' + if "SDLCALL" not in func: + logger.debug(" Discard, doesn't have SDLCALL: %r", func) + continue + + # Discard if it contains 'SDLMAIN_DECLSPEC' (these are not SDL symbols). + if "SDLMAIN_DECLSPEC" in func: + logger.debug(" Discard, has SDLMAIN_DECLSPEC: %r", func) + continue + + logger.debug("Raw data: %r", func) + + # Replace unusual stuff... + func = func.replace(" SDL_PRINTF_VARARG_FUNC(1)", "") + func = func.replace(" SDL_PRINTF_VARARG_FUNC(2)", "") + func = func.replace(" SDL_PRINTF_VARARG_FUNC(3)", "") + func = func.replace(" SDL_PRINTF_VARARG_FUNC(4)", "") + func = func.replace(" SDL_PRINTF_VARARG_FUNCV(1)", "") + func = func.replace(" SDL_PRINTF_VARARG_FUNCV(2)", "") + func = func.replace(" SDL_PRINTF_VARARG_FUNCV(3)", "") + func = func.replace(" SDL_PRINTF_VARARG_FUNCV(4)", "") + func = func.replace(" SDL_WPRINTF_VARARG_FUNC(3)", "") + func = func.replace(" SDL_WPRINTF_VARARG_FUNCV(3)", "") + func = func.replace(" SDL_SCANF_VARARG_FUNC(2)", "") + func = func.replace(" SDL_SCANF_VARARG_FUNCV(2)", "") + func = func.replace(" SDL_ANALYZER_NORETURN", "") + func = func.replace(" SDL_MALLOC", "") + func = func.replace(" SDL_ALLOC_SIZE2(1, 2)", "") + func = func.replace(" SDL_ALLOC_SIZE(2)", "") + func = re.sub(r" SDL_ACQUIRE\(.*\)", "", func) + func = re.sub(r" SDL_ACQUIRE_SHARED\(.*\)", "", func) + func = re.sub(r" SDL_TRY_ACQUIRE\(.*\)", "", func) + func = re.sub(r" SDL_TRY_ACQUIRE_SHARED\(.*\)", "", func) + func = re.sub(r" SDL_RELEASE\(.*\)", "", func) + func = re.sub(r" SDL_RELEASE_SHARED\(.*\)", "", func) + func = re.sub(r" SDL_RELEASE_GENERIC\(.*\)", "", func) + func = re.sub(r"([ (),])(SDL_IN_BYTECAP\([^)]*\))", r"\1", func) + func = re.sub(r"([ (),])(SDL_OUT_BYTECAP\([^)]*\))", r"\1", func) + func = re.sub(r"([ (),])(SDL_INOUT_Z_CAP\([^)]*\))", r"\1", func) + func = re.sub(r"([ (),])(SDL_OUT_Z_CAP\([^)]*\))", r"\1", func) + + # Should be a valid function here + match = RE_PARSING_FUNCTION.match(func) + if not match: + logger.error("Cannot parse: %s", func) + raise ValueError(func) + + func_ret = match.group(1) + func_name = match.group(2) + func_params = match.group(3) + + # + # Parse return value + # + func_ret = func_ret.replace('extern', ' ') + func_ret = func_ret.replace('SDLCALL', ' ') + func_ret = func_ret.replace('SDL_DECLSPEC', ' ') + func_ret, _ = re.subn('([ ]{2,})', ' ', func_ret) + # Remove trailing spaces in front of '*' + func_ret = func_ret.replace(' *', '*') + func_ret = func_ret.strip() + + # + # Parse parameters + # + func_params = func_params.strip() + if func_params == "": + func_params = "void" + + # Identify each function parameters with type and name + # (eventually there are callbacks of several parameters) + tmp = func_params.split(',') + tmp2 = [] + param = "" + for t in tmp: + if param == "": + param = t + else: + param = param + "," + t + # Identify a callback or parameter when there is same count of '(' and ')' + if param.count('(') == param.count(')'): + tmp2.append(param.strip()) + param = "" + + # Process each parameters, separation name and type + func_param_type = [] + func_param_name = [] + for t in tmp2: + if t == "void": + func_param_type.append(t) + func_param_name.append("") + continue + + if t == "...": + func_param_type.append(t) + func_param_name.append("") + continue + + param_name = "" + + # parameter is a callback + if '(' in t: + match = RE_PARSING_CALLBACK.match(t) + if not match: + logger.error("cannot parse callback: %s", t) + raise ValueError(t) + a = match.group(1).strip() + b = match.group(2).strip() + c = match.group(3).strip() + + try: + (param_type, param_name) = b.rsplit('*', 1) + except: + param_type = t + param_name = "param_name_not_specified" + + # bug rsplit ?? + if param_name == "": + param_name = "param_name_not_specified" + + # reconstruct a callback name for future parsing + func_param_type.append(a + " (" + param_type.strip() + " *REWRITE_NAME)" + c) + func_param_name.append(param_name.strip()) + + continue + + # array like "char *buf[]" + has_array = False + if t.endswith("[]"): + t = t.replace("[]", "") + has_array = True + + # pointer + if '*' in t: + try: + (param_type, param_name) = t.rsplit('*', 1) + except: + param_type = t + param_name = "param_name_not_specified" + + # bug rsplit ?? + if param_name == "": + param_name = "param_name_not_specified" + + val = param_type.strip() + "*REWRITE_NAME" + + # Remove trailing spaces in front of '*' + tmp = "" + while val != tmp: + tmp = val + val = val.replace(' ', ' ') + val = val.replace(' *', '*') + # first occurrence + val = val.replace('*', ' *', 1) + val = val.strip() + + else: # non pointer + # cut-off last word on + try: + (param_type, param_name) = t.rsplit(' ', 1) + except: + param_type = t + param_name = "param_name_not_specified" + + val = param_type.strip() + " REWRITE_NAME" + + # set back array + if has_array: + val += "[]" + + func_param_type.append(val) + func_param_name.append(param_name.strip()) + + new_proc = SdlProcedure( + retval=func_ret, # Return value type + name=func_name, # Function name + comment=comment, # Function comment + header=header_path.name, # Header file + parameter=func_param_type, # List of parameters (type + anonymized param name 'REWRITE_NAME') + parameter_name=func_param_name, # Real parameter name, or 'param_name_not_specified' + ) + + header_procedures.append(new_proc) + + if logger.getEffectiveLevel() <= logging.DEBUG: + logger.debug("%s", pprint.pformat(new_proc)) + + return header_procedures + + +# Dump API into a json file +def full_API_json(path: Path, procedures: list[SdlProcedure]): + with path.open('w', newline='') as f: + json.dump([dataclasses.asdict(proc) for proc in procedures], f, indent=4, sort_keys=True) + logger.info("dump API to '%s'", path) + + +class CallOnce: + def __init__(self, cb): + self._cb = cb + self._called = False + def __call__(self, *args, **kwargs): + if self._called: + return + self._called = True + self._cb(*args, **kwargs) + + +# Check public function comments are correct +def print_check_comment_header(): + logger.warning("") + logger.warning("Please fix following warning(s):") + logger.warning("--------------------------------") + + +def check_documentations(procedures: list[SdlProcedure]) -> None: + + check_comment_header = CallOnce(print_check_comment_header) + + warning_header_printed = False + + # Check \param + for proc in procedures: + expected = len(proc.parameter) + if expected == 1: + if proc.parameter[0] == 'void': + expected = 0 + count = proc.comment.count("\\param") + if count != expected: + # skip SDL_stdinc.h + if proc.header != 'SDL_stdinc.h': + # Warning mismatch \param and function prototype + check_comment_header() + logger.warning(" In file %s: function %s() has %d '\\param' but expected %d", proc.header, proc.name, count, expected) + + # Warning check \param uses the correct parameter name + # skip SDL_stdinc.h + if proc.header != 'SDL_stdinc.h': + for n in proc.parameter_name: + if n != "" and "\\param " + n not in proc.comment and "\\param[out] " + n not in proc.comment: + check_comment_header() + logger.warning(" In file %s: function %s() missing '\\param %s'", proc.header, proc.name, n) + + # Check \returns + for proc in procedures: + expected = 1 + if proc.retval == 'void': + expected = 0 + + count = proc.comment.count("\\returns") + if count != expected: + # skip SDL_stdinc.h + if proc.header != 'SDL_stdinc.h': + # Warning mismatch \param and function prototype + check_comment_header() + logger.warning(" In file %s: function %s() has %d '\\returns' but expected %d" % (proc.header, proc.name, count, expected)) + + # Check \since + for proc in procedures: + expected = 1 + count = proc.comment.count("\\since") + if count != expected: + # skip SDL_stdinc.h + if proc.header != 'SDL_stdinc.h': + # Warning mismatch \param and function prototype + check_comment_header() + logger.warning(" In file %s: function %s() has %d '\\since' but expected %d" % (proc.header, proc.name, count, expected)) + + +# Parse 'sdl_dynapi_procs_h' file to find existing functions +def find_existing_proc_names() -> list[str]: + reg = re.compile(r'SDL_DYNAPI_PROC\([^,]*,([^,]*),.*\)') + ret = [] + + with SDL_DYNAPI_PROCS_H.open() as f: + for line in f: + match = reg.match(line) + if not match: + continue + existing_func = match.group(1) + ret.append(existing_func) + return ret + +# Get list of SDL headers +def get_header_list() -> list[Path]: + ret = [] + + for f in SDL_INCLUDE_DIR.iterdir(): + # Only *.h files + if f.is_file() and f.suffix == ".h": + ret.append(f) + else: + logger.debug("Skip %s", f) + + # Order headers for reproducible behavior + ret.sort() + + return ret + +# Write the new API in files: _procs.h _overrivides.h and .sym +def add_dyn_api(proc: SdlProcedure) -> None: + decl_args: list[str] = [] + call_args = [] + for i, argtype in enumerate(proc.parameter): + # Special case, void has no parameter name + if argtype == "void": + assert len(decl_args) == 0 + assert len(proc.parameter) == 1 + decl_args.append("void") + continue + + # Var name: a, b, c, ... + varname = chr(ord('a') + i) + + decl_args.append(argtype.replace("REWRITE_NAME", varname)) + if argtype != "...": + call_args.append(varname) + + macro_args = ( + proc.retval, + proc.name, + "({})".format(",".join(decl_args)), + "({})".format(",".join(call_args)), + "" if proc.retval == "void" else "return", + ) + + # File: SDL_dynapi_procs.h + # + # Add at last + # SDL_DYNAPI_PROC(SDL_EGLConfig,SDL_EGL_GetCurrentConfig,(void),(),return) + with SDL_DYNAPI_PROCS_H.open("a", newline="") as f: + if proc.variadic: + f.write("#ifndef SDL_DYNAPI_PROC_NO_VARARGS\n") + f.write(f"SDL_DYNAPI_PROC({','.join(macro_args)})\n") + if proc.variadic: + f.write("#endif\n") + + # File: SDL_dynapi_overrides.h + # + # Add at last + # "#define SDL_DelayNS SDL_DelayNS_REAL + f = open(SDL_DYNAPI_OVERRIDES_H, "a", newline="") + f.write(f"#define {proc.name} {proc.name}_REAL\n") + f.close() + + # File: SDL_dynapi.sym + # + # Add before "extra symbols go here" line + with SDL_DYNAPI_SYM.open() as f: + new_input = [] + for line in f: + if "extra symbols go here" in line: + new_input.append(f" {proc.name};\n") + new_input.append(line) + + with SDL_DYNAPI_SYM.open('w', newline='') as f: + for line in new_input: + f.write(line) + + +def main(): + parser = argparse.ArgumentParser() + parser.set_defaults(loglevel=logging.INFO) + parser.add_argument('--dump', nargs='?', default=None, const="sdl.json", metavar="JSON", help='output all SDL API into a .json file') + parser.add_argument('--debug', action='store_const', const=logging.DEBUG, dest="loglevel", help='add debug traces') + args = parser.parse_args() + + logging.basicConfig(level=args.loglevel, format='[%(levelname)s] %(message)s') + + # Get list of SDL headers + sdl_list_includes = get_header_list() + procedures = [] + for filename in sdl_list_includes: + header_procedures = parse_header(filename) + procedures.extend(header_procedures) + + # Parse 'sdl_dynapi_procs_h' file to find existing functions + existing_proc_names = find_existing_proc_names() + for procedure in procedures: + if procedure.name not in existing_proc_names: + logger.info("NEW %s", procedure.name) + add_dyn_api(procedure) + + if args.dump: + # Dump API into a json file + full_API_json(path=Path(args.dump), procedures=procedures) + + # Check comment formatting + check_documentations(procedures) + + +if __name__ == '__main__': + raise SystemExit(main()) -- cgit v1.2.3