package sdl3 import "base:builtin" import "base:intrinsics" import "core:c" #assert(size_of(c.int) == size_of(b32)) #assert(size_of(c.int) == size_of(rune)) SIZE_MAX :: 1<<(8*size_of(uint)) - 1 @(require_results) FOURCC :: #force_inline proc "contextless" (#any_int A, B, C, D: u8) -> u32 { return u32(A)<<0 | u32(B)<<8 | u32(C)<<16 | u32(D)<<24 } Sint8 :: i8 Uint8 :: u8 Sint16 :: i16 Uint16 :: u16 Sint32 :: i32 Uint32 :: u32 Sint64 :: i64 Uint64 :: u64 wchar_t :: c.wchar_t /** * SDL times are signed, 64-bit integers representing nanoseconds since the * Unix epoch (Jan 1, 1970). * * They can be converted between POSIX time_t values with SDL_NS_TO_SECONDS() * and SDL_SECONDS_TO_NS(), and between Windows FILETIME values with * SDL_TimeToWindows() and SDL_TimeFromWindows(). * * \since This macro is available since SDL 3.2.0. * * \sa SDL_MAX_SINT64 * \sa SDL_MIN_SINT64 */ Time :: distinct i64 FLT_EPSILON :: 1.1920928955078125e-07 /* 0x0.000002p0 */ INIT_INTERFACE :: proc "contextless" (iface: ^$T) { zerop(iface) iface.version = size_of(iface^) } stack_alloc :: intrinsics.alloca malloc_func :: #type proc "c" (size: uint) -> rawptr calloc_func :: #type proc "c" (nmemb: uint, size: uint) -> rawptr realloc_func :: #type proc "c" (mem: rawptr, size: uint) -> rawptr free_func :: #type proc "c" (mem: rawptr) @(default_calling_convention="c", link_prefix="SDL_") foreign lib { @(require_results) malloc :: proc(size: uint) -> rawptr --- @(require_results) calloc :: proc(nmemb: uint, size: uint) -> rawptr --- @(require_results) realloc :: proc(mem: rawptr, size: uint) -> rawptr --- free :: proc(mem: rawptr) --- GetOriginalMemoryFunctions :: proc(malloc_func: ^malloc_func, calloc_func: ^calloc_func, realloc_func: ^realloc_func, free_func: ^free_func) --- GetMemoryFunctions :: proc(malloc_func: ^malloc_func, calloc_func: ^calloc_func, realloc_func: ^realloc_func, free_func: ^free_func) --- SetMemoryFunctions :: proc(malloc_func: malloc_func, calloc_func: calloc_func, realloc_func: realloc_func, free_func: free_func) --- @(require_results) aligned_alloc :: proc(alignment: uint, size: uint) -> rawptr --- aligned_free :: proc(mem: rawptr) --- @(require_results) GetNumAllocations :: proc() -> c.int --- } Environment :: struct {} @(default_calling_convention="c", link_prefix="SDL_") foreign lib { @(require_results) GetEnvironment :: proc() -> ^Environment --- @(require_results) CreateEnvironment :: proc(populated: bool) -> ^Environment --- @(require_results) GetEnvironmentVariable :: proc(env: ^Environment, name: cstring) -> cstring --- @(require_results) GetEnvironmentVariables :: proc(env: ^Environment) -> [^]cstring --- SetEnvironmentVariable :: proc(env: ^Environment, name, value: cstring, overwrite: bool) -> bool --- UnsetEnvironmentVariable :: proc(env: ^Environment, name: cstring) -> bool --- DestroyEnvironment :: proc(env: ^Environment) --- } @(default_calling_convention="c", link_prefix="SDL_") foreign lib { @(require_results) getenv :: proc(name: cstring) -> cstring --- @(require_results) getenv_unsafe :: proc(name: cstring) -> cstring --- setenv_unsafe :: proc(name, value: cstring, overwrite: b32) -> c.int --- unsetenv_unsafe :: proc(name: cstring) -> c.int --- } CompareCallback :: #type proc "c" (a, b: rawptr) -> c.int CompareCallback_r :: #type proc "c" (userdata: rawptr, a, b: rawptr) -> c.int @(default_calling_convention="c", link_prefix="SDL_") foreign lib { qsort :: proc(base: rawptr, nmemb: uint, size: uint, compare: CompareCallback) --- bsearch :: proc(key: rawptr, base: rawptr, nmemb: uint, size: uint, compare: CompareCallback) -> rawptr --- qsort_r :: proc(base: rawptr, nmemb: uint, size: uint, compare: CompareCallback_r, userdata: rawptr) --- bsearch_r :: proc(key: rawptr, base: rawptr, nmemb: uint, size: uint, compare: CompareCallback_r, userdata: rawptr) -> rawptr --- } abs :: builtin.abs min :: builtin.min max :: builtin.max clamp :: builtin.clamp @(default_calling_convention="c", link_prefix="SDL_", require_results) foreign lib { isalpha :: proc(x: rune) -> b32 --- isalnum :: proc(x: rune) -> b32 --- isblank :: proc(x: rune) -> b32 --- iscntrl :: proc(x: rune) -> b32 --- isdigit :: proc(x: rune) -> b32 --- isxdigit :: proc(x: rune) -> b32 --- ispunct :: proc(x: rune) -> b32 --- isspace :: proc(x: rune) -> b32 --- isupper :: proc(x: rune) -> b32 --- islower :: proc(x: rune) -> b32 --- isprint :: proc(x: rune) -> b32 --- isgraph :: proc(x: rune) -> b32 --- toupper :: proc(x: rune) -> rune --- tolower :: proc(x: rune) -> rune --- crc16 :: proc(crc: Uint16, data: rawptr, len: uint) -> Uint16 --- crc32 :: proc(crc: Uint32, data: rawptr, len: uint) -> Uint32 --- murmur3_32 :: proc(data: rawptr, len: uint, seed: Uint32) -> Uint32 --- } copyp :: #force_inline proc "contextless" (dst, src: ^$T) -> ^T { return (^T)(memcpy(dst, src, size_of(T))) } zerop :: #force_inline proc "contextless" (x: ^$T) { memset(x, 0, size_of(T)) } zeroa :: #force_inline proc "contextless" (x: []$T) { memset(raw_data(x), 0, uint(size_of(T)*len(x))) } @(default_calling_convention="c", link_prefix="SDL_") foreign lib { memcpy :: proc(dst, src: rawptr, len: uint) -> rawptr --- memmove :: proc(dst, src: rawptr, len: uint) -> rawptr --- memset :: proc(dst: rawptr, c: c.int, len: uint) -> rawptr --- @(require_results) memcmp :: proc(s1, s2: rawptr, len: c.int) -> c.int --- } @(default_calling_convention="c", link_prefix="SDL_", require_results) foreign lib { wcslen :: proc(wstr: [^]wchar_t) -> uint --- wcsnlen :: proc(wstr: [^]wchar_t, maxlen: uint) -> uint --- wcslcpy :: proc(dst, src: [^]wchar_t, maxlen: uint) -> uint --- wcslcat :: proc(dst, src: [^]wchar_t, maxlen: uint) -> uint --- wcsdup :: proc(wstr: [^]wchar_t) -> [^]wchar_t --- wcsstr :: proc(haystack, needle: [^]wchar_t) -> [^]wchar_t --- wcsnstr :: proc(haystack, needle: [^]wchar_t, maxlen: uint) -> [^]wchar_t --- wcscmp :: proc(str1, str2: [^]wchar_t) -> int --- wcsncmp :: proc(str1, str2: [^]wchar_t, maxlen: uint) -> int --- wcscasecmp :: proc(str1, str2: [^]wchar_t) -> int --- wcsncasecmp :: proc(str1, str2: [^]wchar_t, maxlen: uint) -> int --- wcstol :: proc(str: [^]wchar_t, endp: ^[^]wchar_t, base: c.int) -> c.long --- } @(default_calling_convention="c", link_prefix="SDL_", require_results) foreign lib { strlen :: proc(str: cstring) -> uint --- strnlen :: proc(str: cstring, maxlen: uint) -> uint --- strlcpy :: proc(dst: [^]u8, src: cstring, maxlen: uint) -> uint --- utf8strlcpy :: proc(dst: [^]u8, src: cstring, dst_bytes: uint) -> uint --- strlcat :: proc(dst: [^]u8, src: cstring, maxlen: uint) -> uint --- strdup :: proc(str: cstring) -> [^]u8 --- strndup :: proc(str: cstring, maxlen: uint) -> [^]u8 --- strrev :: proc(str: [^]u8) -> [^]u8 --- strupr :: proc(str: [^]u8) -> [^]u8 --- strlwr :: proc(str: [^]u8) -> [^]u8 --- strchr :: proc(str: cstring, c: rune) -> [^]u8 --- strrchr :: proc(str: cstring, c: rune) -> [^]u8 --- strstr :: proc(haystack: cstring, needle: cstring) -> [^]u8 --- strnstr :: proc(haystack: cstring, needle: cstring, maxlen: uint) -> [^]u8 --- strcasestr :: proc(haystack: cstring, needle: cstring) -> [^]u8 --- strtok_r :: proc(str: [^]u8, delim: cstring, saveptr: ^[^]u8) -> [^]u8 --- utf8strlen :: proc(str: cstring) -> uint --- utf8strnlen :: proc(str: cstring, bytes: uint) -> uint --- itoa :: proc(value: c.int, str: [^]u8, radix: c.int) -> [^]u8 --- uitoa :: proc(value: c.uint, str: [^]u8, radix: c.int) -> [^]u8 --- ltoa :: proc(value: c.long, str: [^]u8, radix: c.int) -> [^]u8 --- ultoa :: proc(value: c.ulong, str: [^]u8, radix: c.int) -> [^]u8 --- lltoa :: proc(value: c.longlong, str: [^]u8, radix: c.int) -> [^]u8 --- ulltoa :: proc(value: c.ulonglong, str: [^]u8, radix: c.int) -> [^]u8 --- atoi :: proc(str: cstring) -> c.int --- atof :: proc(str: cstring) -> f64 --- strtol :: proc(str: cstring, endp: ^[^]u8, base: c.int) -> c.long --- strtoul :: proc(str: cstring, endp: ^[^]u8, base: c.int) -> c.ulong --- strtoll :: proc(str: cstring, endp: ^[^]u8, base: c.int) -> c.longlong --- strtoull :: proc(str: cstring, endp: ^[^]u8, base: c.int) -> c.ulonglong --- strtod :: proc(str: cstring, endp: ^[^]u8) -> f64 --- strcmp :: proc(str1, str2: cstring) -> c.int --- strncmp :: proc(str1, str2: cstring, maxlen: uint) -> c.int --- strcasecmp :: proc(str1, str2: cstring) -> c.int --- strncasecmp :: proc(str1, str2: cstring, maxlen: uint) -> c.int --- strpbrk :: proc(str: cstring, breakset: cstring) -> [^]u8 --- StepUTF8 :: proc(pstr: ^cstring, pslen: ^uint) -> Uint32 --- StepBackUTF8 :: proc(start: cstring, pstr: ^cstring) -> Uint32 --- UCS4ToUTF8 :: proc(codepoint: rune, dst: [^]u8) -> [^]u8 --- } @(default_calling_convention="c", link_prefix="SDL_") foreign lib { sscanf :: proc(text: cstring, fmt: cstring, #c_vararg args: ..any) -> c.int --- vsscanf :: proc(text: cstring, fmt: cstring, ap: c.va_list) -> c.int --- snprintf :: proc(text: [^]u8, maxlen: uint, fmt: cstring, #c_vararg args: ..any) -> c.int --- swprintf :: proc(text: [^]wchar_t, maxlen: uint, fmt: cstring, #c_vararg args: ..any) -> c.int --- vsnprintf :: proc(text: [^]u8, maxlen: uint, fmt: cstring, ap: c.va_list) -> c.int --- vswprintf :: proc(text: [^]wchar_t, maxlen: uint, fmt: cstring, ap: c.va_list) -> c.int --- asprintf :: proc(strp: ^[^]u8, fmt: cstring, #c_vararg args: ..any) -> c.int --- vasprintf :: proc(strp: ^[^]u8, fmt: cstring, ap: c.va_list) -> c.int --- } @(default_calling_convention="c", link_prefix="SDL_", require_results) foreign lib { srand :: proc(seed: Uint64) --- rand :: proc(n: Sint32) -> Sint32 --- randf :: proc() -> f32 --- rand_bits :: proc() -> Uint32 --- rand_r :: proc(state: ^Uint64, n: Sint32) -> Sint32 --- randf_r :: proc(state: ^Uint64) -> f32 --- rand_bits_r :: proc(state: ^Uint64) -> Uint32 --- } @(default_calling_convention="c", link_prefix="SDL_", require_results) foreign lib { acos :: proc(x: f64) -> f64 --- acosf :: proc(x: f32) -> f32 --- asin :: proc(x: f64) -> f64 --- asinf :: proc(x: f32) -> f32 --- atan :: proc(x: f64) -> f64 --- atanf :: proc(x: f32) -> f32 --- atan2 :: proc(y: f64, x: f64) -> f64 --- atan2f :: proc(y: f32, x: f32) -> f32 --- ceil :: proc(x: f64) -> f64 --- ceilf :: proc(x: f32) -> f32 --- copysign :: proc(x: f64, y: f64) -> f64 --- copysignf :: proc(x: f32, y: f32) -> f32 --- cos :: proc(x: f64) -> f64 --- cosf :: proc(x: f32) -> f32 --- exp :: proc(x: f64) -> f64 --- expf :: proc(x: f32) -> f32 --- fabs :: proc(x: f64) -> f64 --- fabsf :: proc(x: f32) -> f32 --- floor :: proc(x: f64) -> f64 --- floorf :: proc(x: f32) -> f32 --- trunc :: proc(x: f64) -> f64 --- truncf :: proc(x: f32) -> f32 --- fmod :: proc(x: f64, y: f64) -> f64 --- fmodf :: proc(x: f32, y: f32) -> f32 --- isinf :: proc(x: f64) -> c.int --- isinff :: proc(x: f32) -> c.int --- isnan :: proc(x: f64) -> c.int --- isnanf :: proc(x: f32) -> c.int --- log :: proc(x: f64) -> f64 --- logf :: proc(x: f32) -> f32 --- log10 :: proc(x: f64) -> f64 --- log10f :: proc(x: f32) -> f32 --- modf :: proc(x: f64, y: ^f64) -> f64 --- modff :: proc(x: f32, y: ^f32) -> f32 --- pow :: proc(x: f64, y: f64) -> f64 --- powf :: proc(x: f32, y: f32) -> f32 --- round :: proc(x: f64) -> f64 --- roundf :: proc(x: f32) -> f32 --- lround :: proc(x: f64) -> c.long --- lroundf :: proc(x: f32) -> c.long --- scalbn :: proc(x: f64, n: c.int) -> f64 --- scalbnf :: proc(x: f32, n: c.int) -> f32 --- sin :: proc(x: f64) -> f64 --- sinf :: proc(x: f32) -> f32 --- sqrt :: proc(x: f64) -> f64 --- sqrtf :: proc(x: f32) -> f32 --- tan :: proc(x: f64) -> f64 --- tanf :: proc(x: f32) -> f32 --- } iconv_data_t :: struct{} iconv_t :: ^iconv_data_t @(default_calling_convention="c", link_prefix="SDL_") foreign lib { iconv_open :: proc(tocode: cstring) -> iconv_t --- iconv_close :: proc(cd: iconv_t) -> c.int --- iconv :: proc(cd: iconv_t, inbuf: ^cstring, inbytesleft: ^uint, outbuf: ^[^]u8, outbytesleft: ^uint) -> uint --- iconv_string :: proc(tocode: cstring, fromcode: cstring, inbuf: cstring, inbytesleft: uint) -> [^]byte --- } ICONV_ERROR :: transmute(uint)int(-1) /**< Generic error. Check SDL_GetError()? */ ICONV_E2BIG :: transmute(uint)int(-2) /**< Output buffer was too small. */ ICONV_EILSEQ :: transmute(uint)int(-3) /**< Invalid input sequence was encountered. */ ICONV_EINVAL :: transmute(uint)int(-4) /**< Incomplete input sequence was encountered. */ @(require_results) iconv_utf8_locale :: #force_inline proc "c" (S: cstring) -> [^]byte { return iconv_string("", "UTF-8", S, strlen(S)+1) } @(require_results) iconv_utf8_ucs2 :: #force_inline proc "c" (S: cstring) -> [^]Uint16 { return cast([^]Uint16)iconv_string("UCS-2", "UTF-8", S, strlen(S)+1) } @(require_results) iconv_utf8_ucs4 :: #force_inline proc "c" (S: cstring) -> [^]rune { return cast([^]rune)iconv_string("UCS-4", "UTF-8", S, strlen(S)+1) } @(require_results) iconv_wchar_utf8 :: #force_inline proc "c" (S: [^]wchar_t) -> [^]byte { return iconv_string("UTF-8", "WCHAR_T", cstring(([^]u8)(S)), (wcslen(S)+1)*size_of(wchar_t)) } @(require_results) size_mul_check_overflow_ptr :: #force_inline proc "c" (a, b: uint, ret: ^uint) -> bool { if a != 0 && b > SIZE_MAX / a { return false } ret^ = a * b return true } @(require_results) size_mul_check_overflow :: #force_inline proc "c" (a, b: uint, ret: ^uint) -> (uint, bool) { return a * b, !(a != 0 && b > SIZE_MAX / a) } @(require_results) size_add_check_overflow_ptr :: #force_inline proc "c" (a, b: uint, ret: ^uint) -> bool { if b > SIZE_MAX - a { return false } ret^ = a + b return true } @(require_results) size_add_check_overflow :: #force_inline proc "c" (a, b: uint) -> (uint, bool) { return a + b, !(b > SIZE_MAX - a) } FunctionPointer :: #type proc "c" ()