sdl

const (
	AUDIO_MASK_BITSIZE  = C.SDL_AUDIO_MASK_BITSIZE  // (0xFF)
	AUDIO_MASK_DATATYPE = C.SDL_AUDIO_MASK_DATATYPE // (1<<8)
	AUDIO_MASK_ENDIAN   = C.SDL_AUDIO_MASK_ENDIAN   // (1<<12)
	AUDIO_MASK_SIGNED   = C.SDL_AUDIO_MASK_SIGNED   // (1<<15)
)

const (
	AUDIO_S8 = C.AUDIO_S8 // signed 8-bit samples
	AUDIO_U8 = C.AUDIO_U8 // unsigned 8-bit samples

	AUDIO_S16LSB = C.AUDIO_S16LSB // signed 16-bit samples in little-endian byte order
	AUDIO_S16MSB = C.AUDIO_S16MSB // signed 16-bit samples in big-endian byte order
	AUDIO_S16SYS = C.AUDIO_S16SYS // signed 16-bit samples in native byte order
	AUDIO_S16    = C.AUDIO_S16    // AUDIO_S16LSB
	AUDIO_U16LSB = C.AUDIO_U16LSB // unsigned 16-bit samples in little-endian byte order
	AUDIO_U16MSB = C.AUDIO_U16MSB // unsigned 16-bit samples in big-endian byte order
	AUDIO_U16SYS = C.AUDIO_U16SYS // unsigned 16-bit samples in native byte order
	AUDIO_U16    = C.AUDIO_U16    // AUDIO_U16LSB

	AUDIO_S32LSB = C.AUDIO_S32LSB // 32-bit integer samples in little-endian byte order
	AUDIO_S32MSB = C.AUDIO_S32MSB // 32-bit integer samples in big-endian byte order
	AUDIO_S32SYS = C.AUDIO_S32SYS // 32-bit integer samples in native byte order
	AUDIO_S32    = C.AUDIO_S32    // AUDIO_S32LSB

	AUDIO_F32LSB = C.AUDIO_F32LSB // 32-bit floating point samples in little-endian byte order
	AUDIO_F32MSB = C.AUDIO_F32MSB // 32-bit floating point samples in big-endian byte order
	AUDIO_F32SYS = C.AUDIO_F32SYS // 32-bit floating point samples in native byte order
	AUDIO_F32    = C.AUDIO_F32    // AUDIO_F32LSB
)

const (
	AUDIO_ALLOW_FREQUENCY_CHANGE = C.SDL_AUDIO_ALLOW_FREQUENCY_CHANGE
	AUDIO_ALLOW_FORMAT_CHANGE    = C.SDL_AUDIO_ALLOW_FORMAT_CHANGE
	AUDIO_ALLOW_CHANNELS_CHANGE  = C.SDL_AUDIO_ALLOW_CHANNELS_CHANGE
	AUDIO_ALLOW_ANY_CHANGE       = C.SDL_AUDIO_ALLOW_ANY_CHANGE
)

const (
	AUDIO_STOPPED AudioStatus = C.SDL_AUDIO_STOPPED // audio device is stopped
	AUDIO_PLAYING             = C.SDL_AUDIO_PLAYING // audio device is playing
	AUDIO_PAUSED              = C.SDL_AUDIO_PAUSED  // audio device is paused
)

const (
	BLENDMODE_NONE    = C.SDL_BLENDMODE_NONE  // no blending
	BLENDMODE_BLEND   = C.SDL_BLENDMODE_BLEND // alpha blending
	BLENDMODE_ADD     = C.SDL_BLENDMODE_ADD   // additive blending
	BLENDMODE_MOD     = C.SDL_BLENDMODE_MOD   // color modulate
	BLENDMODE_INVALID = C.SDL_BLENDMODE_INVALID
)

const (
	BLENDOPERATION_ADD          = C.SDL_BLENDOPERATION_ADD
	BLENDOPERATION_SUBTRACT     = C.SDL_BLENDOPERATION_SUBTRACT
	BLENDOPERATION_REV_SUBTRACT = C.SDL_BLENDOPERATION_REV_SUBTRACT
	BLENDOPERATION_MINIMUM      = C.SDL_BLENDOPERATION_MINIMUM
	BLENDOPERATION_MAXIMUM      = C.SDL_BLENDOPERATION_MAXIMUM
)

const (
	BLENDFACTOR_ZERO                = C.SDL_BLENDFACTOR_ZERO                // 0, 0, 0, 0
	BLENDFACTOR_ONE                 = C.SDL_BLENDFACTOR_ONE                 // 1, 1, 1, 1
	BLENDFACTOR_SRC_COLOR           = C.SDL_BLENDFACTOR_SRC_COLOR           // srcR, srcG, srcB, srcA
	BLENDFACTOR_ONE_MINUS_SRC_COLOR = C.SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR // 1-srcR, 1-srcG, 1-srcB, 1-srcA
	BLENDFACTOR_SRC_ALPHA           = C.SDL_BLENDFACTOR_SRC_ALPHA           // srcA, srcA, srcA, srcA
	BLENDFACTOR_ONE_MINUS_SRC_ALPHA = C.SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA // 1-srcA, 1-srcA, 1-srcA, 1-srcA
	BLENDFACTOR_DST_COLOR           = C.SDL_BLENDFACTOR_DST_COLOR           // dstR, dstG, dstB, dstA
	BLENDFACTOR_ONE_MINUS_DST_COLOR = C.SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR // 1-dstR, 1-dstG, 1-dstB, 1-dstA
	BLENDFACTOR_DST_ALPHA           = C.SDL_BLENDFACTOR_DST_ALPHA           // dstA, dstA, dstA, dstA
	BLENDFACTOR_ONE_MINUS_DST_ALPHA = C.SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA // 1-dstA, 1-dstA, 1-dstA, 1-dstA
)

const (
	BYTEORDER  = C.SDL_BYTEORDER  // macro that corresponds to the byte order used by the processor type it was compiled for
	LIL_ENDIAN = C.SDL_LIL_ENDIAN // byte order is 1234, where the least significant byte is stored first
	BIG_ENDIAN = C.SDL_BIG_ENDIAN // byte order is 4321, where the most significant byte is stored first
)

const (
	ENOMEM      ErrorCode = C.SDL_ENOMEM      // out of memory
	EFREAD                = C.SDL_EFREAD      // error reading from datastream
	EFWRITE               = C.SDL_EFWRITE     // error writing to datastream
	EFSEEK                = C.SDL_EFSEEK      // error seeking in datastream
	UNSUPPORTED           = C.SDL_UNSUPPORTED // that operation is not supported
	LASTERROR             = C.SDL_LASTERROR   // the highest numbered predefined error
)

const (
	FIRSTEVENT = C.SDL_FIRSTEVENT // do not remove (unused)

	// Application events
	QUIT = C.SDL_QUIT // user-requested quit

	// Android, iOS and WinRT events
	APP_TERMINATING         = C.SDL_APP_TERMINATING         // OS is terminating the application
	APP_LOWMEMORY           = C.SDL_APP_LOWMEMORY           // OS is low on memory; free some
	APP_WILLENTERBACKGROUND = C.SDL_APP_WILLENTERBACKGROUND // application is entering background
	APP_DIDENTERBACKGROUND  = C.SDL_APP_DIDENTERBACKGROUND  //application entered background
	APP_WILLENTERFOREGROUND = C.SDL_APP_WILLENTERFOREGROUND // application is entering foreground
	APP_DIDENTERFOREGROUND  = C.SDL_APP_DIDENTERFOREGROUND  // application entered foreground

	// Display events
	DISPLAYEVENT = C.SDL_DISPLAYEVENT // Display state change

	// Window events
	WINDOWEVENT = C.SDL_WINDOWEVENT // window state change
	SYSWMEVENT  = C.SDL_SYSWMEVENT  // system specific event

	// Keyboard events
	KEYDOWN         = C.SDL_KEYDOWN         // key pressed
	KEYUP           = C.SDL_KEYUP           // key released
	TEXTEDITING     = C.SDL_TEXTEDITING     // keyboard text editing (composition)
	TEXTINPUT       = C.SDL_TEXTINPUT       // keyboard text input
	TEXTEDITING_EXT = C.SDL_TEXTEDITING_EXT // keyboard text editing (composition)
	KEYMAPCHANGED   = C.SDL_KEYMAPCHANGED   // keymap changed due to a system event such as an input language or keyboard layout change (>= SDL 2.0.4)

	// Mouse events
	MOUSEMOTION     = C.SDL_MOUSEMOTION     // mouse moved
	MOUSEBUTTONDOWN = C.SDL_MOUSEBUTTONDOWN // mouse button pressed
	MOUSEBUTTONUP   = C.SDL_MOUSEBUTTONUP   // mouse button released
	MOUSEWHEEL      = C.SDL_MOUSEWHEEL      // mouse wheel motion

	// Joystick events
	JOYAXISMOTION    = C.SDL_JOYAXISMOTION    // joystick axis motion
	JOYBALLMOTION    = C.SDL_JOYBALLMOTION    // joystick trackball motion
	JOYHATMOTION     = C.SDL_JOYHATMOTION     // joystick hat position change
	JOYBUTTONDOWN    = C.SDL_JOYBUTTONDOWN    // joystick button pressed
	JOYBUTTONUP      = C.SDL_JOYBUTTONUP      // joystick button released
	JOYDEVICEADDED   = C.SDL_JOYDEVICEADDED   // joystick connected
	JOYDEVICEREMOVED = C.SDL_JOYDEVICEREMOVED // joystick disconnected

	// Game controller events
	CONTROLLERAXISMOTION     = C.SDL_CONTROLLERAXISMOTION     // controller axis motion
	CONTROLLERBUTTONDOWN     = C.SDL_CONTROLLERBUTTONDOWN     // controller button pressed
	CONTROLLERBUTTONUP       = C.SDL_CONTROLLERBUTTONUP       // controller button released
	CONTROLLERDEVICEADDED    = C.SDL_CONTROLLERDEVICEADDED    // controller connected
	CONTROLLERDEVICEREMOVED  = C.SDL_CONTROLLERDEVICEREMOVED  // controller disconnected
	CONTROLLERDEVICEREMAPPED = C.SDL_CONTROLLERDEVICEREMAPPED // controller mapping updated

	// Touch events
	FINGERDOWN   = C.SDL_FINGERDOWN   // user has touched input device
	FINGERUP     = C.SDL_FINGERUP     // user stopped touching input device
	FINGERMOTION = C.SDL_FINGERMOTION // user is dragging finger on input device

	// Gesture events
	DOLLARGESTURE = C.SDL_DOLLARGESTURE
	DOLLARRECORD  = C.SDL_DOLLARRECORD
	MULTIGESTURE  = C.SDL_MULTIGESTURE

	// Clipboard events
	CLIPBOARDUPDATE = C.SDL_CLIPBOARDUPDATE // the clipboard changed

	// Drag and drop events
	DROPFILE     = C.SDL_DROPFILE     // the system requests a file open
	DROPTEXT     = C.SDL_DROPTEXT     // text/plain drag-and-drop event
	DROPBEGIN    = C.SDL_DROPBEGIN    // a new set of drops is beginning (NULL filename)
	DROPCOMPLETE = C.SDL_DROPCOMPLETE // current set of drops is now complete (NULL filename)

	// Audio hotplug events
	AUDIODEVICEADDED   = C.SDL_AUDIODEVICEADDED   // a new audio device is available (>= SDL 2.0.4)
	AUDIODEVICEREMOVED = C.SDL_AUDIODEVICEREMOVED // an audio device has been removed (>= SDL 2.0.4)

	// Sensor events
	SENSORUPDATE = C.SDL_SENSORUPDATE // a sensor was updated

	// Render events
	RENDER_TARGETS_RESET = C.SDL_RENDER_TARGETS_RESET // the render targets have been reset and their contents need to be updated (>= SDL 2.0.2)
	RENDER_DEVICE_RESET  = C.SDL_RENDER_DEVICE_RESET  // the device has been reset and all textures need to be recreated (>= SDL 2.0.4)

	// These are for your use, and should be allocated with RegisterEvents()
	USEREVENT = C.SDL_USEREVENT // a user-specified event
	LASTEVENT = C.SDL_LASTEVENT // (only for bounding internal arrays)
)

const (
	ADDEVENT  = C.SDL_ADDEVENT  // up to numevents events will be added to the back of the event queue
	PEEKEVENT = C.SDL_PEEKEVENT // up to numevents events at the front of the event queue, within the specified minimum and maximum type, will be returned and will not be removed from the queue
	GETEVENT  = C.SDL_GETEVENT  // up to numevents events at the front of the event queue, within the specified minimum and maximum type, will be returned and will be removed from the queue
)

const (
	QUERY   = C.SDL_QUERY
	IGNORE  = C.SDL_IGNORE
	DISABLE = C.SDL_DISABLE
	ENABLE  = C.SDL_ENABLE
)

const (
	CONTROLLER_BINDTYPE_NONE   = C.SDL_CONTROLLER_BINDTYPE_NONE
	CONTROLLER_BINDTYPE_BUTTON = C.SDL_CONTROLLER_BINDTYPE_BUTTON
	CONTROLLER_BINDTYPE_AXIS   = C.SDL_CONTROLLER_BINDTYPE_AXIS
	CONTROLLER_BINDTYPE_HAT    = C.SDL_CONTROLLER_BINDTYPE_HAT
)

const (
	CONTROLLER_AXIS_INVALID      = C.SDL_CONTROLLER_AXIS_INVALID
	CONTROLLER_AXIS_LEFTX        = C.SDL_CONTROLLER_AXIS_LEFTX
	CONTROLLER_AXIS_LEFTY        = C.SDL_CONTROLLER_AXIS_LEFTY
	CONTROLLER_AXIS_RIGHTX       = C.SDL_CONTROLLER_AXIS_RIGHTX
	CONTROLLER_AXIS_RIGHTY       = C.SDL_CONTROLLER_AXIS_RIGHTY
	CONTROLLER_AXIS_TRIGGERLEFT  = C.SDL_CONTROLLER_AXIS_TRIGGERLEFT
	CONTROLLER_AXIS_TRIGGERRIGHT = C.SDL_CONTROLLER_AXIS_TRIGGERRIGHT
	CONTROLLER_AXIS_MAX          = C.SDL_CONTROLLER_AXIS_MAX
)

const (
	CONTROLLER_BUTTON_INVALID       = C.SDL_CONTROLLER_BUTTON_INVALID
	CONTROLLER_BUTTON_A             = C.SDL_CONTROLLER_BUTTON_A
	CONTROLLER_BUTTON_B             = C.SDL_CONTROLLER_BUTTON_B
	CONTROLLER_BUTTON_X             = C.SDL_CONTROLLER_BUTTON_X
	CONTROLLER_BUTTON_Y             = C.SDL_CONTROLLER_BUTTON_Y
	CONTROLLER_BUTTON_BACK          = C.SDL_CONTROLLER_BUTTON_BACK
	CONTROLLER_BUTTON_GUIDE         = C.SDL_CONTROLLER_BUTTON_GUIDE
	CONTROLLER_BUTTON_START         = C.SDL_CONTROLLER_BUTTON_START
	CONTROLLER_BUTTON_LEFTSTICK     = C.SDL_CONTROLLER_BUTTON_LEFTSTICK
	CONTROLLER_BUTTON_RIGHTSTICK    = C.SDL_CONTROLLER_BUTTON_RIGHTSTICK
	CONTROLLER_BUTTON_LEFTSHOULDER  = C.SDL_CONTROLLER_BUTTON_LEFTSHOULDER
	CONTROLLER_BUTTON_RIGHTSHOULDER = C.SDL_CONTROLLER_BUTTON_RIGHTSHOULDER
	CONTROLLER_BUTTON_DPAD_UP       = C.SDL_CONTROLLER_BUTTON_DPAD_UP
	CONTROLLER_BUTTON_DPAD_DOWN     = C.SDL_CONTROLLER_BUTTON_DPAD_DOWN
	CONTROLLER_BUTTON_DPAD_LEFT     = C.SDL_CONTROLLER_BUTTON_DPAD_LEFT
	CONTROLLER_BUTTON_DPAD_RIGHT    = C.SDL_CONTROLLER_BUTTON_DPAD_RIGHT
	CONTROLLER_BUTTON_MAX           = C.SDL_CONTROLLER_BUTTON_MAX
)

const (
	HAPTIC_CONSTANT     = C.SDL_HAPTIC_CONSTANT     // constant haptic effect
	HAPTIC_SINE         = C.SDL_HAPTIC_SINE         // periodic haptic effect that simulates sine waves
	HAPTIC_LEFTRIGHT    = C.SDL_HAPTIC_LEFTRIGHT    // haptic effect for direct control over high/low frequency motors
	HAPTIC_TRIANGLE     = C.SDL_HAPTIC_TRIANGLE     // periodic haptic effect that simulates triangular waves
	HAPTIC_SAWTOOTHUP   = C.SDL_HAPTIC_SAWTOOTHUP   // periodic haptic effect that simulates saw tooth up waves
	HAPTIC_SAWTOOTHDOWN = C.SDL_HAPTIC_SAWTOOTHDOWN // periodic haptic effect that simulates saw tooth down waves
	HAPTIC_RAMP         = C.SDL_HAPTIC_RAMP         // ramp haptic effect
	HAPTIC_SPRING       = C.SDL_HAPTIC_SPRING       // condition haptic effect that simulates a spring.  Effect is based on the axes position
	HAPTIC_DAMPER       = C.SDL_HAPTIC_DAMPER       // condition haptic effect that simulates dampening.  Effect is based on the axes velocity
	HAPTIC_INERTIA      = C.SDL_HAPTIC_INERTIA      // condition haptic effect that simulates inertia.  Effect is based on the axes acceleration
	HAPTIC_FRICTION     = C.SDL_HAPTIC_FRICTION     // condition haptic effect that simulates friction.  Effect is based on the axes movement
	HAPTIC_CUSTOM       = C.SDL_HAPTIC_CUSTOM       // user defined custom haptic effect
	HAPTIC_GAIN         = C.SDL_HAPTIC_GAIN         // device supports setting the global gain
	HAPTIC_AUTOCENTER   = C.SDL_HAPTIC_AUTOCENTER   // device supports setting autocenter
	HAPTIC_STATUS       = C.SDL_HAPTIC_STATUS       // device can be queried for effect status
	HAPTIC_PAUSE        = C.SDL_HAPTIC_PAUSE        // device can be paused

)

const (
	HAPTIC_POLAR     = C.SDL_HAPTIC_POLAR     // uses polar coordinates for the direction
	HAPTIC_CARTESIAN = C.SDL_HAPTIC_CARTESIAN // uses cartesian coordinates for the direction
	HAPTIC_SPHERICAL = C.SDL_HAPTIC_SPHERICAL // uses spherical coordinates for the direction
	HAPTIC_INFINITY  = C.SDL_HAPTIC_INFINITY  // used to play a device an infinite number of times
)

const (
	HINT_FRAMEBUFFER_ACCELERATION                 = C.SDL_HINT_FRAMEBUFFER_ACCELERATION                 // specifies how 3D acceleration is used with Window.GetSurface()
	HINT_RENDER_DRIVER                            = C.SDL_HINT_RENDER_DRIVER                            // specifies which render driver to use
	HINT_RENDER_OPENGL_SHADERS                    = C.SDL_HINT_RENDER_OPENGL_SHADERS                    // specifies whether the OpenGL render driver uses shaders
	HINT_RENDER_DIRECT3D_THREADSAFE               = C.SDL_HINT_RENDER_DIRECT3D_THREADSAFE               // specifies whether the Direct3D device is initialized for thread-safe operations
	HINT_RENDER_DIRECT3D11_DEBUG                  = C.SDL_HINT_RENDER_DIRECT3D11_DEBUG                  // specifies a variable controlling whether to enable Direct3D 11+'s Debug Layer
	HINT_RENDER_SCALE_QUALITY                     = C.SDL_HINT_RENDER_SCALE_QUALITY                     // specifies scaling quality
	HINT_RENDER_VSYNC                             = C.SDL_HINT_RENDER_VSYNC                             // specifies whether sync to vertical refresh is enabled or disabled in CreateRenderer() to avoid tearing
	HINT_VIDEO_ALLOW_SCREENSAVER                  = C.SDL_HINT_VIDEO_ALLOW_SCREENSAVER                  // specifies whether the screensaver is enabled
	HINT_VIDEO_X11_NET_WM_PING                    = C.SDL_HINT_VIDEO_X11_NET_WM_PING                    // specifies whether the X11 _NET_WM_PING protocol should be supported
	HINT_VIDEO_X11_XVIDMODE                       = C.SDL_HINT_VIDEO_X11_XVIDMODE                       // specifies whether the X11 VidMode extension should be used
	HINT_VIDEO_X11_XINERAMA                       = C.SDL_HINT_VIDEO_X11_XINERAMA                       // specifies whether the X11 Xinerama extension should be used
	HINT_VIDEO_X11_XRANDR                         = C.SDL_HINT_VIDEO_X11_XRANDR                         // specifies whether the X11 XRandR extension should be used
	HINT_GRAB_KEYBOARD                            = C.SDL_HINT_GRAB_KEYBOARD                            // specifies whether grabbing input grabs the keyboard
	HINT_MOUSE_DOUBLE_CLICK_TIME                  = C.SDL_HINT_MOUSE_DOUBLE_CLICK_TIME                  // specifies the double click time, in milliseconds
	HINT_MOUSE_DOUBLE_CLICK_RADIUS                = C.SDL_HINT_MOUSE_DOUBLE_CLICK_RADIUS                // specifies the double click radius, in pixels.
	HINT_MOUSE_RELATIVE_MODE_WARP                 = C.SDL_HINT_MOUSE_RELATIVE_MODE_WARP                 // specifies whether relative mouse mode is implemented using mouse warping
	HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS             = C.SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS             // specifies if a Window is minimized if it loses key focus when in fullscreen mode
	HINT_IDLE_TIMER_DISABLED                      = C.SDL_HINT_IDLE_TIMER_DISABLED                      // specifies a variable controlling whether the idle timer is disabled on iOS
	HINT_IME_INTERNAL_EDITING                     = C.SDL_HINT_IME_INTERNAL_EDITING                     // specifies whether certain IMEs should handle text editing internally instead of sending TextEditingEvents
	HINT_ORIENTATIONS                             = C.SDL_HINT_ORIENTATIONS                             // specifies a variable controlling which orientations are allowed on iOS
	HINT_ACCELEROMETER_AS_JOYSTICK                = C.SDL_HINT_ACCELEROMETER_AS_JOYSTICK                // specifies whether the Android / iOS built-in accelerometer should be listed as a joystick device, rather than listing actual joysticks only
	HINT_XINPUT_ENABLED                           = C.SDL_HINT_XINPUT_ENABLED                           // specifies if Xinput gamepad devices are detected
	HINT_XINPUT_USE_OLD_JOYSTICK_MAPPING          = C.SDL_HINT_XINPUT_USE_OLD_JOYSTICK_MAPPING          // specifies that SDL should use the old axis and button mapping for XInput devices
	HINT_GAMECONTROLLERCONFIG                     = C.SDL_HINT_GAMECONTROLLERCONFIG                     // specifies extra gamecontroller db entries
	HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS         = C.SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS         // specifies if joystick (and gamecontroller) events are enabled even when the application is in the background
	HINT_ALLOW_TOPMOST                            = C.SDL_HINT_ALLOW_TOPMOST                            // specifies if top most bit on an SDL Window can be set
	HINT_THREAD_STACK_SIZE                        = C.SDL_HINT_THREAD_STACK_SIZE                        // specifies a variable specifying SDL's threads stack size in bytes or "0" for the backend's default size
	HINT_TIMER_RESOLUTION                         = C.SDL_HINT_TIMER_RESOLUTION                         // specifies the timer resolution in milliseconds
	HINT_VIDEO_HIGHDPI_DISABLED                   = C.SDL_HINT_VIDEO_HIGHDPI_DISABLED                   // specifies if high-DPI windows ("Retina" on Mac and iOS) are not allowed
	HINT_MAC_BACKGROUND_APP                       = C.SDL_HINT_MAC_BACKGROUND_APP                       // specifies if the SDL app should not be forced to become a foreground process on Mac OS X
	HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK       = C.SDL_HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK       // specifies whether ctrl+click should generate a right-click event on Mac
	HINT_VIDEO_WIN_D3DCOMPILER                    = C.SDL_HINT_VIDEO_WIN_D3DCOMPILER                    // specifies which shader compiler to preload when using the Chrome ANGLE binaries
	HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT          = C.SDL_HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT          // specifies the address of another Window* (as a hex string formatted with "%p")
	HINT_WINRT_PRIVACY_POLICY_URL                 = C.SDL_HINT_WINRT_PRIVACY_POLICY_URL                 // specifies a URL to a WinRT app's privacy policy
	HINT_WINRT_PRIVACY_POLICY_LABEL               = C.SDL_HINT_WINRT_PRIVACY_POLICY_LABEL               // specifies a label text for a WinRT app's privacy policy link
	HINT_WINRT_HANDLE_BACK_BUTTON                 = C.SDL_HINT_WINRT_HANDLE_BACK_BUTTON                 // specifies a variable to allow back-button-press events on Windows Phone to be marked as handled
	HINT_VIDEO_MAC_FULLSCREEN_SPACES              = C.SDL_HINT_VIDEO_MAC_FULLSCREEN_SPACES              // specifies policy for fullscreen Spaces on Mac OS X
	HINT_NO_SIGNAL_HANDLERS                       = C.SDL_HINT_NO_SIGNAL_HANDLERS                       // specifies not to catch the SIGINT or SIGTERM signals
	HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN  = C.SDL_HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN  // specifies whether the window frame and title bar are interactive when the cursor is hidden
	HINT_WINDOWS_ENABLE_MESSAGELOOP               = C.SDL_HINT_WINDOWS_ENABLE_MESSAGELOOP               // specifies whether the windows message loop is processed by SDL
	HINT_WINDOWS_NO_CLOSE_ON_ALT_F4               = C.SDL_HINT_WINDOWS_NO_CLOSE_ON_ALT_F4               // specifies that SDL should not to generate WINDOWEVENT_CLOSE events for Alt+F4 on Microsoft Windows
	HINT_ANDROID_SEPARATE_MOUSE_AND_TOUCH         = C.SDL_HINT_ANDROID_SEPARATE_MOUSE_AND_TOUCH         // specifies a variable to control whether mouse and touch events are to be treated together or separately
	HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION  = C.SDL_HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION  // specifies the Android APK expansion main file version
	HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION = C.SDL_HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION // specifies the Android APK expansion patch file version
	HINT_AUDIO_RESAMPLING_MODE                    = C.SDL_HINT_AUDIO_RESAMPLING_MODE                    // specifies a variable controlling speed/quality tradeoff of audio resampling
	HINT_RENDER_LOGICAL_SIZE_MODE                 = C.SDL_HINT_RENDER_LOGICAL_SIZE_MODE                 // specifies a variable controlling the scaling policy for SDL_RenderSetLogicalSize
	HINT_MOUSE_NORMAL_SPEED_SCALE                 = C.SDL_HINT_MOUSE_NORMAL_SPEED_SCALE                 // specifies a variable setting the speed scale for mouse motion, in floating point, when the mouse is not in relative mode
	HINT_MOUSE_RELATIVE_SPEED_SCALE               = C.SDL_HINT_MOUSE_RELATIVE_SPEED_SCALE               // specifies a variable setting the scale for mouse motion, in floating point, when the mouse is in relative mode
	HINT_MOUSE_TOUCH_EVENTS                       = C.SDL_HINT_MOUSE_TOUCH_EVENTS                       // specifies a variable to control whether mouse events should generate synthetic touch events
	HINT_TOUCH_MOUSE_EVENTS                       = C.SDL_HINT_TOUCH_MOUSE_EVENTS                       // specifies a variable controlling whether touch events should generate synthetic mouse events
	HINT_WINDOWS_INTRESOURCE_ICON                 = C.SDL_HINT_WINDOWS_INTRESOURCE_ICON                 // specifies a variable to specify custom icon resource id from RC file on Windows platform
	HINT_WINDOWS_INTRESOURCE_ICON_SMALL           = C.SDL_HINT_WINDOWS_INTRESOURCE_ICON_SMALL           // specifies a variable to specify custom icon resource id from RC file on Windows platform
	HINT_IOS_HIDE_HOME_INDICATOR                  = C.SDL_HINT_IOS_HIDE_HOME_INDICATOR                  // specifies a variable controlling whether the home indicator bar on iPhone X should be hidden.
	HINT_RETURN_KEY_HIDES_IME                     = C.SDL_HINT_RETURN_KEY_HIDES_IME                     // specifies a variable to control whether the return key on the soft keyboard should hide the soft keyboard on Android and iOS.
	HINT_TV_REMOTE_AS_JOYSTICK                    = C.SDL_HINT_TV_REMOTE_AS_JOYSTICK                    // specifies a variable controlling whether the Android / tvOS remotes  should be listed as joystick devices, instead of sending keyboard events.
	HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR       = C.SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR       // specifies a variable controlling whether the X11 _NET_WM_BYPASS_COMPOSITOR hint should be used.
	HINT_VIDEO_DOUBLE_BUFFER                      = C.SDL_HINT_VIDEO_DOUBLE_BUFFER                      // specifies a variable that tells the video driver that we only want a double buffer.
	HINT_RENDER_BATCHING                          = C.SDL_HINT_RENDER_BATCHING                          // specifies a variable controlling whether the 2D render API is compatible or efficient.
	HINT_EVENT_LOGGING                            = C.SDL_HINT_EVENT_LOGGING                            // specifies a variable controlling whether SDL logs all events pushed onto its internal queue.
	HINT_GAMECONTROLLERCONFIG_FILE                = C.SDL_HINT_GAMECONTROLLERCONFIG_FILE                // specifies a variable that lets you provide a file with extra gamecontroller db entries.
	HINT_ANDROID_BLOCK_ON_PAUSE                   = C.SDL_HINT_ANDROID_BLOCK_ON_PAUSE                   // specifies a variable to control whether the event loop will block itself when the app is paused.
	HINT_DISPLAY_USABLE_BOUNDS                    = C.SDL_HINT_DISPLAY_USABLE_BOUNDS                    // Override for SDL_GetDisplayUsableBounds().
	HINT_GAMECONTROLLERTYPE                       = C.SDL_HINT_GAMECONTROLLERTYPE                       // Overrides the automatic controller type detection.
	HINT_GAMECONTROLLER_USE_BUTTON_LABELS         = C.SDL_HINT_GAMECONTROLLER_USE_BUTTON_LABELS         // If set, game controller face buttons report their values according to their labels instead of their positional layout.
	HINT_JOYSTICK_HIDAPI_GAMECUBE                 = C.SDL_HINT_JOYSTICK_HIDAPI_GAMECUBE                 // A variable controlling whether the HIDAPI driver for Nintendo GameCube controllers should be used.
	HINT_VIDEO_X11_WINDOW_VISUALID                = C.SDL_HINT_VIDEO_X11_WINDOW_VISUALID                // A variable forcing the visual ID chosen for new X11 windows.
	HINT_VIDEO_X11_FORCE_EGL                      = C.SDL_HINT_VIDEO_X11_FORCE_EGL                      // A variable controlling whether X11 should use GLX or EGL by default.
	HINT_JOYSTICK_HIDAPI_PS5                      = C.SDL_HINT_JOYSTICK_HIDAPI_PS5                      // A variable controlling whether the HIDAPI driver for PS5 controllers should be used.
	HINT_MOUSE_RELATIVE_SCALING                   = C.SDL_HINT_MOUSE_RELATIVE_SCALING                   // A variable controlling whether relative mouse motion is affected by renderer scaling.
	HINT_PREFERRED_LOCALES                        = C.SDL_HINT_PREFERRED_LOCALES                        // Override for SDL_GetPreferredLocales().
	HINT_JOYSTICK_RAWINPUT                        = C.SDL_HINT_JOYSTICK_RAWINPUT                        // A variable controlling whether the RAWINPUT joystick drivers should be used for better handling XInput-capable devices.
	HINT_JOYSTICK_RAWINPUT_CORRELATE_XINPUT       = C.SDL_HINT_JOYSTICK_RAWINPUT_CORRELATE_XINPUT       // A variable controlling whether the HIDAPI driver for XBox controllers on Windows should pull correlated data from XInput.
	HINT_JOYSTICK_HIDAPI_CORRELATE_XINPUT         = C.SDL_HINT_JOYSTICK_HIDAPI_CORRELATE_XINPUT         // A variable controlling whether the HIDAPI driver for XBox controllers on Windows should pull correlated data from XInput.
	HINT_AUDIO_DEVICE_APP_NAME                    = C.SDL_HINT_AUDIO_DEVICE_APP_NAME                    // Specify an application name for an audio device.
	HINT_AUDIO_DEVICE_STREAM_NAME                 = C.SDL_HINT_AUDIO_DEVICE_STREAM_NAME                 // Specify an application name for an audio device.
	HINT_LINUX_JOYSTICK_DEADZONES                 = C.SDL_HINT_LINUX_JOYSTICK_DEADZONES                 // A variable controlling whether joysticks on Linux adhere to their HID-defined deadzones or return unfiltered values.
	HINT_THREAD_PRIORITY_POLICY                   = C.SDL_HINT_THREAD_PRIORITY_POLICY                   // A string specifying additional information to use with SDL_SetThreadPriority.
	HINT_THREAD_FORCE_REALTIME_TIME_CRITICAL      = C.SDL_HINT_THREAD_FORCE_REALTIME_TIME_CRITICAL      // Specifies whether SDL_THREAD_PRIORITY_TIME_CRITICAL should be treated as realtime.
	HINT_ANDROID_BLOCK_ON_PAUSE_PAUSEAUDIO        = C.SDL_HINT_ANDROID_BLOCK_ON_PAUSE_PAUSEAUDIO        // A variable to control whether SDL will pause audio in background (Requires SDL_ANDROID_BLOCK_ON_PAUSE as "Non blocking").
	HINT_EMSCRIPTEN_ASYNCIFY                      = C.SDL_HINT_EMSCRIPTEN_ASYNCIFY                      // Disable giving back control to the browser automatically when running with asyncify.
	HINT_AUDIO_INCLUDE_MONITORS                   = C.SDL_HINT_AUDIO_INCLUDE_MONITORS                   // Control whether PulseAudio recording should include monitor devices
	HINT_AUDIO_DEVICE_STREAM_ROLE                 = C.SDL_HINT_AUDIO_DEVICE_STREAM_ROLE                 // Describe the role of your application for audio control panels
	HINT_APP_NAME                                 = C.SDL_HINT_APP_NAME                                 // Lets you specify the application name sent to the OS when required
	HINT_VIDEO_EGL_ALLOW_TRANSPARENCY             = C.SDL_HINT_VIDEO_EGL_ALLOW_TRANSPARENCY             // A variable controlling whether the EGL window is allowed to be composited as transparent, rather than opaque
	HINT_IME_SHOW_UI                              = C.SDL_HINT_IME_SHOW_UI                              // A variable to control whether certain IMEs should show native UI components (such as the Candidate List) instead of suppressing them
	HINT_IME_SUPPORT_EXTENDED_TEXT                = C.SDL_HINT_IME_SUPPORT_EXTENDED_TEXT                // A variable to control if extended IME text support is enabled.
	HINT_SCREENSAVER_INHIBIT_ACTIVITY_NAME        = C.SDL_HINT_SCREENSAVER_INHIBIT_ACTIVITY_NAME        // This hint lets you specify the "activity name" sent to the OS when SDL_DisableScreenSaver() is used (or the screensaver is automatically disabled)
	HINT_LINUX_JOYSTICK_CLASSIC                   = C.SDL_HINT_LINUX_JOYSTICK_CLASSIC                   // A variable controlling whether to use the classic /dev/input/js* joystick interface or the newer /dev/input/event* joystick interface on Linux
	HINT_JOYSTICK_DEVICE                          = C.SDL_HINT_JOYSTICK_DEVICE                          // This variable is currently only used by the Linux joystick driver
	HINT_JOYSTICK_HIDAPI_STEAM                    = C.SDL_HINT_JOYSTICK_HIDAPI_STEAM                    // A variable controlling whether the HIDAPI driver for Steam Controllers should be used
	HINT_RENDER_LINE_METHOD                       = C.SDL_HINT_RENDER_LINE_METHOD                       // A variable controlling how the 2D render API renders lines
	HINT_MOUSE_RELATIVE_MODE_CENTER               = C.SDL_HINT_MOUSE_RELATIVE_MODE_CENTER               // A variable controlling whether relative mouse mode constrains the mouse to the center of the window
	HINT_MOUSE_AUTO_CAPTURE                       = C.SDL_HINT_MOUSE_AUTO_CAPTURE                       // A variable controlling whether the mouse is captured while mouse buttons are pressed
	HINT_VIDEO_FOREIGN_WINDOW_OPENGL              = C.SDL_HINT_VIDEO_FOREIGN_WINDOW_OPENGL              // When calling SDL_CreateWindowFrom(), make the window compatible with OpenGL
	HINT_VIDEO_FOREIGN_WINDOW_VULKAN              = C.SDL_HINT_VIDEO_FOREIGN_WINDOW_VULKAN              // When calling SDL_CreateWindowFrom(), make the window compatible with Vulkan
	HINT_QUIT_ON_LAST_WINDOW_CLOSE                = C.SDL_HINT_QUIT_ON_LAST_WINDOW_CLOSE                // A variable that decides whether to send SDL_QUIT when closing the final window
	HINT_JOYSTICK_ROG_CHAKRAM                     = C.SDL_HINT_JOYSTICK_ROG_CHAKRAM                     // A variable controlling whether the ROG Chakram mice should show up as joysticks
	HINT_X11_WINDOW_TYPE                          = C.SDL_HINT_X11_WINDOW_TYPE                          // A variable that forces X11 windows to create as a custom type
	HINT_VIDEO_WAYLAND_PREFER_LIBDECOR            = C.SDL_HINT_VIDEO_WAYLAND_PREFER_LIBDECOR            // A variable controlling whether the libdecor Wayland backend is preferred over native decrations
	HINT_VIDEODRIVER                              = C.SDL_HINT_VIDEODRIVER                              // A variable that decides what video backend to use
)

const (
	HINT_DEFAULT  = C.SDL_HINT_DEFAULT  // low priority, used for default values
	HINT_NORMAL   = C.SDL_HINT_NORMAL   // medium priority
	HINT_OVERRIDE = C.SDL_HINT_OVERRIDE // high priority
)

const (
	HAT_CENTERED  = C.SDL_HAT_CENTERED
	HAT_UP        = C.SDL_HAT_UP
	HAT_RIGHT     = C.SDL_HAT_RIGHT
	HAT_DOWN      = C.SDL_HAT_DOWN
	HAT_LEFT      = C.SDL_HAT_LEFT
	HAT_RIGHTUP   = C.SDL_HAT_RIGHTUP
	HAT_RIGHTDOWN = C.SDL_HAT_RIGHTDOWN
	HAT_LEFTUP    = C.SDL_HAT_LEFTUP
	HAT_LEFTDOWN  = C.SDL_HAT_LEFTDOWN
)

const (
	JOYSTICK_TYPE_UNKNOWN        = C.SDL_JOYSTICK_TYPE_UNKNOWN
	JOYSTICK_TYPE_GAMECONTROLLER = C.SDL_JOYSTICK_TYPE_GAMECONTROLLER
	JOYSTICK_TYPE_WHEEL          = C.SDL_JOYSTICK_TYPE_WHEEL
	JOYSTICK_TYPE_ARCADE_STICK   = C.SDL_JOYSTICK_TYPE_ARCADE_STICK
	JOYSTICK_TYPE_FLIGHT_STICK   = C.SDL_JOYSTICK_TYPE_FLIGHT_STICK
	JOYSTICK_TYPE_DANCE_PAD      = C.SDL_JOYSTICK_TYPE_DANCE_PAD
	JOYSTICK_TYPE_GUITAR         = C.SDL_JOYSTICK_TYPE_GUITAR
	JOYSTICK_TYPE_DRUM_KIT       = C.SDL_JOYSTICK_TYPE_DRUM_KIT
	JOYSTICK_TYPE_ARCADE_PAD     = C.SDL_JOYSTICK_TYPE_ARCADE_PAD
	JOYSTICK_TYPE_THROTTLE       = C.SDL_JOYSTICK_TYPE_THROTTLE
)

const (
	JOYSTICK_POWER_UNKNOWN = C.SDL_JOYSTICK_POWER_UNKNOWN
	JOYSTICK_POWER_EMPTY   = C.SDL_JOYSTICK_POWER_EMPTY
	JOYSTICK_POWER_LOW     = C.SDL_JOYSTICK_POWER_LOW
	JOYSTICK_POWER_MEDIUM  = C.SDL_JOYSTICK_POWER_MEDIUM
	JOYSTICK_POWER_FULL    = C.SDL_JOYSTICK_POWER_FULL
	JOYSTICK_POWER_WIRED   = C.SDL_JOYSTICK_POWER_WIRED
	JOYSTICK_POWER_MAX     = C.SDL_JOYSTICK_POWER_MAX
)

const (
	K_UNKNOWN = C.SDLK_UNKNOWN // "" (no name, empty string)

	K_RETURN     = C.SDLK_RETURN     // "Return" (the Enter key (main keyboard))
	K_ESCAPE     = C.SDLK_ESCAPE     // "Escape" (the Esc key)
	K_BACKSPACE  = C.SDLK_BACKSPACE  // "Backspace"
	K_TAB        = C.SDLK_TAB        // "Tab" (the Tab key)
	K_SPACE      = C.SDLK_SPACE      // "Space" (the Space Bar key(s))
	K_EXCLAIM    = C.SDLK_EXCLAIM    // "!"
	K_QUOTEDBL   = C.SDLK_QUOTEDBL   // """
	K_HASH       = C.SDLK_HASH       // "#"
	K_PERCENT    = C.SDLK_PERCENT    // "%"
	K_DOLLAR     = C.SDLK_DOLLAR     // "$"
	K_AMPERSAND  = C.SDLK_AMPERSAND  // "&"
	K_QUOTE      = C.SDLK_QUOTE      // "'"
	K_LEFTPAREN  = C.SDLK_LEFTPAREN  // "("
	K_RIGHTPAREN = C.SDLK_RIGHTPAREN // ")"
	K_ASTERISK   = C.SDLK_ASTERISK   // "*"
	K_PLUS       = C.SDLK_PLUS       // "+"
	K_COMMA      = C.SDLK_COMMA      // ","
	K_MINUS      = C.SDLK_MINUS      // "-"
	K_PERIOD     = C.SDLK_PERIOD     // "."
	K_SLASH      = C.SDLK_SLASH      // "/"
	K_0          = C.SDLK_0          // "0"
	K_1          = C.SDLK_1          // "1"
	K_2          = C.SDLK_2          // "2"
	K_3          = C.SDLK_3          // "3"
	K_4          = C.SDLK_4          // "4"
	K_5          = C.SDLK_5          // "5"
	K_6          = C.SDLK_6          // "6"
	K_7          = C.SDLK_7          // "7"
	K_8          = C.SDLK_8          // "8"
	K_9          = C.SDLK_9          // "9"
	K_COLON      = C.SDLK_COLON      // ":"
	K_SEMICOLON  = C.SDLK_SEMICOLON  // ";"
	K_LESS       = C.SDLK_LESS       // "<"
	K_EQUALS     = C.SDLK_EQUALS     // "="
	K_GREATER    = C.SDLK_GREATER    // ">"
	K_QUESTION   = C.SDLK_QUESTION   // "?"
	K_AT         = C.SDLK_AT         // "@"
	/*
	   Skip uppercase letters
	*/
	K_LEFTBRACKET  = C.SDLK_LEFTBRACKET  // "["
	K_BACKSLASH    = C.SDLK_BACKSLASH    // "\"
	K_RIGHTBRACKET = C.SDLK_RIGHTBRACKET // "]"
	K_CARET        = C.SDLK_CARET        // "^"
	K_UNDERSCORE   = C.SDLK_UNDERSCORE   // "_"
	K_BACKQUOTE    = C.SDLK_BACKQUOTE    // "`"
	K_a            = C.SDLK_a            // "A"
	K_b            = C.SDLK_b            // "B"
	K_c            = C.SDLK_c            // "C"
	K_d            = C.SDLK_d            // "D"
	K_e            = C.SDLK_e            // "E"
	K_f            = C.SDLK_f            // "F"
	K_g            = C.SDLK_g            // "G"
	K_h            = C.SDLK_h            // "H"
	K_i            = C.SDLK_i            // "I"
	K_j            = C.SDLK_j            // "J"
	K_k            = C.SDLK_k            // "K"
	K_l            = C.SDLK_l            // "L"
	K_m            = C.SDLK_m            // "M"
	K_n            = C.SDLK_n            // "N"
	K_o            = C.SDLK_o            // "O"
	K_p            = C.SDLK_p            // "P"
	K_q            = C.SDLK_q            // "Q"
	K_r            = C.SDLK_r            // "R"
	K_s            = C.SDLK_s            // "S"
	K_t            = C.SDLK_t            // "T"
	K_u            = C.SDLK_u            // "U"
	K_v            = C.SDLK_v            // "V"
	K_w            = C.SDLK_w            // "W"
	K_x            = C.SDLK_x            // "X"
	K_y            = C.SDLK_y            // "Y"
	K_z            = C.SDLK_z            // "Z"

	K_CAPSLOCK = C.SDLK_CAPSLOCK // "CapsLock"

	K_F1  = C.SDLK_F1  // "F1"
	K_F2  = C.SDLK_F2  // "F2"
	K_F3  = C.SDLK_F3  // "F3"
	K_F4  = C.SDLK_F4  // "F4"
	K_F5  = C.SDLK_F5  // "F5"
	K_F6  = C.SDLK_F6  // "F6"
	K_F7  = C.SDLK_F7  // "F7"
	K_F8  = C.SDLK_F8  // "F8"
	K_F9  = C.SDLK_F9  // "F9"
	K_F10 = C.SDLK_F10 // "F10"
	K_F11 = C.SDLK_F11 // "F11"
	K_F12 = C.SDLK_F12 // "F12"

	K_PRINTSCREEN = C.SDLK_PRINTSCREEN // "PrintScreen"
	K_SCROLLLOCK  = C.SDLK_SCROLLLOCK  // "ScrollLock"
	K_PAUSE       = C.SDLK_PAUSE       // "Pause" (the Pause / Break key)
	K_INSERT      = C.SDLK_INSERT      // "Insert" (insert on PC, help on some Mac keyboards (but does send code 73, not 117))
	K_HOME        = C.SDLK_HOME        // "Home"
	K_PAGEUP      = C.SDLK_PAGEUP      // "PageUp"
	K_DELETE      = C.SDLK_DELETE      // "Delete"
	K_END         = C.SDLK_END         // "End"
	K_PAGEDOWN    = C.SDLK_PAGEDOWN    // "PageDown"
	K_RIGHT       = C.SDLK_RIGHT       // "Right" (the Right arrow key (navigation keypad))
	K_LEFT        = C.SDLK_LEFT        // "Left" (the Left arrow key (navigation keypad))
	K_DOWN        = C.SDLK_DOWN        // "Down" (the Down arrow key (navigation keypad))
	K_UP          = C.SDLK_UP          // "Up" (the Up arrow key (navigation keypad))

	K_NUMLOCKCLEAR = C.SDLK_NUMLOCKCLEAR // "Numlock" (the Num Lock key (PC) / the Clear key (Mac))
	K_KP_DIVIDE    = C.SDLK_KP_DIVIDE    // "Keypad /" (the / key (numeric keypad))
	K_KP_MULTIPLY  = C.SDLK_KP_MULTIPLY  // "Keypad *" (the * key (numeric keypad))
	K_KP_MINUS     = C.SDLK_KP_MINUS     // "Keypad -" (the - key (numeric keypad))
	K_KP_PLUS      = C.SDLK_KP_PLUS      // "Keypad +" (the + key (numeric keypad))
	K_KP_ENTER     = C.SDLK_KP_ENTER     // "Keypad Enter" (the Enter key (numeric keypad))
	K_KP_1         = C.SDLK_KP_1         // "Keypad 1" (the 1 key (numeric keypad))
	K_KP_2         = C.SDLK_KP_2         // "Keypad 2" (the 2 key (numeric keypad))
	K_KP_3         = C.SDLK_KP_3         // "Keypad 3" (the 3 key (numeric keypad))
	K_KP_4         = C.SDLK_KP_4         // "Keypad 4" (the 4 key (numeric keypad))
	K_KP_5         = C.SDLK_KP_5         // "Keypad 5" (the 5 key (numeric keypad))
	K_KP_6         = C.SDLK_KP_6         // "Keypad 6" (the 6 key (numeric keypad))
	K_KP_7         = C.SDLK_KP_7         // "Keypad 7" (the 7 key (numeric keypad))
	K_KP_8         = C.SDLK_KP_8         // "Keypad 8" (the 8 key (numeric keypad))
	K_KP_9         = C.SDLK_KP_9         // "Keypad 9" (the 9 key (numeric keypad))
	K_KP_0         = C.SDLK_KP_0         // "Keypad 0" (the 0 key (numeric keypad))
	K_KP_PERIOD    = C.SDLK_KP_PERIOD    // "Keypad ." (the . key (numeric keypad))

	K_APPLICATION    = C.SDLK_APPLICATION    // "Application" (the Application / Compose / Context Menu (Windows) key)
	K_POWER          = C.SDLK_POWER          // "Power" (The USB document says this is a status flag, not a physical key - but some Mac keyboards do have a power key.)
	K_KP_EQUALS      = C.SDLK_KP_EQUALS      // "Keypad =" (the = key (numeric keypad))
	K_F13            = C.SDLK_F13            // "F13"
	K_F14            = C.SDLK_F14            // "F14"
	K_F15            = C.SDLK_F15            // "F15"
	K_F16            = C.SDLK_F16            // "F16"
	K_F17            = C.SDLK_F17            // "F17"
	K_F18            = C.SDLK_F18            // "F18"
	K_F19            = C.SDLK_F19            // "F19"
	K_F20            = C.SDLK_F20            // "F20"
	K_F21            = C.SDLK_F21            // "F21"
	K_F22            = C.SDLK_F22            // "F22"
	K_F23            = C.SDLK_F23            // "F23"
	K_F24            = C.SDLK_F24            // "F24"
	K_EXECUTE        = C.SDLK_EXECUTE        // "Execute"
	K_HELP           = C.SDLK_HELP           // "Help"
	K_MENU           = C.SDLK_MENU           // "Menu"
	K_SELECT         = C.SDLK_SELECT         // "Select"
	K_STOP           = C.SDLK_STOP           // "Stop"
	K_AGAIN          = C.SDLK_AGAIN          // "Again" (the Again key (Redo))
	K_UNDO           = C.SDLK_UNDO           // "Undo"
	K_CUT            = C.SDLK_CUT            // "Cut"
	K_COPY           = C.SDLK_COPY           // "Copy"
	K_PASTE          = C.SDLK_PASTE          // "Paste"
	K_FIND           = C.SDLK_FIND           // "Find"
	K_MUTE           = C.SDLK_MUTE           // "Mute"
	K_VOLUMEUP       = C.SDLK_VOLUMEUP       // "VolumeUp"
	K_VOLUMEDOWN     = C.SDLK_VOLUMEDOWN     // "VolumeDown"
	K_KP_COMMA       = C.SDLK_KP_COMMA       // "Keypad ," (the Comma key (numeric keypad))
	K_KP_EQUALSAS400 = C.SDLK_KP_EQUALSAS400 // "Keypad = (AS400)" (the Equals AS400 key (numeric keypad))

	K_ALTERASE   = C.SDLK_ALTERASE   // "AltErase" (Erase-Eaze)
	K_SYSREQ     = C.SDLK_SYSREQ     // "SysReq" (the SysReq key)
	K_CANCEL     = C.SDLK_CANCEL     // "Cancel"
	K_CLEAR      = C.SDLK_CLEAR      // "Clear"
	K_PRIOR      = C.SDLK_PRIOR      // "Prior"
	K_RETURN2    = C.SDLK_RETURN2    // "Return"
	K_SEPARATOR  = C.SDLK_SEPARATOR  // "Separator"
	K_OUT        = C.SDLK_OUT        // "Out"
	K_OPER       = C.SDLK_OPER       // "Oper"
	K_CLEARAGAIN = C.SDLK_CLEARAGAIN // "Clear / Again"
	K_CRSEL      = C.SDLK_CRSEL      // "CrSel"
	K_EXSEL      = C.SDLK_EXSEL      // "ExSel"

	K_KP_00              = C.SDLK_KP_00              // "Keypad 00" (the 00 key (numeric keypad))
	K_KP_000             = C.SDLK_KP_000             // "Keypad 000" (the 000 key (numeric keypad))
	K_THOUSANDSSEPARATOR = C.SDLK_THOUSANDSSEPARATOR // "ThousandsSeparator" (the Thousands Separator key)
	K_DECIMALSEPARATOR   = C.SDLK_DECIMALSEPARATOR   // "DecimalSeparator" (the Decimal Separator key)
	K_CURRENCYUNIT       = C.SDLK_CURRENCYUNIT       // "CurrencyUnit" (the Currency Unit key)
	K_CURRENCYSUBUNIT    = C.SDLK_CURRENCYSUBUNIT    // "CurrencySubUnit" (the Currency Subunit key)
	K_KP_LEFTPAREN       = C.SDLK_KP_LEFTPAREN       // "Keypad (" (the Left Parenthesis key (numeric keypad))
	K_KP_RIGHTPAREN      = C.SDLK_KP_RIGHTPAREN      // "Keypad )" (the Right Parenthesis key (numeric keypad))
	K_KP_LEFTBRACE       = C.SDLK_KP_LEFTBRACE       // "Keypad {" (the Left Brace key (numeric keypad))
	K_KP_RIGHTBRACE      = C.SDLK_KP_RIGHTBRACE      // "Keypad }" (the Right Brace key (numeric keypad))
	K_KP_TAB             = C.SDLK_KP_TAB             // "Keypad Tab" (the Tab key (numeric keypad))
	K_KP_BACKSPACE       = C.SDLK_KP_BACKSPACE       // "Keypad Backspace" (the Backspace key (numeric keypad))
	K_KP_A               = C.SDLK_KP_A               // "Keypad A" (the A key (numeric keypad))
	K_KP_B               = C.SDLK_KP_B               // "Keypad B" (the B key (numeric keypad))
	K_KP_C               = C.SDLK_KP_C               // "Keypad C" (the C key (numeric keypad))
	K_KP_D               = C.SDLK_KP_D               // "Keypad D" (the D key (numeric keypad))
	K_KP_E               = C.SDLK_KP_E               // "Keypad E" (the E key (numeric keypad))
	K_KP_F               = C.SDLK_KP_F               // "Keypad F" (the F key (numeric keypad))
	K_KP_XOR             = C.SDLK_KP_XOR             // "Keypad XOR" (the XOR key (numeric keypad))
	K_KP_POWER           = C.SDLK_KP_POWER           // "Keypad ^" (the Power key (numeric keypad))
	K_KP_PERCENT         = C.SDLK_KP_PERCENT         // "Keypad %" (the Percent key (numeric keypad))
	K_KP_LESS            = C.SDLK_KP_LESS            // "Keypad <" (the Less key (numeric keypad))
	K_KP_GREATER         = C.SDLK_KP_GREATER         // "Keypad >" (the Greater key (numeric keypad))
	K_KP_AMPERSAND       = C.SDLK_KP_AMPERSAND       // "Keypad &" (the & key (numeric keypad))
	K_KP_DBLAMPERSAND    = C.SDLK_KP_DBLAMPERSAND    // "Keypad &&" (the && key (numeric keypad))
	K_KP_VERTICALBAR     = C.SDLK_KP_VERTICALBAR     // "Keypad |" (the | key (numeric keypad))
	K_KP_DBLVERTICALBAR  = C.SDLK_KP_DBLVERTICALBAR  // "Keypad ||" (the || key (numeric keypad))
	K_KP_COLON           = C.SDLK_KP_COLON           // "Keypad :" (the : key (numeric keypad))
	K_KP_HASH            = C.SDLK_KP_HASH            // "Keypad #" (the # key (numeric keypad))
	K_KP_SPACE           = C.SDLK_KP_SPACE           // "Keypad Space" (the Space key (numeric keypad))
	K_KP_AT              = C.SDLK_KP_AT              // "Keypad @" (the @ key (numeric keypad))
	K_KP_EXCLAM          = C.SDLK_KP_EXCLAM          // "Keypad !" (the ! key (numeric keypad))
	K_KP_MEMSTORE        = C.SDLK_KP_MEMSTORE        // "Keypad MemStore" (the Mem Store key (numeric keypad))
	K_KP_MEMRECALL       = C.SDLK_KP_MEMRECALL       // "Keypad MemRecall" (the Mem Recall key (numeric keypad))
	K_KP_MEMCLEAR        = C.SDLK_KP_MEMCLEAR        // "Keypad MemClear" (the Mem Clear key (numeric keypad))
	K_KP_MEMADD          = C.SDLK_KP_MEMADD          // "Keypad MemAdd" (the Mem Add key (numeric keypad))
	K_KP_MEMSUBTRACT     = C.SDLK_KP_MEMSUBTRACT     // "Keypad MemSubtract" (the Mem Subtract key (numeric keypad))
	K_KP_MEMMULTIPLY     = C.SDLK_KP_MEMMULTIPLY     // "Keypad MemMultiply" (the Mem Multiply key (numeric keypad))
	K_KP_MEMDIVIDE       = C.SDLK_KP_MEMDIVIDE       // "Keypad MemDivide" (the Mem Divide key (numeric keypad))
	K_KP_PLUSMINUS       = C.SDLK_KP_PLUSMINUS       // "Keypad +/-" (the +/- key (numeric keypad))
	K_KP_CLEAR           = C.SDLK_KP_CLEAR           // "Keypad Clear" (the Clear key (numeric keypad))
	K_KP_CLEARENTRY      = C.SDLK_KP_CLEARENTRY      // "Keypad ClearEntry" (the Clear Entry key (numeric keypad))
	K_KP_BINARY          = C.SDLK_KP_BINARY          // "Keypad Binary" (the Binary key (numeric keypad))
	K_KP_OCTAL           = C.SDLK_KP_OCTAL           // "Keypad Octal" (the Octal key (numeric keypad))
	K_KP_DECIMAL         = C.SDLK_KP_DECIMAL         // "Keypad Decimal" (the Decimal key (numeric keypad))
	K_KP_HEXADECIMAL     = C.SDLK_KP_HEXADECIMAL     // "Keypad Hexadecimal" (the Hexadecimal key (numeric keypad))

	K_LCTRL  = C.SDLK_LCTRL  // "Left Ctrl"
	K_LSHIFT = C.SDLK_LSHIFT // "Left Shift"
	K_LALT   = C.SDLK_LALT   // "Left Alt" (alt, option)
	K_LGUI   = C.SDLK_LGUI   // "Left GUI" (windows, command (apple), meta)
	K_RCTRL  = C.SDLK_RCTRL  // "Right Ctrl"
	K_RSHIFT = C.SDLK_RSHIFT // "Right Shift"
	K_RALT   = C.SDLK_RALT   // "Right Alt" (alt, option)
	K_RGUI   = C.SDLK_RGUI   // "Right GUI" (windows, command (apple), meta)

	K_MODE = C.SDLK_MODE // "ModeSwitch" (I'm not sure if this is really not covered by any of the above, but since there's a special KMOD_MODE for it I'm adding it here)

	K_AUDIONEXT    = C.SDLK_AUDIONEXT    // "AudioNext" (the Next Track media key)
	K_AUDIOPREV    = C.SDLK_AUDIOPREV    // "AudioPrev" (the Previous Track media key)
	K_AUDIOSTOP    = C.SDLK_AUDIOSTOP    // "AudioStop" (the Stop media key)
	K_AUDIOPLAY    = C.SDLK_AUDIOPLAY    // "AudioPlay" (the Play media key)
	K_AUDIOMUTE    = C.SDLK_AUDIOMUTE    // "AudioMute" (the Mute volume key)
	K_MEDIASELECT  = C.SDLK_MEDIASELECT  // "MediaSelect" (the Media Select key)
	K_WWW          = C.SDLK_WWW          // "WWW" (the WWW/World Wide Web key)
	K_MAIL         = C.SDLK_MAIL         // "Mail" (the Mail/eMail key)
	K_CALCULATOR   = C.SDLK_CALCULATOR   // "Calculator" (the Calculator key)
	K_COMPUTER     = C.SDLK_COMPUTER     // "Computer" (the My Computer key)
	K_AC_SEARCH    = C.SDLK_AC_SEARCH    // "AC Search" (the Search key (application control keypad))
	K_AC_HOME      = C.SDLK_AC_HOME      // "AC Home" (the Home key (application control keypad))
	K_AC_BACK      = C.SDLK_AC_BACK      // "AC Back" (the Back key (application control keypad))
	K_AC_FORWARD   = C.SDLK_AC_FORWARD   // "AC Forward" (the Forward key (application control keypad))
	K_AC_STOP      = C.SDLK_AC_STOP      // "AC Stop" (the Stop key (application control keypad))
	K_AC_REFRESH   = C.SDLK_AC_REFRESH   // "AC Refresh" (the Refresh key (application control keypad))
	K_AC_BOOKMARKS = C.SDLK_AC_BOOKMARKS // "AC Bookmarks" (the Bookmarks key (application control keypad))

	K_BRIGHTNESSDOWN = C.SDLK_BRIGHTNESSDOWN // "BrightnessDown" (the Brightness Down key)
	K_BRIGHTNESSUP   = C.SDLK_BRIGHTNESSUP   // "BrightnessUp" (the Brightness Up key)
	K_DISPLAYSWITCH  = C.SDLK_DISPLAYSWITCH  // "DisplaySwitch" (display mirroring/dual display switch, video mode switch)
	K_KBDILLUMTOGGLE = C.SDLK_KBDILLUMTOGGLE // "KBDIllumToggle" (the Keyboard Illumination Toggle key)
	K_KBDILLUMDOWN   = C.SDLK_KBDILLUMDOWN   // "KBDIllumDown" (the Keyboard Illumination Down key)
	K_KBDILLUMUP     = C.SDLK_KBDILLUMUP     // "KBDIllumUp" (the Keyboard Illumination Up key)
	K_EJECT          = C.SDLK_EJECT          // "Eject" (the Eject key)
	K_SLEEP          = C.SDLK_SLEEP          // "Sleep" (the Sleep key)
)

const (
	KMOD_NONE     = C.KMOD_NONE     // 0 (no modifier is applicable)
	KMOD_LSHIFT   = C.KMOD_LSHIFT   // the left Shift key is down
	KMOD_RSHIFT   = C.KMOD_RSHIFT   // the right Shift key is down
	KMOD_LCTRL    = C.KMOD_LCTRL    // the left Ctrl (Control) key is down
	KMOD_RCTRL    = C.KMOD_RCTRL    // the right Ctrl (Control) key is down
	KMOD_LALT     = C.KMOD_LALT     // the left Alt key is down
	KMOD_RALT     = C.KMOD_RALT     // the right Alt key is down
	KMOD_LGUI     = C.KMOD_LGUI     // the left GUI key (often the Windows key) is down
	KMOD_RGUI     = C.KMOD_RGUI     // the right GUI key (often the Windows key) is down
	KMOD_NUM      = C.KMOD_NUM      // the Num Lock key (may be located on an extended keypad) is down
	KMOD_CAPS     = C.KMOD_CAPS     // the Caps Lock key is down
	KMOD_MODE     = C.KMOD_MODE     // the AltGr key is down
	KMOD_CTRL     = C.KMOD_CTRL     // (KMOD_LCTRL|KMOD_RCTRL)
	KMOD_SHIFT    = C.KMOD_SHIFT    // (KMOD_LSHIFT|KMOD_RSHIFT)
	KMOD_ALT      = C.KMOD_ALT      // (KMOD_LALT|KMOD_RALT)
	KMOD_GUI      = C.KMOD_GUI      // (KMOD_LGUI|KMOD_RGUI)
	KMOD_RESERVED = C.KMOD_RESERVED // reserved for future use
)

const (
	LOG_CATEGORY_APPLICATION = iota // application log
	LOG_CATEGORY_ERROR              // error log
	LOG_CATEGORY_ASSERT             // assert log
	LOG_CATEGORY_SYSTEM             // system log
	LOG_CATEGORY_AUDIO              // audio log
	LOG_CATEGORY_VIDEO              // video log
	LOG_CATEGORY_RENDER             // render log
	LOG_CATEGORY_INPUT              // input log
	LOG_CATEGORY_TEST               // test log
	LOG_CATEGORY_RESERVED1          // reserved for future SDL library use
	LOG_CATEGORY_RESERVED2          // reserved for future SDL library use
	LOG_CATEGORY_RESERVED3          // reserved for future SDL library use
	LOG_CATEGORY_RESERVED4          // reserved for future SDL library use
	LOG_CATEGORY_RESERVED5          // reserved for future SDL library use
	LOG_CATEGORY_RESERVED6          // reserved for future SDL library use
	LOG_CATEGORY_RESERVED7          // reserved for future SDL library use
	LOG_CATEGORY_RESERVED8          // reserved for future SDL library use
	LOG_CATEGORY_RESERVED9          // reserved for future SDL library use
	LOG_CATEGORY_RESERVED10         // reserved for future SDL library use
	LOG_CATEGORY_CUSTOM             // reserved for application use
)

const (
	LOG_PRIORITY_VERBOSE  = iota + 1 // verbose
	LOG_PRIORITY_DEBUG               // debug
	LOG_PRIORITY_INFO                // info
	LOG_PRIORITY_WARN                // warn
	LOG_PRIORITY_ERROR               // error
	LOG_PRIORITY_CRITICAL            // critical
	NUM_LOG_PRIORITIES               // (internal use)
)

const (
	SYSTEM_CURSOR_ARROW     = C.SDL_SYSTEM_CURSOR_ARROW     // arrow
	SYSTEM_CURSOR_IBEAM     = C.SDL_SYSTEM_CURSOR_IBEAM     // i-beam
	SYSTEM_CURSOR_WAIT      = C.SDL_SYSTEM_CURSOR_WAIT      // wait
	SYSTEM_CURSOR_CROSSHAIR = C.SDL_SYSTEM_CURSOR_CROSSHAIR // crosshair
	SYSTEM_CURSOR_WAITARROW = C.SDL_SYSTEM_CURSOR_WAITARROW // small wait cursor (or wait if not available)
	SYSTEM_CURSOR_SIZENWSE  = C.SDL_SYSTEM_CURSOR_SIZENWSE  // double arrow pointing northwest and southeast
	SYSTEM_CURSOR_SIZENESW  = C.SDL_SYSTEM_CURSOR_SIZENESW  // double arrow pointing northeast and southwest
	SYSTEM_CURSOR_SIZEWE    = C.SDL_SYSTEM_CURSOR_SIZEWE    // double arrow pointing west and east
	SYSTEM_CURSOR_SIZENS    = C.SDL_SYSTEM_CURSOR_SIZENS    // double arrow pointing north and south
	SYSTEM_CURSOR_SIZEALL   = C.SDL_SYSTEM_CURSOR_SIZEALL   // four pointed arrow pointing north, south, east, and west
	SYSTEM_CURSOR_NO        = C.SDL_SYSTEM_CURSOR_NO        // slashed circle or crossbones
	SYSTEM_CURSOR_HAND      = C.SDL_SYSTEM_CURSOR_HAND      // hand
	NUM_SYSTEM_CURSORS      = C.SDL_NUM_SYSTEM_CURSORS      // (only for bounding internal arrays)
)

const (
	MOUSEWHEEL_NORMAL  = C.SDL_MOUSEWHEEL_NORMAL  // the scroll direction is normal
	MOUSEWHEEL_FLIPPED = C.SDL_MOUSEWHEEL_FLIPPED // the scroll direction is flipped / natural
)

const (
	BUTTON_LEFT   = C.SDL_BUTTON_LEFT   // left mouse button
	BUTTON_MIDDLE = C.SDL_BUTTON_MIDDLE // middle mouse button
	BUTTON_RIGHT  = C.SDL_BUTTON_RIGHT  // right mouse button
	BUTTON_X1     = C.SDL_BUTTON_X1     // x1 mouse button
	BUTTON_X2     = C.SDL_BUTTON_X2     // x2 mouse button
)

const (
	PIXELTYPE_UNKNOWN  = C.SDL_PIXELTYPE_UNKNOWN
	PIXELTYPE_INDEX1   = C.SDL_PIXELTYPE_INDEX1
	PIXELTYPE_INDEX4   = C.SDL_PIXELTYPE_INDEX4
	PIXELTYPE_INDEX8   = C.SDL_PIXELTYPE_INDEX8
	PIXELTYPE_PACKED8  = C.SDL_PIXELTYPE_PACKED8
	PIXELTYPE_PACKED16 = C.SDL_PIXELTYPE_PACKED16
	PIXELTYPE_PACKED32 = C.SDL_PIXELTYPE_PACKED32
	PIXELTYPE_ARRAYU8  = C.SDL_PIXELTYPE_ARRAYU8
	PIXELTYPE_ARRAYU16 = C.SDL_PIXELTYPE_ARRAYU16
	PIXELTYPE_ARRAYU32 = C.SDL_PIXELTYPE_ARRAYU32
	PIXELTYPE_ARRAYF16 = C.SDL_PIXELTYPE_ARRAYF16
	PIXELTYPE_ARRAYF32 = C.SDL_PIXELTYPE_ARRAYF32
)

const (
	BITMAPORDER_NONE = C.SDL_BITMAPORDER_NONE
	BITMAPORDER_4321 = C.SDL_BITMAPORDER_4321
	BITMAPORDER_1234 = C.SDL_BITMAPORDER_1234
)

const (
	PACKEDORDER_NONE = C.SDL_PACKEDORDER_NONE
	PACKEDORDER_XRGB = C.SDL_PACKEDORDER_XRGB
	PACKEDORDER_RGBX = C.SDL_PACKEDORDER_RGBX
	PACKEDORDER_ARGB = C.SDL_PACKEDORDER_ARGB
	PACKEDORDER_RGBA = C.SDL_PACKEDORDER_RGBA
	PACKEDORDER_XBGR = C.SDL_PACKEDORDER_XBGR
	PACKEDORDER_BGRX = C.SDL_PACKEDORDER_BGRX
	PACKEDORDER_ABGR = C.SDL_PACKEDORDER_ABGR
	PACKEDORDER_BGRA = C.SDL_PACKEDORDER_BGRA
)

const (
	ARRAYORDER_NONE = C.SDL_ARRAYORDER_NONE
	ARRAYORDER_RGB  = C.SDL_ARRAYORDER_RGB
	ARRAYORDER_RGBA = C.SDL_ARRAYORDER_RGBA
	ARRAYORDER_ARGB = C.SDL_ARRAYORDER_ARGB
	ARRAYORDER_BGR  = C.SDL_ARRAYORDER_BGR
	ARRAYORDER_BGRA = C.SDL_ARRAYORDER_BGRA
	ARRAYORDER_ABGR = C.SDL_ARRAYORDER_ABGR
)

const (
	PACKEDLAYOUT_NONE    = C.SDL_PACKEDLAYOUT_NONE
	PACKEDLAYOUT_332     = C.SDL_PACKEDLAYOUT_332
	PACKEDLAYOUT_4444    = C.SDL_PACKEDLAYOUT_4444
	PACKEDLAYOUT_1555    = C.SDL_PACKEDLAYOUT_1555
	PACKEDLAYOUT_5551    = C.SDL_PACKEDLAYOUT_5551
	PACKEDLAYOUT_565     = C.SDL_PACKEDLAYOUT_565
	PACKEDLAYOUT_8888    = C.SDL_PACKEDLAYOUT_8888
	PACKEDLAYOUT_2101010 = C.SDL_PACKEDLAYOUT_2101010
	PACKEDLAYOUT_1010102 = C.SDL_PACKEDLAYOUT_1010102
)

const (
	PIXELFORMAT_UNKNOWN     = C.SDL_PIXELFORMAT_UNKNOWN
	PIXELFORMAT_INDEX1LSB   = C.SDL_PIXELFORMAT_INDEX1LSB
	PIXELFORMAT_INDEX1MSB   = C.SDL_PIXELFORMAT_INDEX1MSB
	PIXELFORMAT_INDEX4LSB   = C.SDL_PIXELFORMAT_INDEX4LSB
	PIXELFORMAT_INDEX4MSB   = C.SDL_PIXELFORMAT_INDEX4MSB
	PIXELFORMAT_INDEX8      = C.SDL_PIXELFORMAT_INDEX8
	PIXELFORMAT_RGB332      = C.SDL_PIXELFORMAT_RGB332
	PIXELFORMAT_RGB444      = C.SDL_PIXELFORMAT_RGB444
	PIXELFORMAT_RGB555      = C.SDL_PIXELFORMAT_RGB555
	PIXELFORMAT_BGR555      = C.SDL_PIXELFORMAT_BGR555
	PIXELFORMAT_ARGB4444    = C.SDL_PIXELFORMAT_ARGB4444
	PIXELFORMAT_RGBA4444    = C.SDL_PIXELFORMAT_RGBA4444
	PIXELFORMAT_ABGR4444    = C.SDL_PIXELFORMAT_ABGR4444
	PIXELFORMAT_BGRA4444    = C.SDL_PIXELFORMAT_BGRA4444
	PIXELFORMAT_ARGB1555    = C.SDL_PIXELFORMAT_ARGB1555
	PIXELFORMAT_RGBA5551    = C.SDL_PIXELFORMAT_RGBA5551
	PIXELFORMAT_ABGR1555    = C.SDL_PIXELFORMAT_ABGR1555
	PIXELFORMAT_BGRA5551    = C.SDL_PIXELFORMAT_BGRA5551
	PIXELFORMAT_RGB565      = C.SDL_PIXELFORMAT_RGB565
	PIXELFORMAT_BGR565      = C.SDL_PIXELFORMAT_BGR565
	PIXELFORMAT_RGB24       = C.SDL_PIXELFORMAT_RGB24
	PIXELFORMAT_BGR24       = C.SDL_PIXELFORMAT_BGR24
	PIXELFORMAT_RGB888      = C.SDL_PIXELFORMAT_RGB888
	PIXELFORMAT_RGBX8888    = C.SDL_PIXELFORMAT_RGBX8888
	PIXELFORMAT_BGR888      = C.SDL_PIXELFORMAT_BGR888
	PIXELFORMAT_BGRX8888    = C.SDL_PIXELFORMAT_BGRX8888
	PIXELFORMAT_ARGB8888    = C.SDL_PIXELFORMAT_ARGB8888
	PIXELFORMAT_RGBA8888    = C.SDL_PIXELFORMAT_RGBA8888
	PIXELFORMAT_ABGR8888    = C.SDL_PIXELFORMAT_ABGR8888
	PIXELFORMAT_BGRA8888    = C.SDL_PIXELFORMAT_BGRA8888
	PIXELFORMAT_ARGB2101010 = C.SDL_PIXELFORMAT_ARGB2101010
	PIXELFORMAT_YV12        = C.SDL_PIXELFORMAT_YV12
	PIXELFORMAT_IYUV        = C.SDL_PIXELFORMAT_IYUV
	PIXELFORMAT_YUY2        = C.SDL_PIXELFORMAT_YUY2
	PIXELFORMAT_UYVY        = C.SDL_PIXELFORMAT_UYVY
	PIXELFORMAT_YVYU        = C.SDL_PIXELFORMAT_YVYU
)

const (
	ALPHA_OPAQUE      = C.SDL_ALPHA_OPAQUE
	ALPHA_TRANSPARENT = C.SDL_ALPHA_TRANSPARENT
)

const (
	POWERSTATE_UNKNOWN    = C.SDL_POWERSTATE_UNKNOWN    // cannot determine power status
	POWERSTATE_ON_BATTERY = C.SDL_POWERSTATE_ON_BATTERY // not plugged in, running on the battery
	POWERSTATE_NO_BATTERY = C.SDL_POWERSTATE_NO_BATTERY // plugged in, no battery available
	POWERSTATE_CHARGING   = C.SDL_POWERSTATE_CHARGING   // plugged in, charging battery
	POWERSTATE_CHARGED    = C.SDL_POWERSTATE_CHARGED    // plugged in, battery charged
)

const (
	RENDERER_SOFTWARE      = C.SDL_RENDERER_SOFTWARE      // the renderer is a software fallback
	RENDERER_ACCELERATED   = C.SDL_RENDERER_ACCELERATED   // the renderer uses hardware acceleration
	RENDERER_PRESENTVSYNC  = C.SDL_RENDERER_PRESENTVSYNC  // present is synchronized with the refresh rate
	RENDERER_TARGETTEXTURE = C.SDL_RENDERER_TARGETTEXTURE // the renderer supports rendering to texture
)

const (
	ScaleModeNearest ScaleMode = C.SDL_ScaleModeNearest // nearest pixel sampling
	ScaleModeLinear            = C.SDL_ScaleModeLinear  // linear filtering
	ScaleModeBest              = C.SDL_ScaleModeBest    // anisotropic filtering
)

const (
	TEXTUREACCESS_STATIC    = C.SDL_TEXTUREACCESS_STATIC    // changes rarely, not lockable
	TEXTUREACCESS_STREAMING = C.SDL_TEXTUREACCESS_STREAMING // changes frequently, lockable
	TEXTUREACCESS_TARGET    = C.SDL_TEXTUREACCESS_TARGET    // can be used as a render target
)

const (
	TEXTUREMODULATE_NONE  = C.SDL_TEXTUREMODULATE_NONE  // no modulation
	TEXTUREMODULATE_COLOR = C.SDL_TEXTUREMODULATE_COLOR // srcC = srcC * color
	TEXTUREMODULATE_ALPHA = C.SDL_TEXTUREMODULATE_ALPHA // srcA = srcA * alpha
)

const (
	FLIP_NONE       RendererFlip = C.SDL_FLIP_NONE       // do not flip
	FLIP_HORIZONTAL              = C.SDL_FLIP_HORIZONTAL // flip horizontally
	FLIP_VERTICAL                = C.SDL_FLIP_VERTICAL   // flip vertically
)

const (
	RWOPS_UNKNOWN   = 0 // unknown stream type
	RWOPS_WINFILE   = 1 // win32 file
	RWOPS_STDFILE   = 2 // stdio file
	RWOPS_JNIFILE   = 3 // android asset
	RWOPS_MEMORY    = 4 // memory stream
	RWOPS_MEMORY_RO = 5 // read-only memory stream
)

const (
	RW_SEEK_SET = C.RW_SEEK_SET // seek from the beginning of data
	RW_SEEK_CUR = C.RW_SEEK_CUR // seek relative to current read point
	RW_SEEK_END = C.RW_SEEK_END // seek relative to the end of data
)

const (
	SCANCODE_UNKNOWN = 0 // "" (no name, empty string)

	SCANCODE_A = C.SDL_SCANCODE_A // "A"
	SCANCODE_B = C.SDL_SCANCODE_B // "B"
	SCANCODE_C = C.SDL_SCANCODE_C // "C"
	SCANCODE_D = C.SDL_SCANCODE_D // "D"
	SCANCODE_E = C.SDL_SCANCODE_E // "E"
	SCANCODE_F = C.SDL_SCANCODE_F // "F"
	SCANCODE_G = C.SDL_SCANCODE_G // "G"
	SCANCODE_H = C.SDL_SCANCODE_H // "H"
	SCANCODE_I = C.SDL_SCANCODE_I // "I"
	SCANCODE_J = C.SDL_SCANCODE_J // "J"
	SCANCODE_K = C.SDL_SCANCODE_K // "K"
	SCANCODE_L = C.SDL_SCANCODE_L // "L"
	SCANCODE_M = C.SDL_SCANCODE_M // "M"
	SCANCODE_N = C.SDL_SCANCODE_N // "N"
	SCANCODE_O = C.SDL_SCANCODE_O // "O"
	SCANCODE_P = C.SDL_SCANCODE_P // "P"
	SCANCODE_Q = C.SDL_SCANCODE_Q // "Q"
	SCANCODE_R = C.SDL_SCANCODE_R // "R"
	SCANCODE_S = C.SDL_SCANCODE_S // "S"
	SCANCODE_T = C.SDL_SCANCODE_T // "T"
	SCANCODE_U = C.SDL_SCANCODE_U // "U"
	SCANCODE_V = C.SDL_SCANCODE_V // "V"
	SCANCODE_W = C.SDL_SCANCODE_W // "W"
	SCANCODE_X = C.SDL_SCANCODE_X // "X"
	SCANCODE_Y = C.SDL_SCANCODE_Y // "Y"
	SCANCODE_Z = C.SDL_SCANCODE_Z // "Z"

	SCANCODE_1 = C.SDL_SCANCODE_1 // "1"
	SCANCODE_2 = C.SDL_SCANCODE_2 // "2"
	SCANCODE_3 = C.SDL_SCANCODE_3 // "3"
	SCANCODE_4 = C.SDL_SCANCODE_4 // "4"
	SCANCODE_5 = C.SDL_SCANCODE_5 // "5"
	SCANCODE_6 = C.SDL_SCANCODE_6 // "6"
	SCANCODE_7 = C.SDL_SCANCODE_7 // "7"
	SCANCODE_8 = C.SDL_SCANCODE_8 // "8"
	SCANCODE_9 = C.SDL_SCANCODE_9 // "9"
	SCANCODE_0 = C.SDL_SCANCODE_0 // "0"

	SCANCODE_RETURN    = C.SDL_SCANCODE_RETURN    // "Return"
	SCANCODE_ESCAPE    = C.SDL_SCANCODE_ESCAPE    // "Escape" (the Esc key)
	SCANCODE_BACKSPACE = C.SDL_SCANCODE_BACKSPACE // "Backspace"
	SCANCODE_TAB       = C.SDL_SCANCODE_TAB       // "Tab" (the Tab key)
	SCANCODE_SPACE     = C.SDL_SCANCODE_SPACE     // "Space" (the Space Bar key(s))

	SCANCODE_MINUS        = C.SDL_SCANCODE_MINUS        // "-"
	SCANCODE_EQUALS       = C.SDL_SCANCODE_EQUALS       // "="
	SCANCODE_LEFTBRACKET  = C.SDL_SCANCODE_LEFTBRACKET  // "["
	SCANCODE_RIGHTBRACKET = C.SDL_SCANCODE_RIGHTBRACKET // "]"
	SCANCODE_BACKSLASH    = C.SDL_SCANCODE_BACKSLASH    // "\"
	SCANCODE_NONUSHASH    = C.SDL_SCANCODE_NONUSHASH    // "#" (ISO USB keyboards actually use this code instead of 49 for the same key, but all OSes I've seen treat the two codes identically. So, as an implementor, unless your keyboard generates both of those codes and your OS treats them differently, you should generate SDL_SCANCODE_BACKSLASH instead of this code. As a user, you should not rely on this code because SDL will never generate it with most (all?) keyboards.)
	SCANCODE_SEMICOLON    = C.SDL_SCANCODE_SEMICOLON    // ";"
	SCANCODE_APOSTROPHE   = C.SDL_SCANCODE_APOSTROPHE   // "'"
	SCANCODE_GRAVE        = C.SDL_SCANCODE_GRAVE        // "`"
	SCANCODE_COMMA        = C.SDL_SCANCODE_COMMA        // ","
	SCANCODE_PERIOD       = C.SDL_SCANCODE_PERIOD       // "."
	SCANCODE_SLASH        = C.SDL_SCANCODE_SLASH        // "/"
	SCANCODE_CAPSLOCK     = C.SDL_SCANCODE_CAPSLOCK     // "CapsLock"
	SCANCODE_F1           = C.SDL_SCANCODE_F1           // "F1"
	SCANCODE_F2           = C.SDL_SCANCODE_F2           // "F2"
	SCANCODE_F3           = C.SDL_SCANCODE_F3           // "F3"
	SCANCODE_F4           = C.SDL_SCANCODE_F4           // "F4"
	SCANCODE_F5           = C.SDL_SCANCODE_F5           // "F5"
	SCANCODE_F6           = C.SDL_SCANCODE_F6           // "F6"
	SCANCODE_F7           = C.SDL_SCANCODE_F7           // "F7"
	SCANCODE_F8           = C.SDL_SCANCODE_F8           // "F8"
	SCANCODE_F9           = C.SDL_SCANCODE_F9           // "F9"
	SCANCODE_F10          = C.SDL_SCANCODE_F10          // "F10"
	SCANCODE_F11          = C.SDL_SCANCODE_F11          // "F11"
	SCANCODE_F12          = C.SDL_SCANCODE_F12          // "F12"
	SCANCODE_PRINTSCREEN  = C.SDL_SCANCODE_PRINTSCREEN  // "PrintScreen"
	SCANCODE_SCROLLLOCK   = C.SDL_SCANCODE_SCROLLLOCK   // "ScrollLock"
	SCANCODE_PAUSE        = C.SDL_SCANCODE_PAUSE        // "Pause" (the Pause / Break key)
	SCANCODE_INSERT       = C.SDL_SCANCODE_INSERT       // "Insert" (insert on PC, help on some Mac keyboards (but does send code 73, not 117))
	SCANCODE_HOME         = C.SDL_SCANCODE_HOME         // "Home"
	SCANCODE_PAGEUP       = C.SDL_SCANCODE_PAGEUP       // "PageUp"
	SCANCODE_DELETE       = C.SDL_SCANCODE_DELETE       // "Delete"
	SCANCODE_END          = C.SDL_SCANCODE_END          // "End"
	SCANCODE_PAGEDOWN     = C.SDL_SCANCODE_PAGEDOWN     // "PageDown"
	SCANCODE_RIGHT        = C.SDL_SCANCODE_RIGHT        // "Right" (the Right arrow key (navigation keypad))
	SCANCODE_LEFT         = C.SDL_SCANCODE_LEFT         // "Left" (the Left arrow key (navigation keypad))
	SCANCODE_DOWN         = C.SDL_SCANCODE_DOWN         // "Down" (the Down arrow key (navigation keypad))
	SCANCODE_UP           = C.SDL_SCANCODE_UP           // "Up" (the Up arrow key (navigation keypad))

	SCANCODE_NUMLOCKCLEAR = C.SDL_SCANCODE_NUMLOCKCLEAR // "Numlock" (the Num Lock key (PC) / the Clear key (Mac))
	SCANCODE_KP_DIVIDE    = C.SDL_SCANCODE_KP_DIVIDE    // "Keypad /" (the / key (numeric keypad))
	SCANCODE_KP_MULTIPLY  = C.SDL_SCANCODE_KP_MULTIPLY  // "Keypad *" (the * key (numeric keypad))
	SCANCODE_KP_MINUS     = C.SDL_SCANCODE_KP_MINUS     // "Keypad -" (the - key (numeric keypad))
	SCANCODE_KP_PLUS      = C.SDL_SCANCODE_KP_PLUS      // "Keypad +" (the + key (numeric keypad))
	SCANCODE_KP_ENTER     = C.SDL_SCANCODE_KP_ENTER     // "Keypad Enter" (the Enter key (numeric keypad))
	SCANCODE_KP_1         = C.SDL_SCANCODE_KP_1         // "Keypad 1" (the 1 key (numeric keypad))
	SCANCODE_KP_2         = C.SDL_SCANCODE_KP_2         // "Keypad 2" (the 2 key (numeric keypad))
	SCANCODE_KP_3         = C.SDL_SCANCODE_KP_3         // "Keypad 3" (the 3 key (numeric keypad))
	SCANCODE_KP_4         = C.SDL_SCANCODE_KP_4         // "Keypad 4" (the 4 key (numeric keypad))
	SCANCODE_KP_5         = C.SDL_SCANCODE_KP_5         // "Keypad 5" (the 5 key (numeric keypad))
	SCANCODE_KP_6         = C.SDL_SCANCODE_KP_6         // "Keypad 6" (the 6 key (numeric keypad))
	SCANCODE_KP_7         = C.SDL_SCANCODE_KP_7         // "Keypad 7" (the 7 key (numeric keypad))
	SCANCODE_KP_8         = C.SDL_SCANCODE_KP_8         // "Keypad 8" (the 8 key (numeric keypad))
	SCANCODE_KP_9         = C.SDL_SCANCODE_KP_9         // "Keypad 9" (the 9 key (numeric keypad))
	SCANCODE_KP_0         = C.SDL_SCANCODE_KP_0         // "Keypad 0" (the 0 key (numeric keypad))
	SCANCODE_KP_PERIOD    = C.SDL_SCANCODE_KP_PERIOD    // "Keypad ." (the . key (numeric keypad))

	SCANCODE_NONUSBACKSLASH = C.SDL_SCANCODE_NONUSBACKSLASH // "" (no name, empty string; This is the additional key that ISO keyboards have over ANSI ones, located between left shift and Y. Produces GRAVE ACCENT and TILDE in a US or UK Mac layout, REVERSE SOLIDUS (backslash) and VERTICAL LINE in a US or UK Windows layout, and LESS-THAN SIGN and GREATER-THAN SIGN in a Swiss German, German, or French layout.)
	SCANCODE_APPLICATION    = C.SDL_SCANCODE_APPLICATION    // "Application" (the Application / Compose / Context Menu (Windows) key)
	SCANCODE_POWER          = C.SDL_SCANCODE_POWER          // "Power" (The USB document says this is a status flag, not a physical key - but some Mac keyboards do have a power key.)
	SCANCODE_KP_EQUALS      = C.SDL_SCANCODE_KP_EQUALS      // "Keypad =" (the = key (numeric keypad))
	SCANCODE_F13            = C.SDL_SCANCODE_F13            // "F13"
	SCANCODE_F14            = C.SDL_SCANCODE_F14            // "F14"
	SCANCODE_F15            = C.SDL_SCANCODE_F15            // "F15"
	SCANCODE_F16            = C.SDL_SCANCODE_F16            // "F16"
	SCANCODE_F17            = C.SDL_SCANCODE_F17            // "F17"
	SCANCODE_F18            = C.SDL_SCANCODE_F18            // "F18"
	SCANCODE_F19            = C.SDL_SCANCODE_F19            // "F19"
	SCANCODE_F20            = C.SDL_SCANCODE_F20            // "F20"
	SCANCODE_F21            = C.SDL_SCANCODE_F21            // "F21"
	SCANCODE_F22            = C.SDL_SCANCODE_F22            // "F22"
	SCANCODE_F23            = C.SDL_SCANCODE_F23            // "F23"
	SCANCODE_F24            = C.SDL_SCANCODE_F24            // "F24"
	SCANCODE_EXECUTE        = C.SDL_SCANCODE_EXECUTE        // "Execute"
	SCANCODE_HELP           = C.SDL_SCANCODE_HELP           // "Help"
	SCANCODE_MENU           = C.SDL_SCANCODE_MENU           // "Menu"
	SCANCODE_SELECT         = C.SDL_SCANCODE_SELECT         // "Select"
	SCANCODE_STOP           = C.SDL_SCANCODE_STOP           // "Stop"
	SCANCODE_AGAIN          = C.SDL_SCANCODE_AGAIN          // "Again" (the Again key (Redo))
	SCANCODE_UNDO           = C.SDL_SCANCODE_UNDO           // "Undo"
	SCANCODE_CUT            = C.SDL_SCANCODE_CUT            // "Cut"
	SCANCODE_COPY           = C.SDL_SCANCODE_COPY           // "Copy"
	SCANCODE_PASTE          = C.SDL_SCANCODE_PASTE          // "Paste"
	SCANCODE_FIND           = C.SDL_SCANCODE_FIND           // "Find"
	SCANCODE_MUTE           = C.SDL_SCANCODE_MUTE           // "Mute"
	SCANCODE_VOLUMEUP       = C.SDL_SCANCODE_VOLUMEUP       // "VolumeUp"
	SCANCODE_VOLUMEDOWN     = C.SDL_SCANCODE_VOLUMEDOWN     // "VolumeDown"
	SCANCODE_KP_COMMA       = C.SDL_SCANCODE_KP_COMMA       // "Keypad ," (the Comma key (numeric keypad))
	SCANCODE_KP_EQUALSAS400 = C.SDL_SCANCODE_KP_EQUALSAS400 // "Keypad = (AS400)" (the Equals AS400 key (numeric keypad))

	SCANCODE_INTERNATIONAL1 = C.SDL_SCANCODE_INTERNATIONAL1 // "" (no name, empty string; used on Asian keyboards, see footnotes in USB doc)
	SCANCODE_INTERNATIONAL2 = C.SDL_SCANCODE_INTERNATIONAL2 // "" (no name, empty string)
	SCANCODE_INTERNATIONAL3 = C.SDL_SCANCODE_INTERNATIONAL3 // "" (no name, empty string; Yen)
	SCANCODE_INTERNATIONAL4 = C.SDL_SCANCODE_INTERNATIONAL4 // "" (no name, empty string)
	SCANCODE_INTERNATIONAL5 = C.SDL_SCANCODE_INTERNATIONAL5 // "" (no name, empty string)
	SCANCODE_INTERNATIONAL6 = C.SDL_SCANCODE_INTERNATIONAL6 // "" (no name, empty string)
	SCANCODE_INTERNATIONAL7 = C.SDL_SCANCODE_INTERNATIONAL7 // "" (no name, empty string)
	SCANCODE_INTERNATIONAL8 = C.SDL_SCANCODE_INTERNATIONAL8 // "" (no name, empty string)
	SCANCODE_INTERNATIONAL9 = C.SDL_SCANCODE_INTERNATIONAL9 // "" (no name, empty string)
	SCANCODE_LANG1          = C.SDL_SCANCODE_LANG1          // "" (no name, empty string; Hangul/English toggle)
	SCANCODE_LANG2          = C.SDL_SCANCODE_LANG2          // "" (no name, empty string; Hanja conversion)
	SCANCODE_LANG3          = C.SDL_SCANCODE_LANG3          // "" (no name, empty string; Katakana)
	SCANCODE_LANG4          = C.SDL_SCANCODE_LANG4          // "" (no name, empty string; Hiragana)
	SCANCODE_LANG5          = C.SDL_SCANCODE_LANG5          // "" (no name, empty string; Zenkaku/Hankaku)
	SCANCODE_LANG6          = C.SDL_SCANCODE_LANG6          // "" (no name, empty string; reserved)
	SCANCODE_LANG7          = C.SDL_SCANCODE_LANG7          // "" (no name, empty string; reserved)
	SCANCODE_LANG8          = C.SDL_SCANCODE_LANG8          // "" (no name, empty string; reserved)
	SCANCODE_LANG9          = C.SDL_SCANCODE_LANG9          // "" (no name, empty string; reserved)

	SCANCODE_ALTERASE   = C.SDL_SCANCODE_ALTERASE   // "AltErase" (Erase-Eaze)
	SCANCODE_SYSREQ     = C.SDL_SCANCODE_SYSREQ     // "SysReq" (the SysReq key)
	SCANCODE_CANCEL     = C.SDL_SCANCODE_CANCEL     // "Cancel"
	SCANCODE_CLEAR      = C.SDL_SCANCODE_CLEAR      // "Clear"
	SCANCODE_PRIOR      = C.SDL_SCANCODE_PRIOR      // "Prior"
	SCANCODE_RETURN2    = C.SDL_SCANCODE_RETURN2    // "Return"
	SCANCODE_SEPARATOR  = C.SDL_SCANCODE_SEPARATOR  // "Separator"
	SCANCODE_OUT        = C.SDL_SCANCODE_OUT        // "Out"
	SCANCODE_OPER       = C.SDL_SCANCODE_OPER       // "Oper"
	SCANCODE_CLEARAGAIN = C.SDL_SCANCODE_CLEARAGAIN // "Clear / Again"
	SCANCODE_CRSEL      = C.SDL_SCANCODE_CRSEL      // "CrSel"
	SCANCODE_EXSEL      = C.SDL_SCANCODE_EXSEL      // "ExSel"

	SCANCODE_KP_00              = C.SDL_SCANCODE_KP_00              // "Keypad 00" (the 00 key (numeric keypad))
	SCANCODE_KP_000             = C.SDL_SCANCODE_KP_000             // "Keypad 000" (the 000 key (numeric keypad))
	SCANCODE_THOUSANDSSEPARATOR = C.SDL_SCANCODE_THOUSANDSSEPARATOR // "ThousandsSeparator" (the Thousands Separator key)
	SCANCODE_DECIMALSEPARATOR   = C.SDL_SCANCODE_DECIMALSEPARATOR   // "DecimalSeparator" (the Decimal Separator key)
	SCANCODE_CURRENCYUNIT       = C.SDL_SCANCODE_CURRENCYUNIT       // "CurrencyUnit" (the Currency Unit key)
	SCANCODE_CURRENCYSUBUNIT    = C.SDL_SCANCODE_CURRENCYSUBUNIT    // "CurrencySubUnit" (the Currency Subunit key)
	SCANCODE_KP_LEFTPAREN       = C.SDL_SCANCODE_KP_LEFTPAREN       // "Keypad (" (the Left Parenthesis key (numeric keypad))
	SCANCODE_KP_RIGHTPAREN      = C.SDL_SCANCODE_KP_RIGHTPAREN      // "Keypad )" (the Right Parenthesis key (numeric keypad))
	SCANCODE_KP_LEFTBRACE       = C.SDL_SCANCODE_KP_LEFTBRACE       // "Keypad {" (the Left Brace key (numeric keypad))
	SCANCODE_KP_RIGHTBRACE      = C.SDL_SCANCODE_KP_RIGHTBRACE      // "Keypad }" (the Right Brace key (numeric keypad))
	SCANCODE_KP_TAB             = C.SDL_SCANCODE_KP_TAB             // "Keypad Tab" (the Tab key (numeric keypad))
	SCANCODE_KP_BACKSPACE       = C.SDL_SCANCODE_KP_BACKSPACE       // "Keypad Backspace" (the Backspace key (numeric keypad))
	SCANCODE_KP_A               = C.SDL_SCANCODE_KP_A               // "Keypad A" (the A key (numeric keypad))
	SCANCODE_KP_B               = C.SDL_SCANCODE_KP_B               // "Keypad B" (the B key (numeric keypad))
	SCANCODE_KP_C               = C.SDL_SCANCODE_KP_C               // "Keypad C" (the C key (numeric keypad))
	SCANCODE_KP_D               = C.SDL_SCANCODE_KP_D               // "Keypad D" (the D key (numeric keypad))
	SCANCODE_KP_E               = C.SDL_SCANCODE_KP_E               // "Keypad E" (the E key (numeric keypad))
	SCANCODE_KP_F               = C.SDL_SCANCODE_KP_F               // "Keypad F" (the F key (numeric keypad))
	SCANCODE_KP_XOR             = C.SDL_SCANCODE_KP_XOR             // "Keypad XOR" (the XOR key (numeric keypad))
	SCANCODE_KP_POWER           = C.SDL_SCANCODE_KP_POWER           // "Keypad ^" (the Power key (numeric keypad))
	SCANCODE_KP_PERCENT         = C.SDL_SCANCODE_KP_PERCENT         // "Keypad %" (the Percent key (numeric keypad))
	SCANCODE_KP_LESS            = C.SDL_SCANCODE_KP_LESS            // "Keypad <" (the Less key (numeric keypad))
	SCANCODE_KP_GREATER         = C.SDL_SCANCODE_KP_GREATER         // "Keypad >" (the Greater key (numeric keypad))
	SCANCODE_KP_AMPERSAND       = C.SDL_SCANCODE_KP_AMPERSAND       // "Keypad &" (the & key (numeric keypad))
	SCANCODE_KP_DBLAMPERSAND    = C.SDL_SCANCODE_KP_DBLAMPERSAND    // "Keypad &&" (the && key (numeric keypad))
	SCANCODE_KP_VERTICALBAR     = C.SDL_SCANCODE_KP_VERTICALBAR     // "Keypad |" (the | key (numeric keypad))
	SCANCODE_KP_DBLVERTICALBAR  = C.SDL_SCANCODE_KP_DBLVERTICALBAR  // "Keypad ||" (the || key (numeric keypad))
	SCANCODE_KP_COLON           = C.SDL_SCANCODE_KP_COLON           // "Keypad :" (the : key (numeric keypad))
	SCANCODE_KP_HASH            = C.SDL_SCANCODE_KP_HASH            // "Keypad #" (the # key (numeric keypad))
	SCANCODE_KP_SPACE           = C.SDL_SCANCODE_KP_SPACE           // "Keypad Space" (the Space key (numeric keypad))
	SCANCODE_KP_AT              = C.SDL_SCANCODE_KP_AT              // "Keypad @" (the @ key (numeric keypad))
	SCANCODE_KP_EXCLAM          = C.SDL_SCANCODE_KP_EXCLAM          // "Keypad !" (the ! key (numeric keypad))
	SCANCODE_KP_MEMSTORE        = C.SDL_SCANCODE_KP_MEMSTORE        // "Keypad MemStore" (the Mem Store key (numeric keypad))
	SCANCODE_KP_MEMRECALL       = C.SDL_SCANCODE_KP_MEMRECALL       // "Keypad MemRecall" (the Mem Recall key (numeric keypad))
	SCANCODE_KP_MEMCLEAR        = C.SDL_SCANCODE_KP_MEMCLEAR        // "Keypad MemClear" (the Mem Clear key (numeric keypad))
	SCANCODE_KP_MEMADD          = C.SDL_SCANCODE_KP_MEMADD          // "Keypad MemAdd" (the Mem Add key (numeric keypad))
	SCANCODE_KP_MEMSUBTRACT     = C.SDL_SCANCODE_KP_MEMSUBTRACT     // "Keypad MemSubtract" (the Mem Subtract key (numeric keypad))
	SCANCODE_KP_MEMMULTIPLY     = C.SDL_SCANCODE_KP_MEMMULTIPLY     // "Keypad MemMultiply" (the Mem Multiply key (numeric keypad))
	SCANCODE_KP_MEMDIVIDE       = C.SDL_SCANCODE_KP_MEMDIVIDE       // "Keypad MemDivide" (the Mem Divide key (numeric keypad))
	SCANCODE_KP_PLUSMINUS       = C.SDL_SCANCODE_KP_PLUSMINUS       // "Keypad +/-" (the +/- key (numeric keypad))
	SCANCODE_KP_CLEAR           = C.SDL_SCANCODE_KP_CLEAR           // "Keypad Clear" (the Clear key (numeric keypad))
	SCANCODE_KP_CLEARENTRY      = C.SDL_SCANCODE_KP_CLEARENTRY      // "Keypad ClearEntry" (the Clear Entry key (numeric keypad))
	SCANCODE_KP_BINARY          = C.SDL_SCANCODE_KP_BINARY          // "Keypad Binary" (the Binary key (numeric keypad))
	SCANCODE_KP_OCTAL           = C.SDL_SCANCODE_KP_OCTAL           // "Keypad Octal" (the Octal key (numeric keypad))
	SCANCODE_KP_DECIMAL         = C.SDL_SCANCODE_KP_DECIMAL         // "Keypad Decimal" (the Decimal key (numeric keypad))
	SCANCODE_KP_HEXADECIMAL     = C.SDL_SCANCODE_KP_HEXADECIMAL     // "Keypad Hexadecimal" (the Hexadecimal key (numeric keypad))

	SCANCODE_LCTRL          = C.SDL_SCANCODE_LCTRL          // "Left Ctrl"
	SCANCODE_LSHIFT         = C.SDL_SCANCODE_LSHIFT         // "Left Shift"
	SCANCODE_LALT           = C.SDL_SCANCODE_LALT           // "Left Alt" (alt, option)
	SCANCODE_LGUI           = C.SDL_SCANCODE_LGUI           // "Left GUI" (windows, command (apple), meta)
	SCANCODE_RCTRL          = C.SDL_SCANCODE_RCTRL          // "Right Ctrl"
	SCANCODE_RSHIFT         = C.SDL_SCANCODE_RSHIFT         // "Right Shift"
	SCANCODE_RALT           = C.SDL_SCANCODE_RALT           // "Right Alt" (alt gr, option)
	SCANCODE_RGUI           = C.SDL_SCANCODE_RGUI           // "Right GUI" (windows, command (apple), meta)
	SCANCODE_MODE           = C.SDL_SCANCODE_MODE           // "ModeSwitch" (I'm not sure if this is really not covered by any of the above, but since there's a special KMOD_MODE for it I'm adding it here)
	SCANCODE_AUDIONEXT      = C.SDL_SCANCODE_AUDIONEXT      // "AudioNext" (the Next Track media key)
	SCANCODE_AUDIOPREV      = C.SDL_SCANCODE_AUDIOPREV      // "AudioPrev" (the Previous Track media key)
	SCANCODE_AUDIOSTOP      = C.SDL_SCANCODE_AUDIOSTOP      // "AudioStop" (the Stop media key)
	SCANCODE_AUDIOPLAY      = C.SDL_SCANCODE_AUDIOPLAY      // "AudioPlay" (the Play media key)
	SCANCODE_AUDIOMUTE      = C.SDL_SCANCODE_AUDIOMUTE      // "AudioMute" (the Mute volume key)
	SCANCODE_MEDIASELECT    = C.SDL_SCANCODE_MEDIASELECT    // "MediaSelect" (the Media Select key)
	SCANCODE_WWW            = C.SDL_SCANCODE_WWW            // "WWW" (the WWW/World Wide Web key)
	SCANCODE_MAIL           = C.SDL_SCANCODE_MAIL           // "Mail" (the Mail/eMail key)
	SCANCODE_CALCULATOR     = C.SDL_SCANCODE_CALCULATOR     // "Calculator" (the Calculator key)
	SCANCODE_COMPUTER       = C.SDL_SCANCODE_COMPUTER       // "Computer" (the My Computer key)
	SCANCODE_AC_SEARCH      = C.SDL_SCANCODE_AC_SEARCH      // "AC Search" (the Search key (application control keypad))
	SCANCODE_AC_HOME        = C.SDL_SCANCODE_AC_HOME        // "AC Home" (the Home key (application control keypad))
	SCANCODE_AC_BACK        = C.SDL_SCANCODE_AC_BACK        // "AC Back" (the Back key (application control keypad))
	SCANCODE_AC_FORWARD     = C.SDL_SCANCODE_AC_FORWARD     // "AC Forward" (the Forward key (application control keypad))
	SCANCODE_AC_STOP        = C.SDL_SCANCODE_AC_STOP        // "AC Stop" (the Stop key (application control keypad))
	SCANCODE_AC_REFRESH     = C.SDL_SCANCODE_AC_REFRESH     // "AC Refresh" (the Refresh key (application control keypad))
	SCANCODE_AC_BOOKMARKS   = C.SDL_SCANCODE_AC_BOOKMARKS   // "AC Bookmarks" (the Bookmarks key (application control keypad))
	SCANCODE_BRIGHTNESSDOWN = C.SDL_SCANCODE_BRIGHTNESSDOWN // "BrightnessDown" (the Brightness Down key)
	SCANCODE_BRIGHTNESSUP   = C.SDL_SCANCODE_BRIGHTNESSUP   // "BrightnessUp" (the Brightness Up key)
	SCANCODE_DISPLAYSWITCH  = C.SDL_SCANCODE_DISPLAYSWITCH  // "DisplaySwitch" (display mirroring/dual display switch, video mode switch)
	SCANCODE_KBDILLUMTOGGLE = C.SDL_SCANCODE_KBDILLUMTOGGLE // "KBDIllumToggle" (the Keyboard Illumination Toggle key)
	SCANCODE_KBDILLUMDOWN   = C.SDL_SCANCODE_KBDILLUMDOWN   // "KBDIllumDown" (the Keyboard Illumination Down key)
	SCANCODE_KBDILLUMUP     = C.SDL_SCANCODE_KBDILLUMUP     // "KBDIllumUp" (the Keyboard Illumination Up key)
	SCANCODE_EJECT          = C.SDL_SCANCODE_EJECT          // "Eject" (the Eject key)
	SCANCODE_SLEEP          = C.SDL_SCANCODE_SLEEP          // "Sleep" (the Sleep key)
	SCANCODE_APP1           = C.SDL_SCANCODE_APP1
	SCANCODE_APP2           = C.SDL_SCANCODE_APP2
	NUM_SCANCODES           = C.SDL_NUM_SCANCODES
)

const (
	INIT_TIMER          = C.SDL_INIT_TIMER          // timer subsystem
	INIT_AUDIO          = C.SDL_INIT_AUDIO          // audio subsystem
	INIT_VIDEO          = C.SDL_INIT_VIDEO          // video subsystem; automatically initializes the events subsystem
	INIT_JOYSTICK       = C.SDL_INIT_JOYSTICK       // joystick subsystem; automatically initializes the events subsystem
	INIT_HAPTIC         = C.SDL_INIT_HAPTIC         // haptic (force feedback) subsystem
	INIT_GAMECONTROLLER = C.SDL_INIT_GAMECONTROLLER // controller subsystem; automatically initializes the joystick subsystem
	INIT_EVENTS         = C.SDL_INIT_EVENTS         // events subsystem
	INIT_NOPARACHUTE    = C.SDL_INIT_NOPARACHUTE    // compatibility; this flag is ignored
	INIT_SENSOR         = C.SDL_INIT_SENSOR         // sensor subsystem
	INIT_EVERYTHING     = C.SDL_INIT_EVERYTHING     // all of the above subsystems
)

const (
	RELEASED = 0
	PRESSED  = 1
)

const (
	NONSHAPEABLE_WINDOW    = C.SDL_NONSHAPEABLE_WINDOW
	INVALID_SHAPE_ARGUMENT = C.SDL_INVALID_SHAPE_ARGUMENT
	WINDOW_LACKS_SHAPE     = C.SDL_WINDOW_LACKS_SHAPE
)

const (
	SWSURFACE = C.SDL_SWSURFACE // just here for compatibility
	PREALLOC  = C.SDL_PREALLOC  // surface uses preallocated memory
	RLEACCEL  = C.SDL_RLEACCEL  // surface is RLE encoded
	DONTFREE  = C.SDL_DONTFREE  // surface is referenced internally
)

const (
	YUV_CONVERSION_JPEG      YUV_CONVERSION_MODE = C.SDL_YUV_CONVERSION_JPEG      // Full range JPEG
	YUV_CONVERSION_BT601                         = C.SDL_YUV_CONVERSION_BT601     // BT.601 (the default)
	YUV_CONVERSION_BT709                         = C.SDL_YUV_CONVERSION_BT709     // BT.709
	YUV_CONVERSION_AUTOMATIC                     = C.SDL_YUV_CONVERSION_AUTOMATIC // BT.601 for SD content, BT.709 for HD content
)

const (
	SYSWM_UNKNOWN  = C.SDL_SYSWM_UNKNOWN
	SYSWM_WINDOWS  = C.SDL_SYSWM_WINDOWS  // Microsoft Windows
	SYSWM_X11      = C.SDL_SYSWM_X11      // X Window System
	SYSWM_DIRECTFB = C.SDL_SYSWM_DIRECTFB // DirectFB
	SYSWM_COCOA    = C.SDL_SYSWM_COCOA    // Apple Mac OS X
	SYSWM_UIKIT    = C.SDL_SYSWM_UIKIT    // Apple iOS
	SYSWM_WAYLAND  = C.SDL_SYSWM_WAYLAND  // Wayland (>= SDL 2.0.2)
	SYSWM_MIR      = C.SDL_SYSWM_MIR      // Mir (>= SDL 2.0.2)
	SYSWM_WINRT    = C.SDL_SYSWM_WINRT    // WinRT (>= SDL 2.0.3)
	SYSWM_ANDROID  = C.SDL_SYSWM_ANDROID  // Android (>= SDL 2.0.4)
	SYSWM_VIVANTE  = C.SDL_SYSWM_VIVANTE  // Vivante (>= SDL 2.0.5)
)

const (
	TOUCH_DEVICE_INVALID           TouchDeviceType = C.SDL_TOUCH_DEVICE_INVALID
	TOUCH_DEVICE_DIRECT                            = C.SDL_TOUCH_DEVICE_DIRECT            // touch screen with window-relative coordinates
	TOUCH_DEVICE_INDIRECT_ABSOLUTE                 = C.SDL_TOUCH_DEVICE_INDIRECT_ABSOLUTE // trackpad with absolute device coordinates
	TOUCH_DEVICE_INDIRECT_RELATIVE                 = C.SDL_TOUCH_DEVICE_INDIRECT_RELATIVE // trackpad with screen cursor-relative coordinates
)

const (
	MAJOR_VERSION = C.SDL_MAJOR_VERSION // major version
	MINOR_VERSION = C.SDL_MINOR_VERSION // minor version
	PATCHLEVEL    = C.SDL_PATCHLEVEL    // update version (patchlevel)
)

const (
	WINDOW_FULLSCREEN         = C.SDL_WINDOW_FULLSCREEN         // fullscreen window
	WINDOW_OPENGL             = C.SDL_WINDOW_OPENGL             // window usable with OpenGL context
	WINDOW_SHOWN              = C.SDL_WINDOW_SHOWN              // window is visible
	WINDOW_HIDDEN             = C.SDL_WINDOW_HIDDEN             // window is not visible
	WINDOW_BORDERLESS         = C.SDL_WINDOW_BORDERLESS         // no window decoration
	WINDOW_RESIZABLE          = C.SDL_WINDOW_RESIZABLE          // window can be resized
	WINDOW_MINIMIZED          = C.SDL_WINDOW_MINIMIZED          // window is minimized
	WINDOW_MAXIMIZED          = C.SDL_WINDOW_MAXIMIZED          // window is maximized
	WINDOW_INPUT_GRABBED      = C.SDL_WINDOW_INPUT_GRABBED      // window has grabbed input focus
	WINDOW_INPUT_FOCUS        = C.SDL_WINDOW_INPUT_FOCUS        // window has input focus
	WINDOW_MOUSE_FOCUS        = C.SDL_WINDOW_MOUSE_FOCUS        // window has mouse focus
	WINDOW_FULLSCREEN_DESKTOP = C.SDL_WINDOW_FULLSCREEN_DESKTOP // fullscreen window at the current desktop resolution
	WINDOW_FOREIGN            = C.SDL_WINDOW_FOREIGN            // window not created by SDL
	WINDOW_ALLOW_HIGHDPI      = C.SDL_WINDOW_ALLOW_HIGHDPI      // window should be created in high-DPI mode if supported (>= SDL 2.0.1)
	WINDOW_MOUSE_CAPTURE      = C.SDL_WINDOW_MOUSE_CAPTURE      // window has mouse captured (unrelated to INPUT_GRABBED, >= SDL 2.0.4)
	WINDOW_ALWAYS_ON_TOP      = C.SDL_WINDOW_ALWAYS_ON_TOP      // window should always be above others (X11 only, >= SDL 2.0.5)
	WINDOW_SKIP_TASKBAR       = C.SDL_WINDOW_SKIP_TASKBAR       // window should not be added to the taskbar (X11 only, >= SDL 2.0.5)
	WINDOW_UTILITY            = C.SDL_WINDOW_UTILITY            // window should be treated as a utility window (X11 only, >= SDL 2.0.5)
	WINDOW_TOOLTIP            = C.SDL_WINDOW_TOOLTIP            // window should be treated as a tooltip (X11 only, >= SDL 2.0.5)
	WINDOW_POPUP_MENU         = C.SDL_WINDOW_POPUP_MENU         // window should be treated as a popup menu (X11 only, >= SDL 2.0.5)
	WINDOW_VULKAN             = C.SDL_WINDOW_VULKAN             // window usable for Vulkan surface (>= SDL 2.0.6)
)

const (
	WINDOWEVENT_NONE            = C.SDL_WINDOWEVENT_NONE            // (never used)
	WINDOWEVENT_SHOWN           = C.SDL_WINDOWEVENT_SHOWN           // window has been shown
	WINDOWEVENT_HIDDEN          = C.SDL_WINDOWEVENT_HIDDEN          // window has been hidden
	WINDOWEVENT_EXPOSED         = C.SDL_WINDOWEVENT_EXPOSED         // window has been exposed and should be redrawn
	WINDOWEVENT_MOVED           = C.SDL_WINDOWEVENT_MOVED           // window has been moved to data1, data2
	WINDOWEVENT_RESIZED         = C.SDL_WINDOWEVENT_RESIZED         // window has been resized to data1xdata2; this event is always preceded by WINDOWEVENT_SIZE_CHANGED
	WINDOWEVENT_SIZE_CHANGED    = C.SDL_WINDOWEVENT_SIZE_CHANGED    // window size has changed, either as a result of an API call or through the system or user changing the window size; this event is followed by WINDOWEVENT_RESIZED if the size was changed by an external event, i.e. the user or the window manager
	WINDOWEVENT_MINIMIZED       = C.SDL_WINDOWEVENT_MINIMIZED       // window has been minimized
	WINDOWEVENT_MAXIMIZED       = C.SDL_WINDOWEVENT_MAXIMIZED       // window has been maximized
	WINDOWEVENT_RESTORED        = C.SDL_WINDOWEVENT_RESTORED        // window has been restored to normal size and position
	WINDOWEVENT_ENTER           = C.SDL_WINDOWEVENT_ENTER           // window has gained mouse focus
	WINDOWEVENT_LEAVE           = C.SDL_WINDOWEVENT_LEAVE           // window has lost mouse focus
	WINDOWEVENT_FOCUS_GAINED    = C.SDL_WINDOWEVENT_FOCUS_GAINED    // window has gained keyboard focus
	WINDOWEVENT_FOCUS_LOST      = C.SDL_WINDOWEVENT_FOCUS_LOST      // window has lost keyboard focus
	WINDOWEVENT_CLOSE           = C.SDL_WINDOWEVENT_CLOSE           // the window manager requests that the window be closed
	WINDOWEVENT_TAKE_FOCUS      = C.SDL_WINDOWEVENT_TAKE_FOCUS      // window is being offered a focus (should SDL_SetWindowInputFocus() on itself or a subwindow, or ignore) (>= SDL 2.0.5)
	WINDOWEVENT_HIT_TEST        = C.SDL_WINDOWEVENT_HIT_TEST        // window had a hit test that wasn't SDL_HITTEST_NORMAL (>= SDL 2.0.5)
	WINDOWEVENT_ICCPROF_CHANGED = C.SDL_WINDOWEVENT_ICCPROF_CHANGED // the ICC profile of the window's display has changed
	WINDOWEVENT_DISPLAY_CHANGED = C.SDL_WINDOWEVENT_DISPLAY_CHANGED // window has been moved to display data1
)

const (
	WINDOWPOS_UNDEFINED_MASK = C.SDL_WINDOWPOS_UNDEFINED_MASK // used to indicate that you don't care what the window position is
	WINDOWPOS_UNDEFINED      = C.SDL_WINDOWPOS_UNDEFINED      // used to indicate that you don't care what the window position is
	WINDOWPOS_CENTERED_MASK  = C.SDL_WINDOWPOS_CENTERED_MASK  // used to indicate that the window position should be centered
	WINDOWPOS_CENTERED       = C.SDL_WINDOWPOS_CENTERED       // used to indicate that the window position should be centered
)

const (
	MESSAGEBOX_ERROR       = C.SDL_MESSAGEBOX_ERROR       // error dialog
	MESSAGEBOX_WARNING     = C.SDL_MESSAGEBOX_WARNING     // warning dialog
	MESSAGEBOX_INFORMATION = C.SDL_MESSAGEBOX_INFORMATION // informational dialog
)

const (
	MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT = C.SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT // marks the default button when return is hit
	MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT = C.SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT // marks the default button when escape is hit
)

const (
	GL_RED_SIZE                   = C.SDL_GL_RED_SIZE                   // the minimum number of bits for the red channel of the color buffer; defaults to 3
	GL_GREEN_SIZE                 = C.SDL_GL_GREEN_SIZE                 // the minimum number of bits for the green channel of the color buffer; defaults to 3
	GL_BLUE_SIZE                  = C.SDL_GL_BLUE_SIZE                  // the minimum number of bits for the blue channel of the color buffer; defaults to 2
	GL_ALPHA_SIZE                 = C.SDL_GL_ALPHA_SIZE                 // the minimum number of bits for the alpha channel of the color buffer; defaults to 0
	GL_BUFFER_SIZE                = C.SDL_GL_BUFFER_SIZE                // the minimum number of bits for frame buffer size; defaults to 0
	GL_DOUBLEBUFFER               = C.SDL_GL_DOUBLEBUFFER               // whether the output is single or double buffered; defaults to double buffering on
	GL_DEPTH_SIZE                 = C.SDL_GL_DEPTH_SIZE                 // the minimum number of bits in the depth buffer; defaults to 16
	GL_STENCIL_SIZE               = C.SDL_GL_STENCIL_SIZE               // the minimum number of bits in the stencil buffer; defaults to 0
	GL_ACCUM_RED_SIZE             = C.SDL_GL_ACCUM_RED_SIZE             // the minimum number of bits for the red channel of the accumulation buffer; defaults to 0
	GL_ACCUM_GREEN_SIZE           = C.SDL_GL_ACCUM_GREEN_SIZE           // the minimum number of bits for the green channel of the accumulation buffer; defaults to 0
	GL_ACCUM_BLUE_SIZE            = C.SDL_GL_ACCUM_BLUE_SIZE            // the minimum number of bits for the blue channel of the accumulation buffer; defaults to 0
	GL_ACCUM_ALPHA_SIZE           = C.SDL_GL_ALPHA_SIZE                 // the minimum number of bits for the alpha channel of the accumulation buffer; defaults to 0
	GL_STEREO                     = C.SDL_GL_STEREO                     // whether the output is stereo 3D; defaults to off
	GL_MULTISAMPLEBUFFERS         = C.SDL_GL_MULTISAMPLEBUFFERS         // the number of buffers used for multisample anti-aliasing; defaults to 0; see Remarks for details
	GL_MULTISAMPLESAMPLES         = C.SDL_GL_MULTISAMPLESAMPLES         // the number of samples used around the current pixel used for multisample anti-aliasing; defaults to 0; see Remarks for details
	GL_ACCELERATED_VISUAL         = C.SDL_GL_ACCELERATED_VISUAL         // set to 1 to require hardware acceleration, set to 0 to force software rendering; defaults to allow either
	GL_RETAINED_BACKING           = C.SDL_GL_RETAINED_BACKING           // not used (deprecated)
	GL_CONTEXT_MAJOR_VERSION      = C.SDL_GL_CONTEXT_MAJOR_VERSION      // OpenGL context major version
	GL_CONTEXT_MINOR_VERSION      = C.SDL_GL_CONTEXT_MINOR_VERSION      // OpenGL context minor version
	GL_CONTEXT_EGL                = C.SDL_GL_CONTEXT_EGL                // not used (deprecated)
	GL_CONTEXT_FLAGS              = C.SDL_GL_CONTEXT_FLAGS              // some combination of 0 or more of elements of the GLcontextFlag enumeration; defaults to 0 (https://wiki.libsdl.org/SDL_GLcontextFlag)
	GL_CONTEXT_PROFILE_MASK       = C.SDL_GL_CONTEXT_PROFILE_MASK       // type of GL context (Core, Compatibility, ES); default value depends on platform (https://wiki.libsdl.org/SDL_GLprofile)
	GL_SHARE_WITH_CURRENT_CONTEXT = C.SDL_GL_SHARE_WITH_CURRENT_CONTEXT // OpenGL context sharing; defaults to 0
	GL_FRAMEBUFFER_SRGB_CAPABLE   = C.SDL_GL_FRAMEBUFFER_SRGB_CAPABLE   // requests sRGB capable visual; defaults to 0 (>= SDL 2.0.1)
	GL_CONTEXT_RELEASE_BEHAVIOR   = C.SDL_GL_CONTEXT_RELEASE_BEHAVIOR   // sets context the release behavior; defaults to 1 (>= SDL 2.0.4)
	GL_CONTEXT_RESET_NOTIFICATION = C.SDL_GL_CONTEXT_RESET_NOTIFICATION // (>= SDL 2.0.6)
	GL_CONTEXT_NO_ERROR           = C.SDL_GL_CONTEXT_NO_ERROR           // (>= SDL 2.0.6)
)

const (
	GL_CONTEXT_PROFILE_CORE          = C.SDL_GL_CONTEXT_PROFILE_CORE          // OpenGL core profile - deprecated functions are disabled
	GL_CONTEXT_PROFILE_COMPATIBILITY = C.SDL_GL_CONTEXT_PROFILE_COMPATIBILITY // OpenGL compatibility profile - deprecated functions are allowed
	GL_CONTEXT_PROFILE_ES            = C.SDL_GL_CONTEXT_PROFILE_ES            // OpenGL ES profile - only a subset of the base OpenGL functionality is available
)

const (
	GL_CONTEXT_DEBUG_FLAG              = C.SDL_GL_CONTEXT_DEBUG_FLAG              // intended to put the GL into a "debug" mode which might offer better developer insights, possibly at a loss of performance
	GL_CONTEXT_FORWARD_COMPATIBLE_FLAG = C.SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG // intended to put the GL into a "forward compatible" mode, which means that no deprecated functionality will be supported, possibly at a gain in performance, and only applies to GL 3.0 and later contexts
	GL_CONTEXT_ROBUST_ACCESS_FLAG      = C.SDL_GL_CONTEXT_ROBUST_ACCESS_FLAG      // intended to require a GL context that supports the GL_ARB_robustness extension--a mode that offers a few APIs that are safer than the usual defaults (think snprintf() vs sprintf())
	GL_CONTEXT_RESET_ISOLATION_FLAG    = C.SDL_GL_CONTEXT_RESET_ISOLATION_FLAG    // intended to require the GL to make promises about what to do in the face of driver or hardware failure
)

const (
	FLASH_CANCEL        FlashOperation = C.SDL_FLASH_CANCEL        // Cancel any window flash state
	FLASH_BRIEFLY                      = C.SDL_FLASH_BRIEFLY       // Flash the window briefly to get attention
	FLASH_UNTIL_FOCUSED                = C.SDL_FLASH_UNTIL_FOCUSED // Flash the window until it gets focus
)

const CACHELINE_SIZE = C.SDL_CACHELINE_SIZE

const K_SCANCODE_MASK = 1 << 30

const MIX_MAXVOLUME = C.SDL_MIX_MAXVOLUME // full audio volume

const (
	STANDARD_GRAVITY = 9.80665
)

const TOUCH_MOUSEID = C.SDL_TOUCH_MOUSEID