go-sdl2: github.com/veandco/go-sdl2/sdl Index | Files

package sdl

import "github.com/veandco/go-sdl2/sdl"

Package sdl is SDL2 wrapped for Go users. It enables interoperability between Go and the SDL2 library which is written in C. That means the original SDL2 installation is required for this to work. SDL2 is a cross-platform development library designed to provide low level access to audio, keyboard, mouse, joystick, and graphics hardware via OpenGL and Direct3D.

Index

Package Files

audio.go blendmode.go clipboard.go cpuinfo.go endian.go error.go events.go filesystem.go gamecontroller.go gesture.go haptic.go helpers.go hints.go joystick.go keyboard.go keycode.go loadso.go log.go mouse.go mutex.go pixels.go power.go rect.go render.go rwops.go scancode.go sdl.go surface.go sysrender.go syswm.go timer.go touch.go version.go video.go yuv_sw_c.go

Constants

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

Audio format masks. (https://wiki.libsdl.org/SDL_AudioFormat)

const (
    AUDIO_S8 = C.AUDIO_S8 // unsigned 8-bit samples
    AUDIO_U8 = C.AUDIO_U8 // signed 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
)

Audio format values. (https://wiki.libsdl.org/SDL_AudioFormat)

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
)

AllowedChanges flags specify how SDL should behave when a device cannot offer a specific feature. If the application requests a feature that the hardware doesn't offer, SDL will always try to get the closest equivalent. Used in OpenAudioDevice(). (https://wiki.libsdl.org/SDL_OpenAudioDevice)

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 is an enumeration of blend modes used in Render.Copy() and drawing operations. (https://wiki.libsdl.org/SDL_BlendMode)

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
)

Endian-specific values. (https://wiki.libsdl.org/CategoryEndian)

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

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

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

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

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

Enumeration of the types of events that can be delivered. (https://wiki.libsdl.org/SDL_EventType)

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
)

Actions for PeepEvents(). (https://wiki.libsdl.org/SDL_PeepEvents)

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

Toggles for different event state functions.

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
)

Types of game controller inputs.

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
)

An enumeration of axes available from a controller. (https://wiki.libsdl.org/SDL_GameControllerAxis)

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
)

An enumeration of buttons available from a controller. (https://wiki.libsdl.org/SDL_GameControllerButton)

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

)

Haptic effects. (https://wiki.libsdl.org/SDL_HapticEffect)

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
)

Direction encodings. (https://wiki.libsdl.org/SDL_HapticDirection)

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

Configuration hints (https://wiki.libsdl.org/CategoryHints)

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
)

An enumeration of hint priorities. (https://wiki.libsdl.org/SDL_HintPriority)

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
)

Hat positions. (https://wiki.libsdl.org/SDL_JoystickGetHat)

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

The SDL virtual key representation. (https://wiki.libsdl.org/SDL_Keycode) (https://wiki.libsdl.org/SDLKeycodeLookup)

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
)

An enumeration of key modifier masks. (https://wiki.libsdl.org/SDL_Keymod)

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
)

An enumeration of the predefined log categories. (https://wiki.libsdl.org/SDL_LOG_CATEGORY)

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

An enumeration of the predefined log priorities. (https://wiki.libsdl.org/SDL_LogPriority)

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

Cursor types for CreateSystemCursor()

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

Scroll direction types for the Scroll event

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
)

Used as a mask when testing buttons in buttonstate.

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
)

Pixel types.

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

Bitmap pixel order high bit -> low bit.

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
)

Packed component order high bit -> low bit.

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
)

Array component order low byte -> high byte.

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
)

Packed component layout.

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
)

Pixel format values.

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

These define alpha as the opacity of a surface.

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
)

An enumeration of the basic state of the system's power supply. (https://wiki.libsdl.org/SDL_PowerState)

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
)

An enumeration of flags used when creating a rendering context. (https://wiki.libsdl.org/SDL_RendererFlags)

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
)

An enumeration of texture access patterns.. (https://wiki.libsdl.org/SDL_TextureAccess)

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
)

An enumeration of the texture channel modulation used in Renderer.Copy(). (https://wiki.libsdl.org/SDL_TextureModulate)

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
)

RWops types

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
)

RWops seek from

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
)

The SDL keyboard scancode representation. (https://wiki.libsdl.org/SDL_Scancode) (https://wiki.libsdl.org/SDLScancodeLookup)

const (
    INIT_TIMER          = 0x00000001
    INIT_AUDIO          = 0x00000010
    INIT_VIDEO          = 0x00000020
    INIT_JOYSTICK       = 0x00000200
    INIT_HAPTIC         = 0x00001000
    INIT_GAMECONTROLLER = 0x00002000
    INIT_NOPARACHUTE    = 0x00100000
    INIT_EVERYTHING     = INIT_TIMER | INIT_AUDIO | INIT_VIDEO | INIT_JOYSTICK |
        INIT_HAPTIC | INIT_GAMECONTROLLER
)

These are the flags which may be passed to SDL_Init().

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
)

Surface flags (internal use)

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

Various supported windowing subsystems.

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

The version of SDL in use.

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

An enumeration of window states. (https://wiki.libsdl.org/SDL_WindowFlags)

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

An enumeration of window events. (https://wiki.libsdl.org/SDL_WindowEventID)

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
)

Window position flags. (https://wiki.libsdl.org/SDL_CreateWindow)

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
)

An enumeration of message box flags (e.g. if supported message box will display warning icon). (https://wiki.libsdl.org/SDL_MessageBoxFlags)

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
)

Flags for MessageBoxButtonData.

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

OpenGL configuration attributes. (https://wiki.libsdl.org/SDL_GL_SetAttribute)

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
)

An enumeration of OpenGL profiles. (https://wiki.libsdl.org/SDL_GLprofile)

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
)

An enumeration of OpenGL context configuration flags. (https://wiki.libsdl.org/SDL_GLcontextFlag)

const CACHELINE_SIZE = C.SDL_CACHELINE_SIZE

CACHELINE_SIZE is a cacheline size used for padding.

const K_SCANCODE_MASK = 1 << 30
const MIX_MAXVOLUME = C.SDL_MIX_MAXVOLUME // full audio volume

MIX_MAXVOLUME is the full audio volume value used in MixAudioFormat() and AudioFormat(). (https://wiki.libsdl.org/SDL_MixAudioFormat)

const TOUCH_MOUSEID = C.SDL_TOUCH_MOUSEID

TOUCH_MOUSEID is the device ID for mouse events simulated with touch input

Variables

var (
    PIXELFORMAT_RGBA32 int
    PIXELFORMAT_ARGB32 int
    PIXELFORMAT_BGRA32 int
    PIXELFORMAT_ABGR32 int
)

Pixel format variables.

func AddHintCallback Uses

func AddHintCallback(name string, fn HintCallback, data interface{})

AddHintCallback adds a function to watch a particular hint. (https://wiki.libsdl.org/SDL_AddHintCallback)

func AudioInit Uses

func AudioInit(driverName string) error

AudioInit initializes a particular audio driver. (https://wiki.libsdl.org/SDL_AudioInit)

func AudioQuit Uses

func AudioQuit()

AudioQuit shuts down audio if you initialized it with AudioInit(). (https://wiki.libsdl.org/SDL_AudioQuit)

func Btoi Uses

func Btoi(b bool) int

Btoi returns 0 or 1 according to the value of b.

func BuildAudioCVT Uses

func BuildAudioCVT(cvt *AudioCVT, srcFormat AudioFormat, srcChannels uint8, srcRate int, dstFormat AudioFormat, dstChannels uint8, dstRate int) (converted bool, err error)

BuildAudioCVT initializes an AudioCVT structure for conversion. (https://wiki.libsdl.org/SDL_BuildAudioCVT)

func Button Uses

func Button(flag uint32) uint32

Button is used as a mask when testing buttons in buttonstate.

func ButtonLMask Uses

func ButtonLMask() uint32

ButtonLMask is used as a mask when testing buttons in buttonstate.

func ButtonMMask Uses

func ButtonMMask() uint32

ButtonMMask is used as a mask when testing buttons in buttonstate.

func ButtonRMask Uses

func ButtonRMask() uint32

ButtonRMask is used as a mask when testing buttons in buttonstate.

func ButtonX1Mask Uses

func ButtonX1Mask() uint32

ButtonX1Mask is used as a mask when testing buttons in buttonstate.

func ButtonX2Mask Uses

func ButtonX2Mask() uint32

ButtonX2Mask is used as a mask when testing buttons in buttonstate.

func COMPILEDVERSION Uses

func COMPILEDVERSION() int

COMPILEDVERSION returns the SDL version number that you compiled against. (https://wiki.libsdl.org/SDL_COMPILEDVERSION)

func CalculateGammaRamp Uses

func CalculateGammaRamp(gamma float32, ramp *[256]uint16)

CalculateGammaRamp calculates a 256 entry gamma ramp for a gamma value. (https://wiki.libsdl.org/SDL_CalculateGammaRamp)

func CaptureMouse Uses

func CaptureMouse(toggle bool) error

CaptureMouse captures the mouse and tracks input outside an SDL window. (https://wiki.libsdl.org/SDL_CaptureMouse)

func ClearError Uses

func ClearError()

ClearError clears any previous error message. (https://wiki.libsdl.org/SDL_ClearError)

func ClearHints Uses

func ClearHints()

ClearHints clears all hints. (https://wiki.libsdl.org/SDL_ClearHints)

func ClearQueuedAudio Uses

func ClearQueuedAudio(dev AudioDeviceID)

ClearQueuedAudio drops any queued audio data waiting to be sent to the hardware. (https://wiki.libsdl.org/SDL_ClearQueuedAudio)

func CloseAudio Uses

func CloseAudio()

CloseAudio closes the audio device. New programs might want to use CloseAudioDevice() instead. (https://wiki.libsdl.org/SDL_CloseAudio)

func CloseAudioDevice Uses

func CloseAudioDevice(dev AudioDeviceID)

CloseAudioDevice shuts down audio processing and closes the audio device. (https://wiki.libsdl.org/SDL_CloseAudioDevice)

func ConvertAudio Uses

func ConvertAudio(cvt *AudioCVT) error

ConvertAudio converts audio data to a desired audio format. (https://wiki.libsdl.org/SDL_ConvertAudio)

func ConvertPixels Uses

func ConvertPixels(width, height int32, srcFormat uint32, src unsafe.Pointer, srcPitch int,
    dstFormat uint32, dst unsafe.Pointer, dstPitch int) error

ConvertPixels copies a block of pixels of one format to another format. (https://wiki.libsdl.org/SDL_ConvertPixels)

func DelEventWatch Uses

func DelEventWatch(handle EventWatchHandle)

DelEventWatch removes an event watch callback added with AddEventWatch(). (https://wiki.libsdl.org/SDL_DelEventWatch)

func DelHintCallback Uses

func DelHintCallback(name string)

DelHintCallback removes a function watching a particular hint. (https://wiki.libsdl.org/SDL_DelHintCallback)

func Delay Uses

func Delay(ms uint32)

Delay waits a specified number of milliseconds before returning. (https://wiki.libsdl.org/SDL_Delay)

func DequeueAudio Uses

func DequeueAudio(dev AudioDeviceID, data []byte) error

DequeueAudio dequeues more audio on non-callback devices. (https://wiki.libsdl.org/SDL_DequeueAudio)

func DisableScreenSaver Uses

func DisableScreenSaver()

DisableScreenSaver prevents the screen from being blanked by a screen saver. (https://wiki.libsdl.org/SDL_DisableScreenSaver)

func Do Uses

func Do(f func())

Do the specified function in the main thread. For this function to work, you must have correctly used sdl.Main(..) in your main() function. Calling this function before/without sdl.Main(..) will cause a panic.

func EnableScreenSaver Uses

func EnableScreenSaver()

EnableScreenSaver allows the screen to be blanked by a screen saver. (https://wiki.libsdl.org/SDL_EnableScreenSaver)

func Error Uses

func Error(code ErrorCode)

Error sets the SDL error message to the specified error code.

func EventState Uses

func EventState(type_ uint32, state int) uint8

EventState sets the state of processing events by type. (https://wiki.libsdl.org/SDL_EventState)

func FilterEvents Uses

func FilterEvents(filter EventFilter, userdata interface{})

FilterEvents run a specific filter function on the current event queue, removing any events for which the filter returns 0. (https://wiki.libsdl.org/SDL_FilterEvents)

func FilterEventsFunc Uses

func FilterEventsFunc(filter eventFilterFunc, userdata interface{})

FilterEventsFunc run a specific function on the current event queue, removing any events for which the filter returns 0. (https://wiki.libsdl.org/SDL_FilterEvents)

func FlushEvent Uses

func FlushEvent(type_ uint32)

FlushEvent clears events from the event queue. (https://wiki.libsdl.org/SDL_FlushEvent)

func FlushEvents Uses

func FlushEvents(minType, maxType uint32)

FlushEvents clears events from the event queue. (https://wiki.libsdl.org/SDL_FlushEvents)

func FreeCursor Uses

func FreeCursor(cursor *Cursor)

FreeCursor frees a cursor created with CreateCursor(), CreateColorCursor() or CreateSystemCursor(). (https://wiki.libsdl.org/SDL_FreeCursor)

func FreeWAV Uses

func FreeWAV(audioBuf []uint8)

FreeWAV frees data previously allocated with LoadWAV() or LoadWAVRW(). (https://wiki.libsdl.org/SDL_FreeWAV)

func GLDeleteContext Uses

func GLDeleteContext(context GLContext)

GLDeleteContext deletes an OpenGL context. (https://wiki.libsdl.org/SDL_GL_DeleteContext)

func GLExtensionSupported Uses

func GLExtensionSupported(extension string) bool

GLExtensionSupported reports whether an OpenGL extension is supported for the current context. (https://wiki.libsdl.org/SDL_GL_ExtensionSupported)

func GLGetAttribute Uses

func GLGetAttribute(attr GLattr) (int, error)

GLGetAttribute returns the actual value for an attribute from the current context. (https://wiki.libsdl.org/SDL_GL_GetAttribute)

func GLGetDrawableSize Uses

func GLGetDrawableSize(window *Window) (w, h int32)

GLGetDrawableSize returns the size of a window's underlying drawable in pixels (for use with glViewport). (https://wiki.libsdl.org/SDL_GL_GetDrawableSize)

func GLGetProcAddress Uses

func GLGetProcAddress(proc string) unsafe.Pointer

GLGetProcAddress returns an OpenGL function by name. (https://wiki.libsdl.org/SDL_GL_GetProcAddress)

func GLGetSwapInterval Uses

func GLGetSwapInterval() (int, error)

GLGetSwapInterval returns the swap interval for the current OpenGL context. (https://wiki.libsdl.org/SDL_GL_GetSwapInterval)

func GLLoadLibrary Uses

func GLLoadLibrary(path string) error

GLLoadLibrary dynamically loads an OpenGL library. (https://wiki.libsdl.org/SDL_GL_LoadLibrary)

func GLMakeCurrent Uses

func GLMakeCurrent(window *Window, glcontext GLContext) error

GLMakeCurrent sets up an OpenGL context for rendering into an OpenGL window. (https://wiki.libsdl.org/SDL_GL_MakeCurrent)

func GLSetAttribute Uses

func GLSetAttribute(attr GLattr, value int) error

GLSetAttribute sets an OpenGL window attribute before window creation. (https://wiki.libsdl.org/SDL_GL_SetAttribute)

func GLSetSwapInterval Uses

func GLSetSwapInterval(interval int) error

GLSetSwapInterval sets the swap interval for the current OpenGL context. (https://wiki.libsdl.org/SDL_GL_SetSwapInterval)

func GLSwapWindow Uses

func GLSwapWindow(window *Window)

GLSwapWindow updates a window with OpenGL rendering. (https://wiki.libsdl.org/SDL_GL_SwapWindow)

func GLUnloadLibrary Uses

func GLUnloadLibrary()

GLUnloadLibrary unloads the OpenGL library previously loaded by GLLoadLibrary(). (https://wiki.libsdl.org/SDL_GL_UnloadLibrary)

func GameControllerAddMapping Uses

func GameControllerAddMapping(mappingString string) int

GameControllerAddMapping adds support for controllers that SDL is unaware of or to cause an existing controller to have a different binding. (https://wiki.libsdl.org/SDL_GameControllerAddMapping)

func GameControllerEventState Uses

func GameControllerEventState(state int) int

GameControllerEventState returns the current state of, enable, or disable events dealing with Game Controllers. This will not disable Joystick events, which can also be fired by a controller (see https://wiki.libsdl.org/SDL_JoystickEventState). (https://wiki.libsdl.org/SDL_GameControllerEventState)

func GameControllerGetStringForAxis Uses

func GameControllerGetStringForAxis(axis GameControllerAxis) string

GameControllerGetStringForAxis converts from an axis enum to a string. (https://wiki.libsdl.org/SDL_GameControllerGetStringForAxis)

func GameControllerGetStringForButton Uses

func GameControllerGetStringForButton(btn GameControllerButton) string

GameControllerGetStringForButton turns a button enum into a string mapping. (https://wiki.libsdl.org/SDL_GameControllerGetStringForButton)

func GameControllerMapping Uses

func GameControllerMapping(ctrl *GameController) string

GameControllerMapping returns the current mapping of a Game Controller.

(https://wiki.libsdl.org/SDL_GameControllerMapping)

func GameControllerMappingForGUID Uses

func GameControllerMappingForGUID(guid JoystickGUID) string

GameControllerMappingForGUID returns the game controller mapping string for a given GUID. (https://wiki.libsdl.org/SDL_GameControllerMappingForGUID)

func GameControllerNameForIndex Uses

func GameControllerNameForIndex(index int) string

GameControllerNameForIndex returns the implementation dependent name for the game controller. (https://wiki.libsdl.org/SDL_GameControllerNameForIndex)

func GameControllerUpdate Uses

func GameControllerUpdate()

GameControllerUpdate manually pumps game controller updates if not using the loop. (https://wiki.libsdl.org/SDL_GameControllerUpdate)

func GetAudioDeviceName Uses

func GetAudioDeviceName(index int, isCapture bool) string

GetAudioDeviceName returns the name of a specific audio device. (https://wiki.libsdl.org/SDL_GetAudioDeviceName)

func GetAudioDriver Uses

func GetAudioDriver(index int) string

GetAudioDriver returns the name of a built in audio driver. (https://wiki.libsdl.org/SDL_GetAudioDriver)

func GetBasePath Uses

func GetBasePath() string

GetBasePath returns the directory where the application was run from. This is where the application data directory is. (https://wiki.libsdl.org/SDL_GetBasePath)

func GetCPUCacheLineSize Uses

func GetCPUCacheLineSize() int

GetCPUCacheLineSize returns the L1 cache line size of the CPU. (https://wiki.libsdl.org/SDL_GetCPUCacheLineSize)

func GetCPUCount Uses

func GetCPUCount() int

GetCPUCount returns the number of CPU cores available. (https://wiki.libsdl.org/SDL_GetCPUCount)

func GetClipboardText Uses

func GetClipboardText() (string, error)

GetClipboardText returns UTF-8 text from the clipboard. (https://wiki.libsdl.org/SDL_GetClipboardText)

func GetCurrentAudioDriver Uses

func GetCurrentAudioDriver() string

GetCurrentAudioDriver returns the name of the current audio driver. (https://wiki.libsdl.org/SDL_GetCurrentAudioDriver)

func GetCurrentDisplayMode Uses

func GetCurrentDisplayMode(displayIndex int, mode *DisplayMode) error

GetCurrentDisplayMode returns information about the current display mode. (https://wiki.libsdl.org/SDL_GetCurrentDisplayMode)

func GetCurrentVideoDriver Uses

func GetCurrentVideoDriver() string

GetCurrentVideoDriver returns the name of the currently initialized video driver. (https://wiki.libsdl.org/SDL_GetCurrentVideoDriver)

func GetDesktopDisplayMode Uses

func GetDesktopDisplayMode(displayIndex int, mode *DisplayMode) error

GetDesktopDisplayMode returns information about the desktop display mode. (https://wiki.libsdl.org/SDL_GetDesktopDisplayMode)

func GetDisplayBounds Uses

func GetDisplayBounds(displayIndex int, rect *Rect) error

GetDisplayBounds returns the desktop area represented by a display, with the primary display located at 0,0. (https://wiki.libsdl.org/SDL_GetDisplayBounds)

func GetDisplayMode Uses

func GetDisplayMode(displayIndex int, modeIndex int, mode *DisplayMode) error

GetDisplayMode retruns information about a specific display mode. (https://wiki.libsdl.org/SDL_GetDisplayMode)

func GetDisplayName Uses

func GetDisplayName(displayIndex int) string

GetDisplayName returns the name of a display in UTF-8 encoding. (https://wiki.libsdl.org/SDL_GetDisplayName)

func GetError Uses

func GetError() error

GetError returns the last error that occurred, or an empty string if there hasn't been an error message set since the last call to ClearError(). (https://wiki.libsdl.org/SDL_GetError)

func GetEventState Uses

func GetEventState(type_ uint32) uint8

GetEventState returns the current processing state of the specified event (https://wiki.libsdl.org/SDL_EventState)

func GetHint Uses

func GetHint(name string) string

GetHint returns the value of a hint. (https://wiki.libsdl.org/SDL_GetHint)

func GetKeyName Uses

func GetKeyName(code Keycode) string

GetKeyName returns a human-readable name for a key. (https://wiki.libsdl.org/SDL_GetKeyName)

func GetKeyboardState Uses

func GetKeyboardState() []uint8

GetKeyboardState returns a snapshot of the current state of the keyboard. (https://wiki.libsdl.org/SDL_GetKeyboardState)

func GetMouseState Uses

func GetMouseState() (x, y int32, state uint32)

GetMouseState returns the current state of the mouse. (https://wiki.libsdl.org/SDL_GetMouseState)

func GetNumAudioDevices Uses

func GetNumAudioDevices(isCapture bool) int

GetNumAudioDevices returns the number of built-in audio devices. (https://wiki.libsdl.org/SDL_GetNumAudioDevices)

func GetNumAudioDrivers Uses

func GetNumAudioDrivers() int

GetNumAudioDrivers returns the number of built-in audio drivers. (https://wiki.libsdl.org/SDL_GetNumAudioDrivers)

func GetNumDisplayModes Uses

func GetNumDisplayModes(displayIndex int) (int, error)

GetNumDisplayModes returns the number of available display modes. (https://wiki.libsdl.org/SDL_GetNumDisplayModes)

func GetNumRenderDrivers Uses

func GetNumRenderDrivers() int

GetNumRenderDrivers returns the number of 2D rendering drivers available for the current display. (https://wiki.libsdl.org/SDL_GetNumRenderDrivers)

func GetNumTouchDevices Uses

func GetNumTouchDevices() int

GetNumTouchDevices returns the number of registered touch devices. (https://wiki.libsdl.org/SDL_GetNumTouchDevices)

func GetNumTouchFingers Uses

func GetNumTouchFingers(t TouchID) int

GetNumTouchFingers returns the number of active fingers for a given touch device. (https://wiki.libsdl.org/SDL_GetNumTouchFingers)

func GetNumVideoDisplays Uses

func GetNumVideoDisplays() (int, error)

GetNumVideoDisplays returns the number of available video displays. (https://wiki.libsdl.org/SDL_GetNumVideoDisplays)

func GetNumVideoDrivers Uses

func GetNumVideoDrivers() (int, error)

GetNumVideoDrivers returns the number of video drivers compiled into SDL. (https://wiki.libsdl.org/SDL_GetNumVideoDrivers)

func GetPerformanceCounter Uses

func GetPerformanceCounter() uint64

GetPerformanceCounter returns the current value of the high resolution counter. (https://wiki.libsdl.org/SDL_GetPerformanceCounter)

func GetPerformanceFrequency Uses

func GetPerformanceFrequency() uint64

GetPerformanceFrequency returns the count per second of the high resolution counter. (https://wiki.libsdl.org/SDL_GetPerformanceFrequency)

func GetPixelFormatName Uses

func GetPixelFormatName(format uint) string

GetPixelFormatName returns the human readable name of a pixel format. (https://wiki.libsdl.org/SDL_GetPixelFormatName)

func GetPlatform Uses

func GetPlatform() string

GetPlatform returns the name of the platform. (https://wiki.libsdl.org/SDL_GetPlatform)

func GetPowerInfo Uses

func GetPowerInfo() (int, int, int)

GetPowerInfo returns the current power supply details. (https://wiki.libsdl.org/SDL_GetPowerInfo)

func GetPrefPath Uses

func GetPrefPath(org, app string) string

GetPrefPath returns the "pref dir". This is meant to be where the application can write personal files (Preferences and save games, etc.) that are specific to the application. This directory is unique per user and per application. (https://wiki.libsdl.org/SDL_GetPrefPath)

func GetQueuedAudioSize Uses

func GetQueuedAudioSize(dev AudioDeviceID) uint32

GetQueuedAudioSize returns the number of bytes of still-queued audio. (https://wiki.libsdl.org/SDL_GetQueuedAudioSize)

func GetRGB Uses

func GetRGB(pixel uint32, format *PixelFormat) (r, g, b uint8)

GetRGB returns RGB values from a pixel in the specified format. (https://wiki.libsdl.org/SDL_GetRGB)

func GetRGBA Uses

func GetRGBA(pixel uint32, format *PixelFormat) (r, g, b, a uint8)

GetRGBA returns RGBA values from a pixel in the specified format. (https://wiki.libsdl.org/SDL_GetRGBA)

func GetRelativeMouseMode Uses

func GetRelativeMouseMode() bool

GetRelativeMouseMode reports where relative mouse mode is enabled. (https://wiki.libsdl.org/SDL_GetRelativeMouseMode)

func GetRelativeMouseState Uses

func GetRelativeMouseState() (x, y int32, state uint32)

GetRelativeMouseState returns the relative state of the mouse. (https://wiki.libsdl.org/SDL_GetRelativeMouseState)

func GetRenderDriverInfo Uses

func GetRenderDriverInfo(index int, info *RendererInfo) int

GetRenderDriverInfo returns information about a specific 2D rendering driver for the current display. (https://wiki.libsdl.org/SDL_GetRenderDriverInfo)

func GetRevision Uses

func GetRevision() string

GetRevision returns the code revision of SDL that is linked against your program. (https://wiki.libsdl.org/SDL_GetRevision)

func GetRevisionNumber Uses

func GetRevisionNumber() int

GetRevisionNumber returns the revision number of SDL that is linked against your program. (https://wiki.libsdl.org/SDL_GetRevisionNumber)

func GetScancodeName Uses

func GetScancodeName(code Scancode) string

GetScancodeName returns a human-readable name for a scancode (https://wiki.libsdl.org/SDL_GetScancodeName)

func GetSystemRAM Uses

func GetSystemRAM() int

GetSystemRAM returns the amount of RAM configured in the system. (https://wiki.libsdl.org/SDL_GetSystemRAM)

func GetTicks Uses

func GetTicks() uint32

GetTicks returns the number of milliseconds since the SDL library initialization. (https://wiki.libsdl.org/SDL_GetTicks)

func GetVersion Uses

func GetVersion(v *Version)

GetVersion returns the version of SDL that is linked against your program. (https://wiki.libsdl.org/SDL_GetVersion)

func GetVideoDriver Uses

func GetVideoDriver(index int) string

GetVideoDriver returns the name of a built in video driver. (https://wiki.libsdl.org/SDL_GetVideoDriver)

func HapticIndex Uses

func HapticIndex(h *Haptic) int

HapticIndex returns the index of a haptic device. (https://wiki.libsdl.org/SDL_HapticIndex)

func HapticName Uses

func HapticName(index int) string

HapticName returns the implementation dependent name of a haptic device. (https://wiki.libsdl.org/SDL_HapticName)

func HapticOpened Uses

func HapticOpened(index int) (bool, error)

HapticOpened reports whether the haptic device at the designated index has been opened. (https://wiki.libsdl.org/SDL_HapticOpened)

func Has3DNow Uses

func Has3DNow() bool

Has3DNow reports whether the CPU has 3DNow! features. (https://wiki.libsdl.org/SDL_Has3DNow)

func HasAVX Uses

func HasAVX() bool

HasAVX reports whether the CPU has AVX features. (https://wiki.libsdl.org/SDL_HasAVX)

func HasAltiVec Uses

func HasAltiVec() bool

HasAltiVec reports whether the CPU has AltiVec features. (https://wiki.libsdl.org/SDL_HasAltiVec)

func HasClipboardText Uses

func HasClipboardText() bool

HasClipboardText reports whether the clipboard exists and contains a text string that is non-empty. (https://wiki.libsdl.org/SDL_HasClipboardText)

func HasEvent Uses

func HasEvent(type_ uint32) bool

HasEvent checks for the existence of certain event types in the event queue. (https://wiki.libsdl.org/SDL_HasEvent)

func HasEvents Uses

func HasEvents(minType, maxType uint32) bool

HasEvents checks for the existence of a range of event types in the event queue. (https://wiki.libsdl.org/SDL_HasEvents)

func HasMMX Uses

func HasMMX() bool

HasMMX reports whether the CPU has MMX features. (https://wiki.libsdl.org/SDL_HasMMX)

func HasRDTSC Uses

func HasRDTSC() bool

HasRDTSC reports whether the CPU has the RDTSC instruction. (https://wiki.libsdl.org/SDL_HasRDTSC)

func HasSSE Uses

func HasSSE() bool

HasSSE reports whether the CPU has SSE features. (https://wiki.libsdl.org/SDL_HasSSE)

func HasSSE2 Uses

func HasSSE2() bool

HasSSE2 reports whether the CPU has SSE2 features. (https://wiki.libsdl.org/SDL_HasSSE2)

func HasSSE3 Uses

func HasSSE3() bool

HasSSE3 reports whether the CPU has SSE3 features. (https://wiki.libsdl.org/SDL_HasSSE3)

func HasSSE41 Uses

func HasSSE41() bool

HasSSE41 reports whether the CPU has SSE4.1 features. (https://wiki.libsdl.org/SDL_HasSSE41)

func HasSSE42 Uses

func HasSSE42() bool

HasSSE42 reports whether the CPU has SSE4.2 features. (https://wiki.libsdl.org/SDL_HasSSE42)

func HasScreenKeyboardSupport Uses

func HasScreenKeyboardSupport() bool

HasScreenKeyboardSupport reports whether the platform has some screen keyboard support. (https://wiki.libsdl.org/SDL_HasScreenKeyboardSupport)

func Init Uses

func Init(flags uint32) error

Init initialize the SDL library. This must be called before using most other SDL functions. (https://wiki.libsdl.org/SDL_Init)

func InitSubSystem Uses

func InitSubSystem(flags uint32) error

InitSubSystem initializes specific SDL subsystems. (https://wiki.libsdl.org/SDL_InitSubSystem)

func IsGameController Uses

func IsGameController(index int) bool

IsGameController reports whether the given joystick is supported by the game controller interface. (https://wiki.libsdl.org/SDL_IsGameController)

func IsScreenKeyboardShown Uses

func IsScreenKeyboardShown(window *Window) bool

IsScreenKeyboardShown reports whether the screen keyboard is shown for given window. (https://wiki.libsdl.org/SDL_IsScreenKeyboardShown)

func IsScreenSaverEnabled Uses

func IsScreenSaverEnabled() bool

IsScreenSaverEnabled reports whether the screensaver is currently enabled. (https://wiki.libsdl.org/SDL_IsScreenSaverEnabled)

func IsTextInputActive Uses

func IsTextInputActive() bool

IsTextInputActive checks whether or not Unicode text input events are enabled. (https://wiki.libsdl.org/SDL_IsTextInputActive)

func JoystickEventState Uses

func JoystickEventState(state int) int

JoystickEventState enables or disables joystick event polling. (https://wiki.libsdl.org/SDL_JoystickEventState)

func JoystickGetGUIDString Uses

func JoystickGetGUIDString(guid JoystickGUID) string

JoystickGetGUIDString returns an ASCII string representation for a given JoystickGUID. (https://wiki.libsdl.org/SDL_JoystickGetGUIDString)

func JoystickIsHaptic Uses

func JoystickIsHaptic(joy *Joystick) (bool, error)

JoystickIsHaptic reports whether a joystick has haptic features. (https://wiki.libsdl.org/SDL_JoystickIsHaptic)

func JoystickNameForIndex Uses

func JoystickNameForIndex(index int) string

JoystickNameForIndex returns the implementation dependent name of a joystick. (https://wiki.libsdl.org/SDL_JoystickNameForIndex)

func JoystickUpdate Uses

func JoystickUpdate()

JoystickUpdate updates the current state of the open joysticks. (https://wiki.libsdl.org/SDL_JoystickUpdate)

func LoadDollarTemplates Uses

func LoadDollarTemplates(t TouchID, src *RWops) int

LoadDollarTemplates loads Dollar Gesture templates from a file. (https://wiki.libsdl.org/SDL_LoadDollarTemplates)

func LoadWAV Uses

func LoadWAV(file string, spec *AudioSpec) ([]byte, *AudioSpec)

LoadWAV loads a WAVE from a file. (https://wiki.libsdl.org/SDL_LoadWAV)

func LoadWAVRW Uses

func LoadWAVRW(src *RWops, freeSrc bool, spec *AudioSpec) ([]byte, *AudioSpec)

LoadWAVRW loads a WAVE from the data source, automatically freeing that source if freeSrc is true. (https://wiki.libsdl.org/SDL_LoadWAV_RW)

func LockAudio Uses

func LockAudio()

LockAudio locks the audio device. New programs might want to use LockAudioDevice() instead. (https://wiki.libsdl.org/SDL_LockAudio)

func LockAudioDevice Uses

func LockAudioDevice(dev AudioDeviceID)

LockAudioDevice locks out the audio callback function for a specified device. (https://wiki.libsdl.org/SDL_LockAudioDevice)

func Log Uses

func Log(str string, args ...interface{})

Log logs a message with LOG_CATEGORY_APPLICATION and LOG_PRIORITY_INFO. (https://wiki.libsdl.org/SDL_Log)

func LogCritical Uses

func LogCritical(cat int, str string, args ...interface{})

LogCritical logs a message with LOG_PRIORITY_CRITICAL. (https://wiki.libsdl.org/SDL_LogCritical)

func LogDebug Uses

func LogDebug(cat int, str string, args ...interface{})

LogDebug logs a message with LOG_PRIORITY_DEBUG. (https://wiki.libsdl.org/SDL_LogDebug)

func LogError Uses

func LogError(cat int, str string, args ...interface{})

LogError logs a message with LOG_PRIORITY_ERROR. (https://wiki.libsdl.org/SDL_LogError)

func LogInfo Uses

func LogInfo(cat int, str string, args ...interface{})

LogInfo logs a message with LOG_PRIORITY_INFO. (https://wiki.libsdl.org/SDL_LogInfo)

func LogMessage Uses

func LogMessage(cat int, pri LogPriority, str string, args ...interface{})

LogMessage logs a message with the specified category and priority. (https://wiki.libsdl.org/SDL_LogMessage)

func LogResetPriorities Uses

func LogResetPriorities()

LogResetPriorities resets all priorities to default. (https://wiki.libsdl.org/SDL_LogResetPriorities)

func LogSetAllPriority Uses

func LogSetAllPriority(p LogPriority)

LogSetAllPriority sets the priority of all log categories. (https://wiki.libsdl.org/SDL_LogSetAllPriority)

func LogSetOutputFunction Uses

func LogSetOutputFunction(f LogOutputFunction, data interface{})

LogSetOutputFunction replaces the default log output function with one of your own. (https://wiki.libsdl.org/SDL_LogSetOutputFunction)

func LogSetPriority Uses

func LogSetPriority(category int, p LogPriority)

LogSetPriority sets the priority of a particular log category. (https://wiki.libsdl.org/SDL_LogSetPriority)

func LogVerbose Uses

func LogVerbose(cat int, str string, args ...interface{})

LogVerbose logs a message with LOG_PRIORITY_VERBOSE. (https://wiki.libsdl.org/SDL_LogVerbose)

func LogWarn Uses

func LogWarn(cat int, str string, args ...interface{})

LogWarn logs a message with LOG_PRIORITY_WARN. (https://wiki.libsdl.org/SDL_LogWarn)

func Main Uses

func Main(main func())

Main entry point. Run this function at the beginning of main(), and pass your own main body to it as a function. E.g.:

func main() {
	sdl.Main(func() {
		// Your code here....
		// [....]

		// Calls to SDL can be made by any goroutine, but always guarded by sdl.Do()
		sdl.Do(func() {
			sdl.Init(0)
		})
	})
}

Avoid calling functions like os.Exit(..) within your passed-in function since they don't respect deferred calls. Instead, do this:

func main() {
	var exitcode int
	sdl.Main(func() {
		exitcode = run()) // assuming run has signature func() int
	})
	os.Exit(exitcode)
}

func MapRGB Uses

func MapRGB(format *PixelFormat, r, g, b uint8) uint32

MapRGB maps an RGB triple to an opaque pixel value for a given pixel format. (https://wiki.libsdl.org/SDL_MapRGB)

func MapRGBA Uses

func MapRGBA(format *PixelFormat, r, g, b, a uint8) uint32

MapRGBA maps an RGBA quadruple to a pixel value for a given pixel format. (https://wiki.libsdl.org/SDL_MapRGBA)

func MasksToPixelFormatEnum Uses

func MasksToPixelFormatEnum(bpp int, rmask, gmask, bmask, amask uint32) uint

MasksToPixelFormatEnum converts a bpp value and RGBA masks to an enumerated pixel format. (https://wiki.libsdl.org/SDL_MasksToPixelFormatEnum)

func MixAudio Uses

func MixAudio(dst, src *uint8, len uint32, volume int)

MixAudio mixes audio data. New programs might want to use MixAudioFormat() instead. (https://wiki.libsdl.org/SDL_MixAudio)

func MixAudioFormat Uses

func MixAudioFormat(dst, src *uint8, format AudioFormat, len uint32, volume int)

MixAudioFormat mixes audio data in a specified format. (https://wiki.libsdl.org/SDL_MixAudioFormat)

func MouseIsHaptic Uses

func MouseIsHaptic() (bool, error)

MouseIsHaptic reports whether or not the current mouse has haptic capabilities. (https://wiki.libsdl.org/SDL_MouseIsHaptic)

func NumHaptics Uses

func NumHaptics() int

NumHaptics returns the number of haptic devices attached to the system. (https://wiki.libsdl.org/SDL_NumHaptics)

func NumJoysticks Uses

func NumJoysticks() int

NumJoysticks returns the number of joysticks attached to the system. (https://wiki.libsdl.org/SDL_NumJoysticks)

func OpenAudio Uses

func OpenAudio(desired, obtained *AudioSpec) error

OpenAudio opens the audio device. New programs might want to use OpenAudioDevice() instead. (https://wiki.libsdl.org/SDL_OpenAudio)

func OutOfMemory Uses

func OutOfMemory()

OutOfMemory sets SDL error message to ENOMEM (out of memory).

func PauseAudio Uses

func PauseAudio(pauseOn bool)

PauseAudio pauses and unpauses the audio device. New programs might want to use SDL_PauseAudioDevice() instead. (https://wiki.libsdl.org/SDL_PauseAudio)

func PauseAudioDevice Uses

func PauseAudioDevice(dev AudioDeviceID, pauseOn bool)

PauseAudioDevice pauses and unpauses audio playback on a specified device. (https://wiki.libsdl.org/SDL_PauseAudioDevice)

func PeepEvents Uses

func PeepEvents(events []Event, action EventAction, minType, maxType uint32) (storedEvents int, err error)

PeepEvents checks the event queue for messages and optionally return them. (https://wiki.libsdl.org/SDL_PeepEvents)

func PixelFormatEnumToMasks Uses

func PixelFormatEnumToMasks(format uint) (bpp int, rmask, gmask, bmask, amask uint32, err error)

PixelFormatEnumToMasks converts one of the enumerated pixel formats to a bpp value and RGBA masks. (https://wiki.libsdl.org/SDL_PixelFormatEnumToMasks)

func PumpEvents Uses

func PumpEvents()

PumpEvents pumps the event loop, gathering events from the input devices. (https://wiki.libsdl.org/SDL_PumpEvents)

func PushEvent Uses

func PushEvent(event Event) (filtered bool, err error)

PushEvent adds an event to the event queue. (https://wiki.libsdl.org/SDL_PushEvent)

func QueueAudio Uses

func QueueAudio(dev AudioDeviceID, data []byte) error

QueueAudio queues more audio on non-callback devices. (https://wiki.libsdl.org/SDL_QueueAudio)

func Quit Uses

func Quit()

Quit cleans up all initialized subsystems. You should call it upon all exit conditions. (https://wiki.libsdl.org/SDL_Quit)

func QuitSubSystem Uses

func QuitSubSystem(flags uint32)

QuitSubSystem shuts down specific SDL subsystems. (https://wiki.libsdl.org/SDL_QuitSubSystem)

func RecordGesture Uses

func RecordGesture(t TouchID) int

RecordGesture begins recording a gesture on a specified touch device or all touch devices. (https://wiki.libsdl.org/SDL_RecordGesture)

func RegisterEvents Uses

func RegisterEvents(numEvents int) uint32

RegisterEvents allocates a set of user-defined events, and return the beginning event number for that set of events. (https://wiki.libsdl.org/SDL_RegisterEvents)

func SaveAllDollarTemplates Uses

func SaveAllDollarTemplates(src *RWops) int

SaveAllDollarTemplates saves all currently loaded Dollar Gesture templates. (https://wiki.libsdl.org/SDL_SaveAllDollarTemplates)

func SaveDollarTemplate Uses

func SaveDollarTemplate(g GestureID, src *RWops) int

SaveDollarTemplate saves a currently loaded Dollar Gesture template. (https://wiki.libsdl.org/SDL_SaveDollarTemplate)

func SetClipboardText Uses

func SetClipboardText(text string) error

SetClipboardText puts UTF-8 text into the clipboard. (https://wiki.libsdl.org/SDL_SetClipboardText)

func SetCursor Uses

func SetCursor(cursor *Cursor)

SetCursor sets the active cursor. (https://wiki.libsdl.org/SDL_SetCursor)

func SetEventFilter Uses

func SetEventFilter(filter EventFilter, userdata interface{})

SetEventFilter sets up a filter to process all events before they change internal state and are posted to the internal event queue. (https://wiki.libsdl.org/SDL_SetEventFilter)

func SetEventFilterFunc Uses

func SetEventFilterFunc(filterFunc eventFilterFunc, userdata interface{})

SetEventFilterFunc sets up a function to process all events before they change internal state and are posted to the internal event queue. (https://wiki.libsdl.org/SDL_SetEventFilter)

func SetHint Uses

func SetHint(name, value string) bool

SetHint sets a hint with normal priority. (https://wiki.libsdl.org/SDL_SetHint)

func SetHintWithPriority Uses

func SetHintWithPriority(name, value string, hp HintPriority) bool

SetHintWithPriority sets a hint with a specific priority. (https://wiki.libsdl.org/SDL_SetHintWithPriority)

func SetModState Uses

func SetModState(mod Keymod)

SetModState sets the current key modifier state for the keyboard. (https://wiki.libsdl.org/SDL_SetModState)

func SetRelativeMouseMode Uses

func SetRelativeMouseMode(enabled bool) int

SetRelativeMouseMode sets relative mouse mode. (https://wiki.libsdl.org/SDL_SetRelativeMouseMode)

func SetTextInputRect Uses

func SetTextInputRect(rect *Rect)

SetTextInputRect sets the rectangle used to type Unicode text inputs. (https://wiki.libsdl.org/SDL_SetTextInputRect)

func ShowCursor Uses

func ShowCursor(toggle int) int

ShowCursor toggles whether or not the cursor is shown. (https://wiki.libsdl.org/SDL_ShowCursor)

func ShowMessageBox Uses

func ShowMessageBox(data *MessageBoxData) (buttonid int32, err error)

ShowMessageBox creates a modal message box. (https://wiki.libsdl.org/SDL_ShowMessageBox)

func ShowSimpleMessageBox Uses

func ShowSimpleMessageBox(flags uint32, title, message string, window *Window) error

ShowSimpleMessageBox displays a simple modal message box. (https://wiki.libsdl.org/SDL_ShowSimpleMessageBox)

func StartTextInput Uses

func StartTextInput()

StartTextInput starts accepting Unicode text input events. (https://wiki.libsdl.org/SDL_StartTextInput)

func StopTextInput Uses

func StopTextInput()

StopTextInput stops receiving any text input events. (https://wiki.libsdl.org/SDL_StopTextInput)

func UnlockAudio Uses

func UnlockAudio()

UnlockAudio unlocks the audio device. New programs might want to use UnlockAudioDevice() instead. (https://wiki.libsdl.org/SDL_UnlockAudio)

func UnlockAudioDevice Uses

func UnlockAudioDevice(dev AudioDeviceID)

UnlockAudioDevice unlocks the audio callback function for a specified device. (https://wiki.libsdl.org/SDL_UnlockAudioDevice)

func Unsupported Uses

func Unsupported()

Unsupported sets SDL error message to UNSUPPORTED (that operation is not supported).

func VERSION Uses

func VERSION(v *Version)

VERSION fills the selected struct with the version of SDL in use. (https://wiki.libsdl.org/SDL_VERSION)

func VERSIONNUM Uses

func VERSIONNUM(x, y, z int) int

VERSIONNUM converts separate version components into a single numeric value. (https://wiki.libsdl.org/SDL_VERSIONNUM)

func VERSION_ATLEAST Uses

func VERSION_ATLEAST(x, y, z int) bool

VERSION_ATLEAST reports whether the SDL version compiled against is at least as new as the specified version. (https://wiki.libsdl.org/SDL_VERSION_ATLEAST)

func VideoInit Uses

func VideoInit(driverName string) error

VideoInit initializes the video subsystem, optionally specifying a video driver. (https://wiki.libsdl.org/SDL_VideoInit)

func VideoQuit Uses

func VideoQuit()

VideoQuit shuts down the video subsystem, if initialized with VideoInit(). (https://wiki.libsdl.org/SDL_VideoQuit)

func WasInit Uses

func WasInit(flags uint32) uint32

WasInit returns a mask of the specified subsystems which have previously been initialized. (https://wiki.libsdl.org/SDL_WasInit)

type AudioCVT Uses

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
}

AudioCVT contains audio data conversion information. (https://wiki.libsdl.org/SDL_AudioCVT)

func (*AudioCVT) AllocBuf Uses

func (cvt *AudioCVT) AllocBuf(size uintptr)

AllocBuf allocates the requested memory for AudioCVT buffer.

func (AudioCVT) BufAsSlice Uses

func (cvt AudioCVT) BufAsSlice() []byte

BufAsSlice returns AudioCVT.buf as byte slice. NOTE: Must be used after ConvertAudio() because it uses LenCVT as slice length.

func (*AudioCVT) FreeBuf Uses

func (cvt *AudioCVT) FreeBuf()

FreeBuf deallocates the memory previously allocated from AudioCVT buffer.

type AudioCallback Uses

type AudioCallback C.SDL_AudioCallback

AudioCallback is a function to call when the audio device needs more data.` (https://wiki.libsdl.org/SDL_AudioSpec)

type AudioDeviceID Uses

type AudioDeviceID uint32

AudioDeviceID is ID of an audio device previously opened with OpenAudioDevice(). (https://wiki.libsdl.org/SDL_OpenAudioDevice)

func OpenAudioDevice Uses

func OpenAudioDevice(device string, isCapture bool, desired, obtained *AudioSpec, allowedChanges int) (AudioDeviceID, error)

OpenAudioDevice opens a specific audio device. (https://wiki.libsdl.org/SDL_OpenAudioDevice)

type AudioFilter Uses

type AudioFilter C.SDL_AudioFilter

AudioFilter is the filter list used in AudioCVT() (internal use) (https://wiki.libsdl.org/SDL_AudioCVT)

type AudioFormat Uses

type AudioFormat uint16

AudioFormat is an enumeration of audio formats. (https://wiki.libsdl.org/SDL_AudioFormat)

func (AudioFormat) BitSize Uses

func (fmt AudioFormat) BitSize() uint8

BitSize returns audio formats bit size. (https://wiki.libsdl.org/SDL_AudioFormat)

func (AudioFormat) IsBigEndian Uses

func (fmt AudioFormat) IsBigEndian() bool

IsBigEndian reports whether audio format is big-endian. (https://wiki.libsdl.org/SDL_AudioFormat)

func (AudioFormat) IsFloat Uses

func (fmt AudioFormat) IsFloat() bool

IsFloat reports whether audio format is float. (https://wiki.libsdl.org/SDL_AudioFormat)

func (AudioFormat) IsInt Uses

func (fmt AudioFormat) IsInt() bool

IsInt reports whether audio format is integer. (https://wiki.libsdl.org/SDL_AudioFormat)

func (AudioFormat) IsLittleEndian Uses

func (fmt AudioFormat) IsLittleEndian() bool

IsLittleEndian reports whether audio format is little-endian. (https://wiki.libsdl.org/SDL_AudioFormat)

func (AudioFormat) IsSigned Uses

func (fmt AudioFormat) IsSigned() bool

IsSigned reports whether audio format is signed. (https://wiki.libsdl.org/SDL_AudioFormat)

func (AudioFormat) IsUnsigned Uses

func (fmt AudioFormat) IsUnsigned() bool

IsUnsigned reports whether audio format is unsigned. (https://wiki.libsdl.org/SDL_AudioFormat)

type AudioSpec Uses

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
}

AudioSpec contains the audio output format. It also contains a callback that is called when the audio device needs more data. (https://wiki.libsdl.org/SDL_AudioSpec)

type AudioStatus Uses

type AudioStatus uint32

AudioStatus is an enumeration of audio device states. (https://wiki.libsdl.org/SDL_AudioStatus)

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
)

An enumeration of audio device states used in GetAudioDeviceStatus() and GetAudioStatus(). (https://wiki.libsdl.org/SDL_AudioStatus)

func GetAudioDeviceStatus Uses

func GetAudioDeviceStatus(dev AudioDeviceID) AudioStatus

GetAudioDeviceStatus returns the current audio state of an audio device. (https://wiki.libsdl.org/SDL_GetAudioDeviceStatus)

func GetAudioStatus Uses

func GetAudioStatus() AudioStatus

GetAudioStatus returns the current audio state of the audio device. New programs might want to use GetAudioDeviceStatus() instead. (https://wiki.libsdl.org/SDL_GetAudioStatus)

type BlendMode Uses

type BlendMode uint32

BlendMode is an enumeration of blend modes used in Render.Copy() and drawing operations. (https://wiki.libsdl.org/SDL_BlendMode)

type CEvent Uses

type CEvent struct {
    Type uint32
    // contains filtered or unexported fields
}

CEvent is a union of all event structures used in SDL. (https://wiki.libsdl.org/SDL_Event)

type ClipboardEvent Uses

type ClipboardEvent struct {
    Type      uint32 // CLIPBOARDUPDATE
    Timestamp uint32 // timestamp of the event
}

ClipboardEvent contains clipboard event information. (https://wiki.libsdl.org/SDL_EventType)

type CocoaInfo Uses

type CocoaInfo struct {
    Window unsafe.Pointer // the Cocoa window
}

CocoaInfo contains Apple Mac OS X window information.

type Color Uses

type Color struct {
    R   uint8 // the red component in the range 0-255
    G   uint8 // the green component in the range 0-255
    B   uint8 // the blue component in the range 0-255
    A   uint8 // the alpha component in the range 0-255
}

Color represents a color. (https://wiki.libsdl.org/SDL_Color)

func (Color) RGBA Uses

func (c Color) RGBA() (r, g, b, a uint32)

RGBA returns the alpha-premultiplied red, green, blue and alpha values for the color. Each value ranges within [0, 0xffff], but is represented by a uint32 so that multiplying by a blend factor up to 0xffff will not overflow.

An alpha-premultiplied color component c has been scaled by alpha (a), so has valid values 0 <= c <= a.

func (Color) Uint32 Uses

func (c Color) Uint32() uint32

Uint32 return uint32 representation of RGBA color.

type CommonEvent Uses

type CommonEvent struct {
    Type      uint32 // the event type
    Timestamp uint32 // timestamp of the event
}

CommonEvent contains common event data. (https://wiki.libsdl.org/SDL_Event)

type Cond Uses

type Cond struct {
    Lock     *Mutex
    Waiting  int
    Signals  int
    WaitSem  *Sem
    WaitDone *Sem
}

Cond is the SDL condition variable structure.

func CreateCond Uses

func CreateCond() *Cond

CreateCond (https://wiki.libsdl.org/SDL_CreateCond)

func (*Cond) Broadcast Uses

func (cond *Cond) Broadcast() error

Broadcast restarts all threads that are waiting on the condition variable. (https://wiki.libsdl.org/SDL_CondBroadcast)

func (*Cond) Destroy Uses

func (cond *Cond) Destroy()

Destroy creates a condition variable. (https://wiki.libsdl.org/SDL_DestroyCond)

func (*Cond) Signal Uses

func (cond *Cond) Signal() error

Signal restarts one of the threads that are waiting on the condition variable. (https://wiki.libsdl.org/SDL_CondSignal)

func (*Cond) Wait Uses

func (cond *Cond) Wait(mutex *Mutex) error

Wait waits until a condition variable is signaled. (https://wiki.libsdl.org/SDL_CondWait)

func (*Cond) WaitTimeout Uses

func (cond *Cond) WaitTimeout(mutex *Mutex, ms uint32) error

WaitTimeout waits until a condition variable is signaled or a specified amount of time has passed. (https://wiki.libsdl.org/SDL_CondWaitTimeout)

type ControllerAxisEvent Uses

type ControllerAxisEvent struct {
    Type      uint32     // CONTROLLERAXISMOTION
    Timestamp uint32     // the timestamp of the event
    Which     JoystickID // the joystick instance id
    Axis      uint8      // the controller axis (https://wiki.libsdl.org/SDL_GameControllerAxis)

    Value int16 // the axis value (range: -32768 to 32767)
    // contains filtered or unexported fields
}

ControllerAxisEvent contains game controller axis motion event information. (https://wiki.libsdl.org/SDL_ControllerAxisEvent)

type ControllerButtonEvent Uses

type ControllerButtonEvent struct {
    Type      uint32     // CONTROLLERBUTTONDOWN, CONTROLLERBUTTONUP
    Timestamp uint32     // the timestamp of the event
    Which     JoystickID // the joystick instance id
    Button    uint8      // the controller button (https://wiki.libsdl.org/SDL_GameControllerButton)
    State     uint8      // PRESSED, RELEASED
    // contains filtered or unexported fields
}

ControllerButtonEvent contains game controller button event information. (https://wiki.libsdl.org/SDL_ControllerButtonEvent)

type ControllerDeviceEvent Uses

type ControllerDeviceEvent struct {
    Type      uint32     // CONTROLLERDEVICEADDED, CONTROLLERDEVICEREMOVED, SDL_CONTROLLERDEVICEREMAPPED
    Timestamp uint32     // the timestamp of the event
    Which     JoystickID // the joystick device index for the CONTROLLERDEVICEADDED event or instance id for the CONTROLLERDEVICEREMOVED or CONTROLLERDEVICEREMAPPED event
}

ControllerDeviceEvent contains controller device event information. (https://wiki.libsdl.org/SDL_ControllerDeviceEvent)

type Cursor Uses

type Cursor C.SDL_Cursor

Cursor is a custom cursor created by CreateCursor() or CreateColorCursor().

func CreateColorCursor Uses

func CreateColorCursor(surface *Surface, hotX, hotY int32) *Cursor

CreateColorCursor creates a color cursor. (https://wiki.libsdl.org/SDL_CreateColorCursor)

func CreateCursor Uses

func CreateCursor(data, mask *uint8, w, h, hotX, hotY int32) *Cursor

CreateCursor creates a cursor using the specified bitmap data and mask (in MSB format). (https://wiki.libsdl.org/SDL_CreateCursor)

func CreateSystemCursor Uses

func CreateSystemCursor(id SystemCursor) *Cursor

CreateSystemCursor creates a system cursor. (https://wiki.libsdl.org/SDL_CreateSystemCursor)

func GetCursor Uses

func GetCursor() *Cursor

GetCursor returns the active cursor. (https://wiki.libsdl.org/SDL_GetCursor)

func GetDefaultCursor Uses

func GetDefaultCursor() *Cursor

GetDefaultCursor returns the default cursor. (https://wiki.libsdl.org/SDL_GetDefaultCursor)

type DFBInfo Uses

type DFBInfo struct {
    Dfb     unsafe.Pointer // the DirectFB main interface
    Window  unsafe.Pointer // the DirectFB window handle
    Surface unsafe.Pointer // the DirectFB client surface
}

DFBInfo contains DirectFB window information.

type DisplayMode Uses

type DisplayMode struct {
    Format      uint32         // one of the PixelFormatEnum values (https://wiki.libsdl.org/SDL_PixelFormatEnum)
    W           int32          // width, in screen coordinates
    H           int32          // height, in screen coordinates
    RefreshRate int32          // refresh rate (in Hz), or 0 for unspecified
    DriverData  unsafe.Pointer // driver-specific data, initialize to 0
}

DisplayMode contains the description of a display mode. (https://wiki.libsdl.org/SDL_DisplayMode)

func GetClosestDisplayMode Uses

func GetClosestDisplayMode(displayIndex int, mode *DisplayMode, closest *DisplayMode) (*DisplayMode, error)

GetClosestDisplayMode returns the closest match to the requested display mode. (https://wiki.libsdl.org/SDL_GetClosestDisplayMode)

type DollarGestureEvent Uses

type DollarGestureEvent struct {
    Type       uint32    // DOLLARGESTURE, DOLLARRECORD
    Timestamp  uint32    // timestamp of the event
    TouchID    TouchID   // the touch device id
    GestureID  GestureID // the unique id of the closest gesture to the performed stroke
    NumFingers uint32    // the number of fingers used to draw the stroke
    Error      float32   // the difference between the gesture template and the actual performed gesture (lower error is a better match)
    X          float32   // the normalized center of gesture
    Y          float32   // the normalized center of gesture
}

DollarGestureEvent contains complex gesture event information. (https://wiki.libsdl.org/SDL_DollarGestureEvent)

type DropEvent Uses

type DropEvent struct {
    Type      uint32 // DROPFILE, DROPTEXT, DROPBEGIN, DROPCOMPLETE
    Timestamp uint32 // timestamp of the event
    File      string // the file name
    WindowID  uint32 // the window that was dropped on, if any
}

DropEvent contains an event used to request a file open by the system. (https://wiki.libsdl.org/SDL_DropEvent)

type ErrorCode Uses

type ErrorCode uint32

ErrorCode is an error code used in SDL error messages.

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
)

SDL error codes with their corresponding predefined strings.

type Event Uses

type Event interface{}

Event is a union of all event structures used in SDL. (https://wiki.libsdl.org/SDL_Event)

func PollEvent Uses

func PollEvent() Event

PollEvent polls for currently pending events. (https://wiki.libsdl.org/SDL_PollEvent)

func WaitEvent Uses

func WaitEvent() Event

WaitEvent swait indefinitely for the next available event. (https://wiki.libsdl.org/SDL_WaitEvent)

func WaitEventTimeout Uses

func WaitEventTimeout(timeout int) Event

WaitEventTimeout waits until the specified timeout (in milliseconds) for the next available event. (https://wiki.libsdl.org/SDL_WaitEventTimeout)

type EventAction Uses

type EventAction C.SDL_eventaction

EventAction is the action to take in PeepEvents() function. (https://wiki.libsdl.org/SDL_PeepEvents)

type EventFilter Uses

type EventFilter interface {
    FilterEvent(e Event, userdata interface{}) bool
}

EventFilter is the function to call when an event happens. (https://wiki.libsdl.org/SDL_SetEventFilter)

func GetEventFilter Uses

func GetEventFilter() EventFilter

GetEventFilter queries the current event filter. (https://wiki.libsdl.org/SDL_GetEventFilter)

type EventWatchHandle Uses

type EventWatchHandle uintptr

EventWatchHandle is an event watch callback added with AddEventWatch().

func AddEventWatch Uses

func AddEventWatch(filter EventFilter, userdata interface{}) EventWatchHandle

AddEventWatch adds a callback to be triggered when an event is added to the event queue. (https://wiki.libsdl.org/SDL_AddEventWatch)

func AddEventWatchFunc Uses

func AddEventWatchFunc(filterFunc eventFilterFunc, userdata interface{}) EventWatchHandle

AddEventWatchFunc adds a callback function to be triggered when an event is added to the event queue. (https://wiki.libsdl.org/SDL_AddEventWatch)

type Finger Uses

type Finger struct {
    ID       FingerID // the finger id
    X        float32  // the x-axis location of the touch event, normalized (0...1)
    Y        float32  // the y-axis location of the touch event, normalized (0...1)
    Pressure float32  // the quantity of pressure applied, normalized (0...1)
}

Finger contains touch information.

func GetTouchFinger Uses

func GetTouchFinger(t TouchID, index int) *Finger

GetTouchFinger returns the finger object for specified touch device ID and finger index. (https://wiki.libsdl.org/SDL_GetTouchFinger)

type FingerID Uses

type FingerID C.SDL_FingerID

FingerID is a finger id.

type GLContext Uses

type GLContext C.SDL_GLContext

GLContext is an opaque handle to an OpenGL context.

func GLCreateContext Uses

func GLCreateContext(window *Window) (GLContext, error)

GLCreateContext creates an OpenGL context for use with an OpenGL window, and make it current. (https://wiki.libsdl.org/SDL_GL_CreateContext)

type GLattr Uses

type GLattr C.SDL_GLattr

GLattr is an OpenGL configuration attribute. (https://wiki.libsdl.org/SDL_GLattr)

type GameController Uses

type GameController C.SDL_GameController

GameController used to identify an SDL game controller.

func GameControllerOpen Uses

func GameControllerOpen(index int) *GameController

GameControllerOpen opens a gamecontroller for use. (https://wiki.libsdl.org/SDL_GameControllerOpen)

func (*GameController) Close Uses

func (ctrl *GameController) Close()

Close closes a game controller previously opened with GameControllerOpen(). (https://wiki.libsdl.org/SDL_GameControllerClose)

func (*GameController) GetAttached Uses

func (ctrl *GameController) GetAttached() bool

GetAttached reports whether a controller has been opened and is currently connected. (https://wiki.libsdl.org/SDL_GameControllerGetAttached)

func (*GameController) GetAxis Uses

func (ctrl *GameController) GetAxis(axis GameControllerAxis) int16

GetAxis returns the current state of an axis control on a game controller. (https://wiki.libsdl.org/SDL_GameControllerGetAxis)

func (*GameController) GetBindForAxis Uses

func (ctrl *GameController) GetBindForAxis(axis GameControllerAxis) GameControllerButtonBind

GetBindForAxis returns the SDL joystick layer binding for a controller button mapping. (https://wiki.libsdl.org/SDL_GameControllerGetBindForAxis)

func (*GameController) GetBindForButton Uses

func (ctrl *GameController) GetBindForButton(btn GameControllerButton) GameControllerButtonBind

GetBindForButton returns the SDL joystick layer binding for this controller button mapping. (https://wiki.libsdl.org/SDL_GameControllerGetBindForButton)

func (*GameController) GetButton Uses

func (ctrl *GameController) GetButton(btn GameControllerButton) byte

GetButton returns the current state of a button on a game controller. (https://wiki.libsdl.org/SDL_GameControllerGetButton)

func (*GameController) GetJoystick Uses

func (ctrl *GameController) GetJoystick() *Joystick

GetJoystick returns the Joystick ID from a Game Controller. The game controller builds on the Joystick API, but to be able to use the Joystick's functions with a gamepad, you need to use this first to get the joystick object. (https://wiki.libsdl.org/SDL_GameControllerGetJoystick)

func (*GameController) Name Uses

func (ctrl *GameController) Name() string

Name returns the implementation dependent name for an opened game controller. (https://wiki.libsdl.org/SDL_GameControllerName)

type GameControllerAxis Uses

type GameControllerAxis C.SDL_GameControllerAxis

GameControllerAxis is an axis on a game controller. (https://wiki.libsdl.org/SDL_GameControllerAxis)

func GameControllerGetAxisFromString Uses

func GameControllerGetAxisFromString(pchString string) GameControllerAxis

GameControllerGetAxisFromString converts a string into an enum representation for a GameControllerAxis. (https://wiki.libsdl.org/SDL_GameControllerGetAxisFromString)

type GameControllerBindType Uses

type GameControllerBindType C.SDL_GameControllerBindType

GameControllerBindType is a type of game controller input.

type GameControllerButton Uses

type GameControllerButton C.SDL_GameControllerButton

GameControllerButton is a button on a game controller. (https://wiki.libsdl.org/SDL_GameControllerButton)

func GameControllerGetButtonFromString Uses

func GameControllerGetButtonFromString(pchString string) GameControllerButton

GameControllerGetButtonFromString turns a string into a button mapping. (https://wiki.libsdl.org/SDL_GameControllerGetButtonFromString)

type GameControllerButtonBind Uses

type GameControllerButtonBind C.SDL_GameControllerButtonBind

GameControllerButtonBind SDL joystick layer binding for controller button/axis mapping.

func (*GameControllerButtonBind) Axis Uses

func (bind *GameControllerButtonBind) Axis() int

Axis returns axis mapped for this SDL joystick layer binding.

func (*GameControllerButtonBind) Button Uses

func (bind *GameControllerButtonBind) Button() int

Button returns button mapped for this SDL joystick layer binding.

func (*GameControllerButtonBind) Hat Uses

func (bind *GameControllerButtonBind) Hat() int

Hat returns hat mapped for this SDL joystick layer binding.

func (*GameControllerButtonBind) HatMask Uses

func (bind *GameControllerButtonBind) HatMask() int

HatMask returns hat mask for this SDL joystick layer binding.

func (*GameControllerButtonBind) Type Uses

func (bind *GameControllerButtonBind) Type() int

Type returns the type of game controller input for this SDL joystick layer binding.

type GestureID Uses

type GestureID C.SDL_GestureID

GestureID is the unique id of the closest gesture to the performed stroke.

type Haptic Uses

type Haptic C.SDL_Haptic

Haptic identifies an SDL haptic. (https://wiki.libsdl.org/CategoryForceFeedback)

func HapticOpen Uses

func HapticOpen(index int) (*Haptic, error)

HapticOpen opens a haptic device for use. (https://wiki.libsdl.org/SDL_HapticOpen)

func HapticOpenFromJoystick Uses

func HapticOpenFromJoystick(joy *Joystick) *Haptic

HapticOpenFromJoystick opens a haptic device for use from a joystick device. (https://wiki.libsdl.org/SDL_HapticOpenFromJoystick)

func HapticOpenFromMouse Uses

func HapticOpenFromMouse() (*Haptic, error)

HapticOpenFromMouse open a haptic device from the current mouse. (https://wiki.libsdl.org/SDL_HapticOpenFromMouse)

func (*Haptic) Close Uses

func (h *Haptic) Close()

Close closes a haptic device previously opened with HapticOpen(). (https://wiki.libsdl.org/SDL_HapticClose)

func (*Haptic) DestroyEffect Uses

func (h *Haptic) DestroyEffect(effect int)

DestroyEffect destroys a haptic effect on the device. (https://wiki.libsdl.org/SDL_HapticDestroyEffect)

func (*Haptic) EffectSupported Uses

func (h *Haptic) EffectSupported(he *HapticEffect) (bool, error)

EffectSupported reports whether an effect is supported by a haptic device. (https://wiki.libsdl.org/SDL_HapticEffectSupported)

func (*Haptic) GetEffectStatus Uses

func (h *Haptic) GetEffectStatus(effect int) int

GetEffectStatus returns the status of the current effect on the specified haptic device. (https://wiki.libsdl.org/SDL_HapticGetEffectStatus)

func (*Haptic) NewEffect Uses

func (h *Haptic) NewEffect(he *HapticEffect) (int, error)

NewEffect creates a new haptic effect on a specified device. (https://wiki.libsdl.org/SDL_HapticNewEffect)

func (*Haptic) NumAxes Uses

func (h *Haptic) NumAxes() int

NumAxes returns the number of haptic axes the device has. (https://wiki.libsdl.org/SDL_HapticNumAxes)

func (*Haptic) NumEffects Uses

func (h *Haptic) NumEffects() int

NumEffects returns the number of effects a haptic device can store. (https://wiki.libsdl.org/SDL_HapticNumEffects)

func (*Haptic) NumEffectsPlaying Uses

func (h *Haptic) NumEffectsPlaying() int

NumEffectsPlaying reutrns the number of effects a haptic device can play at the same time. (https://wiki.libsdl.org/SDL_HapticNumEffectsPlaying)

func (*Haptic) Pause Uses

func (h *Haptic) Pause() error

Pause pauses a haptic device. (https://wiki.libsdl.org/SDL_HapticPause)

func (*Haptic) Query Uses

func (h *Haptic) Query() uint

Query returns haptic device's supported features in bitwise manner. (https://wiki.libsdl.org/SDL_HapticQuery)

func (*Haptic) RumbleInit Uses

func (h *Haptic) RumbleInit() error

RumbleInit initializes the haptic device for simple rumble playback. (https://wiki.libsdl.org/SDL_HapticRumbleInit)

func (*Haptic) RumblePlay Uses

func (h *Haptic) RumblePlay(strength float32, length uint32) error

RumblePlay runs a simple rumble effect on a haptic device. (https://wiki.libsdl.org/SDL_HapticRumblePlay)

func (*Haptic) RumbleStop Uses

func (h *Haptic) RumbleStop() error

RumbleStop stops the simple rumble on a haptic device. (https://wiki.libsdl.org/SDL_HapticRumbleStop)

func (*Haptic) RumbleSupported Uses

func (h *Haptic) RumbleSupported() (ok bool, err error)

RumbleSupported reports whether rumble is supported on a haptic device. (https://wiki.libsdl.org/SDL_HapticRumbleSupported)

func (*Haptic) RunEffect Uses

func (h *Haptic) RunEffect(effect int, iterations uint32) error

RunEffect runs the haptic effect on its associated haptic device. (https://wiki.libsdl.org/SDL_HapticRunEffect)

func (*Haptic) SetAutocenter Uses

func (h *Haptic) SetAutocenter(autocenter int) error

SetAutocenter sets the global autocenter of the device. (https://wiki.libsdl.org/SDL_HapticSetAutocenter)

func (*Haptic) SetGain Uses

func (h *Haptic) SetGain(gain int) error

SetGain sets the global gain of the specified haptic device. (https://wiki.libsdl.org/SDL_HapticSetGain)

func (*Haptic) StopAll Uses

func (h *Haptic) StopAll() error

StopAll stops all the currently playing effects on a haptic device. (https://wiki.libsdl.org/SDL_HapticStopAll)

func (*Haptic) StopEffect Uses

func (h *Haptic) StopEffect(effect int) error

StopEffect stops the haptic effect on its associated haptic device. (https://wiki.libsdl.org/SDL_HapticStopEffect)

func (*Haptic) Unpause Uses

func (h *Haptic) Unpause() error

Unpause unpauses a haptic device. (https://wiki.libsdl.org/SDL_HapticUnpause)

func (*Haptic) UpdateEffect Uses

func (h *Haptic) UpdateEffect(effect int, data *HapticEffect) error

UpdateEffect updates the properties of an effect. (https://wiki.libsdl.org/SDL_HapticUpdateEffect)

type HapticCondition Uses

type HapticCondition struct {
    Type       uint16          // HAPTIC_SPRING, HAPTIC_DAMPER, HAPTIC_INERTIA, HAPTIC_FRICTION
    Direction  HapticDirection // direction of the effect - not used at the moment
    Length     uint32          // duration of the effect
    Delay      uint16          // delay before starting the effect
    Button     uint16          // button that triggers the effect
    Interval   uint16          // how soon it can be triggered again after button
    RightSat   [3]uint16       // level when joystick is to the positive side; max 0xFFFF
    LeftSat    [3]uint16       // level when joystick is to the negative side; max 0xFFFF
    RightCoeff [3]int16        // how fast to increase the force towards the positive side
    LeftCoeff  [3]int16        // how fast to increase the force towards the negative side
    Deadband   [3]uint16       // size of the dead zone; max 0xFFFF: whole axis-range when 0-centered
    Center     [3]int16        // position of the dead zone
}

HapticCondition contains a template for a condition effect. (https://wiki.libsdl.org/SDL_HapticCondition)

type HapticConstant Uses

type HapticConstant struct {
    Type         uint16          // HAPTIC_CONSTANT
    Direction    HapticDirection // direction of the effect
    Length       uint32          // duration of the effect
    Delay        uint16          // delay before starting the effect
    Button       uint16          // button that triggers the effect
    Interval     uint16          // how soon it can be triggered again after button
    Level        int16           // strength of the constant effect
    AttackLength uint16          // duration of the attack
    AttackLevel  uint16          // level at the start of the attack
    FadeLength   uint16          // duration of the fade
    FadeLevel    uint16          // level at the end of the fade
}

HapticConstant contains a template for a constant effect. (https://wiki.libsdl.org/SDL_HapticConstant)

type HapticCustom Uses

type HapticCustom struct {
    Type         uint16          // SDL_HAPTIC_CUSTOM
    Direction    HapticDirection // direction of the effect
    Length       uint32          // duration of the effect
    Delay        uint16          // delay before starting the effect
    Button       uint16          // button that triggers the effect
    Interval     uint16          // how soon it can be triggered again after button
    Channels     uint8           // axes to use, minimum of 1
    Period       uint16          // sample periods
    Samples      uint16          // amount of samples
    Data         *uint16         // should contain channels*samples items
    AttackLength uint16          // duration of the attack
    AttackLevel  uint16          // level at the start of the attack
    FadeLength   uint16          // duration of the fade
    FadeLevel    uint16          // level at the end of the fade
}

HapticCustom contains a template for a custom effect. (https://wiki.libsdl.org/SDL_HapticCustom)

type HapticDirection Uses

type HapticDirection struct {
    Type byte // the type of encoding
    // contains filtered or unexported fields
}

HapticDirection contains a haptic direction. (https://wiki.libsdl.org/SDL_HapticDirection)

type HapticEffect Uses

type HapticEffect C.SDL_HapticEffect

HapticEffect union that contains the generic template for any haptic effect. (https://wiki.libsdl.org/SDL_HapticEffect)

func (HapticEffect) Condition Uses

func (he HapticEffect) Condition() *HapticCondition

Condition returns the condition effect. (https://wiki.libsdl.org/SDL_HapticCondition)

func (HapticEffect) Constant Uses

func (he HapticEffect) Constant() *HapticConstant

Constant returns the constant effect. (https://wiki.libsdl.org/SDL_HapticConstant)

func (HapticEffect) Custom Uses

func (he HapticEffect) Custom() *HapticCustom

Custom returns the custom effect. (https://wiki.libsdl.org/SDL_HapticCustom)

func (HapticEffect) LeftRight Uses

func (he HapticEffect) LeftRight() *HapticLeftRight

LeftRight returns the left/right effect. (https://wiki.libsdl.org/SDL_HapticLeftRight)

func (HapticEffect) Periodic Uses

func (he HapticEffect) Periodic() *HapticPeriodic

Periodic returns the periodic effect. (https://wiki.libsdl.org/SDL_HapticPeriodic)

func (HapticEffect) Ramp Uses

func (he HapticEffect) Ramp() *HapticRamp

Ramp returns the ramp effect. (https://wiki.libsdl.org/SDL_HapticRamp)

func (HapticEffect) SetType Uses

func (he HapticEffect) SetType(typ uint16)

SetType sets the happtic effect type. (https://wiki.libsdl.org/SDL_HapticEffect)

func (HapticEffect) Type Uses

func (he HapticEffect) Type() uint16

Type returns the effect type. (https://wiki.libsdl.org/SDL_HapticEffect)

type HapticLeftRight Uses

type HapticLeftRight struct {
    Type           uint16 // HAPTIC_LEFTRIGHT
    Length         uint32 // duration of the effect
    LargeMagnitude uint16 // control of the large controller motor
    SmallMagnitude uint16 // control of the small controller motor
}

HapticLeftRight contains a template for a left/right effect. (https://wiki.libsdl.org/SDL_HapticLeftRight)

type HapticPeriodic Uses

type HapticPeriodic struct {
    Type         uint16          // HAPTIC_SINE, HAPTIC_LEFTRIGHT, HAPTIC_TRIANGLE, HAPTIC_SAWTOOTHUP, HAPTIC_SAWTOOTHDOWN
    Direction    HapticDirection // direction of the effect
    Length       uint32          // duration of the effect
    Delay        uint16          // delay before starting the effect
    Button       uint16          // button that triggers the effect
    Interval     uint16          // how soon it can be triggered again after button
    Period       uint16          // period of the wave
    Magnitude    int16           // peak value; if negative, equivalent to 180 degrees extra phase shift
    Offset       int16           // mean value of the wave
    Phase        uint16          // positive phase shift given by hundredth of a degree
    AttackLength uint16          // duration of the attack
    AttackLevel  uint16          // level at the start of the attack
    FadeLength   uint16          // duration of the fade
    FadeLevel    uint16          // level at the end of the fade
}

HapticPeriodic contains a template for a periodic effect. (https://wiki.libsdl.org/SDL_HapticPeriodic)

type HapticRamp Uses

type HapticRamp struct {
    Type         uint16          // HAPTIC_RAMP
    Direction    HapticDirection // direction of the effect
    Length       uint32          // duration of the effect
    Delay        uint16          // delay before starting the effect
    Button       uint16          // button that triggers the effect
    Interval     uint16          // how soon it can be triggered again after button
    Start        int16           // beginning strength level
    End          int16           // ending strength level
    AttackLength uint16          // duration of the attack
    AttackLevel  uint16          // level at the start of the attack
    FadeLength   uint16          // duration of the fade
    FadeLevel    uint16          // level at the end of the fade
}

HapticRamp contains a template for a ramp effect. (https://wiki.libsdl.org/SDL_HapticRamp)

type HintCallback Uses

type HintCallback func(data interface{}, name, oldValue, newValue string)

HintCallback is the function to call when the hint value changes.

type HintCallbackAndData Uses

type HintCallbackAndData struct {
    // contains filtered or unexported fields
}

HintCallbackAndData contains a callback function and useradata.

type HintPriority Uses

type HintPriority C.SDL_HintPriority

HintPriority is a hint priority used in SetHintWithPriority(). (https://wiki.libsdl.org/SDL_HintPriority)

type JoyAxisEvent Uses

type JoyAxisEvent struct {
    Type      uint32     // JOYAXISMOTION
    Timestamp uint32     // timestamp of the event
    Which     JoystickID // the instance id of the joystick that reported the event
    Axis      uint8      // the index of the axis that changed

    Value int16 // the current position of the axis (range: -32768 to 32767)
    // contains filtered or unexported fields
}

JoyAxisEvent contains joystick axis motion event information. (https://wiki.libsdl.org/SDL_JoyAxisEvent)

type JoyBallEvent Uses

type JoyBallEvent struct {
    Type      uint32     // JOYBALLMOTION
    Timestamp uint32     // timestamp of the event
    Which     JoystickID // the instance id of the joystick that reported the event
    Ball      uint8      // the index of the trackball that changed

    XRel int16 // the relative motion in the X direction
    YRel int16 // the relative motion in the Y direction
    // contains filtered or unexported fields
}

JoyBallEvent contains joystick trackball motion event information. (https://wiki.libsdl.org/SDL_JoyBallEvent)

type JoyButtonEvent Uses

type JoyButtonEvent struct {
    Type      uint32     // JOYBUTTONDOWN, JOYBUTTONUP
    Timestamp uint32     // timestamp of the event
    Which     JoystickID // the instance id of the joystick that reported the event
    Button    uint8      // the index of the button that changed
    State     uint8      // PRESSED, RELEASED
    // contains filtered or unexported fields
}

JoyButtonEvent contains joystick button event information. (https://wiki.libsdl.org/SDL_JoyButtonEvent)

type JoyDeviceEvent Uses

type JoyDeviceEvent struct {
    Type      uint32     // JOYDEVICEADDED, SDL_JOYDEVICEREMOVED
    Timestamp uint32     // the timestamp of the event
    Which     JoystickID // the joystick device index for the JOYDEVICEADDED event or the instance id for the JOYDEVICEREMOVED event
}

JoyDeviceEvent contains joystick device event information. (https://wiki.libsdl.org/SDL_JoyDeviceEvent)

type JoyHatEvent Uses

type JoyHatEvent struct {
    Type      uint32     // JOYHATMOTION
    Timestamp uint32     // timestamp of the event
    Which     JoystickID // the instance id of the joystick that reported the event
    Hat       uint8      // the index of the hat that changed
    Value     uint8      // HAT_LEFTUP, HAT_UP, HAT_RIGHTUP, HAT_LEFT, HAT_CENTERED, HAT_RIGHT, HAT_LEFTDOWN, HAT_DOWN, HAT_RIGHTDOWN
    // contains filtered or unexported fields
}

JoyHatEvent contains joystick hat position change event information. (https://wiki.libsdl.org/SDL_JoyHatEvent)

type Joystick Uses

type Joystick C.SDL_Joystick

Joystick is an SDL joystick.

func JoystickOpen Uses

func JoystickOpen(index JoystickID) *Joystick

JoystickOpen opens a joystick for use. (https://wiki.libsdl.org/SDL_JoystickOpen)

func (*Joystick) Close Uses

func (joy *Joystick) Close()

Close closes a joystick previously opened with JoystickOpen(). (https://wiki.libsdl.org/SDL_JoystickClose)

func (*Joystick) GetAttached Uses

func (joy *Joystick) GetAttached() bool

GetAttached returns the status of a specified joystick. (https://wiki.libsdl.org/SDL_JoystickGetAttached)

func (*Joystick) GetAxis Uses

func (joy *Joystick) GetAxis(axis int) int16

GetAxis returns the current state of an axis control on a joystick. (https://wiki.libsdl.org/SDL_JoystickGetAxis)

func (*Joystick) GetBall Uses

func (joy *Joystick) GetBall(ball int, dx, dy *int32) int

GetBall returns the ball axis change since the last poll. (https://wiki.libsdl.org/SDL_JoystickGetBall)

func (*Joystick) GetButton Uses

func (joy *Joystick) GetButton(button int) byte

GetButton the current state of a button on a joystick. (https://wiki.libsdl.org/SDL_JoystickGetButton)

func (*Joystick) GetGUID Uses

func (joy *Joystick) GetGUID() JoystickGUID

GetGUID returns the implementation-dependent GUID for the joystick. (https://wiki.libsdl.org/SDL_JoystickGetGUID)

func (*Joystick) GetHat Uses

func (joy *Joystick) GetHat(hat int) byte

GetHat returns the current state of a POV hat on a joystick. (https://wiki.libsdl.org/SDL_JoystickGetHat)

func (*Joystick) InstanceID Uses

func (joy *Joystick) InstanceID() JoystickID

InstanceID returns the instance ID of an opened joystick. (https://wiki.libsdl.org/SDL_JoystickInstanceID)

func (*Joystick) Name Uses

func (joy *Joystick) Name() string

Name returns the implementation dependent name of a joystick. (https://wiki.libsdl.org/SDL_JoystickName)

func (*Joystick) NumAxes Uses

func (joy *Joystick) NumAxes() int

NumAxes returns the number of general axis controls on a joystick. (https://wiki.libsdl.org/SDL_JoystickNumAxes)

func (*Joystick) NumBalls Uses

func (joy *Joystick) NumBalls() int

NumBalls returns the number of trackballs on a joystick. (https://wiki.libsdl.org/SDL_JoystickNumBalls)

func (*Joystick) NumButtons Uses

func (joy *Joystick) NumButtons() int

NumButtons returns the number of buttons on a joystick. (https://wiki.libsdl.org/SDL_JoystickNumButtons)

func (*Joystick) NumHats Uses

func (joy *Joystick) NumHats() int

NumHats returns the number of POV hats on a joystick. (https://wiki.libsdl.org/SDL_JoystickNumHats)

type JoystickGUID Uses

type JoystickGUID C.SDL_JoystickGUID

JoystickGUID is a stable unique id for a joystick device.

func JoystickGetDeviceGUID Uses

func JoystickGetDeviceGUID(index int) JoystickGUID

JoystickGetDeviceGUID returns the implementation dependent GUID for the joystick at a given device index. (https://wiki.libsdl.org/SDL_JoystickGetDeviceGUID)

func JoystickGetGUIDFromString Uses

func JoystickGetGUIDFromString(pchGUID string) JoystickGUID

JoystickGetGUIDFromString converts a GUID string into a JoystickGUID structure. (https://wiki.libsdl.org/SDL_JoystickGetGUIDFromString)

type JoystickID Uses

type JoystickID C.SDL_JoystickID

JoystickID is joystick's instance id.

type KeyboardEvent Uses

type KeyboardEvent struct {
    Type      uint32 // KEYUP / KEYDOWN
    Timestamp uint32 // timestamp of the event
    WindowID  uint32 // the window with keyboard focus, if any
    State     uint8  // PRESSED, RELEASED
    Repeat    uint8  // non-zero if this is a key repeat

    Keysym Keysym // Keysym representing the key that was pressed or released
    // contains filtered or unexported fields
}

KeyboardEvent contains keyboard key down event information. (https://wiki.libsdl.org/SDL_KeyboardEvent)

type Keycode Uses

type Keycode C.SDL_Keycode

Keycode is the SDL virtual key representation. (https://wiki.libsdl.org/SDL_Keycode)

func GetKeyFromName Uses

func GetKeyFromName(name string) Keycode

GetKeyFromName returns a key code from a human-readable name. (https://wiki.libsdl.org/SDL_GetKeyFromName)

func GetKeyFromScancode Uses

func GetKeyFromScancode(code Scancode) Keycode

GetKeyFromScancode returns the key code corresponding to the given scancode according to the current keyboard layout. (https://wiki.libsdl.org/SDL_GetKeyFromScancode)

type Keymod Uses

type Keymod C.SDL_Keymod

Keymod is a key modifier masks. (https://wiki.libsdl.org/SDL_Keymod)

func GetModState Uses

func GetModState() Keymod

GetModState returns the current key modifier state for the keyboard. (https://wiki.libsdl.org/SDL_GetModState)

type Keysym Uses

type Keysym struct {
    Scancode Scancode // SDL physical key code
    Sym      Keycode  // SDL virtual key code
    Mod      uint16   // current key modifiers
    // contains filtered or unexported fields
}

Keysym contains key information used in key events. (https://wiki.libsdl.org/SDL_Keysym)

type LogOutputFunction Uses

type LogOutputFunction func(data interface{}, cat int, pri LogPriority, message string)

LogOutputFunction is the function to call instead of the default

func LogGetOutputFunction Uses

func LogGetOutputFunction() (LogOutputFunction, interface{})

LogGetOutputFunction returns the current log output function. (https://wiki.libsdl.org/SDL_LogGetOutputFunction)

type LogPriority Uses

type LogPriority C.SDL_LogPriority

LogPriority is a predefined log priority. (https://wiki.libsdl.org/SDL_LogPriority)

func LogGetPriority Uses

func LogGetPriority(category int) LogPriority

LogGetPriority returns the priority of a particular log category. (https://wiki.libsdl.org/SDL_LogGetPriority)

type MessageBoxButtonData Uses

type MessageBoxButtonData struct {
    Flags    uint32 // MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT, MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT
    ButtonID int32  // user defined button id (value returned via ShowMessageBox())
    Text     string // the UTF-8 button text
}

MessageBoxButtonData contains individual button data for a message box. (https://wiki.libsdl.org/SDL_MessageBoxButtonData)

type MessageBoxColor Uses

type MessageBoxColor struct {
    R   uint8 // the red component in the range 0-255
    G   uint8 // the green component in the range 0-255
    B   uint8 // the blue component in the range 0-255
}

MessageBoxColor contains RGB value used in an MessageBoxColorScheme. (https://wiki.libsdl.org/SDL_MessageBoxColor)

type MessageBoxColorScheme Uses

type MessageBoxColorScheme struct {
    Colors [5]MessageBoxColor // background, text, button border, button background, button selected
}

MessageBoxColorScheme contains a set of colors to use for message box dialogs. (https://wiki.libsdl.org/SDL_MessageBoxColorScheme)

type MessageBoxData Uses

type MessageBoxData struct {
    Flags       uint32                 // MESSAGEBOX_ERROR, MESSAGEBOX_WARNING, MESSAGEBOX_INFORMATION
    Window      *Window                // an parent window, can be nil
    Title       string                 // an UTF-8 title
    Message     string                 // an UTF-8 message text
    NumButtons  int32                  // the number of buttons
    Buttons     []MessageBoxButtonData // an array of MessageBoxButtonData with size of numbuttons
    ColorScheme *MessageBoxColorScheme // a MessageBoxColorScheme, can be nil to use system settings
}

MessageBoxData contains title, text, window and other data for a message box. (https://wiki.libsdl.org/SDL_MessageBoxData)

type MouseButtonEvent Uses

type MouseButtonEvent struct {
    Type      uint32 // MOUSEBUTTONDOWN, MOUSEBUTTONUP
    Timestamp uint32 // timestamp of the event
    WindowID  uint32 // the window with mouse focus, if any
    Which     uint32 // the mouse instance id, or TOUCH_MOUSEID
    Button    uint8  // BUTTON_LEFT, BUTTON_MIDDLE, BUTTON_RIGHT, BUTTON_X1, BUTTON_X2
    State     uint8  // PRESSED, RELEASED

    X   int32 // X coordinate, relative to window
    Y   int32 // Y coordinate, relative to window
    // contains filtered or unexported fields
}

MouseButtonEvent contains mouse button event information. (https://wiki.libsdl.org/SDL_MouseButtonEvent)

type MouseMotionEvent Uses

type MouseMotionEvent struct {
    Type      uint32 // MOUSEMOTION
    Timestamp uint32 // timestamp of the event
    WindowID  uint32 // the window with mouse focus, if any
    Which     uint32 // the mouse instance id, or TOUCH_MOUSEID
    State     uint32 // BUTTON_LEFT, BUTTON_MIDDLE, BUTTON_RIGHT, BUTTON_X1, BUTTON_X2
    X         int32  // X coordinate, relative to window
    Y         int32  // Y coordinate, relative to window
    XRel      int32  // relative motion in the X direction
    YRel      int32  // relative motion in the Y direction
}

MouseMotionEvent contains mouse motion event information. (https://wiki.libsdl.org/SDL_MouseMotionEvent)

type MouseWheelEvent Uses

type MouseWheelEvent struct {
    Type      uint32 // MOUSEWHEEL
    Timestamp uint32 // timestamp of the event
    WindowID  uint32 // the window with mouse focus, if any
    Which     uint32 // the mouse instance id, or TOUCH_MOUSEID
    X         int32  // the amount scrolled horizontally, positive to the right and negative to the left
    Y         int32  // the amount scrolled vertically, positive away from the user and negative toward the user
    Direction uint32 // MOUSEWHEEL_NORMAL, MOUSEWHEEL_FLIPPED (>= SDL 2.0.4)
}

MouseWheelEvent contains mouse wheel event information. (https://wiki.libsdl.org/SDL_MouseWheelEvent)

type MultiGestureEvent Uses

type MultiGestureEvent struct {
    Type       uint32  // MULTIGESTURE
    Timestamp  uint32  // timestamp of the event
    TouchID    TouchID // the touch device id
    DTheta     float32 // the amount that the fingers rotated during this motion
    DDist      float32 // the amount that the fingers pinched during this motion
    X          float32 // the normalized center of gesture
    Y          float32 // the normalized center of gesture
    NumFingers uint16  // the number of fingers used in the gesture
    // contains filtered or unexported fields
}

MultiGestureEvent contains multiple finger gesture event information. (https://wiki.libsdl.org/SDL_MultiGestureEvent)

type Mutex Uses

type Mutex struct {
    Recursive int
    Owner     ThreadID
    Sem       *Sem
}

Mutex is the SDL mutex structure.

func CreateMutex Uses

func CreateMutex() (*Mutex, error)

CreateMutex creates a new mutex. (https://wiki.libsdl.org/SDL_CreateMutex)

func (*Mutex) Destroy Uses

func (mutex *Mutex) Destroy()

Destroy destroys a mutex created with CreateMutex(). (https://wiki.libsdl.org/SDL_DestroyMutex)

func (*Mutex) Lock Uses

func (mutex *Mutex) Lock() error

Lock locks a mutex created with CreateMutex(). (https://wiki.libsdl.org/SDL_LockMutex)

func (*Mutex) TryLock Uses

func (mutex *Mutex) TryLock() error

TryLock tries to lock a mutex without blocking. (https://wiki.libsdl.org/SDL_TryLockMutex)

func (*Mutex) Unlock Uses

func (mutex *Mutex) Unlock() error

Unlock unlocks a mutex created with CreateMutex(). (https://wiki.libsdl.org/SDL_UnlockMutex)

type OSEvent Uses

type OSEvent struct {
    Type      uint32 // the event type
    Timestamp uint32 // timestamp of the event
}

OSEvent contains OS specific event information.

type Palette Uses

type Palette struct {
    Ncolors int32  // the number of colors in the palette
    Colors  *Color // an array of Color structures representing the palette (https://wiki.libsdl.org/SDL_Color)
    // contains filtered or unexported fields
}

Palette contains palette information. (https://wiki.libsdl.org/SDL_Palette)

func AllocPalette Uses

func AllocPalette(ncolors int) (*Palette, error)

AllocPalette creates a palette structure with the specified number of color entries. (https://wiki.libsdl.org/SDL_AllocPalette)

func (*Palette) Free Uses

func (palette *Palette) Free()

Free frees the palette created with AllocPalette(). (https://wiki.libsdl.org/SDL_FreePalette)

func (*Palette) SetColors Uses

func (palette *Palette) SetColors(colors []Color) error

SetColors sets a range of colors in the palette. (https://wiki.libsdl.org/SDL_SetPaletteColors)

type PixelFormat Uses

type PixelFormat struct {
    Format        uint32   // one of the PIXELFORMAT values (https://wiki.libsdl.org/SDL_PixelFormatEnum)
    Palette       *Palette // palette structure associated with this pixel format, or nil if the format doesn't have a palette (https://wiki.libsdl.org/SDL_Palette)
    BitsPerPixel  uint8    // the number of significant bits in a pixel value, eg: 8, 15, 16, 24, 32
    BytesPerPixel uint8    // the number of bytes required to hold a pixel value, eg: 1, 2, 3, 4

    Rmask uint32 // a mask representing the location of the red component of the pixel
    Gmask uint32 // a mask representing the location of the green component of the pixel
    Bmask uint32 // a mask representing the location of the blue component of the pixel
    Amask uint32 // a mask representing the location of the alpha component of the pixel or 0 if the pixel format doesn't have any alpha information
    // contains filtered or unexported fields
}

PixelFormat contains pixel format information. (https://wiki.libsdl.org/SDL_PixelFormat)

func AllocFormat Uses

func AllocFormat(format uint) (*PixelFormat, error)

AllocFormat creates a PixelFormat structure corresponding to a pixel format. (https://wiki.libsdl.org/SDL_AllocFormat)

func (*PixelFormat) Free Uses

func (format *PixelFormat) Free()

Free frees the PixelFormat structure allocated by AllocFormat(). (https://wiki.libsdl.org/SDL_FreeFormat)

func (*PixelFormat) SetPalette Uses

func (format *PixelFormat) SetPalette(palette *Palette) error

SetPalette sets the palette for the pixel format structure. (https://wiki.libsdl.org/SDL_SetPixelFormatPalette)

type Point Uses

type Point struct {
    X   int32 // the x coordinate of the point
    Y   int32 // the y coordinate of the point
}

Point defines a two dimensional point. (https://wiki.libsdl.org/SDL_Point)

func (*Point) InRect Uses

func (p *Point) InRect(r *Rect) bool

InRect reports whether the point resides inside a rectangle. (https://wiki.libsdl.org/SDL_PointInRect)

type PowerState Uses

type PowerState C.SDL_PowerState

PowerState is the basic state for the system's power supply. (https://wiki.libsdl.org/SDL_PowerState)

type QuitEvent Uses

type QuitEvent struct {
    Type      uint32 // QUIT
    Timestamp uint32 // timestamp of the event
}

QuitEvent contains the "quit requested" event. (https://wiki.libsdl.org/SDL_QuitEvent)

type RWops Uses

type RWops C.SDL_RWops

RWops provides an abstract interface to stream I/O. Applications can generally ignore the specifics of this structure's internals and treat them as opaque pointers. The details are important to lower-level code that might need to implement one of these, however. (https://wiki.libsdl.org/SDL_RWops)

func AllocRW Uses

func AllocRW() *RWops

AllocRW allocates an empty, unpopulated RWops structure. (https://wiki.libsdl.org/SDL_AllocRW)

func RWFromFile Uses

func RWFromFile(file, mode string) *RWops

RWFromFile creates a new RWops structure for reading from and/or writing to a named file. (https://wiki.libsdl.org/SDL_RWFromFile)

func RWFromMem Uses

func RWFromMem(mem unsafe.Pointer, size int) *RWops

RWFromMem prepares a read-write memory buffer for use with RWops. (https://wiki.libsdl.org/SDL_RWFromMem)

func (*RWops) FreeRW Uses

func (rwops *RWops) FreeRW()

FreeRW frees the RWops structure allocated by AllocRW(). (https://wiki.libsdl.org/SDL_FreeRW)

func (*RWops) RWclose Uses

func (rwops *RWops) RWclose() error

RWclose closes and frees the allocated RWops structure. (https://wiki.libsdl.org/SDL_RWclose)

func (*RWops) RWread Uses

func (rwops *RWops) RWread(ptr unsafe.Pointer, size, maxnum uint) uint

RWread read from a data source. (https://wiki.libsdl.org/SDL_RWread)

func (*RWops) RWseek Uses

func (rwops *RWops) RWseek(offset int64, whence int) int64

RWseek seek within the RWops data stream. (https://wiki.libsdl.org/SDL_RWseek)

func (*RWops) RWsize Uses

func (rwops *RWops) RWsize() int64

RWsize returns the size of the data stream in the RWops. (https://wiki.libsdl.org/SDL_RWsize)

func (*RWops) RWtell Uses

func (rwops *RWops) RWtell() int64

RWtell returns the current read/write offset in the RWops data stream. (https://wiki.libsdl.org/SDL_RWtell)

func (*RWops) RWwrite Uses

func (rwops *RWops) RWwrite(ptr unsafe.Pointer, size, num uint) uint

RWwrite writes to the RWops data stream. (https://wiki.libsdl.org/SDL_RWwrite)

func (*RWops) ReadBE16 Uses

func (rwops *RWops) ReadBE16() uint16

ReadBE16 read 16 bits of big-endian data from the RWops and returns in native format. (https://wiki.libsdl.org/SDL_ReadBE16)

func (*RWops) ReadBE32 Uses

func (rwops *RWops) ReadBE32() uint32

ReadBE32 reads 32 bits of big-endian data from the RWops and returns in native format. (https://wiki.libsdl.org/SDL_ReadBE32)

func (*RWops) ReadBE64 Uses

func (rwops *RWops) ReadBE64() uint64

ReadBE64 reads 64 bits of big-endian data from the RWops and returns in native format. (https://wiki.libsdl.org/SDL_ReadBE64)

func (*RWops) ReadLE16 Uses

func (rwops *RWops) ReadLE16() uint16

ReadLE16 reads 16 bits of little-endian data from the RWops and returns in native format. (https://wiki.libsdl.org/SDL_ReadLE16)

func (*RWops) ReadLE32 Uses

func (rwops *RWops) ReadLE32() uint32

ReadLE32 reads 32 bits of little-endian data from the RWops and returns in native format. (https://wiki.libsdl.org/SDL_ReadLE32)

func (*RWops) ReadLE64 Uses

func (rwops *RWops) ReadLE64() uint64

ReadLE64 reads 64 bits of little-endian data from the RWops and returns in native format. (https://wiki.libsdl.org/SDL_ReadLE64)

func (*RWops) ReadU8 Uses

func (rwops *RWops) ReadU8() uint8

ReadU8 reads a byte from the RWops. (https://wiki.libsdl.org/SDL_ReadU8)

func (*RWops) WriteBE16 Uses

func (rwops *RWops) WriteBE16(value uint16) uint

WriteBE16 writes 16 bits in native format to the RWops as big-endian data. (https://wiki.libsdl.org/SDL_WriteBE16)

func (*RWops) WriteBE32 Uses

func (rwops *RWops) WriteBE32(value uint32) uint

WriteBE32 writes 32 bits in native format to the RWops as big-endian data. (https://wiki.libsdl.org/SDL_WriteBE32)

func (*RWops) WriteBE64 Uses

func (rwops *RWops) WriteBE64(value uint64) uint

WriteBE64 writes 64 bits in native format to the RWops as big-endian data. (https://wiki.libsdl.org/SDL_WriteBE64)

func (*RWops) WriteLE16 Uses

func (rwops *RWops) WriteLE16(value uint16) uint

WriteLE16 writes 16 bits in native format to the RWops as little-endian data. (https://wiki.libsdl.org/SDL_WriteLE16)

func (*RWops) WriteLE32 Uses

func (rwops *RWops) WriteLE32(value uint32) uint

WriteLE32 writes 32 bits in native format to the RWops as little-endian data. (https://wiki.libsdl.org/SDL_WriteLE32)

func (*RWops) WriteLE64 Uses

func (rwops *RWops) WriteLE64(value uint64) uint

WriteLE64 writes 64 bits in native format to the RWops as little-endian data. (https://wiki.libsdl.org/SDL_WriteLE64)

func (*RWops) WriteU8 Uses

func (rwops *RWops) WriteU8(value uint8) uint

WriteU8 writes a byte to the RWops. (https://wiki.libsdl.org/SDL_WriteU8)

type Rect Uses

type Rect struct {
    X   int32 // the x location of the rectangle's upper left corner
    Y   int32 // the y location of the rectangle's upper left corner
    W   int32 // the width of the rectangle
    H   int32 // the height of the rectangle
}

Rect contains the definition of a rectangle, with the origin at the upper left. (https://wiki.libsdl.org/SDL_Rect)

func EnclosePoints Uses

func EnclosePoints(points []Point, clip *Rect) (Rect, bool)

EnclosePoints calculates a minimal rectangle that encloses a set of points. (https://wiki.libsdl.org/SDL_EnclosePoints)

func (*Rect) Empty Uses

func (a *Rect) Empty() bool

Empty reports whether a rectangle has no area. (https://wiki.libsdl.org/SDL_RectEmpty)

func (*Rect) Equals Uses

func (a *Rect) Equals(b *Rect) bool

Equals reports whether two rectangles are equal. (https://wiki.libsdl.org/SDL_RectEquals)

func (*Rect) HasIntersection Uses

func (a *Rect) HasIntersection(b *Rect) bool

HasIntersection reports whether two rectangles intersect. (https://wiki.libsdl.org/SDL_HasIntersection)

func (*Rect) Intersect Uses

func (a *Rect) Intersect(b *Rect) (Rect, bool)

Intersect calculates the intersection of two rectangles. (https://wiki.libsdl.org/SDL_IntersectRect)

func (*Rect) IntersectLine Uses

func (a *Rect) IntersectLine(X1, Y1, X2, Y2 *int32) bool

IntersectLine calculates the intersection of a rectangle and a line segment. (https://wiki.libsdl.org/SDL_IntersectRectAndLine)

func (*Rect) Union Uses

func (a *Rect) Union(b *Rect) Rect

Union calculates the union of two rectangles. (https://wiki.libsdl.org/SDL_UnionRect)

type RenderEvent Uses

type RenderEvent struct {
    Type      uint32 // the event type
    Timestamp uint32 // timestamp of the event
}

RenderEvent contains render event information. (https://wiki.libsdl.org/SDL_EventType)

type Renderer Uses

type Renderer C.SDL_Renderer

Renderer contains a rendering state. (https://wiki.libsdl.org/SDL_Renderer)

func CreateRenderer Uses

func CreateRenderer(window *Window, index int, flags uint32) (*Renderer, error)

CreateRenderer returns a new 2D rendering context for a window. (https://wiki.libsdl.org/SDL_CreateRenderer)

func CreateSoftwareRenderer Uses

func CreateSoftwareRenderer(surface *Surface) (*Renderer, error)

CreateSoftwareRenderer returns a new 2D software rendering context for a surface. (https://wiki.libsdl.org/SDL_CreateSoftwareRenderer)

func (*Renderer) Clear Uses

func (renderer *Renderer) Clear() error

Clear clears the current rendering target with the drawing color. (https://wiki.libsdl.org/SDL_RenderClear)

func (*Renderer) Copy Uses

func (renderer *Renderer) Copy(texture *Texture, src, dst *Rect) error

Copy copies a portion of the texture to the current rendering target. (https://wiki.libsdl.org/SDL_RenderCopy)

func (*Renderer) CopyEx Uses

func (renderer *Renderer) CopyEx(texture *Texture, src, dst *Rect, angle float64, center *Point, flip RendererFlip) error

CopyEx copies a portion of the texture to the current rendering target, optionally rotating it by angle around the given center and also flipping it top-bottom and/or left-right. (https://wiki.libsdl.org/SDL_RenderCopyEx)

func (*Renderer) CreateTexture Uses

func (renderer *Renderer) CreateTexture(format uint32, access int, w, h int32) (*Texture, error)

CreateTexture returns a new texture for a rendering context. (https://wiki.libsdl.org/SDL_CreateTexture)

func (*Renderer) CreateTextureFromSurface Uses

func (renderer *Renderer) CreateTextureFromSurface(surface *Surface) (*Texture, error)

CreateTextureFromSurface returns a new texture from an existing surface. (https://wiki.libsdl.org/SDL_CreateTextureFromSurface)

func (*Renderer) Destroy Uses

func (renderer *Renderer) Destroy()

Destroy destroys the rendering context for a window and free associated textures. (https://wiki.libsdl.org/SDL_DestroyRenderer)

func (*Renderer) DrawLine Uses

func (renderer *Renderer) DrawLine(x1, y1, x2, y2 int32) error

DrawLine draws a line on the current rendering target. (https://wiki.libsdl.org/SDL_RenderDrawLine)

func (*Renderer) DrawLines Uses

func (renderer *Renderer) DrawLines(points []Point) error

DrawLines draws a series of connected lines on the current rendering target. (https://wiki.libsdl.org/SDL_RenderDrawLines)

func (*Renderer) DrawPoint Uses

func (renderer *Renderer) DrawPoint(x, y int32) error

DrawPoint draws a point on the current rendering target. (https://wiki.libsdl.org/SDL_RenderDrawPoint)

func (*Renderer) DrawPoints Uses

func (renderer *Renderer) DrawPoints(points []Point) error

DrawPoints draws multiple points on the current rendering target. (https://wiki.libsdl.org/SDL_RenderDrawPoints)

func (*Renderer) DrawRect Uses

func (renderer *Renderer) DrawRect(rect *Rect) error

DrawRect draws a rectangle on the current rendering target. (https://wiki.libsdl.org/SDL_RenderDrawRect)

func (*Renderer) DrawRects Uses

func (renderer *Renderer) DrawRects(rects []Rect) error

DrawRects draws some number of rectangles on the current rendering target. (https://wiki.libsdl.org/SDL_RenderDrawRects)

func (*Renderer) FillRect Uses

func (renderer *Renderer) FillRect(rect *Rect) error

FillRect fills a rectangle on the current rendering target with the drawing color. (https://wiki.libsdl.org/SDL_RenderFillRect)

func (*Renderer) FillRects Uses

func (renderer *Renderer) FillRects(rects []Rect) error

FillRects fills some number of rectangles on the current rendering target with the drawing color. (https://wiki.libsdl.org/SDL_RenderFillRects)

func (*Renderer) GetClipRect Uses

func (renderer *Renderer) GetClipRect(rect *Rect)

GetClipRect returns the clip rectangle for the current target. (https://wiki.libsdl.org/SDL_RenderGetClipRect)

func (*Renderer) GetDrawBlendMode Uses

func (renderer *Renderer) GetDrawBlendMode(bm *BlendMode) error

GetDrawBlendMode returns the blend mode used for drawing operations. (https://wiki.libsdl.org/SDL_GetRenderDrawBlendMode)

func (*Renderer) GetDrawColor Uses

func (renderer *Renderer) GetDrawColor() (r, g, b, a uint8, err error)

GetDrawColor returns the color used for drawing operations (Rect, Line and Clear). (https://wiki.libsdl.org/SDL_GetRenderDrawColor)

func (*Renderer) GetInfo Uses

func (renderer *Renderer) GetInfo() (RendererInfo, error)

GetInfo returns information about a rendering context. (https://wiki.libsdl.org/SDL_GetRendererInfo)

func (*Renderer) GetLogicalSize Uses

func (renderer *Renderer) GetLogicalSize() (w, h int32)

GetLogicalSize returns device independent resolution for rendering. (https://wiki.libsdl.org/SDL_RenderGetLogicalSize)

func (*Renderer) GetOutputSize Uses

func (renderer *Renderer) GetOutputSize() (w, h int32, err error)

GetOutputSize returns the output size in pixels of a rendering context. (https://wiki.libsdl.org/SDL_GetRendererOutputSize)

func (*Renderer) GetRenderTarget Uses

func (renderer *Renderer) GetRenderTarget() *Texture

GetRenderTarget returns the current render target. (https://wiki.libsdl.org/SDL_GetRenderTarget)

func (*Renderer) GetScale Uses

func (renderer *Renderer) GetScale() (scaleX, scaleY float32)

GetScale returns the drawing scale for the current target. (https://wiki.libsdl.org/SDL_RenderGetScale)

func (*Renderer) GetViewport Uses

func (renderer *Renderer) GetViewport(rect *Rect)

GetViewport returns the drawing area for the current target. (https://wiki.libsdl.org/SDL_RenderGetViewport)

func (*Renderer) Present Uses

func (renderer *Renderer) Present()

Present updates the screen with any rendering performed since the previous call. (https://wiki.libsdl.org/SDL_RenderPresent)

func (*Renderer) ReadPixels Uses

func (renderer *Renderer) ReadPixels(rect *Rect, format uint32, pixels unsafe.Pointer, pitch int) error

ReadPixels reads pixels from the current rendering target. (https://wiki.libsdl.org/SDL_RenderReadPixels)

func (*Renderer) RenderTargetSupported Uses

func (renderer *Renderer) RenderTargetSupported() bool

RenderTargetSupported reports whether a window supports the use of render targets. (https://wiki.libsdl.org/SDL_RenderTargetSupported)

func (*Renderer) SetClipRect Uses

func (renderer *Renderer) SetClipRect(rect *Rect) error

SetClipRect sets the clip rectangle for rendering on the specified target. (https://wiki.libsdl.org/SDL_RenderSetClipRect)

func (*Renderer) SetDrawBlendMode Uses

func (renderer *Renderer) SetDrawBlendMode(bm BlendMode) error

SetDrawBlendMode sets the blend mode used for drawing operations (Fill and Line). (https://wiki.libsdl.org/SDL_SetRenderDrawBlendMode)

func (*Renderer) SetDrawColor Uses

func (renderer *Renderer) SetDrawColor(r, g, b, a uint8) error

SetDrawColor sets the color used for drawing operations (Rect, Line and Clear). (https://wiki.libsdl.org/SDL_SetRenderDrawColor)

func (*Renderer) SetDrawColorArray Uses

func (renderer *Renderer) SetDrawColorArray(bs ...uint8) error

SetDrawColorArray is a custom variant of SetDrawColor.

func (*Renderer) SetLogicalSize Uses

func (renderer *Renderer) SetLogicalSize(w, h int32) error

SetLogicalSize sets a device independent resolution for rendering. (https://wiki.libsdl.org/SDL_RenderSetLogicalSize)

func (*Renderer) SetRenderTarget Uses

func (renderer *Renderer) SetRenderTarget(texture *Texture) error

SetRenderTarget sets a texture as the current rendering target. (https://wiki.libsdl.org/SDL_SetRenderTarget)

func (*Renderer) SetScale Uses

func (renderer *Renderer) SetScale(scaleX, scaleY float32) error

SetScale sets the drawing scale for rendering on the current target. (https://wiki.libsdl.org/SDL_RenderSetScale)

func (*Renderer) SetViewport Uses

func (renderer *Renderer) SetViewport(rect *Rect) error

SetViewport sets the drawing area for rendering on the current target. (https://wiki.libsdl.org/SDL_RenderSetViewport)

type RendererFlip Uses

type RendererFlip uint32

RendererFlip is an enumeration of flags that can be used in the flip parameter for Renderer.CopyEx(). (https://wiki.libsdl.org/SDL_RendererFlip)

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
)

An enumeration of flags that can be used in the flip parameter for Renderer.CopyEx(). (https://wiki.libsdl.org/SDL_RendererFlip)

type RendererInfo Uses

type RendererInfo struct {
    Name string // the name of the renderer
    RendererInfoData
}

RendererInfo contains information on the capabilities of a render driver or the current render context. (https://wiki.libsdl.org/SDL_RendererInfo)

type RendererInfoData Uses

type RendererInfoData struct {
    Flags             uint32    // a mask of supported renderer flags
    NumTextureFormats uint32    // the number of available texture formats
    TextureFormats    [16]int32 // the available texture formats
    MaxTextureWidth   int32     // the maximum texture width
    MaxTextureHeight  int32     // the maximum texture height
}

RendererInfoData contains information on the capabilities of a render driver or the current render context. (https://wiki.libsdl.org/SDL_RendererInfo)

type SWYUVTexture Uses

type SWYUVTexture struct {
    Format       uint32
    TargetFormat uint32
    W            int
    H            int
    Pixels       *uint8
    ColorTab     *int
    Rgb2Pix      *uint32
    Display1X    unsafe.Pointer
    Display2x    unsafe.Pointer
    Pitches      [3]uint16
    Planes       *[3]uint8
    Stretch      *Surface
    Display      *Surface
}

SWYUVTexture is the software implementation of the YUV texture support.

type Scancode Uses

type Scancode uint32

Scancode is an SDL keyboard scancode representation. (https://wiki.libsdl.org/SDL_Scancode)

func GetScancodeFromKey Uses

func GetScancodeFromKey(code Keycode) Scancode

GetScancodeFromKey returns the scancode corresponding to the given key code according to the current keyboard layout. (https://wiki.libsdl.org/SDL_GetScancodeFromKey)

func GetScancodeFromName Uses

func GetScancodeFromName(name string) Scancode

GetScancodeFromName returns a scancode from a human-readable name. (https://wiki.libsdl.org/SDL_GetScancodeFromName)

type Sem Uses

type Sem struct {
    Count        uint32
    WaitersCount uint32
    CountLock    *Mutex
    CountNonzero *Cond
}

Sem is the SDL semaphore structure.

func CreateSemaphore Uses

func CreateSemaphore(initialValue uint32) (*Sem, error)

CreateSemaphore creates a semaphore. (https://wiki.libsdl.org/SDL_CreateSemaphore)

func (*Sem) Destroy Uses

func (sem *Sem) Destroy()

Destroy destroys a semaphore. (https://wiki.libsdl.org/SDL_DestroySemaphore)

func (*Sem) Post Uses

func (sem *Sem) Post() error

Post atomically increments a semaphore's value and wake waiting threads. (https://wiki.libsdl.org/SDL_SemPost)

func (*Sem) TryWait Uses

func (sem *Sem) TryWait() error

TryWait sees if a semaphore has a positive value and decrement it if it does. (https://wiki.libsdl.org/SDL_SemTryWait)

func (*Sem) Value Uses

func (sem *Sem) Value() uint32

Value returns the current value of a semaphore. (https://wiki.libsdl.org/SDL_SemValue)

func (*Sem) Wait Uses

func (sem *Sem) Wait() error

Wait waits until a semaphore has a positive value and then decrements it. (https://wiki.libsdl.org/SDL_SemWait)

func (*Sem) WaitTimeout Uses

func (sem *Sem) WaitTimeout(ms uint32) error

WaitTimeout waits until a semaphore has a positive value and then decrements it. (https://wiki.libsdl.org/SDL_SemWaitTimeout)

type SharedObject Uses

type SharedObject uintptr

SharedObject is a pointer to the object handle.

func LoadObject Uses

func LoadObject(sofile string) SharedObject

LoadObject dynamically loads a shared object and returns a pointer to the object handle. (https://wiki.libsdl.org/SDL_LoadObject)

func (SharedObject) LoadFunction Uses

func (handle SharedObject) LoadFunction(name string) unsafe.Pointer

LoadFunction returns a pointer to the named function from the shared object. (https://wiki.libsdl.org/SDL_LoadFunction)

func (SharedObject) Unload Uses

func (handle SharedObject) Unload()

Unload unloads a shared object from memory. (https://wiki.libsdl.org/SDL_UnloadObject)

type Surface Uses

type Surface struct {
    Format *PixelFormat // the format of the pixels stored in the surface (read-only) (https://wiki.libsdl.org/SDL_PixelFormat)
    W      int32        // the width in pixels (read-only)
    H      int32        // the height in pixels (read-only)
    Pitch  int32        // the length of a row of pixels in bytes (read-only)

    UserData unsafe.Pointer // an arbitrary pointer you can set

    ClipRect Rect // a Rect structure used to clip blits to the surface which can be set by SetClipRect() (read-only)

    RefCount int32 // reference count that can be incremented by the application
    // contains filtered or unexported fields
}

Surface contains a collection of pixels used in software blitting. (https://wiki.libsdl.org/SDL_Surface)

func CreateRGBSurface Uses

func CreateRGBSurface(flags uint32, width, height, depth int32, Rmask, Gmask, Bmask, Amask uint32) (*Surface, error)

CreateRGBSurface allocates a new RGB surface. (https://wiki.libsdl.org/SDL_CreateRGBSurface)

func CreateRGBSurfaceFrom Uses

func CreateRGBSurfaceFrom(pixels unsafe.Pointer, width, height int32, depth, pitch int, Rmask, Gmask, Bmask, Amask uint32) (*Surface, error)

CreateRGBSurfaceFrom allocate a new RGB surface with existing pixel data. (https://wiki.libsdl.org/SDL_CreateRGBSurfaceFrom)

func LoadBMP Uses

func LoadBMP(file string) (*Surface, error)

LoadBMP loads a surface from a BMP file. (https://wiki.libsdl.org/SDL_LoadBMP)

func LoadBMPRW Uses

func LoadBMPRW(src *RWops, freeSrc int) (*Surface, error)

LoadBMPRW loads a BMP image from a seekable SDL data stream (memory or file). (https://wiki.libsdl.org/SDL_LoadBMP_RW)

func (*Surface) Blit Uses

func (surface *Surface) Blit(srcRect *Rect, dst *Surface, dstRect *Rect) error

Blit performs a fast surface copy to a destination surface. (https://wiki.libsdl.org/SDL_BlitSurface)

func (*Surface) BlitScaled Uses

func (surface *Surface) BlitScaled(srcRect *Rect, dst *Surface, dstRect *Rect) error

BlitScaled performs a scaled surface copy to a destination surface. (https://wiki.libsdl.org/SDL_BlitScaled)

func (*Surface) BytesPerPixel Uses

func (surface *Surface) BytesPerPixel() int

BytesPerPixel return the number of significant bits in a pixel values of the surface.

func (*Surface) Convert Uses

func (surface *Surface) Convert(fmt *PixelFormat, flags uint32) (*Surface, error)

Convert copies the existing surface into a new one that is optimized for blitting to a surface of a specified pixel format. (https://wiki.libsdl.org/SDL_ConvertSurface)

func (*Surface) ConvertFormat Uses

func (surface *Surface) ConvertFormat(pixelFormat uint32, flags uint32) (*Surface, error)

ConvertFormat copies the existing surface to a new surface of the specified format. (https://wiki.libsdl.org/SDL_ConvertSurfaceFormat)

func (*Surface) Data Uses

func (surface *Surface) Data() unsafe.Pointer

Data returns the pointer to the actual pixel data of the surface.

func (*Surface) FillRect Uses

func (surface *Surface) FillRect(rect *Rect, color uint32) error

FillRect performs a fast fill of a rectangle with a specific color. (https://wiki.libsdl.org/SDL_FillRect)

func (*Surface) FillRects Uses

func (surface *Surface) FillRects(rects []Rect, color uint32) error

FillRects performs a fast fill of a set of rectangles with a specific color. (https://wiki.libsdl.org/SDL_FillRects)

func (*Surface) Free Uses

func (surface *Surface) Free()

Free frees the RGB surface. (https://wiki.libsdl.org/SDL_FreeSurface)

func (*Surface) GetAlphaMod Uses

func (surface *Surface) GetAlphaMod() (alpha uint8, err error)

GetAlphaMod returns the additional alpha value used in blit operations. (https://wiki.libsdl.org/SDL_GetSurfaceAlphaMod)

func (*Surface) GetBlendMode Uses

func (surface *Surface) GetBlendMode() (bm BlendMode, err error)

GetBlendMode returns the blend mode used for blit operations. (https://wiki.libsdl.org/SDL_GetSurfaceBlendMode)

func (*Surface) GetClipRect Uses

func (surface *Surface) GetClipRect(rect *Rect)

GetClipRect returns the clipping rectangle for a surface. (https://wiki.libsdl.org/SDL_GetClipRect)

func (*Surface) GetColorKey Uses

func (surface *Surface) GetColorKey() (key uint32, err error)

GetColorKey retruns the color key (transparent pixel) for the surface. (https://wiki.libsdl.org/SDL_GetColorKey)

func (*Surface) GetColorMod Uses

func (surface *Surface) GetColorMod() (r, g, b uint8, err error)

GetColorMod returns the additional color value multiplied into blit operations. (https://wiki.libsdl.org/SDL_GetSurfaceColorMod)

func (*Surface) Lock Uses

func (surface *Surface) Lock() error

Lock sets up the surface for directly accessing the pixels. (https://wiki.libsdl.org/SDL_LockSurface)

func (*Surface) LowerBlit Uses

func (surface *Surface) LowerBlit(srcRect *Rect, dst *Surface, dstRect *Rect) error

LowerBlit performs low-level surface blitting only. (https://wiki.libsdl.org/SDL_LowerBlit)

func (*Surface) LowerBlitScaled Uses

func (surface *Surface) LowerBlitScaled(srcRect *Rect, dst *Surface, dstRect *Rect) error

LowerBlitScaled performs low-level surface scaled blitting only. (https://wiki.libsdl.org/SDL_LowerBlitScaled)

func (*Surface) MustLock Uses

func (surface *Surface) MustLock() bool

MustLock reports whether the surface must be locked for access. (https://wiki.libsdl.org/SDL_MUSTLOCK)

func (*Surface) PixelNum Uses

func (surface *Surface) PixelNum() int

PixelNum returns the number of pixels stored in the surface.

func (*Surface) Pixels Uses

func (surface *Surface) Pixels() []byte

Pixels returns the actual pixel data of the surface.

func (*Surface) SaveBMP Uses

func (surface *Surface) SaveBMP(file string) error

SaveBMP saves the surface to a BMP file. (https://wiki.libsdl.org/SDL_SaveBMP)

func (*Surface) SaveBMPRW Uses

func (surface *Surface) SaveBMPRW(dst *RWops, freeDst int) error

SaveBMPRW save the surface to a seekable SDL data stream (memory or file) in BMP format. (https://wiki.libsdl.org/SDL_SaveBMP_RW)

func (*Surface) SetAlphaMod Uses

func (surface *Surface) SetAlphaMod(alpha uint8) error

SetAlphaMod sets an additional alpha value used in blit operations. (https://wiki.libsdl.org/SDL_SetSurfaceAlphaMod)

func (*Surface) SetBlendMode Uses

func (surface *Surface) SetBlendMode(bm BlendMode) error

SetBlendMode sets the blend mode used for blit operations. (https://wiki.libsdl.org/SDL_SetSurfaceBlendMode)

func (*Surface) SetClipRect Uses

func (surface *Surface) SetClipRect(rect *Rect) bool

SetClipRect sets the clipping rectangle for the surface (https://wiki.libsdl.org/SDL_SetClipRect)

func (*Surface) SetColorKey Uses

func (surface *Surface) SetColorKey(flag int, key uint32) error

SetColorKey sets the color key (transparent pixel) in the surface. (https://wiki.libsdl.org/SDL_SetColorKey)

func (*Surface) SetColorMod Uses

func (surface *Surface) SetColorMod(r, g, b uint8) error

SetColorMod sets an additional color value multiplied into blit operations. (https://wiki.libsdl.org/SDL_SetSurfaceColorMod)

func (*Surface) SetPalette Uses

func (surface *Surface) SetPalette(palette *Palette) error

SetPalette sets the palette used by the surface. (https://wiki.libsdl.org/SDL_SetSurfacePalette)

func (*Surface) SetRLE Uses

func (surface *Surface) SetRLE(flag int) error

SetRLE sets the RLE acceleration hint for the surface. (https://wiki.libsdl.org/SDL_SetSurfaceRLE)

func (*Surface) SoftStretch Uses

func (surface *Surface) SoftStretch(srcRect *Rect, dst *Surface, dstRect *Rect) error

SoftStretch has been replaced by BlitScaled(). (https://wiki.libsdl.org/SDL_SoftStretch)

func (*Surface) Unlock Uses

func (surface *Surface) Unlock()

Unlock releases the surface after directly accessing the pixels. (https://wiki.libsdl.org/SDL_UnlockSurface)

func (*Surface) UpperBlit Uses

func (surface *Surface) UpperBlit(srcRect *Rect, dst *Surface, dstRect *Rect) error

UpperBlit has been replaced by Blit(). (https://wiki.libsdl.org/SDL_UpperBlit)

func (*Surface) UpperBlitScaled Uses

func (surface *Surface) UpperBlitScaled(srcRect *Rect, dst *Surface, dstRect *Rect) error

UpperBlitScaled has been replaced by BlitScaled(). (https://wiki.libsdl.org/SDL_UpperBlitScaled)

type SysWMEvent Uses

type SysWMEvent struct {
    Type      uint32 // SYSWMEVENT
    Timestamp uint32 // timestamp of the event
    // contains filtered or unexported fields
}

SysWMEvent contains a video driver dependent system event. (https://wiki.libsdl.org/SDL_SysWMEvent)

type SysWMInfo Uses

type SysWMInfo struct {
    Version   Version // a Version structure that contains the current SDL version
    Subsystem uint32  // the windowing system type
    // contains filtered or unexported fields
}

SysWMInfo contains system-dependent information about a window. (https://wiki.libsdl.org/SDL_SysWMinfo)

func (*SysWMInfo) GetCocoaInfo Uses

func (info *SysWMInfo) GetCocoaInfo() *CocoaInfo

GetCocoaInfo returns Apple Mac OS X window information.

func (*SysWMInfo) GetDFBInfo Uses

func (info *SysWMInfo) GetDFBInfo() *DFBInfo

GetDFBInfo returns DirectFB window information.

func (*SysWMInfo) GetUIKitInfo Uses

func (info *SysWMInfo) GetUIKitInfo() *UIKitInfo

GetUIKitInfo returns Apple iOS window information.

func (*SysWMInfo) GetWindowsInfo Uses

func (info *SysWMInfo) GetWindowsInfo() *WindowsInfo

GetWindowsInfo returns Microsoft Windows window information.

func (*SysWMInfo) GetX11Info Uses

func (info *SysWMInfo) GetX11Info() *X11Info

GetX11Info returns X Window System window information.

type SystemCursor Uses

type SystemCursor C.SDL_SystemCursor

SystemCursor is a system cursor created by CreateSystemCursor().

type TextEditingEvent Uses

type TextEditingEvent struct {
    Type      uint32                               // TEXTEDITING
    Timestamp uint32                               // timestamp of the event
    WindowID  uint32                               // the window with keyboard focus, if any
    Text      [C.SDL_TEXTINPUTEVENT_TEXT_SIZE]byte // the null-terminated editing text in UTF-8 encoding
    Start     int32                                // the location to begin editing from
    Length    int32                                // the number of characters to edit from the start point
}

TextEditingEvent contains keyboard text editing event information. (https://wiki.libsdl.org/SDL_TextEditingEvent)

type TextInputEvent Uses

type TextInputEvent struct {
    Type      uint32                               // TEXTINPUT
    Timestamp uint32                               // timestamp of the event
    WindowID  uint32                               // the window with keyboard focus, if any
    Text      [C.SDL_TEXTINPUTEVENT_TEXT_SIZE]byte // the null-terminated input text in UTF-8 encoding
}

TextInputEvent contains keyboard text input event information. (https://wiki.libsdl.org/SDL_TextInputEvent)

type Texture Uses

type Texture C.SDL_Texture

Texture contains an efficient, driver-specific representation of pixel data. (https://wiki.libsdl.org/SDL_Texture)

func (*Texture) Destroy Uses

func (texture *Texture) Destroy()

Destroy destroys the specified texture. (https://wiki.libsdl.org/SDL_DestroyTexture)

func (*Texture) GLBind Uses

func (texture *Texture) GLBind(texw, texh *float32) error

GLBind binds an OpenGL/ES/ES2 texture to the current context for use with OpenGL instructions when rendering OpenGL primitives directly. (https://wiki.libsdl.org/SDL_GL_BindTexture)

func (*Texture) GLUnbind Uses

func (texture *Texture) GLUnbind() error

GLUnbind unbinds an OpenGL/ES/ES2 texture from the current context. (https://wiki.libsdl.org/SDL_GL_UnbindTexture)

func (*Texture) GetAlphaMod Uses

func (texture *Texture) GetAlphaMod() (alpha uint8, err error)

GetAlphaMod returns the additional alpha value multiplied into render copy operations. (https://wiki.libsdl.org/SDL_GetTextureAlphaMod)

func (*Texture) GetBlendMode Uses

func (texture *Texture) GetBlendMode() (bm BlendMode, err error)

GetBlendMode returns the blend mode used for texture copy operations. (https://wiki.libsdl.org/SDL_GetTextureBlendMode)

func (*Texture) Lock Uses

func (texture *Texture) Lock(rect *Rect) ([]byte, int, error)

Lock locks a portion of the texture for write-only pixel access. (https://wiki.libsdl.org/SDL_LockTexture)

func (*Texture) Query Uses

func (texture *Texture) Query() (uint32, int, int32, int32, error)

Query returns the attributes of a texture. (https://wiki.libsdl.org/SDL_QueryTexture)

func (*Texture) SetAlphaMod Uses

func (texture *Texture) SetAlphaMod(alpha uint8) error

SetAlphaMod sets an additional alpha value multiplied into render copy operations. (https://wiki.libsdl.org/SDL_SetTextureAlphaMod)

func (*Texture) SetBlendMode Uses

func (texture *Texture) SetBlendMode(bm BlendMode) error

SetBlendMode sets the blend mode for a texture, used by Renderer.Copy(). (https://wiki.libsdl.org/SDL_SetTextureBlendMode)

func (*Texture) SetColorMod Uses

func (texture *Texture) SetColorMod(r uint8, g uint8, b uint8) error

SetColorMod sets an additional color value multiplied into render copy operations. (https://wiki.libsdl.org/SDL_SetTextureColorMod)

func (*Texture) Unlock Uses

func (texture *Texture) Unlock()

Unlock unlocks a texture, uploading the changes to video memory, if needed. (https://wiki.libsdl.org/SDL_UnlockTexture)

func (*Texture) Update Uses

func (texture *Texture) Update(rect *Rect, pixels []byte, pitch int) error

Update updates the given texture rectangle with new pixel data. (https://wiki.libsdl.org/SDL_UpdateTexture)

func (*Texture) UpdateYUV Uses

func (texture *Texture) UpdateYUV(rect *Rect, yPlane []byte, yPitch int, uPlane []byte, uPitch int, vPlane []byte, vPitch int) error

UpdateYUV updates a rectangle within a planar YV12 or IYUV texture with new pixel data. (https://wiki.libsdl.org/SDL_UpdateYUVTexture)

type ThreadID Uses

type ThreadID uint64

ThreadID is the thread identifier for a thread.

type TouchFingerEvent Uses

type TouchFingerEvent struct {
    Type      uint32   // FINGERMOTION, FINGERDOWN, FINGERUP
    Timestamp uint32   // timestamp of the event
    TouchID   TouchID  // the touch device id
    FingerID  FingerID // the finger id
    X         float32  // the x-axis location of the touch event, normalized (0...1)
    Y         float32  // the y-axis location of the touch event, normalized (0...1)
    DX        float32  // the distance moved in the x-axis, normalized (-1...1)
    DY        float32  // the distance moved in the y-axis, normalized (-1...1)
    Pressure  float32  // the quantity of pressure applied, normalized (0...1)
}

TouchFingerEvent contains finger touch event information. (https://wiki.libsdl.org/SDL_TouchFingerEvent)

type TouchID Uses

type TouchID C.SDL_TouchID

TouchID is the ID of a touch device.

func GetTouchDevice Uses

func GetTouchDevice(index int) TouchID

GetTouchDevice returns the touch ID with the given index. (https://wiki.libsdl.org/SDL_GetTouchDevice)

type UIKitInfo Uses

type UIKitInfo struct {
    Window unsafe.Pointer // the UIKit window
}

UIKitInfo contains Apple iOS window information.

type UserEvent Uses

type UserEvent struct {
    Type      uint32         // value obtained from RegisterEvents()
    Timestamp uint32         // timestamp of the event
    WindowID  uint32         // the associated window, if any
    Code      int32          // user defined event code
    Data1     unsafe.Pointer // user defined data pointer
    Data2     unsafe.Pointer // user defined data pointer
}

UserEvent contains an application-defined event type. (https://wiki.libsdl.org/SDL_UserEvent)

type Version Uses

type Version struct {
    Major uint8 // major version
    Minor uint8 // minor version
    Patch uint8 // update version (patchlevel)
}

Version contains information about the version of SDL in use. (https://wiki.libsdl.org/SDL_version)

type Window Uses

type Window C.SDL_Window

Window is a type used to identify a window.

func CreateWindow Uses

func CreateWindow(title string, x, y, w, h int32, flags uint32) (*Window, error)

CreateWindow creates a window with the specified position, dimensions, and flags. (https://wiki.libsdl.org/SDL_CreateWindow)

func CreateWindowAndRenderer Uses

func CreateWindowAndRenderer(w, h int32, flags uint32) (*Window, *Renderer, error)

CreateWindowAndRenderer returns a new window and default renderer. (https://wiki.libsdl.org/SDL_CreateWindowAndRenderer)

func CreateWindowFrom Uses

func CreateWindowFrom(data unsafe.Pointer) (*Window, error)

CreateWindowFrom creates an SDL window from an existing native window. (https://wiki.libsdl.org/SDL_CreateWindowFrom)

func GetKeyboardFocus Uses

func GetKeyboardFocus() *Window

GetKeyboardFocus returns the window which currently has keyboard focus. (https://wiki.libsdl.org/SDL_GetKeyboardFocus)

func GetMouseFocus Uses

func GetMouseFocus() *Window

GetMouseFocus returns the window which currently has mouse focus. (https://wiki.libsdl.org/SDL_GetMouseFocus)

func GetWindowFromID Uses

func GetWindowFromID(id uint32) (*Window, error)

GetWindowFromID returns a window from a stored ID. (https://wiki.libsdl.org/SDL_GetWindowFromID)

func (*Window) Destroy Uses

func (window *Window) Destroy()

Destroy destroys the window. (https://wiki.libsdl.org/SDL_DestroyWindow)

func (*Window) GetBrightness Uses

func (window *Window) GetBrightness() float32

GetBrightness returns the brightness (gamma multiplier) for the display that owns the given window. (https://wiki.libsdl.org/SDL_GetWindowBrightness)

func (*Window) GetData Uses

func (window *Window) GetData(name string) unsafe.Pointer

GetData returns the data pointer associated with the window. (https://wiki.libsdl.org/SDL_GetWindowData)

func (*Window) GetDisplayIndex Uses

func (window *Window) GetDisplayIndex() (int, error)

GetDisplayIndex returns the index of the display associated with the window. (https://wiki.libsdl.org/SDL_GetWindowDisplayIndex)

func (*Window) GetDisplayMode Uses

func (window *Window) GetDisplayMode(mode *DisplayMode) error

GetDisplayMode fills in information about the display mode to use when the window is visible at fullscreen. (https://wiki.libsdl.org/SDL_GetWindowDisplayMode)

func (*Window) GetFlags Uses

func (window *Window) GetFlags() uint32

GetFlags returns the window flags. (https://wiki.libsdl.org/SDL_GetWindowFlags)

func (*Window) GetGammaRamp Uses

func (window *Window) GetGammaRamp() (red, green, blue *[256]uint16, err error)

GetGammaRamp returns the gamma ramp for the display that owns a given window. (https://wiki.libsdl.org/SDL_GetWindowGammaRamp)

func (*Window) GetGrab Uses

func (window *Window) GetGrab() bool

GetGrab returns the window's input grab mode. (https://wiki.libsdl.org/SDL_GetWindowGrab)

func (*Window) GetID Uses

func (window *Window) GetID() uint32

GetID returns the numeric ID of the window, for logging purposes.

(https://wiki.libsdl.org/SDL_GetWindowID)

func (*Window) GetMaximumSize Uses

func (window *Window) GetMaximumSize() (w, h int32)

GetMaximumSize returns the maximum size of the window's client area. (https://wiki.libsdl.org/SDL_GetWindowMaximumSize)

func (*Window) GetMinimumSize Uses

func (window *Window) GetMinimumSize() (w, h int32)

GetMinimumSize returns the minimum size of the window's client area. (https://wiki.libsdl.org/SDL_GetWindowMinimumSize)

func (*Window) GetPixelFormat Uses

func (window *Window) GetPixelFormat() (uint32, error)

GetPixelFormat returns the pixel format associated with the window. (https://wiki.libsdl.org/SDL_GetWindowPixelFormat)

func (*Window) GetPosition Uses

func (window *Window) GetPosition() (x, y int32)

GetPosition returns the position of the window. (https://wiki.libsdl.org/SDL_GetWindowPosition)

func (*Window) GetRenderer Uses

func (window *Window) GetRenderer() (*Renderer, error)

GetRenderer returns the renderer associated with a window. (https://wiki.libsdl.org/SDL_GetRenderer)

func (*Window) GetSize Uses

func (window *Window) GetSize() (w, h int32)

GetSize returns the size of the window's client area. (https://wiki.libsdl.org/SDL_GetWindowSize)

func (*Window) GetSurface Uses

func (window *Window) GetSurface() (*Surface, error)

GetSurface returns the SDL surface associated with the window. (https://wiki.libsdl.org/SDL_GetWindowSurface)

func (*Window) GetTitle Uses

func (window *Window) GetTitle() string

GetTitle returns the title of the window. (https://wiki.libsdl.org/SDL_GetWindowTitle)

func (*Window) GetWMInfo Uses

func (window *Window) GetWMInfo() (*SysWMInfo, error)

GetWMInfo returns driver specific information about a window. (https://wiki.libsdl.org/SDL_GetWindowWMInfo)

func (*Window) Hide Uses

func (window *Window) Hide()

Hide hides the window. (https://wiki.libsdl.org/SDL_HideWindow)

func (*Window) Maximize Uses

func (window *Window) Maximize()

Maximize makes the window as large as possible. (https://wiki.libsdl.org/SDL_MaximizeWindow)

func (*Window) Minimize Uses

func (window *Window) Minimize()

Minimize minimizes the window to an iconic representation. (https://wiki.libsdl.org/SDL_MinimizeWindow)

func (*Window) Raise Uses

func (window *Window) Raise()

Raise raises the window above other windows and set the input focus. (https://wiki.libsdl.org/SDL_RaiseWindow)

func (*Window) Restore Uses

func (window *Window) Restore()

Restore restores the size and position of a minimized or maximized window. (https://wiki.libsdl.org/SDL_RestoreWindow)

func (*Window) SetBordered Uses

func (window *Window) SetBordered(bordered bool)

SetBordered sets the border state of the window. (https://wiki.libsdl.org/SDL_SetWindowBordered)

func (*Window) SetBrightness Uses

func (window *Window) SetBrightness(brightness float32) error

SetBrightness sets the brightness (gamma multiplier) for the display that owns the given window. (https://wiki.libsdl.org/SDL_SetWindowBrightness)

func (*Window) SetData Uses

func (window *Window) SetData(name string, userdata unsafe.Pointer) unsafe.Pointer

SetData associates an arbitrary named pointer with the window. (https://wiki.libsdl.org/SDL_SetWindowData)

func (*Window) SetDisplayMode Uses

func (window *Window) SetDisplayMode(mode *DisplayMode) error

SetDisplayMode sets the display mode to use when the window is visible at fullscreen. (https://wiki.libsdl.org/SDL_SetWindowDisplayMode)

func (*Window) SetFullscreen Uses

func (window *Window) SetFullscreen(flags uint32) error

SetFullscreen sets the window's fullscreen state. (https://wiki.libsdl.org/SDL_SetWindowFullscreen)

func (*Window) SetGammaRamp Uses

func (window *Window) SetGammaRamp(red, green, blue *[256]uint16) error

SetGammaRamp sets the gamma ramp for the display that owns the given window. (https://wiki.libsdl.org/SDL_SetWindowGammaRamp)

func (*Window) SetGrab Uses

func (window *Window) SetGrab(grabbed bool)

SetGrab sets the window's input grab mode. (https://wiki.libsdl.org/SDL_SetWindowGrab)

func (*Window) SetIcon Uses

func (window *Window) SetIcon(icon *Surface)

SetIcon sets the icon for the window. (https://wiki.libsdl.org/SDL_SetWindowIcon)

func (*Window) SetMaximumSize Uses

func (window *Window) SetMaximumSize(maxW, maxH int32)

SetMaximumSize sets the maximum size of the window's client area. (https://wiki.libsdl.org/SDL_SetWindowMaximumSize)

func (*Window) SetMinimumSize Uses

func (window *Window) SetMinimumSize(minW, minH int32)

SetMinimumSize sets the minimum size of the window's client area. (https://wiki.libsdl.org/SDL_SetWindowMinimumSize)

func (*Window) SetPosition Uses

func (window *Window) SetPosition(x, y int32)

SetPosition sets the position of the window. (https://wiki.libsdl.org/SDL_SetWindowPosition)

func (*Window) SetResizable Uses

func (window *Window) SetResizable(resizable bool)

SetResizable sets the user-resizable state of the window. (https://wiki.libsdl.org/SDL_SetWindowResizable)

func (*Window) SetSize Uses

func (window *Window) SetSize(w, h int32)

SetSize sets the size of the window's client area. (https://wiki.libsdl.org/SDL_SetWindowSize)

func (*Window) SetTitle Uses

func (window *Window) SetTitle(title string)

SetTitle sets the title of the window. (https://wiki.libsdl.org/SDL_SetWindowTitle)

func (*Window) Show Uses

func (window *Window) Show()

Show shows the window. (https://wiki.libsdl.org/SDL_ShowWindow)

func (*Window) UpdateSurface Uses

func (window *Window) UpdateSurface() error

UpdateSurface copies the window surface to the screen. (https://wiki.libsdl.org/SDL_UpdateWindowSurface)

func (*Window) UpdateSurfaceRects Uses

func (window *Window) UpdateSurfaceRects(rects []Rect) error

UpdateSurfaceRects copies areas of the window surface to the screen. (https://wiki.libsdl.org/SDL_UpdateWindowSurfaceRects)

func (*Window) WarpMouseInWindow Uses

func (window *Window) WarpMouseInWindow(x, y int32)

WarpMouseInWindow moves the mouse to the given position within the window. (https://wiki.libsdl.org/SDL_WarpMouseInWindow)

type WindowEvent Uses

type WindowEvent struct {
    Type      uint32 // WINDOWEVENT
    Timestamp uint32 // timestamp of the event
    WindowID  uint32 // the associated window
    Event     uint8  // (https://wiki.libsdl.org/SDL_WindowEventID)

    Data1 int32 // event dependent data
    Data2 int32 // event dependent data
    // contains filtered or unexported fields
}

WindowEvent contains window state change event data. (https://wiki.libsdl.org/SDL_WindowEvent)

type WindowsInfo Uses

type WindowsInfo struct {
    Window unsafe.Pointer // the window handle
}

WindowsInfo contains Microsoft Windows window information.

type X11Info Uses

type X11Info struct {
    Display unsafe.Pointer // the X11 display
    Window  uint           // the X11 window
}

X11Info contains X Window System window information.

Package sdl imports 8 packages (graph) and is imported by 103 packages. Updated 2017-11-22. Refresh now. Tools for package owners.