package vendor:sdl3

Source

AppEvent_func :: proc "c" (appstate: rawptr, event: ^Event) -> AppResult

AppInit_func :: proc "c" (appstate: ^rawptr, argc: i32, argv: [^]cstring) -> AppResult

AppIterate_func :: proc "c" (appstate: rawptr) -> AppResult

AppQuit_func :: proc "c" (appstate: rawptr, result: AppResult)

AppResult :: enum i32 {
	CONTINUE, // *< Value that requests that the app continue from the main callbacks.
	SUCCESS,  // *< Value that requests termination with success from the main callbacks.
	FAILURE,  // *< Value that requests termination with error from the main callbacks.
}

ArrayOrder :: enum i32 {
	NONE, 
	RGB, 
	RGBA, 
	ARGB, 
	BGR, 
	BGRA, 
	ABGR, 
}

AssertData :: struct {
	always_ignore: bool,
	// *< true if app should always continue when assertion is triggered. 
	trigger_count: u32,
	// *< Number of times this assertion has been triggered. 
	condition:     cstring,
	// *< A string of this assert's test code. 
	filename:      cstring,
	// *< The source file where this assert lives. 
	linenum:       i32,
	// *< The line in `filename` where this assert lives. 
	function:      cstring,
	// *< The name of the function where this assert lives. 
	next:          ^AssertData,
}

AssertState :: enum i32 {
	RETRY,         // *< Retry the assert immediately.
	BREAK,         // *< Make the debugger trigger a breakpoint.
	ABORT,         // *< Terminate the program.
	IGNORE,        // *< Ignore the assert.
	ALWAYS_IGNORE, // *< Ignore the assert from now on.
}

AssertionHandler :: proc "c" (data: ^AssertData, userdata: rawptr) -> AssertState

AsyncIO :: struct {}

AsyncIOOutcome :: struct {
	asyncio:           ^AsyncIO,
	// *< what generated this task. This pointer will be invalid if it was closed! 
	type:              AsyncIOTaskType,
	// *< What sort of task was this? Read, write, etc? 
	result:            AsyncIOResult,
	// *< the result of the work (success, failure, cancellation). 
	buffer:            rawptr,
	// *< buffer where data was read/written. 
	offset:            u64,
	// *< offset in the SDL_AsyncIO where data was read/written. 
	bytes_requested:   u64,
	// *< number of bytes the task was to read/write. 
	bytes_transferred: u64,
	// *< actual number of bytes that were read/written. 
	userdata:          rawptr,
}

AsyncIOQueue :: struct {}

AsyncIOResult :: enum i32 {
	COMPLETE, // *< request was completed without error
	FAILURE,  // *< request failed for some reason; check SDL_GetError()!
	CANCELED, // *< request was canceled before completing.
}

AsyncIOTaskType :: enum i32 {
	READ,  // *< A read operation.
	WRITE, // *< A write operation.
	CLOSE, // *< A close operation.
}

AtomicInt :: distinct i32

AtomicU32 :: distinct u32

AudioDeviceEvent :: struct {
	using commonEvent: CommonEvent,
	// *< SDL_EVENT_AUDIO_DEVICE_ADDED, or SDL_EVENT_AUDIO_DEVICE_REMOVED, or SDL_EVENT_AUDIO_DEVICE_FORMAT_CHANGED 
	which:       AudioDeviceID,
	// *< SDL_AudioDeviceID for the device being added or removed or changing 
	recording:   bool,
	// *< false if a playback device, true if a recording device. 
	_:           u8,
	_:           u8,
	_:           u8,
}

AudioDeviceID :: distinct u32

AudioFormat :: enum i32 {
	UNKNOWN = 0,     // *< Unspecified audio format
	U8      = 8,     // *< Unsigned 8-bit samples
	// DEFINE_AUDIO_FORMAT(0, 0, 0, 8), 
	S8      = 32776, // *< Signed 8-bit samples
	// DEFINE_AUDIO_FORMAT(1, 0, 0, 8), 
	S16LE   = 32784, // *< Signed 16-bit samples
	// DEFINE_AUDIO_FORMAT(1, 0, 0, 16), 
	S16BE   = 36880, // *< As above, but big-endian byte order
	// DEFINE_AUDIO_FORMAT(1, 1, 0, 16), 
	S32LE   = 32800, // *< 32-bit integer samples
	// DEFINE_AUDIO_FORMAT(1, 0, 0, 32), 
	S32BE   = 36896, // *< As above, but big-endian byte order
	// DEFINE_AUDIO_FORMAT(1, 1, 0, 32), 
	F32LE   = 33056, // *< 32-bit floating point samples
	// DEFINE_AUDIO_FORMAT(1, 0, 1, 32), 
	F32BE   = 37152, // *< As above, but big-endian byte order
	// These represent the current system's byteorder. 
	S16     = 32784, 
	S32     = 32800, 
	F32     = 33056, 
}

AudioPostmixCallback :: proc "c" (userdata: rawptr, spec: ^AudioSpec, buffer: [^]f32, buflen: i32)

AudioSpec :: struct {
	format:   AudioFormat,
	// *< Audio data format 
	channels: i32,
	// *< Number of channels: 1 mono, 2 stereo, etc 
	freq:     i32,
}

AudioStream :: struct {}

AudioStreamCallback :: proc "c" (userdata: rawptr, stream: ^AudioStream, additional_amount, total_amount: i32)

BitmapOrder :: enum i32 {
	NONE, 
	ORDER_4321, 
	ORDER_1234, 
}

BlendFactor :: enum i32 {
	ZERO                = 1,  // *< 0, 0, 0, 0
	ONE                 = 2,  // *< 1, 1, 1, 1
	SRC_COLOR           = 3,  // *< srcR, srcG, srcB, srcA
	ONE_MINUS_SRC_COLOR = 4,  // *< 1-srcR, 1-srcG, 1-srcB, 1-srcA
	SRC_ALPHA           = 5,  // *< srcA, srcA, srcA, srcA
	ONE_MINUS_SRC_ALPHA = 6,  // *< 1-srcA, 1-srcA, 1-srcA, 1-srcA
	DST_COLOR           = 7,  // *< dstR, dstG, dstB, dstA
	ONE_MINUS_DST_COLOR = 8,  // *< 1-dstR, 1-dstG, 1-dstB, 1-dstA
	DST_ALPHA           = 9,  // *< dstA, dstA, dstA, dstA
	ONE_MINUS_DST_ALPHA = 10, // *< 1-dstA, 1-dstA, 1-dstA, 1-dstA
}

BlendMode :: distinct bit_set[BlendModeFlag; u32]

BlendModeFlag :: enum u32 {
	BLEND               = 0, // log2(0x00000001)
	BLEND_PREMULTIPLIED = 4, // log2(0x00000010)
	ADD                 = 1, // log2(0x00000002)
	ADD_PREMULTIPLIED   = 5, // log2(0x00000020)
	MOD                 = 2, // log2(0x00000004)
	MUL                 = 3, // log2(0x00000008)
}

BlendOperation :: enum i32 {
	ADD          = 1, // *< dst + src: supported by all renderers
	SUBTRACT     = 2, // *< src - dst : supported by D3D, OpenGL, OpenGLES, and Vulkan
	REV_SUBTRACT = 3, // *< dst - src : supported by D3D, OpenGL, OpenGLES, and Vulkan
	MINIMUM      = 4, // *< min(dst, src) : supported by D3D, OpenGL, OpenGLES, and Vulkan
	MAXIMUM      = 5, // *< max(dst, src) : supported by D3D, OpenGL, OpenGLES, and Vulkan
}

Camera :: struct {}

CameraDeviceEvent :: struct {
	using commonEvent: CommonEvent,
	// *< SDL_EVENT_CAMERA_DEVICE_ADDED, SDL_EVENT_CAMERA_DEVICE_REMOVED, SDL_EVENT_CAMERA_DEVICE_APPROVED, SDL_EVENT_CAMERA_DEVICE_DENIED 
	which:       CameraID,
}

CameraID :: distinct u32

CameraPosition :: enum i32 {
	UNKNOWN, 
	FRONT_FACING, 
	BACK_FACING, 
}

CameraSpec :: struct {
	format:                PixelFormat,
	// *< Frame format 
	colorspace:            Colorspace,
	// *< Frame colorspace 
	width:                 i32,
	// *< Frame width 
	height:                i32,
	// *< Frame height 
	framerate_numerator:   i32,
	// *< Frame rate numerator ((num / denom) == FPS, (denom / num) == duration in seconds) 
	framerate_denominator: i32,
}

Capitalization :: enum i32 {
	NONE,      // *< No auto-capitalization will be done
	SENTENCES, // *< The first letter of sentences will be capitalized
	WORDS,     // *< The first letter of words will be capitalized
	LETTERS,   // *< All letters will be capitalized
}

ChromaLocation :: enum i32 {
	NONE    = 0, // *< RGB, no chroma sampling
	LEFT    = 1, // *< In MPEG-2, MPEG-4, and AVC, Cb and Cr are taken on midpoint of the left-edge of the 2x2 square. In other words, they have the same horizontal location as the top-left pixel, but is shifted one-half pixel down vertically.
	CENTER  = 2, // *< In JPEG/JFIF, H.261, and MPEG-1, Cb and Cr are taken at the center of the 2x2 square. In other words, they are offset one-half pixel to the right and one-half pixel down compared to the top-left pixel.
	TOPLEFT = 3, // *< In HEVC for BT.2020 and BT.2100 content (in particular on Blu-rays), Cb and Cr are sampled at the same location as the group's top-left Y pixel ("co-sited", "co-located").
}

CleanupPropertyCallback :: proc "c" (userdata: rawptr, value: rawptr)

ClipboardCleanupCallback :: proc "c" (userdata: rawptr)

ClipboardDataCallback :: proc "c" (userdata: rawptr, mime_type: cstring, size: ^uint) -> rawptr

ClipboardEvent :: struct {
	using commonEvent: CommonEvent,
	// *< SDL_EVENT_CLIPBOARD_UPDATE 
	owner:          bool,
	// *< are we owning the clipboard (internal update) 
	num_mime_types: i32,
	// *< number of mime types 
	mime_types:     [^]cstring `fmt:"v,num_mime_types"`,
}

Color :: distinct [4]u8

ColorPrimaries :: enum i32 {
	UNKNOWN      = 0, 
	BT709        = 1,  // *< ITU-R BT.709-6
	UNSPECIFIED  = 2, 
	BT470M       = 4,  // *< ITU-R BT.470-6 System M
	BT470BG      = 5,  // *< ITU-R BT.470-6 System B, G / ITU-R BT.601-7 625
	BT601        = 6,  // *< ITU-R BT.601-7 525, SMPTE 170M
	SMPTE240     = 7,  // *< SMPTE 240M, functionally the same as SDL_COLOR_PRIMARIES_BT601
	GENERIC_FILM = 8,  // *< Generic film (color filters using Illuminant C)
	BT2020       = 9,  // *< ITU-R BT.2020-2 / ITU-R BT.2100-0
	XYZ          = 10, // *< SMPTE ST 428-1
	SMPTE431     = 11, // *< SMPTE RP 431-2
	SMPTE432     = 12, // *< SMPTE EG 432-1 / DCI P3
	EBU3213      = 22, // *< EBU Tech. 3213-E
	CUSTOM       = 31, 
}

ColorRange :: enum i32 {
	UNKNOWN = 0, 
	LIMITED = 1, // *< Narrow range, e.g. 16-235 for 8-bit RGB and luma, and 16-240 for 8-bit chroma
	FULL    = 2, // *< Full range, e.g. 0-255 for 8-bit RGB and luma, and 1-255 for 8-bit chroma
}

ColorType :: enum i32 {
	UNKNOWN = 0, 
	RGB     = 1, 
	YCBCR   = 2, 
}

Colorspace :: enum i32 {
	UNKNOWN        = 0, 
	// sRGB is a gamma corrected colorspace, and the default colorspace for SDL rendering and 8-bit RGB surfaces 
	SRGB           = 301991328, // *< Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709
	// This is a linear colorspace and the default colorspace for floating point surfaces. On Windows this is the scRGB colorspace, and on Apple platforms this is kCGColorSpaceExtendedLinearSRGB for EDR content 
	SRGB_LINEAR    = 301991168, // *< Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709
	// HDR10 is a non-linear HDR colorspace and the default colorspace for 10-bit surfaces 
	HDR10          = 301999616, // *< Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020
	JPEG           = 570426566, // *< Equivalent to DXGI_COLOR_SPACE_YCBCR_FULL_G22_NONE_P709_X601
	BT601_LIMITED  = 554703046, // *< Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601
	BT601_FULL     = 571480262, // *< Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601
	BT709_LIMITED  = 554697761, // *< Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709
	BT709_FULL     = 571474977, // *< Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709
	BT2020_LIMITED = 554706441, // *< Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P2020
	BT2020_FULL    = 571483657, // *< Equivalent to DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P2020
	RGB_DEFAULT    = 301991328, // *< The default colorspace for RGB surfaces if no colorspace is specified
	YUV_DEFAULT    = 570426566, // *< The default colorspace for YUV surfaces if no colorspace is specified
}

CommonEvent :: struct {
	type:      EventType,
	// *< Event type, shared with all events, Uint32 to cover user events which are not in the SDL_EventType enumeration 
	_:         u32,
	timestamp: u64,
}

CompareCallback :: proc "c" (a, b: rawptr) -> i32

CompareCallback_r :: proc "c" (userdata: rawptr, a, b: rawptr) -> i32

Cursor :: struct {}

DateFormat :: enum i32 {
	YYYYMMDD = 0, // *< Year/Month/Day
	DDMMYYYY = 1, // *< Day/Month/Year
	MMDDYYYY = 2, // *< Month/Day/Year
}

DateTime :: struct {
	year:        i32,
	// *< Year 
	month:       i32,
	// *< Month [01-12] 
	day:         i32,
	// *< Day of the month [01-31] 
	hour:        i32,
	// *< Hour [0-23] 
	minute:      i32,
	// *< Minute [0-59] 
	second:      i32,
	// *< Seconds [0-60] 
	nanosecond:  i32,
	// *< Nanoseconds [0-999999999] 
	day_of_week: i32,
	// *< Day of the week [0-6] (0 being Sunday) 
	utc_offset:  i32,
}

DialogFileCallback :: proc "c" (userdata: rawptr, filelist: [^]cstring, filter: i32)

DialogFileFilter :: struct {
	name:    cstring,
	pattern: cstring,
}

DisplayEvent :: struct {
	using commonEvent: CommonEvent,
	// *< SDL_DISPLAYEVENT_* 
	displayID:   DisplayID,
	// *< The associated display 
	data1:       i32,
	// *< event dependent data 
	data2:       i32,
}

DisplayID :: distinct u32

DisplayMode :: struct {
	displayID:                DisplayID,
	// *< the display this mode is associated with 
	format:                   PixelFormat,
	// *< pixel format 
	w:                        i32,
	// *< width 
	h:                        i32,
	// *< height 
	pixel_density:            f32,
	// *< scale converting size to pixels (e.g. a 1920x1080 mode with 2.0 scale would have 3840x2160 pixels) 
	refresh_rate:             f32,
	// *< refresh rate (or 0.0f for unspecified) 
	refresh_rate_numerator:   i32,
	// *< precise refresh rate numerator (or 0 for unspecified) 
	refresh_rate_denominator: i32,
	// *< precise refresh rate denominator 
	internal:                 ^DisplayModeData,
}

DisplayModeData :: struct {}

DisplayOrientation :: enum i32 {
	UNKNOWN,           // *< The display orientation can't be determined
	LANDSCAPE,         // *< The display is in landscape mode, with the right side up, relative to portrait mode
	LANDSCAPE_FLIPPED, // *< The display is in landscape mode, with the left side up, relative to portrait mode
	PORTRAIT,          // *< The display is in portrait mode
	PORTRAIT_FLIPPED,  // *< The display is in portrait mode, upside down
}

DropEvent :: struct {
	using commonEvent: CommonEvent,
	// *< SDL_EVENT_DROP_BEGIN or SDL_EVENT_DROP_FILE or SDL_EVENT_DROP_TEXT or SDL_EVENT_DROP_COMPLETE or SDL_EVENT_DROP_POSITION 
	windowID:    WindowID,
	// *< The window that was dropped on, if any 
	x:           f32,
	// *< X coordinate, relative to window (not on begin) 
	y:           f32,
	// *< Y coordinate, relative to window (not on begin) 
	source:      cstring,
	// *< The source app that sent this drop event, or NULL if that isn't available 
	data:        cstring,
}

EGLAttrib :: distinct uintptr

EGLAttribArrayCallback :: proc "c" (userdata: rawptr) -> ^EGLint

EGLConfig :: distinct rawptr

EGLDisplay :: distinct rawptr

EGLIntArrayCallback :: proc "c" (userdata: rawptr, display: EGLDisplay, config: EGLConfig) -> [^]EGLint

EGLSurface :: distinct rawptr

EGLint :: distinct i32

EnumerateDirectoryCallback :: proc "c" (userdata: rawptr, dirname, fname: cstring) -> EnumerationResult

EnumeratePropertiesCallback :: proc "c" (userdata: rawptr, props: PropertiesID, name: cstring)

EnumerationResult :: enum i32 {
	CONTINUE, // *< Value that requests that enumeration continue.
	SUCCESS,  // *< Value that requests that enumeration stop, successfully.
	FAILURE,  // *< Value that requests that enumeration stop, as a failure.
}

Environment :: struct {}

Event :: struct #raw_union {
	type:            EventType,
	// *< Event type, shared with all events, Uint32 to cover user events which are not in the SDL_EventType enumeration 
	common:          CommonEvent,
	// *< Common event data 
	display:         DisplayEvent,
	// *< Display event data 
	window:          WindowEvent,
	// *< Window event data 
	kdevice:         KeyboardDeviceEvent,
	// *< Keyboard device change event data 
	key:             KeyboardEvent,
	// *< Keyboard event data 
	edit:            TextEditingEvent,
	// *< Text editing event data 
	edit_candidates: TextEditingCandidatesEvent,
	// *< Text editing candidates event data 
	text:            TextInputEvent,
	// *< Text input event data 
	mdevice:         MouseDeviceEvent,
	// *< Mouse device change event data 
	motion:          MouseMotionEvent,
	// *< Mouse motion event data 
	button:          MouseButtonEvent,
	// *< Mouse button event data 
	wheel:           MouseWheelEvent,
	// *< Mouse wheel event data 
	jdevice:         JoyDeviceEvent,
	// *< Joystick device change event data 
	jaxis:           JoyAxisEvent,
	// *< Joystick axis event data 
	jball:           JoyBallEvent,
	// *< Joystick ball event data 
	jhat:            JoyHatEvent,
	// *< Joystick hat event data 
	jbutton:         JoyButtonEvent,
	// *< Joystick button event data 
	jbattery:        JoyBatteryEvent,
	// *< Joystick battery event data 
	gdevice:         GamepadDeviceEvent,
	// *< Gamepad device event data 
	gaxis:           GamepadAxisEvent,
	// *< Gamepad axis event data 
	gbutton:         GamepadButtonEvent,
	// *< Gamepad button event data 
	gtouchpad:       GamepadTouchpadEvent,
	// *< Gamepad touchpad event data 
	gsensor:         GamepadSensorEvent,
	// *< Gamepad sensor event data 
	adevice:         AudioDeviceEvent,
	// *< Audio device event data 
	cdevice:         CameraDeviceEvent,
	// *< Camera device event data 
	sensor:          SensorEvent,
	// *< Sensor event data 
	quit:            QuitEvent,
	// *< Quit request event data 
	user:            UserEvent,
	// *< Custom event data 
	tfinger:         TouchFingerEvent,
	// *< Touch finger event data 
	pproximity:      PenProximityEvent,
	// *< Pen proximity event data 
	ptouch:          PenTouchEvent,
	// *< Pen tip touching event data 
	pmotion:         PenMotionEvent,
	// *< Pen motion event data 
	pbutton:         PenButtonEvent,
	// *< Pen button event data 
	paxis:           PenAxisEvent,
	// *< Pen axis event data 
	render:          RenderEvent,
	// *< Render event data 
	drop:            DropEvent,
	// *< Drag and drop event data 
	clipboard:       ClipboardEvent,
	// This is necessary for ABI compatibility between Visual C++ and GCC.
	// 	   Visual C++ will respect the push pack pragma and use 52 bytes (size of
	// 	   SDL_TextEditingEvent, the largest structure for 32-bit and 64-bit
	// 	   architectures) for this union, and GCC will use the alignment of the
	// 	   largest datatype within the union, which is 8 bytes on 64-bit
	// 	   architectures.
	// 
	// 	   So... we'll add _to force the size to be the same for both.
	// 
	// 	   On architectures where pointers are 16 bytes, this needs rounding up to
	// 	   the next multiple of 16, 64, and on architectures where pointers are
	// 	   even larger the size of SDL_UserEvent will dominate as being 3 pointers.
	padding:         [128]u8,
}

EventAction :: enum i32 {
	ADDEVENT,  // *< Add events to the back of the queue.
	PEEKEVENT, // *< Check but don't remove events from the queue front.
	GETEVENT,  // *< Retrieve/remove events from the front of the queue.
}

EventFilter :: proc "c" (userdata: rawptr, event: ^Event) -> bool

EventType :: enum u32 {
	FIRST                         = 0,     // *< Unused (do not remove)
	// Application events 
	QUIT                          = 256,   // *< User-requested quit
	// These application events have special meaning on iOS and Android, see README-ios.md and README-android.md for details 
	TERMINATING,                           // *< The application is being terminated by the OS. This event must be handled in a callback set with SDL_AddEventWatch().
	                             Called on iOS in applicationWillTerminate()
	                             Called on Android in onDestroy()
	LOW_MEMORY,                            // *< The application is low on memory, free memory if possible. This event must be handled in a callback set with SDL_AddEventWatch().
	                             Called on iOS in applicationDidReceiveMemoryWarning()
	                             Called on Android in onTrimMemory()
	WILL_ENTER_BACKGROUND,                 // *< The application is about to enter the background. This event must be handled in a callback set with SDL_AddEventWatch().
	                             Called on iOS in applicationWillResignActive()
	                             Called on Android in onPause()
	DID_ENTER_BACKGROUND,                  // *< The application did enter the background and may not get CPU for some time. This event must be handled in a callback set with SDL_AddEventWatch().
	                             Called on iOS in applicationDidEnterBackground()
	                             Called on Android in onPause()
	WILL_ENTER_FOREGROUND,                 // *< The application is about to enter the foreground. This event must be handled in a callback set with SDL_AddEventWatch().
	                             Called on iOS in applicationWillEnterForeground()
	                             Called on Android in onResume()
	DID_ENTER_FOREGROUND,                  // *< The application is now interactive. This event must be handled in a callback set with SDL_AddEventWatch().
	                             Called on iOS in applicationDidBecomeActive()
	                             Called on Android in onResume()
	LOCALE_CHANGED,                        // *< The user's locale preferences have changed.
	SYSTEM_THEME_CHANGED,                  // *< The system theme changed
	// Display events 
	// 0x150 was SDL_DISPLAYEVENT, reserve the number for sdl2-compat 
	DISPLAY_ORIENTATION           = 337,   // *< Display orientation has changed to data1
	DISPLAY_ADDED,                         // *< Display has been added to the system
	DISPLAY_REMOVED,                       // *< Display has been removed from the system
	DISPLAY_MOVED,                         // *< Display has changed position
	DISPLAY_DESKTOP_MODE_CHANGED,          // *< Display has changed desktop mode
	DISPLAY_CURRENT_MODE_CHANGED,          // *< Display has changed current mode
	DISPLAY_CONTENT_SCALE_CHANGED,         // *< Display has changed content scale
	DISPLAY_FIRST                 = 337, 
	DISPLAY_LAST                  = 343, 
	// Window events 
	// 0x200 was SDL_WINDOWEVENT, reserve the number for sdl2-compat 
	// 0x201 was SYSWM, reserve the number for sdl2-compat 
	WINDOW_SHOWN                  = 514,   // *< Window has been shown
	WINDOW_HIDDEN,                         // *< Window has been hidden
	WINDOW_EXPOSED,                        // *< Window has been exposed and should be redrawn, and can be redrawn directly from event watchers for this event
	WINDOW_MOVED,                          // *< Window has been moved to data1, data2
	WINDOW_RESIZED,                        // *< Window has been resized to data1xdata2
	WINDOW_PIXEL_SIZE_CHANGED,             // *< The pixel size of the window has changed to data1xdata2
	WINDOW_METAL_VIEW_RESIZED,             // *< The pixel size of a Metal view associated with the window has changed
	WINDOW_MINIMIZED,                      // *< Window has been minimized
	WINDOW_MAXIMIZED,                      // *< Window has been maximized
	WINDOW_RESTORED,                       // *< Window has been restored to normal size and position
	WINDOW_MOUSE_ENTER,                    // *< Window has gained mouse focus
	WINDOW_MOUSE_LEAVE,                    // *< Window has lost mouse focus
	WINDOW_FOCUS_GAINED,                   // *< Window has gained keyboard focus
	WINDOW_FOCUS_LOST,                     // *< Window has lost keyboard focus
	WINDOW_CLOSE_REQUESTED,                // *< The window manager requests that the window be closed
	WINDOW_HIT_TEST,                       // *< Window had a hit test that wasn't SDL_HITTEST_NORMAL
	WINDOW_ICCPROF_CHANGED,                // *< The ICC profile of the window's display has changed
	WINDOW_DISPLAY_CHANGED,                // *< Window has been moved to display data1
	WINDOW_DISPLAY_SCALE_CHANGED,          // *< Window display scale has been changed
	WINDOW_SAFE_AREA_CHANGED,              // *< The window safe area has been changed
	WINDOW_OCCLUDED,                       // *< The window has been occluded
	WINDOW_ENTER_FULLSCREEN,               // *< The window has entered fullscreen mode
	WINDOW_LEAVE_FULLSCREEN,               // *< The window has left fullscreen mode
	WINDOW_DESTROYED,                      // *< The window with the associated ID is being or has been destroyed. If this message is being handled
	                                     in an event watcher, the window handle is still valid and can still be used to retrieve any properties
	                                     associated with the window. Otherwise, the handle has already been destroyed and all resources
	                                     associated with it are invalid
	WINDOW_HDR_STATE_CHANGED,              // *< Window HDR properties have changed
	WINDOW_FIRST                  = 514, 
	WINDOW_LAST                   = 538, 
	// Keyboard events 
	KEY_DOWN                      = 768,   // *< Key pressed
	KEY_UP,                                // *< Key released
	TEXT_EDITING,                          // *< Keyboard text editing (composition)
	TEXT_INPUT,                            // *< Keyboard text input
	KEYMAP_CHANGED,                        // *< Keymap changed due to a system event such as an
	                                    input language or keyboard layout change.
	KEYBOARD_ADDED,                        // *< A new keyboard has been inserted into the system
	KEYBOARD_REMOVED,                      // *< A keyboard has been removed
	TEXT_EDITING_CANDIDATES,               // *< Keyboard text editing candidates
	// Mouse events 
	MOUSE_MOTION                  = 1024,  // *< Mouse moved
	MOUSE_BUTTON_DOWN,                     // *< Mouse button pressed
	MOUSE_BUTTON_UP,                       // *< Mouse button released
	MOUSE_WHEEL,                           // *< Mouse wheel motion
	MOUSE_ADDED,                           // *< A new mouse has been inserted into the system
	MOUSE_REMOVED,                         // *< A mouse has been removed
	// Joystick events 
	JOYSTICK_AXIS_MOTION          = 1536,  // *< Joystick axis motion
	JOYSTICK_BALL_MOTION,                  // *< Joystick trackball motion
	JOYSTICK_HAT_MOTION,                   // *< Joystick hat position change
	JOYSTICK_BUTTON_DOWN,                  // *< Joystick button pressed
	JOYSTICK_BUTTON_UP,                    // *< Joystick button released
	JOYSTICK_ADDED,                        // *< A new joystick has been inserted into the system
	JOYSTICK_REMOVED,                      // *< An opened joystick has been removed
	JOYSTICK_BATTERY_UPDATED,              // *< Joystick battery level change
	JOYSTICK_UPDATE_COMPLETE,              // *< Joystick update is complete
	// Gamepad events 
	GAMEPAD_AXIS_MOTION           = 1616,  // *< Gamepad axis motion
	GAMEPAD_BUTTON_DOWN,                   // *< Gamepad button pressed
	GAMEPAD_BUTTON_UP,                     // *< Gamepad button released
	GAMEPAD_ADDED,                         // *< A new gamepad has been inserted into the system
	GAMEPAD_REMOVED,                       // *< A gamepad has been removed
	GAMEPAD_REMAPPED,                      // *< The gamepad mapping was updated
	GAMEPAD_TOUCHPAD_DOWN,                 // *< Gamepad touchpad was touched
	GAMEPAD_TOUCHPAD_MOTION,               // *< Gamepad touchpad finger was moved
	GAMEPAD_TOUCHPAD_UP,                   // *< Gamepad touchpad finger was lifted
	GAMEPAD_SENSOR_UPDATE,                 // *< Gamepad sensor was updated
	GAMEPAD_UPDATE_COMPLETE,               // *< Gamepad update is complete
	GAMEPAD_STEAM_HANDLE_UPDATED,          // *< Gamepad Steam handle has changed
	// Touch events 
	FINGER_DOWN                   = 1792, 
	FINGER_UP, 
	FINGER_MOTION, 
	FINGER_CANCELED, 
	// Clipboard events 
	CLIPBOARD_UPDATE              = 2304,  // *< The clipboard or primary selection changed
	// Drag and drop events 
	DROP_FILE                     = 4096,  // *< The system requests a file open
	DROP_TEXT,                             // *< text/plain drag-and-drop event
	DROP_BEGIN,                            // *< A new set of drops is beginning (NULL filename)
	DROP_COMPLETE,                         // *< Current set of drops is now complete (NULL filename)
	DROP_POSITION,                         // *< Position while moving over the window
	// Audio hotplug events 
	AUDIO_DEVICE_ADDED            = 4352,  // *< A new audio device is available
	AUDIO_DEVICE_REMOVED,                  // *< An audio device has been removed.
	AUDIO_DEVICE_FORMAT_CHANGED,           // *< An audio device's format has been changed by the system.
	// Sensor events 
	SENSOR_UPDATE                 = 4608,  // *< A sensor was updated
	// Pressure-sensitive pen events 
	PEN_PROXIMITY_IN              = 4864,  // *< Pressure-sensitive pen has become available
	PEN_PROXIMITY_OUT,                     // *< Pressure-sensitive pen has become unavailable
	PEN_DOWN,                              // *< Pressure-sensitive pen touched drawing surface
	PEN_UP,                                // *< Pressure-sensitive pen stopped touching drawing surface
	PEN_BUTTON_DOWN,                       // *< Pressure-sensitive pen button pressed
	PEN_BUTTON_UP,                         // *< Pressure-sensitive pen button released
	PEN_MOTION,                            // *< Pressure-sensitive pen is moving on the tablet
	PEN_AXIS,                              // *< Pressure-sensitive pen angle/pressure/etc changed
	// Camera hotplug events 
	CAMERA_DEVICE_ADDED           = 5120,  // *< A new camera device is available
	CAMERA_DEVICE_REMOVED,                 // *< A camera device has been removed.
	CAMERA_DEVICE_APPROVED,                // *< A camera device has been approved for use by the user.
	CAMERA_DEVICE_DENIED,                  // *< A camera device has been denied for use by the user.
	// Render events 
	RENDER_TARGETS_RESET          = 8192,  // *< The render targets have been reset and their contents need to be updated
	RENDER_DEVICE_RESET,                   // *< The device has been reset and all textures need to be recreated
	RENDER_DEVICE_LOST,                    // *< The device has been lost and can't be recovered.
	// Reserved events for private platforms 
	PRIVATE0                      = 16384, 
	PRIVATE1, 
	PRIVATE2, 
	PRIVATE3, 
	// Internal events 
	POLL_SENTINEL                 = 32512, // *< Signals the end of an event poll cycle
	// Events USER through LAST are for your use,
	// 	*  and should be allocated with SDL_RegisterEvents()
	USER                          = 32768, 
	// *
	// 	*  This last event is only for bounding internal arrays
	LAST                          = 65535, 
}

FColor :: distinct [4]f32

FPoint :: distinct [2]f32

FRect :: struct {
	x: f32,
	y: f32,
	w: f32,
	h: f32,
}

FileDialogType :: enum i32 {
	OPENFILE, 
	SAVEFILE, 
	OPENFOLDER, 
}

Finger :: struct {
	id:       FingerID,
	// *< the finger ID 
	x:        f32,
	// *< the x-axis location of the touch event, normalized (0...1) 
	y:        f32,
	// *< the y-axis location of the touch event, normalized (0...1) 
	pressure: f32,
}

FingerID :: distinct u64

FlashOperation :: enum i32 {
	CANCEL,        // *< Cancel any window flash state
	BRIEFLY,       // *< Flash the window briefly to get attention
	UNTIL_FOCUSED, // *< Flash the window until it gets focus
}

FlipMode :: enum i32 {
	NONE,       // *< Do not flip
	HORIZONTAL, // *< flip horizontally
	VERTICAL,   // *< flip vertically
}

Folder :: enum i32 {
	HOME,        // *< The folder which contains all of the current user's data, preferences, and documents. It usually contains most of the other folders. If a requested folder does not exist, the home folder can be considered a safe fallback to store a user's documents.
	DESKTOP,     // *< The folder of files that are displayed on the desktop. Note that the existence of a desktop folder does not guarantee that the system does show icons on its desktop; certain GNU/Linux distros with a graphical environment may not have desktop icons.
	DOCUMENTS,   // *< User document files, possibly application-specific. This is a good place to save a user's projects.
	DOWNLOADS,   // *< Standard folder for user files downloaded from the internet.
	MUSIC,       // *< Music files that can be played using a standard music player (mp3, ogg...).
	PICTURES,    // *< Image files that can be displayed using a standard viewer (png, jpg...).
	PUBLICSHARE, // *< Files that are meant to be shared with other users on the same computer.
	SAVEDGAMES,  // *< Save files for games.
	SCREENSHOTS, // *< Application screenshots.
	TEMPLATES,   // *< Template files to be used when the user requests the desktop environment to create a new file in a certain folder, such as "New Text File.txt".  Any file in the Templates folder can be used as a starting point for a new file.
	VIDEOS,      // *< Video files that can be played using a standard video player (mp4, webm...).
}

FunctionPointer :: proc "c" ()

GLAttr :: enum i32 {
	RED_SIZE,                   // *< the minimum number of bits for the red channel of the color buffer; defaults to 3.
	GREEN_SIZE,                 // *< the minimum number of bits for the green channel of the color buffer; defaults to 3.
	BLUE_SIZE,                  // *< the minimum number of bits for the blue channel of the color buffer; defaults to 2.
	ALPHA_SIZE,                 // *< the minimum number of bits for the alpha channel of the color buffer; defaults to 0.
	BUFFER_SIZE,                // *< the minimum number of bits for frame buffer size; defaults to 0.
	DOUBLEBUFFER,               // *< whether the output is single or double buffered; defaults to double buffering on.
	DEPTH_SIZE,                 // *< the minimum number of bits in the depth buffer; defaults to 16.
	STENCIL_SIZE,               // *< the minimum number of bits in the stencil buffer; defaults to 0.
	ACCUM_RED_SIZE,             // *< the minimum number of bits for the red channel of the accumulation buffer; defaults to 0.
	ACCUM_GREEN_SIZE,           // *< the minimum number of bits for the green channel of the accumulation buffer; defaults to 0.
	ACCUM_BLUE_SIZE,            // *< the minimum number of bits for the blue channel of the accumulation buffer; defaults to 0.
	ACCUM_ALPHA_SIZE,           // *< the minimum number of bits for the alpha channel of the accumulation buffer; defaults to 0.
	STEREO,                     // *< whether the output is stereo 3D; defaults to off.
	MULTISAMPLEBUFFERS,         // *< the number of buffers used for multisample anti-aliasing; defaults to 0.
	MULTISAMPLESAMPLES,         // *< the number of samples used around the current pixel used for multisample anti-aliasing.
	ACCELERATED_VISUAL,         // *< set to 1 to require hardware acceleration, set to 0 to force software rendering; defaults to allow either.
	RETAINED_BACKING,           // *< not used (deprecated).
	CONTEXT_MAJOR_VERSION,      // *< OpenGL context major version.
	CONTEXT_MINOR_VERSION,      // *< OpenGL context minor version.
	CONTEXT_FLAGS,              // *< some combination of 0 or more of elements of the SDL_GLContextFlag enumeration; defaults to 0.
	CONTEXT_PROFILE_MASK,       // *< type of GL context (Core, Compatibility, ES). See SDL_GLProfile; default value depends on platform.
	SHARE_WITH_CURRENT_CONTEXT, // *< OpenGL context sharing; defaults to 0.
	FRAMEBUFFER_SRGB_CAPABLE,   // *< requests sRGB capable visual; defaults to 0.
	CONTEXT_RELEASE_BEHAVIOR,   // *< sets context the release behavior. See SDL_GLContextReleaseFlag; defaults to FLUSH.
	CONTEXT_RESET_NOTIFICATION, // *< set context reset notification. See SDL_GLContextResetNotification; defaults to NO_NOTIFICATION.
	CONTEXT_NO_ERROR, 
	FLOATBUFFERS, 
	EGL_PLATFORM, 
}

GLContext :: ^GLContextState

GLContextFlag :: distinct bit_set[GLContextFlagBit; u32]

GLContextFlagBit :: enum u32 {
	DEBUG              = 0, 
	FORWARD_COMPATIBLE = 1, 
	ROBUST_ACCESS      = 2, 
	RESET_ISOLATION    = 3, 
}

GLContextReleaseFlag :: distinct bit_set[GLContextReleaseFlagBit; u32]

GLContextReleaseFlagBit :: enum u32 {
	BEHAVIOR_FLUSH = 0, 
}

GLContextResetNotification :: distinct bit_set[GLContextResetNotificationFlag; u32]

GLContextResetNotificationFlag :: enum u32 {
	LOSE_CONTEXT = 0, 
}

GLContextState :: struct {}

GLProfile :: distinct bit_set[GLProfileFlag; u32]

GLProfileFlag :: enum u32 {
	CORE          = 0, // *< OpenGL Core Profile context
	COMPATIBILITY = 1, // *< OpenGL Compatibility Profile context
	ES            = 2, // *< GLX_CONTEXT_ES2_PROFILE_BIT_EXT
}

GPUBlendFactor :: enum i32 {
	INVALID, 
	ZERO,                     // *< 0
	ONE,                      // *< 1
	SRC_COLOR,                // *< source color
	ONE_MINUS_SRC_COLOR,      // *< 1 - source color
	DST_COLOR,                // *< destination color
	ONE_MINUS_DST_COLOR,      // *< 1 - destination color
	SRC_ALPHA,                // *< source alpha
	ONE_MINUS_SRC_ALPHA,      // *< 1 - source alpha
	DST_ALPHA,                // *< destination alpha
	ONE_MINUS_DST_ALPHA,      // *< 1 - destination alpha
	CONSTANT_COLOR,           // *< blend constant
	ONE_MINUS_CONSTANT_COLOR, // *< 1 - blend constant
	SRC_ALPHA_SATURATE,       // *< min(source alpha, 1 - destination alpha)
}

GPUBlendOp :: enum i32 {
	INVALID, 
	ADD,              // *< (source * source_factor) + (destination * destination_factor)
	SUBTRACT,         // *< (source * source_factor) - (destination * destination_factor)
	REVERSE_SUBTRACT, // *< (destination * destination_factor) - (source * source_factor)
	MIN,              // *< min(source, destination)
	MAX,              // *< max(source, destination)
}