mirror of
https://github.com/odin-lang/Odin.git
synced 2026-06-15 14:53:43 +00:00
505 lines
21 KiB
Odin
505 lines
21 KiB
Odin
package sdl2
|
|
|
|
import "core:c"
|
|
|
|
when ODIN_OS == .Windows {
|
|
@(ignore_duplicates)
|
|
foreign import lib "SDL2.lib"
|
|
} else {
|
|
@(ignore_duplicates)
|
|
foreign import lib "system:SDL2"
|
|
}
|
|
|
|
RELEASED :: 0
|
|
PRESSED :: 1
|
|
|
|
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.
|
|
*/
|
|
|
|
/* 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 */
|
|
|
|
/* 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 */
|
|
|
|
/* 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 */
|
|
|
|
/** 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,
|
|
}
|
|
|
|
CommonEvent :: struct {
|
|
type: EventType,
|
|
timestamp: u32, /**< In milliseconds, populated using SDL_GetTicks() */
|
|
}
|
|
|
|
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, /**< event dependent data */
|
|
}
|
|
|
|
WindowEvent :: struct {
|
|
type: EventType, /**< ::SDL_WINDOWEVENT */
|
|
timestamp: u32, /**< In milliseconds, populated using SDL_GetTicks() */
|
|
windowID: u32, /**< The associated window */
|
|
event: WindowEventID, /**< ::SDL_WindowEventID */
|
|
_: u8,
|
|
_: u8,
|
|
_: u8,
|
|
data1: i32, /**< event dependent data */
|
|
data2: i32, /**< event dependent data */
|
|
}
|
|
|
|
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, /**< The key that was pressed or released */
|
|
}
|
|
|
|
TEXTEDITINGEVENT_TEXT_SIZE :: 32
|
|
TextEditingEvent :: struct {
|
|
type: EventType, /**< ::SDL_TEXTEDITING */
|
|
timestamp: u32, /**< In milliseconds, populated using SDL_GetTicks() */
|
|
windowID: u32, /**< The window with keyboard focus, if any */
|
|
text: [TEXTEDITINGEVENT_TEXT_SIZE]u8, /**< The editing text */
|
|
start: i32, /**< The start cursor of selected editing text */
|
|
length: i32, /**< The length of selected editing text */
|
|
}
|
|
|
|
|
|
TEXTINPUTEVENT_TEXT_SIZE :: 32
|
|
TextInputEvent :: struct {
|
|
type: EventType, /**< ::SDL_TEXTINPUT */
|
|
timestamp: u32, /**< In milliseconds, populated using SDL_GetTicks() */
|
|
windowID: u32, /**< The window with keyboard focus, if any */
|
|
text: [TEXTINPUTEVENT_TEXT_SIZE]u8, /**< The input text */
|
|
}
|
|
|
|
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, /**< The relative motion in the Y direction */
|
|
}
|
|
|
|
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, /**< Y coordinate, relative to window */
|
|
}
|
|
|
|
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 */
|
|
}
|
|
|
|
JoyAxisEvent :: struct {
|
|
type: EventType, /**< ::SDL_JOYAXISMOTION */
|
|
timestamp: u32, /**< In milliseconds, populated using SDL_GetTicks() */
|
|
which: JoystickID, /**< The joystick instance id */
|
|
axis: u8, /**< The joystick axis index */
|
|
_: 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, /**< The relative motion in the Y direction */
|
|
}
|
|
|
|
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,
|
|
}
|
|
|
|
JoyButtonEvent :: struct {
|
|
type: EventType, /**< ::SDL_JOYBUTTONDOWN or ::SDL_JOYBUTTONUP */
|
|
timestamp: u32, /**< In milliseconds, populated using SDL_GetTicks() */
|
|
which: JoystickID, /**< The joystick instance id */
|
|
button: u8, /**< The joystick button index */
|
|
state: u8, /**< ::SDL_PRESSED or ::SDL_RELEASED */
|
|
_: u8,
|
|
_: u8,
|
|
}
|
|
|
|
JoyDeviceEvent :: struct {
|
|
type: EventType, /**< ::SDL_JOYDEVICEADDED or ::SDL_JOYDEVICEREMOVED */
|
|
timestamp: u32, /**< In milliseconds, populated using SDL_GetTicks() */
|
|
which: i32, /**< The joystick device index for the ADDED event, instance id for the REMOVED event */
|
|
}
|
|
|
|
|
|
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, /**< The joystick device index for the ADDED event, instance id for the REMOVED or REMAPPED event */
|
|
}
|
|
|
|
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, /**< Normalized in the range 0...1 */
|
|
}
|
|
|
|
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 */
|
|
}
|
|
|
|
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,
|
|
}
|
|
|
|
|
|
TouchFingerEvent :: struct {
|
|
type: EventType, /**< ::SDL_FINGERMOTION or ::SDL_FINGERDOWN or ::SDL_FINGERUP */
|
|
timestamp: u32, /**< In milliseconds, populated using SDL_GetTicks() */
|
|
touchId: TouchID, /**< The touch device id */
|
|
fingerId: FingerID,
|
|
x: f32, /**< Normalized in the range 0...1 */
|
|
y: f32, /**< Normalized in the range 0...1 */
|
|
dx: f32, /**< Normalized in the range -1...1 */
|
|
dy: f32, /**< Normalized in the range -1...1 */
|
|
pressure: f32, /**< Normalized in the range 0...1 */
|
|
windowID: u32, /**< The window underneath the finger, if any */
|
|
}
|
|
|
|
|
|
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,
|
|
}
|
|
|
|
|
|
/**
|
|
* \brief Dollar Gesture Event (event.dgesture.*)
|
|
*/
|
|
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, /**< Normalized center of gesture */
|
|
}
|
|
|
|
|
|
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, /**< The window that was dropped on, if any */
|
|
}
|
|
|
|
|
|
SensorEvent :: struct {
|
|
type: EventType, /**< ::SDL_SENSORUPDATE */
|
|
timestamp: u32, /**< In milliseconds, populated using SDL_GetTicks() */
|
|
which: i32, /**< The instance ID of the sensor */
|
|
data: [6]f32, /**< Up to 6 values from the sensor - additional values can be queried using SDL_SensorGetData() */
|
|
}
|
|
|
|
QuitEvent :: struct {
|
|
type: EventType, /**< ::SDL_QUIT */
|
|
timestamp: u32, /**< In milliseconds, populated using SDL_GetTicks() */
|
|
}
|
|
|
|
OSEvent :: struct {
|
|
type: EventType, /**< ::SDL_QUIT */
|
|
timestamp: u32, /**< In milliseconds, populated using SDL_GetTicks() */
|
|
}
|
|
|
|
UserEvent :: struct {
|
|
type: EventType, /**< ::SDL_USEREVENT through ::SDL_LASTEVENT-1 */
|
|
timestamp: u32, /**< In milliseconds, populated using SDL_GetTicks() */
|
|
windowID: u32, /**< The associated window if any */
|
|
code: i32, /**< User defined event code */
|
|
data1: rawptr, /**< User defined data pointer */
|
|
data2: rawptr, /**< User defined data pointer */
|
|
}
|
|
|
|
|
|
SysWMEvent :: struct {
|
|
type: EventType, /**< ::SDL_SYSWMEVENT */
|
|
timestamp: u32, /**< In milliseconds, populated using SDL_GetTicks() */
|
|
msg: ^SysWMmsg, /**< driver dependent data, defined in SDL_syswm.h */
|
|
}
|
|
|
|
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 */
|
|
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 */
|
|
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 when size_of(rawptr) <= 8 else 64 when size_of(rawptr) == 16 else 3 * size_of(rawptr)]u8,
|
|
}
|
|
|
|
|
|
|
|
/* Make sure we haven't broken binary compatibility */
|
|
#assert(size_of(Event) == size_of(Event{}.padding))
|
|
|
|
|
|
|
|
eventaction :: enum c.int {
|
|
ADDEVENT,
|
|
PEEKEVENT,
|
|
GETEVENT,
|
|
}
|
|
|
|
EventFilter :: proc "c" (userdata: rawptr, event: ^Event) -> c.int
|
|
|
|
QUERY :: -1
|
|
IGNORE :: 0
|
|
DISABLE :: 0
|
|
ENABLE :: 1
|
|
|
|
|
|
GetEventState :: #force_inline proc "c" (type: EventType) -> b8 { return EventState(type, QUERY) }
|
|
|
|
|
|
@(default_calling_convention="c", link_prefix="SDL_")
|
|
foreign lib {
|
|
PumpEvents :: proc() ---
|
|
PeepEvents :: proc(events: [^]Event, numevents: c.int, action: eventaction, minType, maxType: EventType) -> c.int ---
|
|
HasEvent :: proc(type: EventType) -> bool ---
|
|
HasEvents :: proc(minType, maxType: EventType) -> bool ---
|
|
FlushEvent :: proc(type: EventType) ---
|
|
FlushEvents :: proc(minType, maxType: EventType) ---
|
|
PollEvent :: proc(event: ^Event) -> bool --- // original return value is c.int
|
|
WaitEvent :: proc(event: ^Event) -> bool --- // original return value is c.int
|
|
WaitEventTimeout :: proc(event: ^Event, timeout: c.int) -> bool --- // original return value is c.int
|
|
PushEvent :: proc(event: ^Event) -> bool --- // original return value is c.int
|
|
SetEventFilter :: proc(filter: EventFilter, userdata: rawptr) ---
|
|
GetEventFilter :: proc(filter: ^EventFilter, userdata: ^rawptr) -> bool ---
|
|
AddEventWatch :: proc(filter: EventFilter, userdata: rawptr) ---
|
|
DelEventWatch :: proc(filter: EventFilter, userdata: rawptr) ---
|
|
FilterEvents :: proc(filter: EventFilter, userdata: rawptr) ---
|
|
EventState :: proc(type: EventType, state: c.int) -> b8 --- // original return value is u8
|
|
RegisterEvents :: proc(numevents: c.int) -> u32 ---
|
|
}
|