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
    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.
)

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 (
    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 (
    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)
)

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 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

var (
    PIXELFORMAT_RGBA32 = C.SDL_PIXELFORMAT_RGBA32
    PIXELFORMAT_ARGB32 = C.SDL_PIXELFORMAT_ARGB32
    PIXELFORMAT_BGRA32 = C.SDL_PIXELFORMAT_BGRA32
    PIXELFORMAT_ABGR32 = C.SDL_PIXELFORMAT_ABGR32
)

var (
    RGB444Model   color.Model = color.ModelFunc(rgb444Model)
    RGB332Model   color.Model = color.ModelFunc(rgb332Model)
    RGB565Model   color.Model = color.ModelFunc(rgb565Model)
    RGB555Model   color.Model = color.ModelFunc(rgb555Model)
    BGR565Model   color.Model = color.ModelFunc(bgr565Model)
    BGR555Model   color.Model = color.ModelFunc(bgr555Model)
    ARGB4444Model color.Model = color.ModelFunc(argb4444Model)
    ABGR4444Model color.Model = color.ModelFunc(abgr4444Model)
    RGBA4444Model color.Model = color.ModelFunc(rgba4444Model)
    BGRA4444Model color.Model = color.ModelFunc(bgra4444Model)
    ARGB1555Model color.Model = color.ModelFunc(argb1555Model)
    RGBA5551Model color.Model = color.ModelFunc(rgba5551Model)
    ABGR1555Model color.Model = color.ModelFunc(abgr1555Model)
    BGRA5551Model color.Model = color.ModelFunc(bgra5551Model)
    RGBA8888Model color.Model = color.ModelFunc(rgba8888Model)
    BGRA8888Model color.Model = color.ModelFunc(bgra8888Model)
)

var ErrInvalidParameters = errors.New("Invalid Parameters")

type ABGR1555 struct {
    A, R, G, B byte
}

type ABGR4444 struct {
    A, B, G, R byte
}

type ARGB1555 struct {
    A, R, G, B byte
}

type ARGB4444 struct {
    A, R, G, B byte
}

type AudioCVT struct {
    Needed    int32          // set to 1 if conversion possible
    SrcFormat AudioFormat    // source audio format
    DstFormat AudioFormat    // target audio format
    RateIncr  float64        // rate conversion increment
    Buf       unsafe.Pointer // the buffer to hold entire audio data. Use AudioCVT.BufAsSlice() for access via a Go slice
    Len       int32          // length of original audio buffer
    LenCVT    int32          // length of converted audio buffer
    LenMult   int32          // buf must be len*len_mult big
    LenRatio  float64        // given len, final size is len*len_ratio
    // contains filtered or unexported fields
}

type AudioCallback C.SDL_AudioCallback

type AudioDeviceEvent struct {
    Type      uint32 // AUDIODEVICEADDED, AUDIODEVICEREMOVED
    Timestamp uint32 // the timestamp of the event
    Which     uint32 // the audio device index for the AUDIODEVICEADDED event (valid until next GetNumAudioDevices() call), AudioDeviceID for the AUDIODEVICEREMOVED event
    IsCapture uint8  // zero if an audio output device, non-zero if an audio capture device
    // contains filtered or unexported fields
}

type AudioDeviceID uint32

type AudioFilter C.SDL_AudioFilter

type AudioFormat uint16

type AudioSpec struct {
    Freq     int32       // DSP frequency (samples per second)
    Format   AudioFormat // audio data format
    Channels uint8       // number of separate sound channels
    Silence  uint8       // audio buffer silence value (calculated)
    Samples  uint16      // audio buffer size in samples (power of 2)

    Size     uint32         // audio buffer size in bytes (calculated)
    Callback AudioCallback  // the function to call when the audio device needs more data
    UserData unsafe.Pointer // a pointer that is passed to callback (otherwise ignored by SDL)
    // contains filtered or unexported fields
}

type AudioStatus uint32

type AudioStream C.SDL_AudioStream

type BGR555 struct {
    B, G, R byte
}

type BGR565 struct {
    B, G, R byte
}

type BGRA4444 struct {
    B, G, R, A byte
}

type BGRA5551 struct {
    B, G, R, A byte
}

type BGRA8888 struct {
    B, G, R, A byte
}

type BlendFactor C.SDL_BlendFactor

type BlendMode uint32