package vendor:sdl2

Source

AudioAllowChangeFlag :: enum i32 {
	FREQUENCY = 0, 
	FORMAT    = 1, 
	CHANNELS  = 2, 
	SAMPLES   = 3, 
}

AudioAllowChangeFlags :: distinct bit_set[AudioAllowChangeFlag; i32]

AudioCVT :: struct #packed {
	needed:       i32,
	// *< Set to 1 if conversion possible 
	src_format:   AudioFormat,
	// *< Source audio format 
	dst_format:   AudioFormat,
	// *< Target audio format 
	rate_incr:    f64,
	// *< Rate conversion increment 
	buf:          [^]u8,
	// *< Buffer to hold entire audio data 
	len:          i32,
	// *< Length of original audio buffer 
	len_cvt:      i32,
	// *< Length of converted audio buffer 
	len_mult:     i32,
	// *< buffer must be len*len_mult big 
	len_ratio:    f64,
	// *< Given len, final size is len*len_ratio 
	filters:      [10]AudioFilter,
	// *< NULL-terminated list of filter functions 
	filter_index: i32,
}

AudioCallback :: proc "c" (userdata: rawptr, stream: [^]u8, len: i32)

AudioDeviceEvent :: struct {
	type:      EventType,
	// *< ::SDL_AUDIODEVICEADDED, or ::SDL_AUDIODEVICEREMOVED 
	timestamp: u32,
	// *< In milliseconds, populated using SDL_GetTicks() 
	which:     u32,
	// *< The audio device index for the ADDED event (valid until next SDL_GetNumAudioDevices() call), SDL_AudioDeviceID for the REMOVED event 
	iscapture: u8,
	// *< zero if an output device, non-zero if a capture device. 
	_:         u8,
	_:         u8,
	_:         u8,
}

AudioDeviceID :: distinct u32

AudioFilter :: proc "c" (cvt: ^AudioCVT, format: AudioFormat)

AudioFormat :: distinct u16

AudioSpec :: struct {
	freq:     i32,
	// *< DSP frequency -- samples per second 
	format:   AudioFormat,
	// *< Audio data format 
	channels: u8,
	// *< Number of channels: 1 mono, 2 stereo 
	silence:  u8,
	// *< Audio buffer silence value (calculated) 
	samples:  u16,
	// *< Audio buffer size in sample FRAMES (total samples divided by channel count) 
	padding:  u16,
	// *< Necessary for some compile environments 
	size:     u32,
	// *< Audio buffer size in bytes (calculated) 
	callback: AudioCallback,
	// *< Callback that feeds the audio device (NULL to use SDL_QueueAudio()). 
	userdata: rawptr,
}

AudioStatus :: enum i32 {
	STOPPED = 0, 
	PLAYING, 
	PAUSED, 
}

AudioStream :: struct {}

BlendFactor :: enum i32 {
	ZERO                = 0x1, // *< 0, 0, 0, 0
	ONE                 = 0x2, // *< 1, 1, 1, 1
	SRC_COLOR           = 0x3, // *< srcR, srcG, srcB, srcA
	ONE_MINUS_SRC_COLOR = 0x4, // *< 1-srcR, 1-srcG, 1-srcB, 1-srcA
	SRC_ALPHA           = 0x5, // *< srcA, srcA, srcA, srcA
	ONE_MINUS_SRC_ALPHA = 0x6, // *< 1-srcA, 1-srcA, 1-srcA, 1-srcA
	DST_COLOR           = 0x7, // *< dstR, dstG, dstB, dstA
	ONE_MINUS_DST_COLOR = 0x8, // *< 1-dstR, 1-dstG, 1-dstB, 1-dstA
	DST_ALPHA           = 0x9, // *< dstA, dstA, dstA, dstA
	ONE_MINUS_DST_ALPHA = 0xA, // *< 1-dstA, 1-dstA, 1-dstA, 1-dstA
}

BlendMode :: enum i32 {
	NONE    = 0x00000000, // *< no blending
	                        dstRGBA = srcRGBA
	BLEND   = 0x00000001, // *< alpha blending
	                        dstRGB = (srcRGB * srcA) + (dstRGB * (1-srcA))
	                        dstA = srcA + (dstA * (1-srcA))
	ADD     = 0x00000002, // *< additive blending
	                        dstRGB = (srcRGB * srcA) + dstRGB
	                        dstA = dstA
	MOD     = 0x00000004, // *< color modulate
	                        dstRGB = srcRGB * dstRGB
	                        dstA = dstA
	MUL     = 0x00000008, // *< color multiply
	                        dstRGB = (srcRGB * dstRGB) + (dstRGB * (1-srcA))
	                        dstA = (srcA * dstA) + (dstA * (1-srcA))
	INVALID = 0x7FFFFFFF, 
}

BlendOperation :: enum i32 {
	ADD          = 0x1, // *< dst + src: supported by all renderers
	SUBTRACT     = 0x2, // *< dst - src : supported by D3D9, D3D11, OpenGL, OpenGLES
	REV_SUBTRACT = 0x3, // *< src - dst : supported by D3D9, D3D11, OpenGL, OpenGLES
	MINIMUM      = 0x4, // *< min(dst, src) : supported by D3D11
	MAXIMUM      = 0x5, // *< max(dst, src) : supported by D3D11
}

BlitMap :: struct {}

Color :: struct {
	r: u8,
	g: u8,
	b: u8,
	a: u8,
}

Colour :: Color

CommonEvent :: struct {
	type:      EventType,
	timestamp: u32,
}

ControllerAxisEvent :: struct {
	type:      EventType,
	// *< ::SDL_CONTROLLERAXISMOTION 
	timestamp: u32,
	// *< In milliseconds, populated using SDL_GetTicks() 
	which:     JoystickID,
	// *< The joystick instance id 
	axis:      u8,
	// *< The controller axis (SDL_GameControllerAxis) 
	_:         u8,
	_:         u8,
	_:         u8,
	value:     i16,
	// *< The axis value (range: -32768 to 32767) 
	_:         u16,
}

ControllerButtonEvent :: struct {
	type:      EventType,
	// *< ::SDL_CONTROLLERBUTTONDOWN or ::SDL_CONTROLLERBUTTONUP 
	timestamp: u32,
	// *< In milliseconds, populated using SDL_GetTicks() 
	which:     JoystickID,
	// *< The joystick instance id 
	button:    u8,
	// *< The controller button (SDL_GameControllerButton) 
	state:     u8,
	// *< ::SDL_PRESSED or ::SDL_RELEASED 
	_:         u8,
	_:         u8,
}

ControllerDeviceEvent :: struct {
	type:      EventType,
	// *< ::SDL_CONTROLLERDEVICEADDED, ::SDL_CONTROLLERDEVICEREMOVED, or ::SDL_CONTROLLERDEVICEREMAPPED 
	timestamp: u32,
	// *< In milliseconds, populated using SDL_GetTicks() 
	which:     i32,
}

ControllerSensorEvent :: struct {
	type:         EventType,
	// *< ::SDL_CONTROLLERSENSORUPDATE 
	timestamp:    u32,
	// *< In milliseconds, populated using SDL_GetTicks() 
	which:        JoystickID,
	// *< The joystick instance id 
	sensor:       i32,
	// *< The type of the sensor, one of the values of ::SDL_SensorType 
	data:         [3]f32,
	// *< Up to 3 values from the sensor, as defined in SDL_sensor.h 
	timestamp_us: u64,
}

ControllerTouchpadEvent :: struct {
	type:      EventType,
	// *< ::SDL_CONTROLLERTOUCHPADDOWN or ::SDL_CONTROLLERTOUCHPADMOTION or ::SDL_CONTROLLERTOUCHPADUP 
	timestamp: u32,
	// *< In milliseconds, populated using SDL_GetTicks() 
	which:     JoystickID,
	// *< The joystick instance id 
	touchpad:  i32,
	// *< The index of the touchpad 
	finger:    i32,
	// *< The index of the finger on the touchpad 
	x:         f32,
	// *< Normalized in the range 0...1 with 0 being on the left 
	y:         f32,
	// *< Normalized in the range 0...1 with 0 being at the top 
	pressure:  f32,
}

Cursor :: struct {}

DisplayEvent :: struct {
	type:      EventType,
	// *< ::SDL_DISPLAYEVENT 
	timestamp: u32,
	// *< In milliseconds, populated using SDL_GetTicks() 
	display:   u32,
	// *< The associated display index 
	event:     DisplayEventID,
	// *< ::SDL_DisplayEventID 
	_:         u8,
	_:         u8,
	_:         u8,
	data1:     i32,
}

DisplayEventID :: enum u8 {
	NONE,         // *< Never used
	ORIENTATION,  // *< Display orientation has changed to data1
	CONNECTED,    // *< Display has been added to the system
	DISCONNECTED, // *< Display has been removed from the system
	MOVED,        // *< Display has changed position
}

DisplayMode :: struct {
	format:       u32,
	// *< pixel format 
	w:            i32,
	// *< width, in screen coordinates 
	h:            i32,
	// *< height, in screen coordinates 
	refresh_rate: i32,
	// *< refresh rate (or zero for unspecified) 
	driverdata:   rawptr,
}

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
}

DollarGestureEvent :: struct {
	type:       EventType,
	// *< ::SDL_DOLLARGESTURE or ::SDL_DOLLARRECORD 
	timestamp:  u32,
	// *< In milliseconds, populated using SDL_GetTicks() 
	touchId:    TouchID,
	// *< The touch device id 
	gestureId:  GestureID,
	numFingers: u32,
	error:      f32,
	x:          f32,
	// *< Normalized center of gesture 
	y:          f32,
}

DropEvent :: struct {
	type:      EventType,
	// *< ::SDL_DROPBEGIN or ::SDL_DROPFILE or ::SDL_DROPTEXT or ::SDL_DROPCOMPLETE 
	timestamp: u32,
	// *< In milliseconds, populated using SDL_GetTicks() 
	file:      cstring,
	// *< The file name, which should be freed with SDL_free(), is NULL on begin/complete 
	windowID:  u32,
}

Event :: struct #raw_union {
	type:      EventType,
	// *< Event type, shared with all events 
	common:    CommonEvent,
	// *< Common event data 
	display:   DisplayEvent,
	// *< Display event data 
	window:    WindowEvent,
	// *< Window event data 
	key:       KeyboardEvent,
	// *< Keyboard event data 
	edit:      TextEditingEvent,
	// *< Text editing event data 
	editExt:   TextEditingExtEvent,
	// *< Extended text editing event data 
	text:      TextInputEvent,
	// *< Text input event data 
	motion:    MouseMotionEvent,
	// *< Mouse motion event data 
	button:    MouseButtonEvent,
	// *< Mouse button event data 
	wheel:     MouseWheelEvent,
	// *< Mouse wheel 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 
	jdevice:   JoyDeviceEvent,
	// *< Joystick device change event data 
	jbattery:  JoyBatteryEvent,
	// *< Joystick battery event data 
	caxis:     ControllerAxisEvent,
	// *< Game Controller axis event data 
	cbutton:   ControllerButtonEvent,
	// *< Game Controller button event data 
	cdevice:   ControllerDeviceEvent,
	// *< Game Controller device event data 
	ctouchpad: ControllerTouchpadEvent,
	// *< Game Controller touchpad event data 
	csensor:   ControllerSensorEvent,
	// *< Game Controller sensor event data 
	adevice:   AudioDeviceEvent,
	// *< Audio device event data 
	sensor:    SensorEvent,
	// *< Sensor event data 
	quit:      QuitEvent,
	// *< Quit request event data 
	user:      UserEvent,
	// *< Custom event data 
	syswm:     SysWMEvent,
	// *< System dependent window event data 
	tfinger:   TouchFingerEvent,
	// *< Touch finger event data 
	mgesture:  MultiGestureEvent,
	// *< Gesture event data 
	dgesture:  DollarGestureEvent,
	// *< Gesture event data 
	drop:      DropEvent,
	// *< Drag and drop event data 
	padding:   [56]u8,
}

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

EventType :: enum u32 {
	FIRSTEVENT                                 = 0,      // *< Unused (do not remove)
	// Application events 
	QUIT                                       = 0x100,  // *< User-requested quit
	// These application events have special meaning on iOS, see README-ios.md for details 
	APP_TERMINATING,                                     // *< The application is being terminated by the OS
	                             Called on iOS in applicationWillTerminate()
	                             Called on Android in onDestroy()
	APP_LOWMEMORY,                                       // *< The application is low on memory, free memory if possible.
	                             Called on iOS in applicationDidReceiveMemoryWarning()
	                             Called on Android in onLowMemory()
	APP_WILLENTERBACKGROUND,                             // *< The application is about to enter the background
	                             Called on iOS in applicationWillResignActive()
	                             Called on Android in onPause()
	APP_DIDENTERBACKGROUND,                              // *< The application did enter the background and may not get CPU for some time
	                             Called on iOS in applicationDidEnterBackground()
	                             Called on Android in onPause()
	APP_WILLENTERFOREGROUND,                             // *< The application is about to enter the foreground
	                             Called on iOS in applicationWillEnterForeground()
	                             Called on Android in onResume()
	APP_DIDENTERFOREGROUND,                              // *< The application is now interactive
	                             Called on iOS in applicationDidBecomeActive()
	                             Called on Android in onResume()
	LOCALECHANGED,                                       // *< The user's locale preferences have changed.
	// Display events 
	DISPLAYEVENT                               = 0x150,  // *< Display state change
	// Window events 
	WINDOWEVENT                                = 0x200,  // *< Window state change
	SYSWMEVENT,                                          // *< System specific event
	// Keyboard events 
	KEYDOWN                                    = 0x300,  // *< Key pressed
	KEYUP,                                               // *< Key released
	TEXTEDITING,                                         // *< Keyboard text editing (composition)
	TEXTINPUT,                                           // *< Keyboard text input
	KEYMAPCHANGED,                                       // *< Keymap changed due to a system event such as an
	                             input language or keyboard layout change.
	TEXTEDITING_EXT,                                     // *< Extended keyboard text editing (composition)
	// Mouse events 
	MOUSEMOTION                                = 0x400,  // *< Mouse moved
	MOUSEBUTTONDOWN,                                     // *< Mouse button pressed
	MOUSEBUTTONUP,                                       // *< Mouse button released
	MOUSEWHEEL,                                          // *< Mouse wheel motion
	// Joystick events 
	JOYAXISMOTION                              = 0x600,  // *< Joystick axis motion
	JOYBALLMOTION,                                       // *< Joystick trackball motion
	JOYHATMOTION,                                        // *< Joystick hat position change
	JOYBUTTONDOWN,                                       // *< Joystick button pressed
	JOYBUTTONUP,                                         // *< Joystick button released
	JOYDEVICEADDED,                                      // *< A new joystick has been inserted into the system
	JOYDEVICEREMOVED,                                    // *< An opened joystick has been removed
	JOYBATTERYUPDATED,                                   // *< Joystick battery level change
	// Game controller events 
	CONTROLLERAXISMOTION                       = 0x650,  // *< Game controller axis motion
	CONTROLLERBUTTONDOWN,                                // *< Game controller button pressed
	CONTROLLERBUTTONUP,                                  // *< Game controller button released
	CONTROLLERDEVICEADDED,                               // *< A new Game controller has been inserted into the system
	CONTROLLERDEVICEREMOVED,                             // *< An opened Game controller has been removed
	CONTROLLERDEVICEREMAPPED,                            // *< The controller mapping was updated
	CONTROLLERTOUCHPADDOWN,                              // *< Game controller touchpad was touched
	CONTROLLERTOUCHPADMOTION,                            // *< Game controller touchpad finger was moved
	CONTROLLERTOUCHPADUP,                                // *< Game controller touchpad finger was lifted
	CONTROLLERSENSORUPDATE,                              // *< Game controller sensor was updated
	CONTROLLERUPDATECOMPLETE_RESERVED_FOR_SDL3, 
	CONTROLLERSTEAMHANDLEUPDATED,                        // *< Game controller Steam handle has changed
	// Touch events 
	FINGERDOWN                                 = 0x700, 
	FINGERUP, 
	FINGERMOTION, 
	// Gesture events 
	DOLLARGESTURE                              = 0x800, 
	DOLLARRECORD, 
	MULTIGESTURE, 
	// Clipboard events 
	CLIPBOARDUPDATE                            = 0x900,  // *< The clipboard changed
	// Drag and drop events 
	DROPFILE                                   = 0x1000, // *< The system requests a file open
	DROPTEXT,                                            // *< text/plain drag-and-drop event
	DROPBEGIN,                                           // *< A new set of drops is beginning (NULL filename)
	DROPCOMPLETE,                                        // *< Current set of drops is now complete (NULL filename)
	// Audio hotplug events 
	AUDIODEVICEADDED                           = 0x1100, // *< A new audio device is available
	AUDIODEVICEREMOVED,                                  // *< An audio device has been removed.
	// Sensor events 
	SENSORUPDATE                               = 0x1200, // *< A sensor was updated
	// Render events 
	RENDER_TARGETS_RESET                       = 0x2000, // *< 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
	// Internal events 
	POLLSENTINEL                               = 0x7F00, // *< Signals the end of an event poll cycle
	// Events ::SDL_USEREVENT through ::SDL_LASTEVENT are for your use,
	// 	*  and should be allocated with SDL_RegisterEvents()
	USEREVENT                                  = 0x8000, 
	// *
	// 	*  This last event is only for bounding internal arrays
	LASTEVENT                                  = 0xFFFF, 
}

FPoint :: struct {
	x: f32,
	y: f32,
}

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

Finger :: struct {
	id:       FingerID,
	x:        f32,
	y:        f32,
	pressure: f32,
}

FingerID :: distinct i64

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
}

GLContext :: distinct rawptr

GLContextResetNotification :: enum i32 {
	NO_NOTIFICATION = 0x0000, 
	LOSE_CONTEXT    = 0x0001, 
}

GLattr :: enum i32 {
	RED_SIZE, 
	GREEN_SIZE, 
	BLUE_SIZE, 
	ALPHA_SIZE, 
	BUFFER_SIZE, 
	DOUBLEBUFFER, 
	DEPTH_SIZE, 
	STENCIL_SIZE, 
	ACCUM_RED_SIZE, 
	ACCUM_GREEN_SIZE, 
	ACCUM_BLUE_SIZE, 
	ACCUM_ALPHA_SIZE, 
	STEREO, 
	MULTISAMPLEBUFFERS, 
	MULTISAMPLESAMPLES, 
	ACCELERATED_VISUAL, 
	RETAINED_BACKING, 
	CONTEXT_MAJOR_VERSION, 
	CONTEXT_MINOR_VERSION, 
	CONTEXT_EGL, 
	CONTEXT_FLAGS, 
	CONTEXT_PROFILE_MASK, 
	SHARE_WITH_CURRENT_CONTEXT, 
	FRAMEBUFFER_SRGB_CAPABLE, 
	CONTEXT_RELEASE_BEHAVIOR, 
	CONTEXT_RESET_NOTIFICATION, 
	CONTEXT_NO_ERROR, 
	FLOATBUFFERS, 
}

GLcontextFlag :: enum i32 {
	DEBUG_FLAG              = 0x0001, 
	FORWARD_COMPATIBLE_FLAG = 0x0002, 
	ROBUST_ACCESS_FLAG      = 0x0004, 
	RESET_ISOLATION_FLAG    = 0x0008, 
}

GLcontextReleaseFlag :: enum i32 {
	NONE  = 0x0000, 
	FLUSH = 0x0001, 
}

GLprofile :: enum i32 {
	CORE          = 0x0001, 
	COMPATIBILITY = 0x0002, 
	ES            = 0x0004, // *< GLX_CONTEXT_ES2_PROFILE_BIT_EXT
}

GUID :: struct {
	data: [16]u8,
}

GameController :: struct {}

GameControllerAxis :: enum i32 {
	INVALID      = -1, 
	LEFTX, 
	LEFTY, 
	RIGHTX, 
	RIGHTY, 
	TRIGGERLEFT, 
	TRIGGERRIGHT, 
	MAX, 
}

GameControllerBindType :: enum i32 {
	NONE   = 0, 
	BUTTON, 
	AXIS, 
	HAT, 
}

GameControllerButton :: enum i32 {
	INVALID       = -1, 
	A, 
	B, 
	X, 
	Y, 
	BACK, 
	GUIDE, 
	START, 
	LEFTSTICK, 
	RIGHTSTICK, 
	LEFTSHOULDER, 
	RIGHTSHOULDER, 
	DPAD_UP, 
	DPAD_DOWN, 
	DPAD_LEFT, 
	DPAD_RIGHT, 
	MISC1,              // Xbox Series X share button, PS5 microphone button, Nintendo Switch Pro capture button, Amazon Luna microphone button
	PADDLE1,            // Xbox Elite paddle P1
	PADDLE2,            // Xbox Elite paddle P3
	PADDLE3,            // Xbox Elite paddle P2
	PADDLE4,            // Xbox Elite paddle P4
	TOUCHPAD,           // PS4/PS5 touchpad button
	MAX, 
}

GameControllerButtonBind :: struct {
	bindType: GameControllerBindType,
	value:    struct #raw_union {
		button: i32,
		axis:   i32,
		hat:    struct {
			hat:      i32,
			hat_mask: i32,
		},
	},
}

GameControllerType :: enum i32 {
	UNKNOWN                      = 0, 
	XBOX360, 
	XBOXONE, 
	PS3, 
	PS4, 
	NINTENDO_SWITCH_PRO, 
	VIRTUAL, 
	PS5, 
	AMAZON_LUNA, 
	GOOGLE_STADIA, 
	NVIDIA_SHIELD, 
	NINTENDO_SWITCH_JOYCON_LEFT, 
	NINTENDO_SWITCH_JOYCON_RIGHT, 
	NINTENDO_SWITCH_JOYCON_PAIR, 
	MAX, 
}

GestureID :: distinct i64

Haptic :: struct {}

HapticCondition :: struct {
	// Header 
	type:        HapticType,
	// *< ::SDL_HAPTIC_SPRING, ::SDL_HAPTIC_DAMPER,
	// 	                         ::SDL_HAPTIC_INERTIA or ::SDL_HAPTIC_FRICTION 
	direction:   HapticDirection,
	// Replay 
	length:      u32,
	// *< Duration of the effect. 
	delay:       u16,
	// Trigger 
	button:      u16,
	// *< Button that triggers the effect. 
	interval:    u16,
	// Condition 
	right_sat:   [3]u16,
	// *< Level when joystick is to the positive side; max 0xFFFF. 
	left_sat:    [3]u16,
	// *< Level when joystick is to the negative side; max 0xFFFF. 
	right_coeff: [3]i16,
	// *< How fast to increase the force towards the positive side. 
	left_coeff:  [3]i16,
	// *< How fast to increase the force towards the negative side. 
	deadband:    [3]u16,
	// *< Size of the dead zone; max 0xFFFF: whole axis-range when 0-centered. 
	center:      [3]i16,
}

HapticConstant :: struct {
	// Header 
	type:          HapticType,
	// *< ::SDL_HAPTIC_CONSTANT 
	direction:     HapticDirection,
	// Replay 
	length:        u32,
	// *< Duration of the effect. 
	delay:         u16,
	// Trigger 
	button:        u16,
	// *< Button that triggers the effect. 
	interval:      u16,
	// Constant 
	level:         i16,
	// Envelope 
	attack_length: u16,
	// *< Duration of the attack. 
	attack_level:  u16,
	// *< Level at the start of the attack. 
	fade_length:   u16,
	// *< Duration of the fade. 
	fade_level:    u16,
}

HapticCustom :: struct {
	// Header 
	type:          HapticType,
	// *< ::SDL_HAPTIC_CUSTOM 
	direction:     HapticDirection,
	// Replay 
	length:        u32,
	// *< Duration of the effect. 
	delay:         u16,
	// Trigger 
	button:        u16,
	// *< Button that triggers the effect. 
	interval:      u16,
	// Custom 
	channels:      u8,
	// *< Axes to use, minimum of one. 
	period:        u16,
	// *< Sample periods. 
	samples:       u16,
	// *< Amount of samples. 
	data:          [^]u16,
	// Envelope 
	attack_length: u16,
	// *< Duration of the attack. 
	attack_level:  u16,
	// *< Level at the start of the attack. 
	fade_length:   u16,
	// *< Duration of the fade. 
	fade_level:    u16,
}

HapticDirection :: struct {
	type: HapticDirectionType,
	// *< The type of encoding. 
	dir:  [3]i32,
}

HapticDirectionType :: enum u8 {
	POLAR         = 0, 
	CARTESIAN     = 1, 
	SPHERICAL     = 2, 
	STEERING_AXIS = 3, 
}

HapticEffect :: struct #raw_union {
	// Common for all force feedback effects 
	type:      HapticType,
	// *< Effect type. 
	constant:  HapticConstant,
	// *< Constant effect. 
	periodic:  HapticPeriodic,
	// *< Periodic effect. 
	condition: HapticCondition,
	// *< Condition effect. 
	ramp:      HapticRamp,
	// *< Ramp effect. 
	leftright: HapticLeftRight,
	// *< Left/Right effect. 
	custom:    HapticCustom,
}

HapticLeftRight :: struct {
	// Header 
	type:            HapticType,
	// Replay 
	length:          u32,
	// Rumble 
	large_magnitude: u16,
	// *< Control of the large controller motor. 
	small_magnitude: u16,
}

HapticPeriodic :: struct {
	// Header 
	type:          HapticType,
	// *< ::SDL_HAPTIC_SINE, ::SDL_HAPTIC_LEFTRIGHT,
	// 	                        ::SDL_HAPTIC_TRIANGLE, ::SDL_HAPTIC_SAWTOOTHUP or
	// 	                        ::SDL_HAPTIC_SAWTOOTHDOWN 
	direction:     HapticDirection,
	// Replay 
	length:        u32,
	// *< Duration of the effect. 
	delay:         u16,
	// Trigger 
	button:        u16,
	// *< Button that triggers the effect. 
	interval:      u16,
	// Periodic 
	period:        u16,
	// *< Period of the wave. 
	magnitude:     i16,
	// *< Peak value; if negative, equivalent to 180 degrees extra phase shift. 
	offset:        i16,
	// *< Mean value of the wave. 
	phase:         u16,
	// Envelope 
	attack_length: u16,
	// *< Duration of the attack. 
	attack_level:  u16,
	// *< Level at the start of the attack. 
	fade_length:   u16,
	// *< Duration of the fade. 
	fade_level:    u16,
}

HapticRamp :: struct {
	// Header 
	type:          HapticType,
	// *< ::SDL_HAPTIC_RAMP 
	direction:     HapticDirection,
	// Replay 
	length:        u32,
	// *< Duration of the effect. 
	delay:         u16,
	// Trigger 
	button:        u16,
	// *< Button that triggers the effect. 
	interval:      u16,
	// Ramp 
	start:         i16,
	// *< Beginning strength level. 
	end:           i16,
	// Envelope 
	attack_length: u16,
	// *< Duration of the attack. 
	attack_level:  u16,
	// *< Level at the start of the attack. 
	fade_length:   u16,
	// *< Duration of the fade. 
	fade_level:    u16,
}

HapticType :: enum u16 {
	CONSTANT     = 1 << 0, 
	SINE         = 1 << 1, 
	LEFTRIGHT    = 1 << 2, 
	TRIANGLE     = 1 << 3, 
	SAWTOOTHUP   = 1 << 4, 
	SAWTOOTHDOWN = 1 << 5, 
	RAMP         = 1 << 6, 
	SPRING       = 1 << 7, 
	DAMPER       = 1 << 8, 
	INERTIA      = 1 << 9, 
	FRICTION     = 1 << 10, 
	CUSTOM       = 1 << 11, 
	GAIN         = 1 << 12, 
	AUTOCENTER   = 1 << 13, 
	STATUS       = 1 << 14, 
	PAUSE        = 1 << 15, 
}

HintCallback :: proc "c" (userdata: rawptr, name, oldValue, newValue: cstring)

HintPriority :: enum i32 {
	DEFAULT, 
	NORMAL, 
	OVERRIDE, 
}

HitTest :: proc "c" (win: ^Window, area: ^Point, data: rawptr) -> HitTestResult

HitTestResult :: enum i32 {
	NORMAL,             // *< Region is normal. No special properties.
	DRAGGABLE,          // *< Region can drag entire window.
	RESIZE_TOPLEFT, 
	RESIZE_TOP, 
	RESIZE_TOPRIGHT, 
	RESIZE_RIGHT, 
	RESIZE_BOTTOMRIGHT, 
	RESIZE_BOTTOM, 
	RESIZE_BOTTOMLEFT, 
	RESIZE_LEFT, 
}

ID3D11Device :: struct {}

IDirect3DDevice9 :: struct {}

InitFlag :: enum u32 {
	TIMER          = 0x00, 
	AUDIO          = 0x04, 
	VIDEO          = 0x05, 
	JOYSTICK       = 0x09, 
	HAPTIC         = 0x0c, 
	GAMECONTROLLER = 0x0d, 
	EVENTS         = 0x0e, 
	SENSOR         = 0x0f, 
	NOPARACHUTE    = 0x14, 
}

InitFlags :: bit_set[InitFlag; u32]

JoyAxisEvent :: struct {
	type:      EventType,
	// *< ::SDL_CONTROLLERAXISMOTION 
	timestamp: u32,
	// *< In milliseconds, populated using SDL_GetTicks() 
	which:     JoystickID,
	// *< The joystick instance id 
	axis:      u8,
	// *< The controller axis (SDL_GameControllerAxis) 
	_:         u8,
	_:         u8,
	_:         u8,
	value:     i16,
	// *< The axis value (range: -32768 to 32767) 
	_:         u16,
}

JoyBallEvent :: struct {
	type:      EventType,
	// *< ::SDL_JOYBALLMOTION 
	timestamp: u32,
	// *< In milliseconds, populated using SDL_GetTicks() 
	which:     JoystickID,
	// *< The joystick instance id 
	ball:      u8,
	// *< The joystick trackball index 
	_:         u8,
	_:         u8,
	_:         u8,
	xrel:      i16,
	// *< The relative motion in the X direction 
	yrel:      i16,
}

JoyBatteryEvent :: struct {
	type:      EventType,
	// *< ::SDL_JOYBATTERYUPDATED 
	timestamp: u32,
	// *< In milliseconds, populated using SDL_GetTicks() 
	which:     JoystickID,
	// *< The joystick instance id 
	level:     JoystickPowerLevel,
}

JoyButtonEvent :: struct {
	type:      EventType,
	// *< ::SDL_CONTROLLERBUTTONDOWN or ::SDL_CONTROLLERBUTTONUP 
	timestamp: u32,
	// *< In milliseconds, populated using SDL_GetTicks() 
	which:     JoystickID,
	// *< The joystick instance id 
	button:    u8,
	// *< The controller button (SDL_GameControllerButton) 
	state:     u8,
	// *< ::SDL_PRESSED or ::SDL_RELEASED 
	_:         u8,
	_:         u8,
}

JoyDeviceEvent :: struct {
	type:      EventType,
	// *< ::SDL_CONTROLLERDEVICEADDED, ::SDL_CONTROLLERDEVICEREMOVED, or ::SDL_CONTROLLERDEVICEREMAPPED 
	timestamp: u32,
	// *< In milliseconds, populated using SDL_GetTicks() 
	which:     i32,
}

JoyHatEvent :: struct {
	type:      EventType,
	// *< ::SDL_JOYHATMOTION 
	timestamp: u32,
	// *< In milliseconds, populated using SDL_GetTicks() 
	which:     JoystickID,
	// *< The joystick instance id 
	hat:       u8,
	// *< The joystick hat index 
	value:     u8,
	// *< The hat position value.
	// 	                 *   \sa ::SDL_HAT_LEFTUP ::SDL_HAT_UP ::SDL_HAT_RIGHTUP
	// 	                 *   \sa ::SDL_HAT_LEFT ::SDL_HAT_CENTERED ::SDL_HAT_RIGHT
	// 	                 *   \sa ::SDL_HAT_LEFTDOWN ::SDL_HAT_DOWN ::SDL_HAT_RIGHTDOWN
	// 	                 *
	// 	                 *   Note that zero means the POV is centered.
	_:         u8,
	_:         u8,
}

Joystick :: struct {}

JoystickGUID :: GUID

JoystickID :: distinct i32

JoystickPowerLevel :: enum i32 {
	UNKNOWN = -1, 
	EMPTY,        // <= 5%
	LOW,          // <= 20%
	MEDIUM,       // <= 70%
	FULL,         // <= 100%
	WIRED, 
	MAX, 
}

JoystickType :: enum i32 {
	UNKNOWN, 
	GAMECONTROLLER, 
	WHEEL, 
	ARCADE_STICK, 
	FLIGHT_STICK, 
	DANCE_PAD, 
	GUITAR, 
	DRUM_KIT, 
	ARCADE_PAD, 
	THROTTLE, 
}

KeyboardEvent :: struct {
	type:      EventType,
	// *< ::SDL_KEYDOWN or ::SDL_KEYUP 
	timestamp: u32,
	// *< In milliseconds, populated using SDL_GetTicks() 
	windowID:  u32,
	// *< The window with keyboard focus, if any 
	state:     u8,
	// *< ::SDL_PRESSED or ::SDL_RELEASED 
	repeat:    u8,
	// *< Non-zero if this is a key repeat 
	_:         u8,
	_:         u8,
	keysym:    Keysym,
}

Keycode :: enum i32 {
	UNKNOWN            = 0, 
	RETURN             = '\r', 
	ESCAPE             = '\x1B', 
	BACKSPACE          = '\b', 
	TAB                = '\t', 
	SPACE              = ' ', 
	EXCLAIM            = '!', 
	QUOTEDBL           = '"', 
	HASH               = '#', 
	PERCENT            = '%', 
	DOLLAR             = '$', 
	AMPERSAND          = '&', 
	QUOTE              = '\'', 
	LEFTPAREN          = '(', 
	RIGHTPAREN         = ')', 
	ASTERISK           = '*', 
	PLUS               = '+', 
	COMMA              = ',', 
	MINUS              = '-', 
	PERIOD             = '.', 
	SLASH              = '/', 
	NUM0               = '0', 
	NUM1               = '1', 
	NUM2               = '2', 
	NUM3               = '3', 
	NUM4               = '4', 
	NUM5               = '5', 
	NUM6               = '6', 
	NUM7               = '7', 
	NUM8               = '8', 
	NUM9               = '9', 
	COLON              = ':', 
	SEMICOLON          = ';', 
	LESS               = '<', 
	EQUALS             = '=', 
	GREATER            = '>', 
	QUESTION           = '?', 
	AT                 = '@', 
	LEFTBRACKET        = '[', 
	BACKSLASH          = '\\', 
	RIGHTBRACKET       = ']', 
	CARET              = '^', 
	UNDERSCORE         = '_', 
	BACKQUOTE          = '`', 
	a                  = 'a', 
	b                  = 'b', 
	c                  = 'c', 
	d                  = 'd', 
	e                  = 'e', 
	f                  = 'f', 
	g                  = 'g', 
	h                  = 'h', 
	i                  = 'i', 
	j                  = 'j', 
	k                  = 'k', 
	l                  = 'l', 
	m                  = 'm', 
	n                  = 'n', 
	o                  = 'o', 
	p                  = 'p', 
	q                  = 'q', 
	r                  = 'r', 
	s                  = 's', 
	t                  = 't', 
	u                  = 'u', 
	v                  = 'v', 
	w                  = 'w', 
	x                  = 'x', 
	y                  = 'y', 
	z                  = 'z', 
	A                  = a, 
	B                  = b, 
	C                  = c, 
	D                  = d, 
	E                  = e, 
	F                  = f, 
	G                  = g, 
	H                  = h, 
	I                  = i, 
	J                  = j, 
	K                  = k, 
	L                  = l, 
	M                  = m, 
	N                  = n, 
	O                  = o, 
	P                  = p, 
	Q                  = q, 
	R                  = r, 
	S                  = s, 
	T                  = t, 
	U                  = u, 
	V                  = v, 
	W                  = w, 
	X                  = x, 
	Y                  = y, 
	Z                  = z, 
	CAPSLOCK           = auto_cast (Scancode.CAPSLOCK | SCANCODE_MASK), 
	F1                 = auto_cast (Scancode.F1 | SCANCODE_MASK), 
	F2                 = auto_cast (Scancode.F2 | SCANCODE_MASK), 
	F3                 = auto_cast (Scancode.F3 | SCANCODE_MASK), 
	F4                 = auto_cast (Scancode.F4 | SCANCODE_MASK), 
	F5                 = auto_cast (Scancode.F5 | SCANCODE_MASK), 
	F6                 = auto_cast (Scancode.F6 | SCANCODE_MASK), 
	F7                 = auto_cast (Scancode.F7 | SCANCODE_MASK), 
	F8                 = auto_cast (Scancode.F8 | SCANCODE_MASK), 
	F9                 = auto_cast (Scancode.F9 | SCANCODE_MASK), 
	F10                = auto_cast (Scancode.F10 | SCANCODE_MASK), 
	F11                = auto_cast (Scancode.F11 | SCANCODE_MASK), 
	F12                = auto_cast (Scancode.F12 | SCANCODE_MASK), 
	PRINTSCREEN        = auto_cast (Scancode.PRINTSCREEN | SCANCODE_MASK), 
	SCROLLLOCK         = auto_cast (Scancode.SCROLLLOCK | SCANCODE_MASK), 
	PAUSE              = auto_cast (Scancode.PAUSE | SCANCODE_MASK), 
	INSERT             = auto_cast (Scancode.INSERT | SCANCODE_MASK), 
	HOME               = auto_cast (Scancode.HOME | SCANCODE_MASK), 
	PAGEUP             = auto_cast (Scancode.PAGEUP | SCANCODE_MASK), 
	DELETE             = '\x7F', 
	END                = auto_cast (Scancode.END | SCANCODE_MASK), 
	PAGEDOWN           = auto_cast (Scancode.PAGEDOWN | SCANCODE_MASK), 
	RIGHT              = auto_cast (Scancode.RIGHT | SCANCODE_MASK), 
	LEFT               = auto_cast (Scancode.LEFT | SCANCODE_MASK), 
	DOWN               = auto_cast (Scancode.DOWN | SCANCODE_MASK), 
	UP                 = auto_cast (Scancode.UP | SCANCODE_MASK), 
	NUMLOCKCLEAR       = auto_cast (Scancode.NUMLOCKCLEAR | SCANCODE_MASK), 
	KP_DIVIDE          = auto_cast (Scancode.KP_DIVIDE | SCANCODE_MASK), 
	KP_MULTIPLY        = auto_cast (Scancode.KP_MULTIPLY | SCANCODE_MASK), 
	KP_MINUS           = auto_cast (Scancode.KP_MINUS | SCANCODE_MASK), 
	KP_PLUS            = auto_cast (Scancode.KP_PLUS | SCANCODE_MASK), 
	KP_ENTER           = auto_cast (Scancode.KP_ENTER | SCANCODE_MASK), 
	KP_1               = auto_cast (Scancode.KP_1 | SCANCODE_MASK), 
	KP_2               = auto_cast (Scancode.KP_2 | SCANCODE_MASK), 
	KP_3               = auto_cast (Scancode.KP_3 | SCANCODE_MASK), 
	KP_4               = auto_cast (Scancode.KP_4 | SCANCODE_MASK), 
	KP_5               = auto_cast (Scancode.KP_5 | SCANCODE_MASK), 
	KP_6               = auto_cast (Scancode.KP_6 | SCANCODE_MASK), 
	KP_7               = auto_cast (Scancode.KP_7 | SCANCODE_MASK), 
	KP_8               = auto_cast (Scancode.KP_8 | SCANCODE_MASK), 
	KP_9               = auto_cast (Scancode.KP_9 | SCANCODE_MASK), 
	KP_0               = auto_cast (Scancode.KP_0 | SCANCODE_MASK), 
	KP_PERIOD          = auto_cast (Scancode.KP_PERIOD | SCANCODE_MASK), 
	APPLICATION        = auto_cast (Scancode.APPLICATION | SCANCODE_MASK), 
	POWER              = auto_cast (Scancode.POWER | SCANCODE_MASK), 
	KP_EQUALS          = auto_cast (Scancode.KP_EQUALS | SCANCODE_MASK), 
	F13                = auto_cast (Scancode.F13 | SCANCODE_MASK), 
	F14                = auto_cast (Scancode.F14 | SCANCODE_MASK), 
	F15                = auto_cast (Scancode.F15 | SCANCODE_MASK), 
	F16                = auto_cast (Scancode.F16 | SCANCODE_MASK), 
	F17                = auto_cast (Scancode.F17 | SCANCODE_MASK), 
	F18                = auto_cast (Scancode.F18 | SCANCODE_MASK), 
	F19                = auto_cast (Scancode.F19 | SCANCODE_MASK), 
	F20                = auto_cast (Scancode.F20 | SCANCODE_MASK), 
	F21                = auto_cast (Scancode.F21 | SCANCODE_MASK), 
	F22                = auto_cast (Scancode.F22 | SCANCODE_MASK), 
	F23                = auto_cast (Scancode.F23 | SCANCODE_MASK), 
	F24                = auto_cast (Scancode.F24 | SCANCODE_MASK), 
	EXECUTE            = auto_cast (Scancode.EXECUTE | SCANCODE_MASK), 
	HELP               = auto_cast (Scancode.HELP | SCANCODE_MASK), 
	MENU               = auto_cast (Scancode.MENU | SCANCODE_MASK), 
	SELECT             = auto_cast (Scancode.SELECT | SCANCODE_MASK), 
	STOP               = auto_cast (Scancode.STOP | SCANCODE_MASK), 
	AGAIN              = auto_cast (Scancode.AGAIN | SCANCODE_MASK), 
	UNDO               = auto_cast (Scancode.UNDO | SCANCODE_MASK), 
	CUT                = auto_cast (Scancode.CUT | SCANCODE_MASK), 
	COPY               = auto_cast (Scancode.COPY | SCANCODE_MASK), 
	PASTE              = auto_cast (Scancode.PASTE | SCANCODE_MASK), 
	FIND               = auto_cast (Scancode.FIND | SCANCODE_MASK), 
	MUTE               = auto_cast (Scancode.MUTE | SCANCODE_MASK), 
	VOLUMEUP           = auto_cast (Scancode.VOLUMEUP | SCANCODE_MASK), 
	VOLUMEDOWN         = auto_cast (Scancode.VOLUMEDOWN | SCANCODE_MASK), 
	KP_COMMA           = auto_cast (Scancode.KP_COMMA | SCANCODE_MASK), 
	KP_EQUALSAS400     = auto_cast (Scancode.KP_EQUALSAS400 | SCANCODE_MASK), 
	ALTERASE           = auto_cast (Scancode.ALTERASE | SCANCODE_MASK), 
	SYSREQ             = auto_cast (Scancode.SYSREQ | SCANCODE_MASK), 
	CANCEL             = auto_cast (Scancode.CANCEL | SCANCODE_MASK), 
	CLEAR              = auto_cast (Scancode.CLEAR | SCANCODE_MASK), 
	PRIOR              = auto_cast (Scancode.PRIOR | SCANCODE_MASK), 
	RETURN2            = auto_cast (Scancode.RETURN2 | SCANCODE_MASK), 
	SEPARATOR          = auto_cast (Scancode.SEPARATOR | SCANCODE_MASK), 
	OUT                = auto_cast (Scancode.OUT | SCANCODE_MASK), 
	OPER               = auto_cast (Scancode.OPER | SCANCODE_MASK), 
	CLEARAGAIN         = auto_cast (Scancode.CLEARAGAIN | SCANCODE_MASK), 
	CRSEL              = auto_cast (Scancode.CRSEL | SCANCODE_MASK), 
	EXSEL              = auto_cast (Scancode.EXSEL | SCANCODE_MASK), 
	KP_00              = auto_cast (Scancode.KP_00 | SCANCODE_MASK), 
	KP_000             = auto_cast (Scancode.KP_000 | SCANCODE_MASK), 
	THOUSANDSSEPARATOR = auto_cast (Scancode.THOUSANDSSEPARATOR | SCANCODE_MASK), 
	DECIMALSEPARATOR   = auto_cast (Scancode.DECIMALSEPARATOR | SCANCODE_MASK), 
	CURRENCYUNIT       = auto_cast (Scancode.CURRENCYUNIT | SCANCODE_MASK), 
	CURRENCYSUBUNIT    = auto_cast (Scancode.CURRENCYSUBUNIT | SCANCODE_MASK), 
	KP_LEFTPAREN       = auto_cast (Scancode.KP_LEFTPAREN | SCANCODE_MASK), 
	KP_RIGHTPAREN      = auto_cast (Scancode.KP_RIGHTPAREN | SCANCODE_MASK), 
	KP_LEFTBRACE       = auto_cast (Scancode.KP_LEFTBRACE | SCANCODE_MASK), 
	KP_RIGHTBRACE      = auto_cast (Scancode.KP_RIGHTBRACE | SCANCODE_MASK), 
	KP_TAB             = auto_cast (Scancode.KP_TAB | SCANCODE_MASK), 
	KP_BACKSPACE       = auto_cast (Scancode.KP_BACKSPACE | SCANCODE_MASK), 
	KP_A               = auto_cast (Scancode.KP_A | SCANCODE_MASK), 
	KP_B               = auto_cast (Scancode.KP_B | SCANCODE_MASK), 
	KP_C               = auto_cast (Scancode.KP_C | SCANCODE_MASK), 
	KP_D               = auto_cast (Scancode.KP_D | SCANCODE_MASK), 
	KP_E               = auto_cast (Scancode.KP_E | SCANCODE_MASK), 
	KP_F               = auto_cast (Scancode.KP_F | SCANCODE_MASK), 
	KP_XOR             = auto_cast (Scancode.KP_XOR | SCANCODE_MASK), 
	KP_POWER           = auto_cast (Scancode.KP_POWER | SCANCODE_MASK), 
	KP_PERCENT         = auto_cast (Scancode.KP_PERCENT | SCANCODE_MASK), 
	KP_LESS            = auto_cast (Scancode.KP_LESS | SCANCODE_MASK), 
	KP_GREATER         = auto_cast (Scancode.KP_GREATER | SCANCODE_MASK), 
	KP_AMPERSAND       = auto_cast (Scancode.KP_AMPERSAND | SCANCODE_MASK), 
	KP_DBLAMPERSAND    = auto_cast (Scancode.KP_DBLAMPERSAND | SCANCODE_MASK), 
	KP_VERTICALBAR     = auto_cast (Scancode.KP_VERTICALBAR | SCANCODE_MASK), 
	KP_DBLVERTICALBAR  = auto_cast (Scancode.KP_DBLVERTICALBAR | SCANCODE_MASK), 
	KP_COLON           = auto_cast (Scancode.KP_COLON | SCANCODE_MASK), 
	KP_HASH            = auto_cast (Scancode.KP_HASH | SCANCODE_MASK), 
	KP_SPACE           = auto_cast (Scancode.KP_SPACE | SCANCODE_MASK), 
	KP_AT              = auto_cast (Scancode.KP_AT | SCANCODE_MASK), 
	KP_EXCLAM          = auto_cast (Scancode.KP_EXCLAM | SCANCODE_MASK), 
	KP_MEMSTORE        = auto_cast (Scancode.KP_MEMSTORE | SCANCODE_MASK), 
	KP_MEMRECALL       = auto_cast (Scancode.KP_MEMRECALL | SCANCODE_MASK), 
	KP_MEMCLEAR        = auto_cast (Scancode.KP_MEMCLEAR | SCANCODE_MASK), 
	KP_MEMADD          = auto_cast (Scancode.KP_MEMADD | SCANCODE_MASK), 
	KP_MEMSUBTRACT     = auto_cast (Scancode.KP_MEMSUBTRACT | SCANCODE_MASK), 
	KP_MEMMULTIPLY     = auto_cast (Scancode.KP_MEMMULTIPLY | SCANCODE_MASK), 
	KP_MEMDIVIDE       = auto_cast (Scancode.KP_MEMDIVIDE | SCANCODE_MASK), 
	KP_PLUSMINUS       = auto_cast (Scancode.KP_PLUSMINUS | SCANCODE_MASK), 
	KP_CLEAR           = auto_cast (Scancode.KP_CLEAR | SCANCODE_MASK), 
	KP_CLEARENTRY      = auto_cast (Scancode.KP_CLEARENTRY | SCANCODE_MASK), 
	KP_BINARY          = auto_cast (Scancode.KP_BINARY | SCANCODE_MASK), 
	KP_OCTAL           = auto_cast (Scancode.KP_OCTAL | SCANCODE_MASK), 
	KP_DECIMAL         = auto_cast (Scancode.KP_DECIMAL | SCANCODE_MASK), 
	KP_HEXADECIMAL     = auto_cast (Scancode.KP_HEXADECIMAL | SCANCODE_MASK), 
	LCTRL              = auto_cast (Scancode.LCTRL | SCANCODE_MASK), 
	LSHIFT             = auto_cast (Scancode.LSHIFT | SCANCODE_MASK), 
	LALT               = auto_cast (Scancode.LALT | SCANCODE_MASK), 
	LGUI               = auto_cast (Scancode.LGUI | SCANCODE_MASK), 
	RCTRL              = auto_cast (Scancode.RCTRL | SCANCODE_MASK), 
	RSHIFT             = auto_cast (Scancode.RSHIFT | SCANCODE_MASK), 
	RALT               = auto_cast (Scancode.RALT | SCANCODE_MASK), 
	RGUI               = auto_cast (Scancode.RGUI | SCANCODE_MASK), 
	MODE               = auto_cast (Scancode.MODE | SCANCODE_MASK), 
	AUDIONEXT          = auto_cast (Scancode.AUDIONEXT | SCANCODE_MASK), 
	AUDIOPREV          = auto_cast (Scancode.AUDIOPREV | SCANCODE_MASK), 
	AUDIOSTOP          = auto_cast (Scancode.AUDIOSTOP | SCANCODE_MASK), 
	AUDIOPLAY          = auto_cast (Scancode.AUDIOPLAY | SCANCODE_MASK), 
	AUDIOMUTE          = auto_cast (Scancode.AUDIOMUTE | SCANCODE_MASK), 
	MEDIASELECT        = auto_cast (Scancode.MEDIASELECT | SCANCODE_MASK), 
	WWW                = auto_cast (Scancode.WWW | SCANCODE_MASK), 
	MAIL               = auto_cast (Scancode.MAIL | SCANCODE_MASK), 
	CALCULATOR         = auto_cast (Scancode.CALCULATOR | SCANCODE_MASK), 
	COMPUTER           = auto_cast (Scancode.COMPUTER | SCANCODE_MASK), 
	AC_SEARCH          = auto_cast (Scancode.AC_SEARCH | SCANCODE_MASK), 
	AC_HOME            = auto_cast (Scancode.AC_HOME | SCANCODE_MASK), 
	AC_BACK            = auto_cast (Scancode.AC_BACK | SCANCODE_MASK), 
	AC_FORWARD         = auto_cast (Scancode.AC_FORWARD | SCANCODE_MASK), 
	AC_STOP            = auto_cast (Scancode.AC_STOP | SCANCODE_MASK), 
	AC_REFRESH         = auto_cast (Scancode.AC_REFRESH | SCANCODE_MASK), 
	AC_BOOKMARKS       = auto_cast (Scancode.AC_BOOKMARKS | SCANCODE_MASK), 
	BRIGHTNESSDOWN     = auto_cast (Scancode.BRIGHTNESSDOWN | SCANCODE_MASK), 
	BRIGHTNESSUP       = auto_cast (Scancode.BRIGHTNESSUP | SCANCODE_MASK), 
	DISPLAYSWITCH      = auto_cast (Scancode.DISPLAYSWITCH | SCANCODE_MASK), 
	KBDILLUMTOGGLE     = auto_cast (Scancode.KBDILLUMTOGGLE | SCANCODE_MASK), 
	KBDILLUMDOWN       = auto_cast (Scancode.KBDILLUMDOWN | SCANCODE_MASK), 
	KBDILLUMUP         = auto_cast (Scancode.KBDILLUMUP | SCANCODE_MASK), 
	EJECT              = auto_cast (Scancode.EJECT | SCANCODE_MASK), 
	SLEEP              = auto_cast (Scancode.SLEEP | SCANCODE_MASK), 
	APP1               = auto_cast (Scancode.APP1 | SCANCODE_MASK), 
	APP2               = auto_cast (Scancode.APP2 | SCANCODE_MASK), 
	AUDIOREWIND        = auto_cast (Scancode.AUDIOREWIND | SCANCODE_MASK), 
	AUDIOFASTFORWARD   = auto_cast (Scancode.AUDIOFASTFORWARD | SCANCODE_MASK), 
	SOFTLEFT           = auto_cast (Scancode.SOFTLEFT | SCANCODE_MASK), 
	SOFTRIGHT          = auto_cast (Scancode.SOFTRIGHT | SCANCODE_MASK), 
	CALL               = auto_cast (Scancode.CALL | SCANCODE_MASK), 
	ENDCALL            = auto_cast (Scancode.ENDCALL | SCANCODE_MASK), 
}

Keymod :: distinct bit_set[KeymodFlag; u16]

KeymodFlag :: enum u16 {
	LSHIFT = 0x0, 
	RSHIFT = 0x1, 
	LCTRL  = 0x6, 
	RCTRL  = 0x7, 
	LALT   = 0x8, 
	RALT   = 0x9, 
	LGUI   = 0xa, 
	RGUI   = 0xb, 
	NUM    = 0xc, 
	CAPS   = 0xd, 
	MODE   = 0xe, 
	SCROLL = 0xf, 
}

Keysym :: struct {
	scancode: Scancode,
	// *< SDL physical key code - see ::SDL_Scancode for details 
	sym:      Keycode,
	// *< SDL virtual key code - see ::SDL_Keycode for details 
	mod:      Keymod,
	// *< current key modifiers 
	unused:   u32,
}

Locale :: struct {
	language: cstring,
	// *< A language name, like "en" for English. 
	country:  cstring,
}

LogCategory :: enum i32 {
	APPLICATION, 
	ERROR, 
	ASSERT, 
	SYSTEM, 
	AUDIO, 
	VIDEO, 
	RENDER, 
	INPUT, 
	TEST, 
	// Reserved for future SDL library use 
	RESERVED1, 
	RESERVED2, 
	RESERVED3, 
	RESERVED4, 
	RESERVED5, 
	RESERVED6, 
	RESERVED7, 
	RESERVED8, 
	RESERVED9, 
	RESERVED10, 
	// Beyond this point is reserved for application use, e.g.
	// 	enum {
	// 		MYAPP_CATEGORY_AWESOME1 = SDL_LOG_CATEGORY_CUSTOM,
	// 		MYAPP_CATEGORY_AWESOME2,
	// 		MYAPP_CATEGORY_AWESOME3,
	// 		...
	// 	};
	CUSTOM, 
}

LogOutputFunction :: proc "c" (userdata: rawptr, category: LogCategory, priority: LogPriority, message: cstring)

LogPriority :: enum i32 {
	DEFAULT  = 0, // CUSTOM ONE
	VERBOSE  = 1, 
	DEBUG, 
	INFO, 
	WARN, 
	ERROR, 
	CRITICAL, 
	NUM, 
}

MessageBoxButtonData :: struct {
	flags:    MessageBoxButtonFlags,
	// *< ::SDL_MessageBoxButtonFlags 
	buttonid: i32,
	// *< User defined button id (value returned via SDL_ShowMessageBox) 
	text:     cstring,
}

MessageBoxButtonFlag :: enum u32 {
	RETURNKEY_DEFAULT = 0, // *< Marks the default button when return is hit
	ESCAPEKEY_DEFAULT = 1, // *< Marks the default button when escape is hit
}

MessageBoxButtonFlags :: distinct bit_set[MessageBoxButtonFlag; u32]

MessageBoxColor :: struct {
	r: u8,
	g: u8,
	b: u8,
}

MessageBoxColorScheme :: struct {
	colors: [MessageBoxColorType]MessageBoxColor,
}

MessageBoxColorType :: enum i32 {
	BACKGROUND, 
	TEXT, 
	BUTTON_BORDER, 
	BUTTON_BACKGROUND, 
	BUTTON_SELECTED, 
}

MessageBoxData :: struct {
	flags:       MessageBoxFlags,
	// *< ::SDL_MessageBoxFlags 
	window:      ^Window,
	// *< Parent window, can be NULL 
	title:       cstring,
	// *< UTF-8 title 
	message:     cstring,
	// *< UTF-8 message text 
	numbuttons:  i32,
	buttons:     [^]MessageBoxButtonData,
	colorScheme: ^MessageBoxColorScheme,
}

MessageBoxFlag :: enum u32 {
	ERROR                 = 4, // *< error dialog
	WARNING               = 5, // *< warning dialog
	INFORMATION           = 6, // *< informational dialog
	BUTTONS_LEFT_TO_RIGHT = 7, // *< buttons placed left to right
	BUTTONS_RIGHT_TO_LEFT = 8, // *< buttons placed right to left
}

MessageBoxFlags :: distinct bit_set[MessageBoxFlag; u32]

MetalView :: distinct rawptr

MouseButtonEvent :: struct {
	type:      EventType,
	// *< ::SDL_MOUSEBUTTONDOWN or ::SDL_MOUSEBUTTONUP 
	timestamp: u32,
	// *< In milliseconds, populated using SDL_GetTicks() 
	windowID:  u32,
	// *< The window with mouse focus, if any 
	which:     u32,
	// *< The mouse instance id, or SDL_TOUCH_MOUSEID 
	button:    u8,
	// *< The mouse button index 
	state:     u8,
	// *< ::SDL_PRESSED or ::SDL_RELEASED 
	clicks:    u8,
	// *< 1 for single-click, 2 for double-click, etc. 
	_:         u8,
	x:         i32,
	// *< X coordinate, relative to window 
	y:         i32,
}

MouseMotionEvent :: struct {
	type:      EventType,
	// *< ::SDL_MOUSEMOTION 
	timestamp: u32,
	// *< In milliseconds, populated using SDL_GetTicks() 
	windowID:  u32,
	// *< The window with mouse focus, if any 
	which:     u32,
	// *< The mouse instance id, or SDL_TOUCH_MOUSEID 
	state:     u32,
	// *< The current button state 
	x:         i32,
	// *< X coordinate, relative to window 
	y:         i32,
	// *< Y coordinate, relative to window 
	xrel:      i32,
	// *< The relative motion in the X direction 
	yrel:      i32,
}

MouseWheelDirection :: enum i32 {
	NORMAL,  // *< The scroll direction is normal
	FLIPPED, // *< The scroll direction is flipped / natural
}

MouseWheelEvent :: struct {
	type:      EventType,
	// *< ::SDL_MOUSEWHEEL 
	timestamp: u32,
	// *< In milliseconds, populated using SDL_GetTicks() 
	windowID:  u32,
	// *< The window with mouse focus, if any 
	which:     u32,
	// *< The mouse instance id, or SDL_TOUCH_MOUSEID 
	x:         i32,
	// *< The amount scrolled horizontally, positive to the right and negative to the left 
	y:         i32,
	// *< The amount scrolled vertically, positive away from the user and negative toward the user 
	direction: u32,
	// *< Set to one of the SDL_MOUSEWHEEL_* defines. When FLIPPED the values in X and Y will be opposite. Multiply by -1 to change them back 
	preciseX:  f32,
	// *< The amount scrolled horizontally, positive to the right and negative to the left, with float precision (added in 2.0.18) 
	preciseY:  f32,
	// *< The amount scrolled vertically, positive away from the user and negative toward the user, with float precision (added in 2.0.18) 
	mouseX:    i32,
	// *< X coordinate, relative to window (added in 2.26.0) 
	mouseY:    i32,
}

MultiGestureEvent :: struct {
	type:       EventType,
	// *< ::SDL_MULTIGESTURE 
	timestamp:  u32,
	// *< In milliseconds, populated using SDL_GetTicks() 
	touchId:    TouchID,
	// *< The touch device id 
	dTheta:     f32,
	dDist:      f32,
	x:          f32,
	y:          f32,
	numFingers: u16,
	padding:    u16,
}

OSEvent :: struct {
	type:      EventType,
	timestamp: u32,
}

Palette :: struct {
	ncolors:  i32,
	colors:   ^Color,
	version:  u32,
	refcount: i32,
}

PixelFormat :: struct {
	format:        u32,
	palette:       ^Palette,
	BitsPerPixel:  u8,
	BytesPerPixel: u8,
	padding:       [2]u8,
	Rmask:         u32,
	Gmask:         u32,
	Bmask:         u32,
	Amask:         u32,
	Rloss:         u8,
	Gloss:         u8,
	Bloss:         u8,
	Aloss:         u8,
	Rshift:        u8,
	Gshift:        u8,
	Bshift:        u8,
	Ashift:        u8,
	refcount:      i32,
	next:          ^PixelFormat,
}

PixelFormatEnum :: enum u32 {
	UNKNOWN      = 0, 
	INDEX1LSB    = 1 << 28 | PIXELTYPE_INDEX1 << 24 | BITMAPORDER_4321 << 20 | 0 << 16 | 1 << 8 | 0 << 0, 
	INDEX1MSB    = 1 << 28 | PIXELTYPE_INDEX1 << 24 | BITMAPORDER_1234 << 20 | 0 << 16 | 1 << 8 | 0 << 0, 
	INDEX2LSB    = 1 << 28 | PIXELTYPE_INDEX2 << 24 | BITMAPORDER_4321 << 20 | 0 << 16 | 2 << 8 | 0 << 0, 
	INDEX2MSB    = 1 << 28 | PIXELTYPE_INDEX2 << 24 | BITMAPORDER_1234 << 20 | 0 << 16 | 2 << 8 | 0 << 0, 
	INDEX4LSB    = 1 << 28 | PIXELTYPE_INDEX4 << 24 | BITMAPORDER_4321 << 20 | 0 << 16 | 4 << 8 | 0 << 0, 
	INDEX4MSB    = 1 << 28 | PIXELTYPE_INDEX4 << 24 | BITMAPORDER_1234 << 20 | 0 << 16 | 4 << 8 | 0 << 0, 
	INDEX8       = 1 << 28 | PIXELTYPE_INDEX8 << 24 | 0 << 20 | 0 << 16 | 8 << 8 | 1 << 0, 
	RGB332       = 1 << 28 | PIXELTYPE_PACKED8 << 24 | PACKEDORDER_XRGB << 20 | PACKEDLAYOUT_332 << 16 | 8 << 8 | 1 << 0, 
	XRGB4444     = 1 << 28 | PIXELTYPE_PACKED16 << 24 | PACKEDORDER_XRGB << 20 | PACKEDLAYOUT_4444 << 16 | 12 << 8 | 2 << 0, 
	RGB444       = XRGB4444, 
	XBGR4444     = 1 << 28 | PIXELTYPE_PACKED16 << 24 | PACKEDORDER_XBGR << 20 | PACKEDLAYOUT_4444 << 16 | 12 << 8 | 2 << 0, 
	BGR444       = XBGR4444, 
	XRGB1555     = 1 << 28 | PIXELTYPE_PACKED16 << 24 | PACKEDORDER_XRGB << 20 | PACKEDLAYOUT_1555 << 16 | 15 << 8 | 2 << 0, 
	RGB555       = XRGB1555, 
	XBGR1555     = 1 << 28 | PIXELTYPE_PACKED16 << 24 | PACKEDORDER_XBGR << 20 | PACKEDLAYOUT_1555 << 16 | 15 << 8 | 2 << 0, 
	BGR555       = XBGR1555, 
	ARGB4444     = 1 << 28 | PIXELTYPE_PACKED16 << 24 | PACKEDORDER_ARGB << 20 | PACKEDLAYOUT_4444 << 16 | 16 << 8 | 2 << 0, 
	RGBA4444     = 1 << 28 | PIXELTYPE_PACKED16 << 24 | PACKEDORDER_RGBA << 20 | PACKEDLAYOUT_4444 << 16 | 16 << 8 | 2 << 0, 
	ABGR4444     = 1 << 28 | PIXELTYPE_PACKED16 << 24 | PACKEDORDER_ABGR << 20 | PACKEDLAYOUT_4444 << 16 | 16 << 8 | 2 << 0, 
	BGRA4444     = 1 << 28 | PIXELTYPE_PACKED16 << 24 | PACKEDORDER_BGRA << 20 | PACKEDLAYOUT_4444 << 16 | 16 << 8 | 2 << 0, 
	ARGB1555     = 1 << 28 | PIXELTYPE_PACKED16 << 24 | PACKEDORDER_ARGB << 20 | PACKEDLAYOUT_1555 << 16 | 16 << 8 | 2 << 0, 
	RGBA5551     = 1 << 28 | PIXELTYPE_PACKED16 << 24 | PACKEDORDER_RGBA << 20 | PACKEDLAYOUT_5551 << 16 | 16 << 8 | 2 << 0, 
	ABGR1555     = 1 << 28 | PIXELTYPE_PACKED16 << 24 | PACKEDORDER_ABGR << 20 | PACKEDLAYOUT_1555 << 16 | 16 << 8 | 2 << 0, 
	BGRA5551     = 1 << 28 | PIXELTYPE_PACKED16 << 24 | PACKEDORDER_BGRA << 20 | PACKEDLAYOUT_5551 << 16 | 16 << 8 | 2 << 0, 
	RGB565       = 1 << 28 | PIXELTYPE_PACKED16 << 24 | PACKEDORDER_XRGB << 20 | PACKEDLAYOUT_565 << 16 | 16 << 8 | 2 << 0, 
	BGR565       = 1 << 28 | PIXELTYPE_PACKED16 << 24 | PACKEDORDER_XBGR << 20 | PACKEDLAYOUT_565 << 16 | 16 << 8 | 2 << 0, 
	RGB24        = 1 << 28 | PIXELTYPE_ARRAYU8 << 24 | ARRAYORDER_RGB << 20 | 0 << 16 | 24 << 8 | 3 << 0, 
	BGR24        = 1 << 28 | PIXELTYPE_ARRAYU8 << 24 | ARRAYORDER_BGR << 20 | 0 << 16 | 24 << 8 | 3 << 0, 
	XRGB8888     = 1 << 28 | PIXELTYPE_PACKED32 << 24 | PACKEDORDER_XRGB << 20 | PACKEDLAYOUT_8888 << 16 | 24 << 8 | 4 << 0, 
	RGB888       = XRGB8888, 
	RGBX8888     = 1 << 28 | PIXELTYPE_PACKED32 << 24 | PACKEDORDER_RGBX << 20 | PACKEDLAYOUT_8888 << 16 | 24 << 8 | 4 << 0, 
	XBGR8888     = 1 << 28 | PIXELTYPE_PACKED32 << 24 | PACKEDORDER_XBGR << 20 | PACKEDLAYOUT_8888 << 16 | 24 << 8 | 4 << 0, 
	BGR888       = XBGR8888, 
	BGRX8888     = 1 << 28 | PIXELTYPE_PACKED32 << 24 | PACKEDORDER_BGRX << 20 | PACKEDLAYOUT_8888 << 16 | 24 << 8 | 4 << 0, 
	ARGB8888     = 1 << 28 | PIXELTYPE_PACKED32 << 24 | PACKEDORDER_ARGB << 20 | PACKEDLAYOUT_8888 << 16 | 32 << 8 | 4 << 0, 
	RGBA8888     = 1 << 28 | PIXELTYPE_PACKED32 << 24 | PACKEDORDER_RGBA << 20 | PACKEDLAYOUT_8888 << 16 | 32 << 8 | 4 << 0, 
	ABGR8888     = 1 << 28 | PIXELTYPE_PACKED32 << 24 | PACKEDORDER_ABGR << 20 | PACKEDLAYOUT_8888 << 16 | 32 << 8 | 4 << 0, 
	BGRA8888     = 1 << 28 | PIXELTYPE_PACKED32 << 24 | PACKEDORDER_BGRA << 20 | PACKEDLAYOUT_8888 << 16 | 32 << 8 | 4 << 0, 
	ARGB2101010  = 1 << 28 | PIXELTYPE_PACKED32 << 24 | PACKEDORDER_ARGB << 20 | PACKEDLAYOUT_2101010 << 16 | 32 << 8 | 4 << 0, 
	// Aliases for RGBA byte arrays of color data, for the current platform 
	RGBA32       = RGBA8888 when ODIN_ENDIAN == .Big else ABGR8888, 
	ARGB32       = ARGB8888 when ODIN_ENDIAN == .Big else BGRA8888, 
	BGRA32       = BGRA8888 when ODIN_ENDIAN == .Big else ARGB8888, 
	ABGR32       = ABGR8888 when ODIN_ENDIAN == .Big else RGBA8888, 
	RGBX32       = RGBX8888 when ODIN_ENDIAN == .Big else XBGR8888, 
	XRGB32       = XRGB8888 when ODIN_ENDIAN == .Big else BGRX8888, 
	BGRX32       = BGRX8888 when ODIN_ENDIAN == .Big else XRGB8888, 
	XBGR32       = XBGR8888 when ODIN_ENDIAN == .Big else RGBX8888, 
	YV12         = 'Y' << 0 | 'V' << 8 | '1' << 16 | '2' << 24, 
	IYUV         = 'I' << 0 | 'Y' << 8 | 'U' << 16 | 'V' << 24, 
	YUY2         = 'Y' << 0 | 'U' << 8 | 'Y' << 16 | '2' << 24, 
	UYVY         = 'U' << 0 | 'Y' << 8 | 'V' << 16 | 'Y' << 24, 
	YVYU         = 'Y' << 0 | 'V' << 8 | 'Y' << 16 | 'U' << 24, 
	NV12         = 'N' << 0 | 'V' << 8 | '1' << 16 | '2' << 24, 
	NV21         = 'N' << 0 | 'V' << 8 | '2' << 16 | '1' << 24, 
	EXTERNAL_OES = 'O' << 0 | 'E' << 8 | 'S' << 16 | ' ' << 24, 
}

Point :: struct {
	x: i32,
	y: i32,
}

PowerState :: enum i32 {
	UNKNOWN,    // *< cannot determine power status
	ON_BATTERY, // *< Not plugged in, running on the battery
	NO_BATTERY, // *< Plugged in, no battery available
	CHARGING,   // *< Plugged in, charging battery
	CHARGED,    // *< Plugged in, battery charged
}

QuitEvent :: struct {
	type:      EventType,
	timestamp: u32,
}

RWops :: struct {
	size:   proc "c" (ctx: ^RWops) -> i64,
	seek:   proc "c" (ctx: ^RWops, offset: i64, whence: i32) -> i64,
	read:   proc "c" (ctx: ^RWops, ptr: rawptr, size: uint, maxnum: uint) -> uint,
	write:  proc "c" (ctx: ^RWops, ptr: rawptr, size: uint, num: uint) -> uint,
	close:  proc "c" (ctx: ^RWops) -> i32,
	type:   u32,
	hidden: struct #raw_union {
		androidio: struct {
			asset: rawptr,
		},
		windowsio: struct {
			append: bool,
			h:      rawptr,
			buffer: struct {
				data: rawptr,
				size: uint,
				left: uint,
			},
		},
		vitaio:    struct {
			h:      i32,
			buffer: struct {
				data: rawptr,
				size: uint,
				left: uint,
			},
		},
		stdio:     struct {
			autoclose: bool,
			fp:        rawptr,
		},
		mem:       struct {
			base: ^u8,
			here: ^u8,
			stop: ^u8,
		},
		unknown:   struct {
			data1: rawptr,
			data2: rawptr,
		},
	},
}

Rect :: struct {
	x: i32,
	y: i32,
	w: i32,
	h: i32,
}

Renderer :: struct {}