initial commit

archive/vendor/github.com/veandco/go-sdl2/sdl/TODO.md

@@ -0,0 +1,266 @@
+## 2.0.16
+
+[x] SDL_FlashWindow() to get a user’s attention
+[x] SDL_GetAudioDeviceSpec() to get the preferred audio format of a device
+[x] SDL_SetWindowAlwaysOnTop() to dynamically change the SDL_WINDOW_ALWAYS_ON_TOP flag for a window
+[x] SDL_SetWindowKeyboardGrab() to support grabbing the keyboard independently of the mouse
+[x] SDL_SoftStretchLinear() to do bilinear scaling between 32-bit software surfaces
+[x] SDL_UpdateNVTexture() to update streaming NV12/21 textures
+[x] SDL_GameControllerSendEffect() and SDL_JoystickSendEffect() to allow sending custom trigger effects to the DualSense controller
+[x] SDL_GameControllerGetSensorDataRate() to get the sensor data rate for PlayStation and Nintendo Switch controllers
+
+### Windows
+
+[?] SDL_SetWindowsMessageHook() to set a function that is called for all Windows messages
+[?] SDL_RenderGetD3D11Device() to get the D3D11 device used by the SDL renderer
+
+### Linux
+
+[x] SDL_HINT_AUDIO_INCLUDE_MONITORS to control whether PulseAudio recording should include monitor devices
+[x] SDL_HINT_AUDIO_DEVICE_STREAM_ROLE to describe the role of your application for audio control panels
+
+### Android:
+
+[?] SDL_AndroidShowToast() to show a lightweight notification
+
+## 2.0.14
+
+[x] SDL_GameControllerGetSerial()
+[x] SDL_GameControllerHasAxis()
+[x] SDL_GameControllerHasButton()
+[x] SDL_GameControllerGetNumTouchpads()
+[x] SDL_GameControllerGetNumTouchpadFingers()
+[x] SDL_GameControllerGetTouchpadFinger()
+[x] SDL_GameControllerHasSensor()
+[x] SDL_GameControllerSetSensorEnabled()
+[x] SDL_GameControllerIsSensorEnabled()
+[x] SDL_GameControllerGetSensorData
+[x] SDL_GameControllerRumbleTriggers()
+[x] SDL_GameControllerHasLED()
+[x] SDL_GameControllerSetLED()
+[x] SDL_JoystickGetSerial()
+[x] SDL_JoystickRumbleTriggers()
+[x] SDL_JoystickHasLED()
+[x] SDL_JoystickSetLED()
+[x] SDL_JoystickAttachVirtual()
+[x] SDL_JoystickDetachVirtual()
+[x] SDL_JoystickIsVirtual()
+[x] SDL_JoystickSetVirtualAxis()
+[x] SDL_JoystickSetVirtualButton()
+[x] SDL_JoystickSetVirtualHat()
+[x] SDL_LockSensors()
+[x] SDL_UnlockSensors()
+[x] SDL_HAPTIC_STEERING_AXIS
+[x] SDL_GetPreferredLocales()
+[x] SDL_OpenURL()
+[x] SDL_HasSurfaceRLE()
+[x] SDL_SIMDRealloc()
+[x] SDL_GetErrorMsg()
+[x] SDL_Metal_GetLayer()
+[x] SDL_Metal_GetDrawableSize()
+[x] SDL_HINT_JOYSTICK_HIDAPI_PS5
+[x] SDL_HINT_MOUSE_RELATIVE_SCALING
+[x] SDL_HINT_PREFERRED_LOCALES
+[x] SDL_HINT_JOYSTICK_RAWINPUT
+[x] SDL_HINT_JOYSTICK_HIDAPI_CORRELATE_XINPUT
+[x] SDL_HINT_AUDIO_DEVICE_APP_NAME
+[x] SDL_HINT_AUDIO_DEVICE_STREAM_NAME
+[x] SDL_HINT_LINUX_JOYSTICK_DEADZONES
+[x] SDL_HINT_THREAD_PRIORITY_POLICY
+[x] SDL_HINT_THREAD_FORCE_REALTIME_TIME_CRITICAL
+[x] SDL_HINT_ANDROID_BLOCK_ON_PAUSE_PAUSEAUDIO
+[x] SDL_HINT_EMSCRIPTEN_ASYNCIFY
+[x] SDL_PIXELFORMAT_XRGB4444
+[x] SDL_PIXELFORMAT_XBGR4444
+[x] SDL_PIXELFORMAT_XRGB1555
+[x] SDL_PIXELFORMAT_XBGR1555
+[x] SDL_PIXELFORMAT_XRGB8888
+[x] SDL_PIXELFORMAT_XBGR8888
+[x] SDL_WINDOW_METAL
+[x] SDL_AndroidRequestPermission()
+
+## 2.0.12
+
+[x] SDL_GameControllerTypeForIndex
+[x] SDL_GameControllerGetType
+[x] SDL_GameControllerFromPlayerIndex
+[x] SDL_GameControllerSetPlayerIndex
+[x] SDL_JoystickFromPlayerIndex
+[x] SDL_JoystickSetPlayerIndex
+[x] SDL_GetTextureScaleMode
+[x] SDL_SetTextureScaleMode
+[x] SDL_LockTextureToSurface
+[x] SDL_BLENDMODE_MUL
+[x] SDL_TouchFingerEvent update
+[x] SDL_HasARMSIMD
+[x] SDL_HINT_DISPLAY_USABLE_BOUNDS
+[x] SDL_HINT_GAMECONTROLLERTYPE
+[x] SDL_HINT_GAMECONTROLLER_USE_BUTTON_LABELS
+[x] SDL_HINT_JOYSTICK_HIDAPI_GAMECUBE
+[x] SDL_HINT_VIDEO_X11_WINDOW_VISUALID
+[x] SDL_HINT_VIDEO_X11_FORCE_EGL
+[x] SDL_Metal_CreateView
+[x] SDL_Metal_DestroyView
+[x] SDL_GetAndroidSDKVersion
+
+## 2.0.10
+
+[x] SDL_SIMDGetAlignment
+[x] SDL_SIMDAlloc
+[x] SDL_SIMDFree
+[x] SDL_RenderDrawPointF
+[x] SDL_RenderDrawPointsF
+[x] SDL_RenderDrawLineF
+[x] SDL_RenderDrawLinesF
+[x] SDL_RenderDrawRectF
+[x] SDL_RenderDrawRectsF
+[x] SDL_RenderFillRectF
+[x] SDL_RenderFillRectsF
+[x] SDL_RenderCopyF
+[x] SDL_RenderCopyExF
+[x] SDL_GetTouchDeviceType
+[x] SDL_RenderFlush
+[x] SDL_HINT_RENDER_BATCHING
+[x] SDL_HINT_EVENT_LOGGING
+[x] SDL_HINT_GAMECONTROLLERCONFIG_FILE
+[x] SDL_HINT_MOUSE_TOUCH_EVENTS
+
+## 2.0.9
+
+[x] SDL_SENSORUPDATE
+[x] SDL_DISPLAYEVENT
+[x] SDL_JoystickGetDevicePlayerIndex
+[x] SDL_JoystickGetPlayerIndex
+[x] SDL_GameControllerGetPlayerIndex
+[x] SDL_GameControllerRumble
+[x] SDL_JoystickRumble
+[x] SDL_GameControllerMappingForDeviceIndex
+[x] SDL_HINT_MOUSE_DOUBLE_CLICK_TIME
+[x] SDL_HINT_MOUSE_DOUBLE_CLICK_RADIUS
+[x] SDL_HasColorKey
+[x] SDL_HasAVX512F
+[x] SDL_IsTablet
+[?] SDL_THREAD_PRIORITY_TIME_CRITICAL
+
+## 2.0.8
+
+### Hints
+
+[x] SDL_HINT_IOS_HIDE_HOME_INDICATOR
+[x] SDL_HINT_RETURN_KEY_HIDES_IME
+[x] SDL_HINT_TV_REMOTE_AS_JOYSTICK
+[x] SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR
+[x] SDL_HINT_VIDEO_DOUBLE_BUFFER
+
+### Surface
+
+[x] SDL_SetYUVConversionMode()
+[x] SDL_GetYUVConversionMode()
+
+### Android
+
+[x] SDL_IsAndroidTV()
+
+### Mac OS X / iOS / tvOS
+
+[x] SDL_RenderGetMetalLayer()
+[x] SDL_RenderGetMetalCommandEncoder()
+
+### Windows UWP
+
+[ ] SDL_WinRTGetDeviceFamily()
+
+## 2.0.7
+
+### General
+
+Audio
+
+- [x] SDL_NewAudioStream()
+- [x] SDL_AudioStreamPut()
+- [x] SDL_AudioStreamGet()
+- [x] SDL_AudioStreamAvailable()
+- [x] SDL_AudioStreamFlush()
+- [x] SDL_AudioStreamClear()
+- [x] SDL_FreeAudioStream()
+
+Joystick
+
+- [x] SDL_LockJoysticks()
+- [x] SDL_UnlockJoysticks()
+
+Stdinc
+
+- [ ] SDL_GetMemoryFunctions()
+- [ ] SDL_SetMemoryFunctions()
+- [ ] SDL_GetNumAllocations()
+
+## 2.0.6
+
+### General
+
+Blend Mode
+
+- [x] SDL_ComposeCustomBlendMode()
+
+CPU Info
+
+- [x] SDL_HasNEON()
+
+Game Controller
+
+- [x] SDL_GameControllerGetVendor()
+- [x] SDL_GameControllerGetProduct()
+- [x] SDL_GameControllerGetProductVersion()
+- [x] SDL_GameControllerNumMappings()
+- [x] SDL_GameControllerMappingForIndex()
+
+Hints
+
+- [x] SDL_HINT_AUDIO_RESAMPLING_MODE
+- [x] SDL_HINT_RENDER_LOGICAL_SIZE_MODE
+- [x] SDL_HINT_MOUSE_NORMAL_SPEED_SCALE
+- [x] SDL_HINT_MOUSE_RELATIVE_SPEED_SCALE
+- [x] SDL_HINT_TOUCH_MOUSE_EVENTS
+
+Joystick
+
+- [x] SDL_JoystickGetDeviceVendor()
+- [x] SDL_JoystickGetDeviceProduct()
+- [x] SDL_JoystickGetDeviceProductVersion()
+- [x] SDL_JoystickGetDeviceType()
+- [x] SDL_JoystickGetDeviceInstanceID()
+- [x] SDL_JoystickGetVendor()
+- [x] SDL_JoystickGetProduct()
+- [x] SDL_JoystickGetProductVersion()
+- [x] SDL_JoystickGetType()
+- [x] SDL_JoystickGetAxisInitialState()
+
+RW Ops
+
+- [x] SDL_LoadFile()
+- [x] SDL_LoadFile_RW()
+
+Surface
+
+- [x] SDL_DuplicateSurface()
+
+Vulkan
+
+- [x] SDL_Vulkan_LoadLibrary()
+- [x] SDL_Vulkan_GetVkGetInstanceProcAddr()
+- [x] SDL_Vulkan_GetInstanceExtensions()
+- [x] SDL_Vulkan_CreateSurface()
+- [x] SDL_Vulkan_GetDrawableSize()
+- [x] SDL_Vulkan_UnloadLibrary()
+
+### Windows
+
+Hints
+
+- [x] SDL_HINT_WINDOWS_INTRESOURCE_ICON
+- [x] SDL_HINT_WINDOWS_INTRESOURCE_ICON_SMALL
+
+## Miscellaneous
+
+- [ ] Add ability to set window title bar color on runtime

archive/vendor/github.com/veandco/go-sdl2/sdl/audio.go

@@ -0,0 +1,651 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if !(SDL_VERSION_ATLEAST(2,0,4))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_QueueAudio is not supported before SDL 2.0.4")
+#endif
+
+static int SDL_QueueAudio(SDL_AudioDeviceID dev, const void *data, Uint32 len)
+{
+	return -1;
+}
+static Uint32 SDL_GetQueuedAudioSize(SDL_AudioDeviceID dev_id)
+{
+	return 0;
+}
+static void SDL_ClearQueuedAudio(SDL_AudioDeviceID dev)
+{
+}
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,5))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_DequeueAudio is not supported before SDL 2.0.5")
+#endif
+
+static int SDL_DequeueAudio(SDL_AudioDeviceID dev, const void *data, Uint32 len)
+{
+	return -1;
+}
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,7))
+
+struct _SDL_AudioStream;
+typedef struct _SDL_AudioStream SDL_AudioStream;
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_NewAudioStream is not supported before SDL 2.0.7")
+#endif
+
+static SDL_AudioStream * SDL_NewAudioStream(const SDL_AudioFormat src_format, const Uint8 src_channels, const int src_rate, const SDL_AudioFormat dst_format, const Uint8 dst_channels, const int dst_rate)
+{
+	return 0;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_AudioStreamPut is not supported before SDL 2.0.7")
+#endif
+
+static int SDL_AudioStreamPut(SDL_AudioStream *stream, const void *buf, int len)
+{
+	return -1;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_AudioStreamGet is not supported before SDL 2.0.7")
+#endif
+
+static int SDL_AudioStreamGet(SDL_AudioStream *stream, void *buf, int len)
+{
+	return -1;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_AudioStreamAvailable is not supported before SDL 2.0.7")
+#endif
+
+static int SDL_AudioStreamAvailable(SDL_AudioStream *stream)
+{
+	return -1;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_AudioStreamFlush is not supported before SDL 2.0.7")
+#endif
+
+static int SDL_AudioStreamFlush(SDL_AudioStream *stream)
+{
+	return -1;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_AudioStreamClear is not supported before SDL 2.0.7")
+#endif
+
+static int SDL_AudioStreamClear(SDL_AudioStream *stream)
+{
+	return -1;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_FreeAudioStream is not supported before SDL 2.0.7")
+#endif
+
+static void SDL_FreeAudioStream(SDL_AudioStream *stream)
+{
+}
+
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,16))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_GetAudioDeviceSpec is not supported before SDL 2.0.16")
+#endif
+
+static int SDL_GetAudioDeviceSpec(int index, int iscapture, SDL_AudioSpec *spec)
+{
+	return -1;
+}
+
+
+#endif
+*/
+import "C"
+import (
+	"reflect"
+	"unsafe"
+)
+
+// Audio format masks.
+// (https://wiki.libsdl.org/SDL_AudioFormat)
+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 values.
+// (https://wiki.libsdl.org/SDL_AudioFormat)
+const (
+	AUDIO_S8 = C.AUDIO_S8 // signed 8-bit samples
+	AUDIO_U8 = C.AUDIO_U8 // unsigned 8-bit samples
+
+	AUDIO_S16LSB = C.AUDIO_S16LSB // signed 16-bit samples in little-endian byte order
+	AUDIO_S16MSB = C.AUDIO_S16MSB // signed 16-bit samples in big-endian byte order
+	AUDIO_S16SYS = C.AUDIO_S16SYS // signed 16-bit samples in native byte order
+	AUDIO_S16    = C.AUDIO_S16    // AUDIO_S16LSB
+	AUDIO_U16LSB = C.AUDIO_U16LSB // unsigned 16-bit samples in little-endian byte order
+	AUDIO_U16MSB = C.AUDIO_U16MSB // unsigned 16-bit samples in big-endian byte order
+	AUDIO_U16SYS = C.AUDIO_U16SYS // unsigned 16-bit samples in native byte order
+	AUDIO_U16    = C.AUDIO_U16    // AUDIO_U16LSB
+
+	AUDIO_S32LSB = C.AUDIO_S32LSB // 32-bit integer samples in little-endian byte order
+	AUDIO_S32MSB = C.AUDIO_S32MSB // 32-bit integer samples in big-endian byte order
+	AUDIO_S32SYS = C.AUDIO_S32SYS // 32-bit integer samples in native byte order
+	AUDIO_S32    = C.AUDIO_S32    // AUDIO_S32LSB
+
+	AUDIO_F32LSB = C.AUDIO_F32LSB // 32-bit floating point samples in little-endian byte order
+	AUDIO_F32MSB = C.AUDIO_F32MSB // 32-bit floating point samples in big-endian byte order
+	AUDIO_F32SYS = C.AUDIO_F32SYS // 32-bit floating point samples in native byte order
+	AUDIO_F32    = C.AUDIO_F32    // AUDIO_F32LSB
+)
+
+// 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 (
+	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
+)
+
+// An enumeration of audio device states used in GetAudioDeviceStatus() and GetAudioStatus().
+// (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
+)
+
+// MIX_MAXVOLUME is the full audio volume value used in MixAudioFormat() and AudioFormat().
+// (https://wiki.libsdl.org/SDL_MixAudioFormat)
+const MIX_MAXVOLUME = C.SDL_MIX_MAXVOLUME // full audio volume
+
+// AudioFormat is an enumeration of audio formats.
+// (https://wiki.libsdl.org/SDL_AudioFormat)
+type AudioFormat uint16
+
+// AudioCallback is a function to call when the audio device needs more data.`
+// (https://wiki.libsdl.org/SDL_AudioSpec)
+type AudioCallback C.SDL_AudioCallback
+
+// AudioFilter is the filter list used in AudioCVT() (internal use)
+// (https://wiki.libsdl.org/SDL_AudioCVT)
+type AudioFilter C.SDL_AudioFilter
+
+// AudioDeviceID is ID of an audio device previously opened with OpenAudioDevice().
+// (https://wiki.libsdl.org/SDL_OpenAudioDevice)
+type AudioDeviceID uint32
+
+// AudioStatus is an enumeration of audio device states.
+// (https://wiki.libsdl.org/SDL_AudioStatus)
+type AudioStatus uint32
+type cAudioStatus C.SDL_AudioStatus
+
+// 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 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)
+	_        uint16         // padding
+	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)
+}
+type cAudioSpec C.SDL_AudioSpec
+
+// AudioCVT contains audio data conversion information.
+// (https://wiki.libsdl.org/SDL_AudioCVT)
+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
+	filters     [10]AudioFilter // filter list (internal use)
+	filterIndex int32           // current audio conversion function (internal use)
+}
+type cAudioCVT C.SDL_AudioCVT
+
+// AudioStream is a new audio conversion interface.
+// (https://wiki.libsdl.org/SDL_AudioStream)
+type AudioStream C.SDL_AudioStream
+
+func (fmt AudioFormat) c() C.SDL_AudioFormat {
+	return C.SDL_AudioFormat(fmt)
+}
+
+func (id AudioDeviceID) c() C.SDL_AudioDeviceID {
+	return C.SDL_AudioDeviceID(id)
+}
+
+func (as *AudioSpec) cptr() *C.SDL_AudioSpec {
+	return (*C.SDL_AudioSpec)(unsafe.Pointer(as))
+}
+
+func (cvt *AudioCVT) cptr() *C.SDL_AudioCVT {
+	return (*C.SDL_AudioCVT)(unsafe.Pointer(cvt))
+}
+
+func (stream *AudioStream) cptr() *C.SDL_AudioStream {
+	return (*C.SDL_AudioStream)(unsafe.Pointer(stream))
+}
+
+// BitSize returns audio formats bit size.
+// (https://wiki.libsdl.org/SDL_AudioFormat)
+func (fmt AudioFormat) BitSize() uint8 {
+	return uint8(fmt & AUDIO_MASK_BITSIZE)
+}
+
+// IsFloat reports whether audio format is float.
+// (https://wiki.libsdl.org/SDL_AudioFormat)
+func (fmt AudioFormat) IsFloat() bool {
+	return (fmt & AUDIO_MASK_DATATYPE) > 0
+}
+
+// IsBigEndian reports whether audio format is big-endian.
+// (https://wiki.libsdl.org/SDL_AudioFormat)
+func (fmt AudioFormat) IsBigEndian() bool {
+	return (fmt & AUDIO_MASK_ENDIAN) > 0
+}
+
+// IsSigned reports whether audio format is signed.
+// (https://wiki.libsdl.org/SDL_AudioFormat)
+func (fmt AudioFormat) IsSigned() bool {
+	return (fmt & AUDIO_MASK_SIGNED) > 0
+}
+
+// IsInt reports whether audio format is integer.
+// (https://wiki.libsdl.org/SDL_AudioFormat)
+func (fmt AudioFormat) IsInt() bool {
+	return !fmt.IsFloat()
+}
+
+// IsLittleEndian reports whether audio format is little-endian.
+// (https://wiki.libsdl.org/SDL_AudioFormat)
+func (fmt AudioFormat) IsLittleEndian() bool {
+	return !fmt.IsBigEndian()
+}
+
+// IsUnsigned reports whether audio format is unsigned.
+// (https://wiki.libsdl.org/SDL_AudioFormat)
+func (fmt AudioFormat) IsUnsigned() bool {
+	return !fmt.IsSigned()
+}
+
+// AllocBuf allocates the requested memory for AudioCVT buffer.
+func (cvt *AudioCVT) AllocBuf(size uintptr) {
+	cvt.Buf = C.malloc(C.size_t(size))
+}
+
+// FreeBuf deallocates the memory previously allocated from AudioCVT buffer.
+func (cvt *AudioCVT) FreeBuf() {
+	C.free(cvt.Buf)
+}
+
+// BufAsSlice returns AudioCVT.buf as byte slice.
+// NOTE: Must be used after ConvertAudio() because it uses LenCVT as slice length.
+func (cvt AudioCVT) BufAsSlice() []byte {
+	var b []byte
+	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+	sliceHeader.Len = int(cvt.LenCVT)
+	sliceHeader.Cap = int(cvt.Len * cvt.LenMult)
+	sliceHeader.Data = uintptr(unsafe.Pointer(cvt.Buf))
+	return b
+}
+
+// GetNumAudioDrivers returns the number of built-in audio drivers.
+// (https://wiki.libsdl.org/SDL_GetNumAudioDrivers)
+func GetNumAudioDrivers() int {
+	return int(C.SDL_GetNumAudioDrivers())
+}
+
+// GetAudioDriver returns the name of a built in audio driver.
+// (https://wiki.libsdl.org/SDL_GetAudioDriver)
+func GetAudioDriver(index int) string {
+	return string(C.GoString(C.SDL_GetAudioDriver(C.int(index))))
+}
+
+// AudioInit initializes a particular audio driver.
+// (https://wiki.libsdl.org/SDL_AudioInit)
+func AudioInit(driverName string) error {
+	_driverName := C.CString(driverName)
+	defer C.free(unsafe.Pointer(_driverName))
+	if C.SDL_AudioInit(_driverName) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// AudioQuit shuts down audio if you initialized it with AudioInit().
+// (https://wiki.libsdl.org/SDL_AudioQuit)
+func AudioQuit() {
+	C.SDL_AudioQuit()
+}
+
+// GetCurrentAudioDriver returns the name of the current audio driver.
+// (https://wiki.libsdl.org/SDL_GetCurrentAudioDriver)
+func GetCurrentAudioDriver() string {
+	return string(C.GoString(C.SDL_GetCurrentAudioDriver()))
+}
+
+// OpenAudio opens the audio device. New programs might want to use OpenAudioDevice() instead.
+// (https://wiki.libsdl.org/SDL_OpenAudio)
+func OpenAudio(desired, obtained *AudioSpec) error {
+	if C.SDL_OpenAudio(desired.cptr(), obtained.cptr()) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// GetNumAudioDevices returns the number of built-in audio devices.
+// (https://wiki.libsdl.org/SDL_GetNumAudioDevices)
+func GetNumAudioDevices(isCapture bool) int {
+	return int(C.SDL_GetNumAudioDevices(C.int(Btoi(isCapture))))
+}
+
+// GetAudioDeviceName returns the name of a specific audio device.
+// (https://wiki.libsdl.org/SDL_GetAudioDeviceName)
+func GetAudioDeviceName(index int, isCapture bool) string {
+	return string(C.GoString(C.SDL_GetAudioDeviceName(C.int(index), C.int(Btoi(isCapture)))))
+}
+
+// OpenAudioDevice opens a specific audio device.
+// (https://wiki.libsdl.org/SDL_OpenAudioDevice)
+func OpenAudioDevice(device string, isCapture bool, desired, obtained *AudioSpec, allowedChanges int) (AudioDeviceID, error) {
+	_device := C.CString(device)
+	if device == "" {
+		_device = nil
+	}
+	defer C.free(unsafe.Pointer(_device))
+	if id := AudioDeviceID(C.SDL_OpenAudioDevice(_device, C.int(Btoi(isCapture)), desired.cptr(), obtained.cptr(), C.int(allowedChanges))); id > 0 {
+		return id, nil
+	}
+	return 0, GetError()
+}
+
+// GetAudioStatus returns the current audio state of the audio device. New programs might want to use GetAudioDeviceStatus() instead.
+// (https://wiki.libsdl.org/SDL_GetAudioStatus)
+func GetAudioStatus() AudioStatus {
+	return (AudioStatus)(C.SDL_GetAudioStatus())
+}
+
+// GetAudioDeviceStatus returns the current audio state of an audio device.
+// (https://wiki.libsdl.org/SDL_GetAudioDeviceStatus)
+func GetAudioDeviceStatus(dev AudioDeviceID) AudioStatus {
+	return (AudioStatus)(C.SDL_GetAudioDeviceStatus(dev.c()))
+}
+
+// PauseAudio pauses and unpauses the audio device. New programs might want to use SDL_PauseAudioDevice() instead.
+// (https://wiki.libsdl.org/SDL_PauseAudio)
+func PauseAudio(pauseOn bool) {
+	C.SDL_PauseAudio(C.int(Btoi(pauseOn)))
+}
+
+// PauseAudioDevice pauses and unpauses audio playback on a specified device.
+// (https://wiki.libsdl.org/SDL_PauseAudioDevice)
+func PauseAudioDevice(dev AudioDeviceID, pauseOn bool) {
+	C.SDL_PauseAudioDevice(dev.c(), C.int(Btoi(pauseOn)))
+}
+
+// LoadWAVRW loads a WAVE from the data source, automatically freeing that source if freeSrc is true.
+// (https://wiki.libsdl.org/SDL_LoadWAV_RW)
+func LoadWAVRW(src *RWops, freeSrc bool) ([]byte, *AudioSpec) {
+	var _audioBuf *C.Uint8
+	var _audioLen C.Uint32
+	audioSpec := (*AudioSpec)(unsafe.Pointer(C.SDL_LoadWAV_RW(src.cptr(), C.int(Btoi(freeSrc)), (&AudioSpec{}).cptr(), &_audioBuf, &_audioLen)))
+
+	var b []byte
+	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+	sliceHeader.Len = (int)(_audioLen)
+	sliceHeader.Cap = (int)(_audioLen)
+	sliceHeader.Data = uintptr(unsafe.Pointer(_audioBuf))
+	return b, audioSpec
+}
+
+// LoadWAV loads a WAVE from a file.
+// (https://wiki.libsdl.org/SDL_LoadWAV)
+func LoadWAV(file string) ([]byte, *AudioSpec) {
+	_file := C.CString(file)
+	_rb := C.CString("rb")
+	defer C.free(unsafe.Pointer(_file))
+	defer C.free(unsafe.Pointer(_rb))
+
+	var _audioBuf *C.Uint8
+	var _audioLen C.Uint32
+	audioSpec := (*AudioSpec)(unsafe.Pointer(C.SDL_LoadWAV_RW(C.SDL_RWFromFile(_file, _rb), 1, (&AudioSpec{}).cptr(), &_audioBuf, &_audioLen)))
+
+	var b []byte
+	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+	sliceHeader.Len = (int)(_audioLen)
+	sliceHeader.Cap = (int)(_audioLen)
+	sliceHeader.Data = uintptr(unsafe.Pointer(_audioBuf))
+	return b, audioSpec
+}
+
+// FreeWAV frees data previously allocated with LoadWAV() or LoadWAVRW().
+// (https://wiki.libsdl.org/SDL_FreeWAV)
+func FreeWAV(audioBuf []uint8) {
+	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&audioBuf))
+	_audioBuf := (*C.Uint8)(unsafe.Pointer(sliceHeader.Data))
+	C.SDL_FreeWAV(_audioBuf)
+}
+
+// BuildAudioCVT initializes an AudioCVT structure for conversion.
+// (https://wiki.libsdl.org/SDL_BuildAudioCVT)
+func BuildAudioCVT(cvt *AudioCVT, srcFormat AudioFormat, srcChannels uint8, srcRate int, dstFormat AudioFormat, dstChannels uint8, dstRate int) (converted bool, err error) {
+	switch int(C.SDL_BuildAudioCVT(cvt.cptr(), srcFormat.c(), C.Uint8(srcChannels), C.int(srcRate), dstFormat.c(), C.Uint8(dstChannels), C.int(dstRate))) {
+	case 1:
+		return true, nil
+	case 0:
+		return false, nil
+	}
+	return false, GetError()
+}
+
+// ConvertAudio converts audio data to a desired audio format.
+// (https://wiki.libsdl.org/SDL_ConvertAudio)
+func ConvertAudio(cvt *AudioCVT) error {
+	_cvt := (*C.SDL_AudioCVT)(unsafe.Pointer(cvt))
+	if C.SDL_ConvertAudio(_cvt) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// QueueAudio queues more audio on non-callback devices.
+// (https://wiki.libsdl.org/SDL_QueueAudio)
+func QueueAudio(dev AudioDeviceID, data []byte) error {
+	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&data))
+	_data := unsafe.Pointer(sliceHeader.Data)
+	_len := (C.Uint32)(sliceHeader.Len)
+	if C.SDL_QueueAudio(dev.c(), _data, _len) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// DequeueAudio dequeues more audio on non-callback devices. Returns the number of bytes dequeued, which could be less than requested
+// (https://wiki.libsdl.org/SDL_DequeueAudio)
+func DequeueAudio(dev AudioDeviceID, data []byte) (n int, err error) {
+	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&data))
+	_data := unsafe.Pointer(sliceHeader.Data)
+	_len := (C.Uint32)(sliceHeader.Len)
+	if dequeued := int(C.SDL_DequeueAudio(dev.c(), _data, _len)); dequeued > 0 {
+		return dequeued, nil
+	}
+	return 0, GetError()
+}
+
+// GetQueuedAudioSize returns the number of bytes of still-queued audio.
+// (https://wiki.libsdl.org/SDL_GetQueuedAudioSize)
+func GetQueuedAudioSize(dev AudioDeviceID) uint32 {
+	return uint32(C.SDL_GetQueuedAudioSize(dev.c()))
+}
+
+// ClearQueuedAudio drops any queued audio data waiting to be sent to the hardware.
+// (https://wiki.libsdl.org/SDL_ClearQueuedAudio)
+func ClearQueuedAudio(dev AudioDeviceID) {
+	C.SDL_ClearQueuedAudio(dev.c())
+}
+
+// MixAudio mixes audio data. New programs might want to use MixAudioFormat() instead.
+// (https://wiki.libsdl.org/SDL_MixAudio)
+func MixAudio(dst, src *uint8, len uint32, volume int) {
+	_dst := (*C.Uint8)(unsafe.Pointer(dst))
+	_src := (*C.Uint8)(unsafe.Pointer(src))
+	C.SDL_MixAudio(_dst, _src, C.Uint32(len), C.int(volume))
+}
+
+// MixAudioFormat mixes audio data in a specified format.
+// (https://wiki.libsdl.org/SDL_MixAudioFormat)
+func MixAudioFormat(dst, src *uint8, format AudioFormat, len uint32, volume int) {
+	_dst := (*C.Uint8)(unsafe.Pointer(dst))
+	_src := (*C.Uint8)(unsafe.Pointer(src))
+	C.SDL_MixAudioFormat(_dst, _src, format.c(), C.Uint32(len), C.int(volume))
+}
+
+// LockAudio locks the audio device. New programs might want to use LockAudioDevice() instead.
+// (https://wiki.libsdl.org/SDL_LockAudio)
+func LockAudio() {
+	C.SDL_LockAudio()
+}
+
+// LockAudioDevice locks out the audio callback function for a specified device.
+// (https://wiki.libsdl.org/SDL_LockAudioDevice)
+func LockAudioDevice(dev AudioDeviceID) {
+	C.SDL_LockAudioDevice(dev.c())
+}
+
+// UnlockAudio unlocks the audio device. New programs might want to use UnlockAudioDevice() instead.
+// (https://wiki.libsdl.org/SDL_UnlockAudio)
+func UnlockAudio() {
+	C.SDL_UnlockAudio()
+}
+
+// UnlockAudioDevice unlocks the audio callback function for a specified device.
+// (https://wiki.libsdl.org/SDL_UnlockAudioDevice)
+func UnlockAudioDevice(dev AudioDeviceID) {
+	C.SDL_UnlockAudioDevice(dev.c())
+}
+
+// CloseAudio closes the audio device. New programs might want to use CloseAudioDevice() instead.
+// (https://wiki.libsdl.org/SDL_CloseAudio)
+func CloseAudio() {
+	C.SDL_CloseAudio()
+}
+
+// CloseAudioDevice shuts down audio processing and closes the audio device.
+// (https://wiki.libsdl.org/SDL_CloseAudioDevice)
+func CloseAudioDevice(dev AudioDeviceID) {
+	C.SDL_CloseAudioDevice(dev.c())
+}
+
+// NewAudioStream creates a new audio stream
+// TODO: (https://wiki.libsdl.org/SDL_NewAudioStream)
+func NewAudioStream(srcFormat AudioFormat, srcChannels uint8, srcRate int, dstFormat AudioFormat, dstChannels uint8, dstRate int) (stream *AudioStream, err error) {
+	_srcFormat := C.SDL_AudioFormat(srcFormat)
+	_srcChannels := C.Uint8(srcChannels)
+	_srcRate := C.int(srcRate)
+	_dstFormat := C.SDL_AudioFormat(dstFormat)
+	_dstChannels := C.Uint8(dstChannels)
+	_dstRate := C.int(dstRate)
+
+	stream = (*AudioStream)(C.SDL_NewAudioStream(_srcFormat, _srcChannels, _srcRate, _dstFormat, _dstChannels, _dstRate))
+	if stream == nil {
+		err = GetError()
+	}
+	return
+}
+
+// Put adds data to be converted/resampled to the stream
+// TODO: (https://wiki.libsdl.org/SDL_AudioStreamPut)
+func (stream *AudioStream) Put(buf []byte) (err error) {
+	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
+	_buf := unsafe.Pointer(sliceHeader.Data)
+	_len := C.int(len(buf))
+	ret := int(C.SDL_AudioStreamPut(stream.cptr(), _buf, _len))
+	err = errorFromInt(ret)
+	return
+}
+
+// Get gets converted/resampled data from the stream. Returns the number of bytes read from the stream.
+// (https://wiki.libsdl.org/SDL_AudioStreamGet)
+func (stream *AudioStream) Get(buf []byte) (n int, err error) {
+	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
+	_buf := unsafe.Pointer(sliceHeader.Data)
+	_len := C.int(len(buf))
+	if ret := int(C.SDL_AudioStreamGet(stream.cptr(), _buf, _len)); ret < 0 {
+		return 0, errorFromInt(ret)
+	} else {
+		return ret, nil
+	}
+}
+
+// Available gets the number of converted/resampled bytes available
+// (https://wiki.libsdl.org/SDL_AudioStreamAvailable)
+func (stream *AudioStream) Available() (n int) {
+	n = int(C.SDL_AudioStreamAvailable(stream.cptr()))
+	return
+}
+
+// Flush tells the stream that you're done sending data, and anything being buffered
+// should be converted/resampled and made available immediately.
+// TODO: (https://wiki.libsdl.org/SDL_AudioStreamFlush)
+func (stream *AudioStream) Flush() (err error) {
+	ret := int(C.SDL_AudioStreamFlush(stream.cptr()))
+	err = errorFromInt(ret)
+	return
+}
+
+// Clear clears any pending data in the stream without converting it
+// TODO: (https://wiki.libsdl.org/SDL_AudioStreamClear)
+func (stream *AudioStream) Clear() {
+	C.SDL_AudioStreamClear(stream.cptr())
+}
+
+// Free frees the audio stream
+// TODO: (https://wiki.libsdl.org/SDL_AudoiStreamFree)
+func (stream *AudioStream) Free() {
+	C.SDL_FreeAudioStream(stream.cptr())
+}
+
+// GetAudioDeviceSpec returns the preferred audio format of a specific audio device.
+// (https://wiki.libsdl.org/SDL_GetAudioDeviceSpec)
+func GetAudioDeviceSpec(index int, isCapture bool) (spec *AudioSpec, err error) {
+	spec = &AudioSpec{}
+	err = errorFromInt(int(C.SDL_GetAudioDeviceSpec(C.int(index), C.int(Btoi(isCapture)), spec.cptr())))
+	return
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/blendmode.go

@@ -0,0 +1,126 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if !(SDL_VERSION_ATLEAST(2,0,6))
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_BLENDMODE_INVALID is not supported before SDL 2.0.6")
+#endif
+
+#define SDL_BLENDMODE_INVALID (0x7FFFFFFF)
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_BlendOperation is not supported before SDL 2.0.6")
+#endif
+
+typedef enum
+{
+    SDL_BLENDOPERATION_ADD              = 0x1,
+    SDL_BLENDOPERATION_SUBTRACT         = 0x2,
+    SDL_BLENDOPERATION_REV_SUBTRACT     = 0x3,
+    SDL_BLENDOPERATION_MINIMUM          = 0x4,
+    SDL_BLENDOPERATION_MAXIMUM          = 0x5
+} SDL_BlendOperation;
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_BlendFactor is not supported before SDL 2.0.6")
+#endif
+
+typedef enum
+{
+    SDL_BLENDFACTOR_ZERO                = 0x1,
+    SDL_BLENDFACTOR_ONE                 = 0x2,
+    SDL_BLENDFACTOR_SRC_COLOR           = 0x3,
+    SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR = 0x4,
+    SDL_BLENDFACTOR_SRC_ALPHA           = 0x5,
+    SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA = 0x6,
+    SDL_BLENDFACTOR_DST_COLOR           = 0x7,
+    SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR = 0x8,
+    SDL_BLENDFACTOR_DST_ALPHA           = 0x9,
+    SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA = 0xA
+
+} SDL_BlendFactor;
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_ComposeCustomBlendMode is not supported before SDL 2.0.6")
+#endif
+
+SDL_BlendMode SDLCALL SDL_ComposeCustomBlendMode(SDL_BlendFactor srcColorFactor, SDL_BlendFactor dstColorFactor, SDL_BlendOperation colorOperation, SDL_BlendFactor srcAlphaFactor, SDL_BlendFactor dstAlphaFactor, SDL_BlendOperation alphaOperation)
+{
+	return SDL_BLENDMODE_NONE;
+}
+#endif
+*/
+import "C"
+import "unsafe"
+
+// BlendMode is an enumeration of blend modes used in Render.Copy() and drawing operations.
+// (https://wiki.libsdl.org/SDL_BlendMode)
+type BlendMode uint32
+
+const (
+	BLENDMODE_NONE    = C.SDL_BLENDMODE_NONE  // no blending
+	BLENDMODE_BLEND   = C.SDL_BLENDMODE_BLEND // alpha blending
+	BLENDMODE_ADD     = C.SDL_BLENDMODE_ADD   // additive blending
+	BLENDMODE_MOD     = C.SDL_BLENDMODE_MOD   // color modulate
+	BLENDMODE_INVALID = C.SDL_BLENDMODE_INVALID
+)
+
+func (bm BlendMode) c() C.SDL_BlendMode {
+	return C.SDL_BlendMode(C.Uint32(bm))
+}
+
+func (bm *BlendMode) cptr() *C.SDL_BlendMode {
+	return (*C.SDL_BlendMode)(unsafe.Pointer(bm))
+}
+
+// BlendOperation is an enumeration of blend operations used when creating a custom blend mode with ComposeCustomBlendMode().
+// (https://wiki.libsdl.org/SDL_BlendOperation)
+type BlendOperation C.SDL_BlendOperation
+
+const (
+	BLENDOPERATION_ADD          = C.SDL_BLENDOPERATION_ADD
+	BLENDOPERATION_SUBTRACT     = C.SDL_BLENDOPERATION_SUBTRACT
+	BLENDOPERATION_REV_SUBTRACT = C.SDL_BLENDOPERATION_REV_SUBTRACT
+	BLENDOPERATION_MINIMUM      = C.SDL_BLENDOPERATION_MINIMUM
+	BLENDOPERATION_MAXIMUM      = C.SDL_BLENDOPERATION_MAXIMUM
+)
+
+// BlendFactor is an enumeration of blend factors used when creating a custom blend mode with ComposeCustomBlendMode().
+// (https://wiki.libsdl.org/SDL_BlendFactor)
+type BlendFactor C.SDL_BlendFactor
+
+const (
+	BLENDFACTOR_ZERO                = C.SDL_BLENDFACTOR_ZERO                // 0, 0, 0, 0
+	BLENDFACTOR_ONE                 = C.SDL_BLENDFACTOR_ONE                 // 1, 1, 1, 1
+	BLENDFACTOR_SRC_COLOR           = C.SDL_BLENDFACTOR_SRC_COLOR           // srcR, srcG, srcB, srcA
+	BLENDFACTOR_ONE_MINUS_SRC_COLOR = C.SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR // 1-srcR, 1-srcG, 1-srcB, 1-srcA
+	BLENDFACTOR_SRC_ALPHA           = C.SDL_BLENDFACTOR_SRC_ALPHA           // srcA, srcA, srcA, srcA
+	BLENDFACTOR_ONE_MINUS_SRC_ALPHA = C.SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA // 1-srcA, 1-srcA, 1-srcA, 1-srcA
+	BLENDFACTOR_DST_COLOR           = C.SDL_BLENDFACTOR_DST_COLOR           // dstR, dstG, dstB, dstA
+	BLENDFACTOR_ONE_MINUS_DST_COLOR = C.SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR // 1-dstR, 1-dstG, 1-dstB, 1-dstA
+	BLENDFACTOR_DST_ALPHA           = C.SDL_BLENDFACTOR_DST_ALPHA           // dstA, dstA, dstA, dstA
+	BLENDFACTOR_ONE_MINUS_DST_ALPHA = C.SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA // 1-dstA, 1-dstA, 1-dstA, 1-dstA
+)
+
+// ComposeCustomBlendMode creates a custom blend mode, which may or may not be supported by a given renderer
+// The result of the blend mode operation will be:
+//     dstRGB = dstRGB * dstColorFactor colorOperation srcRGB * srcColorFactor
+// and
+//     dstA = dstA * dstAlphaFactor alphaOperation srcA * srcAlphaFactor
+// (https://wiki.libsdl.org/SDL_ComposeCustomBlendMode)
+func ComposeCustomBlendMode(srcColorFactor, dstColorFactor BlendFactor, colorOperation BlendOperation, srcAlphaFactor, dstAlphaFactor BlendFactor, alphaOperation BlendOperation) BlendMode {
+	_srcColorFactor := C.SDL_BlendFactor(srcColorFactor)
+	_dstColorFactor := C.SDL_BlendFactor(dstColorFactor)
+	_colorOperation := C.SDL_BlendOperation(colorOperation)
+	_srcAlphaFactor := C.SDL_BlendFactor(srcAlphaFactor)
+	_dstAlphaFactor := C.SDL_BlendFactor(dstAlphaFactor)
+	_alphaOperation := C.SDL_BlendOperation(alphaOperation)
+	return BlendMode(C.SDL_ComposeCustomBlendMode(_srcColorFactor, _dstColorFactor, _colorOperation, _srcAlphaFactor, _dstAlphaFactor, _alphaOperation))
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/clipboard.go

@@ -0,0 +1,34 @@
+package sdl
+
+// #include "sdl_wrapper.h"
+import "C"
+import "unsafe"
+
+// SetClipboardText puts UTF-8 text into the clipboard.
+// (https://wiki.libsdl.org/SDL_SetClipboardText)
+func SetClipboardText(text string) error {
+	_text := C.CString(text)
+	defer C.free(unsafe.Pointer(_text))
+	if C.SDL_SetClipboardText(_text) < 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// GetClipboardText returns UTF-8 text from the clipboard.
+// (https://wiki.libsdl.org/SDL_GetClipboardText)
+func GetClipboardText() (string, error) {
+	text := C.SDL_GetClipboardText()
+	if text == nil {
+		return "", GetError()
+	}
+	defer C.SDL_free(unsafe.Pointer(text))
+	_text := C.GoString(text)
+	return _text, nil
+}
+
+// HasClipboardText reports whether the clipboard exists and contains a text string that is non-empty.
+// (https://wiki.libsdl.org/SDL_HasClipboardText)
+func HasClipboardText() bool {
+	return C.SDL_HasClipboardText() > 0
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/cpuinfo.go

@@ -0,0 +1,216 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if !(SDL_VERSION_ATLEAST(2,0,9))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_HasAVX512F is not supported before SDL 2.0.9")
+#endif
+
+static inline SDL_bool SDL_HasAVX512F()
+{
+	return SDL_FALSE;
+}
+
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,1))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_GetSystemRAM is not supported before SDL 2.0.1")
+#endif
+
+static inline int SDL_GetSystemRAM()
+{
+	return -1;
+}
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,2))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_HasAVX is not supported before SDL 2.0.2")
+#endif
+
+static inline SDL_bool SDL_HasAVX()
+{
+	return SDL_FALSE;
+}
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,4))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_HasAVX2 is not supported before SDL 2.0.4")
+#endif
+
+static inline SDL_bool SDL_HasAVX2()
+{
+	return SDL_FALSE;
+}
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,6))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_HasNEON is not supported before SDL 2.0.4")
+#endif
+
+static inline SDL_bool SDL_HasNEON()
+{
+	return SDL_FALSE;
+}
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,10))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_SIMDGetAlignment is not supported before SDL 2.0.10")
+#endif
+
+static inline size_t SDL_SIMDGetAlignment(void)
+{
+	return 0;
+}
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_SIMDAlloc is not supported before SDL 2.0.10")
+#endif
+
+static inline void * SDL_SIMDAlloc(const size_t len)
+{
+	return NULL;
+}
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_SIMDFree is not supported before SDL 2.0.10")
+#endif
+
+static inline void SDL_SIMDFree(void *ptr)
+{
+}
+
+#endif
+
+*/
+import "C"
+import "unsafe"
+
+// CACHELINE_SIZE is a cacheline size used for padding.
+const CACHELINE_SIZE = C.SDL_CACHELINE_SIZE
+
+// GetCPUCount returns the number of CPU cores available.
+// (https://wiki.libsdl.org/SDL_GetCPUCount)
+func GetCPUCount() int {
+	return int(C.SDL_GetCPUCount())
+}
+
+// GetCPUCacheLineSize returns the L1 cache line size of the CPU.
+// (https://wiki.libsdl.org/SDL_GetCPUCacheLineSize)
+func GetCPUCacheLineSize() int {
+	return int(C.SDL_GetCPUCacheLineSize())
+}
+
+// HasRDTSC reports whether the CPU has the RDTSC instruction.
+// (https://wiki.libsdl.org/SDL_HasRDTSC)
+func HasRDTSC() bool {
+	return C.SDL_HasRDTSC() > 0
+}
+
+// HasAltiVec reports whether the CPU has AltiVec features.
+// (https://wiki.libsdl.org/SDL_HasAltiVec)
+func HasAltiVec() bool {
+	return C.SDL_HasAltiVec() > 0
+}
+
+// HasMMX reports whether the CPU has MMX features.
+// (https://wiki.libsdl.org/SDL_HasMMX)
+func HasMMX() bool {
+	return C.SDL_HasMMX() > 0
+}
+
+// Has3DNow reports whether the CPU has 3DNow! features.
+// (https://wiki.libsdl.org/SDL_Has3DNow)
+func Has3DNow() bool {
+	return C.SDL_Has3DNow() > 0
+}
+
+// HasSSE reports whether the CPU has SSE features.
+// (https://wiki.libsdl.org/SDL_HasSSE)
+func HasSSE() bool {
+	return C.SDL_HasSSE() > 0
+}
+
+// HasSSE2 reports whether the CPU has SSE2 features.
+// (https://wiki.libsdl.org/SDL_HasSSE2)
+func HasSSE2() bool {
+	return C.SDL_HasSSE2() > 0
+}
+
+// HasSSE3 reports whether the CPU has SSE3 features.
+// (https://wiki.libsdl.org/SDL_HasSSE3)
+func HasSSE3() bool {
+	return C.SDL_HasSSE3() > 0
+}
+
+// HasSSE41 reports whether the CPU has SSE4.1 features.
+// (https://wiki.libsdl.org/SDL_HasSSE41)
+func HasSSE41() bool {
+	return C.SDL_HasSSE41() > 0
+}
+
+// HasSSE42 reports whether the CPU has SSE4.2 features.
+// (https://wiki.libsdl.org/SDL_HasSSE42)
+func HasSSE42() bool {
+	return C.SDL_HasSSE42() > 0
+}
+
+// GetSystemRAM returns the amount of RAM configured in the system.
+// (https://wiki.libsdl.org/SDL_GetSystemRAM)
+func GetSystemRAM() int {
+	return int(C.SDL_GetSystemRAM())
+}
+
+// HasAVX reports whether the CPU has AVX features.
+// (https://wiki.libsdl.org/SDL_HasAVX)
+func HasAVX() bool {
+	return C.SDL_HasAVX() > 0
+}
+
+// HasAVX512F reports whether the CPU has AVX-512F (foundation) features.
+// TODO: (https://wiki.libsdl.org/SDL_HasAVX512F)
+func HasAVX512F() bool {
+	return C.SDL_HasAVX512F() > 0
+}
+
+// HasAVX2 reports whether the CPU has AVX2 features.
+// (https://wiki.libsdl.org/SDL_HasAVX2)
+func HasAVX2() bool {
+	return C.SDL_HasAVX2() > 0
+}
+
+// HasNEON reports whether the CPU has NEON features.
+// (https://wiki.libsdl.org/SDL_HasNEON)
+func HasNEON() bool {
+	return C.SDL_HasNEON() > 0
+}
+
+// SIMDGetAlignment reports the alignment this system needs for SIMD allocations.
+// TODO: (https://wiki.libsdl.org/SDL_SIMDGetAlignment)
+func SIMDGetAlignment() int {
+	return int(C.SDL_SIMDGetAlignment())
+}
+
+// SIMDAlloc allocates memory in a SIMD-friendly way.
+// TODO: (https://wiki.libsdl.org/SDL_SIMDAlloc)
+func SIMDAlloc(_len int) unsafe.Pointer {
+	return C.SDL_SIMDAlloc(C.size_t(_len))
+}
+
+// SIMDFree deallocates memory obtained from SDL_SIMDAlloc.
+// TODO: (https://wiki.libsdl.org/SDL_SIMDFree)
+func SIMDFree(p unsafe.Pointer) {
+	C.SDL_SIMDFree(p)
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/endian.go

@@ -0,0 +1,12 @@
+package sdl
+
+// #include "sdl_wrapper.h"
+import "C"
+
+// Endian-specific values.
+// (https://wiki.libsdl.org/CategoryEndian)
+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
+)

archive/vendor/github.com/veandco/go-sdl2/sdl/error.go

@@ -0,0 +1,89 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+void GoSetError(const char *fmt) {
+  SDL_SetError("%s", fmt);
+}
+
+*/
+// #include "sdl_wrapper.h"
+import "C"
+import "errors"
+
+var emptyCString *C.char = C.CString("")
+var ErrInvalidParameters = errors.New("Invalid Parameters")
+
+// SDL error codes with their corresponding predefined strings.
+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
+)
+
+// ErrorCode is an error code used in SDL error messages.
+type ErrorCode uint32
+type cErrorCode C.SDL_errorcode
+
+func (ec ErrorCode) c() C.SDL_errorcode {
+	return C.SDL_errorcode(ec)
+}
+
+// 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 GetError() error {
+	if err := C.SDL_GetError(); err != nil {
+		gostr := C.GoString(err)
+		// SDL_GetError returns "an empty string if there hasn't been an error message"
+		if len(gostr) > 0 {
+			return errors.New(gostr)
+		}
+	}
+	return nil
+}
+
+// SetError set the SDL error message.
+// (https://wiki.libsdl.org/SDL_SetError)
+func SetError(err error) {
+	if err != nil {
+		C.GoSetError(C.CString(err.Error()))
+		return
+	}
+	C.GoSetError(emptyCString)
+}
+
+// ClearError clears any previous error message.
+// (https://wiki.libsdl.org/SDL_ClearError)
+func ClearError() {
+	C.SDL_ClearError()
+}
+
+// Error sets the SDL error message to the specified error code.
+func Error(code ErrorCode) {
+	C.SDL_Error(code.c())
+}
+
+// OutOfMemory sets SDL error message to ENOMEM (out of memory).
+func OutOfMemory() {
+	Error(ENOMEM)
+}
+
+// Unsupported sets SDL error message to UNSUPPORTED (that operation is not supported).
+func Unsupported() {
+	Error(UNSUPPORTED)
+}
+
+// errorFromInt returns GetError() if passed negative value, otherwise it returns nil.
+func errorFromInt(code int) (err error) {
+	if code < 0 {
+		err = GetError()
+		if err == nil {
+			err = errors.New("Unknown error (probably using old version of SDL2 and the function called is not supported?)")
+		}
+	}
+	return
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/events.c

@@ -0,0 +1,34 @@
+#include "_cgo_export.h"
+#include "events.h"
+
+SDL_Event event;
+
+void setEventFilter()
+{
+	SDL_SetEventFilter((SDL_EventFilter)goSetEventFilterCallback, NULL);
+}
+
+void clearEventFilter()
+{
+	SDL_SetEventFilter(NULL, NULL);
+}
+
+void filterEvents(void *userdata)
+{
+	SDL_FilterEvents((SDL_EventFilter)goEventFilterCallback, userdata);
+}
+
+void addEventWatch(void *userdata)
+{
+	SDL_AddEventWatch((SDL_EventFilter)goEventFilterCallback, userdata);
+}
+
+void delEventWatch(void *userdata)
+{
+	SDL_DelEventWatch((SDL_EventFilter)goEventFilterCallback, userdata);
+}
+
+int PollEvent()
+{
+	return SDL_PollEvent(&event);
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/events.h

@@ -0,0 +1,19 @@
+#ifndef _GO_SDL_EVENTS_H
+#define _GO_SDL_EVENTS_H
+
+#if defined(_WIN32)
+	#include <SDL2/SDL_events.h>
+#else
+	#include <SDL_events.h>
+#endif
+
+extern SDL_Event event;
+
+extern void setEventFilter();
+extern void clearEventFilter();
+extern void filterEvents(void *userdata);
+extern void addEventWatch(void *userdata);
+extern void delEventWatch(void *userdata);
+extern int PollEvent();
+
+#endif

archive/vendor/github.com/veandco/go-sdl2/sdl/filesystem.go

@@ -0,0 +1,50 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if !(SDL_VERSION_ATLEAST(2,0,1))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_GetBasePath is not supported before SDL 2.0.1")
+#endif
+
+static inline char* SDL_GetBasePath()
+{
+	return NULL;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_GetPrefPath is not supported before SDL 2.0.1")
+#endif
+
+static inline char* SDL_GetPrefPath(const char *org, const char *app)
+{
+	return NULL;
+}
+#endif
+
+*/
+import "C"
+import "unsafe"
+
+// 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 GetBasePath() string {
+	_val := C.SDL_GetBasePath()
+	defer C.SDL_free(unsafe.Pointer(_val))
+	return C.GoString(_val)
+}
+
+// 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 GetPrefPath(org, app string) string {
+	_org := C.CString(org)
+	_app := C.CString(app)
+	defer C.free(unsafe.Pointer(_org))
+	defer C.free(unsafe.Pointer(_app))
+	_val := C.SDL_GetPrefPath(_org, _app)
+	defer C.SDL_free(unsafe.Pointer(_val))
+	return C.GoString(_val)
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/gamecontroller.go

@@ -0,0 +1,611 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if !(SDL_VERSION_ATLEAST(2,0,4))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_GameControllerFromInstanceID is not supported before SDL 2.0.4")
+#endif
+
+static SDL_GameController* SDL_GameControllerFromInstanceID(SDL_JoystickID joyid)
+{
+	return NULL;
+}
+
+#endif
+
+
+#if !(SDL_VERSION_ATLEAST(2,0,6))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_GameControllerGetVendor is not supported before SDL 2.0.6")
+#pragma message("SDL_GameControllerGetProduct is not supported before SDL 2.0.6")
+#pragma message("SDL_GameControllerGetProductVersion is not supported before SDL 2.0.6")
+#pragma message("SDL_GameControllerNumMappings is not supported before SDL 2.0.6")
+#pragma message("SDL_GameControllerMappingForIndex is not supported before SDL 2.0.6")
+#endif
+
+static Uint16 SDL_GameControllerGetVendor(SDL_GameController* gamecontroller)
+{
+	return 0;
+}
+
+
+static Uint16 SDL_GameControllerGetProduct(SDL_GameController* gamecontroller)
+{
+	return 0;
+}
+
+static Uint16 SDL_GameControllerGetProductVersion(SDL_GameController* gamecontroller)
+{
+	return 0;
+}
+
+static int SDL_GameControllerNumMappings(void)
+{
+	return 0;
+}
+
+static char* SDL_GameControllerMappingForIndex(int mapping_index)
+{
+	return NULL;
+}
+#endif
+
+
+#if !(SDL_VERSION_ATLEAST(2,0,9))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_GameControllerGetPlayerIndex is not supported before SDL 2.0.9")
+#pragma message("SDL_GameControllerRumble is not supported before SDL 2.0.9")
+#pragma message("SDL_GameControllerMappingForDeviceIndex is not supported before SDL 2.0.9")
+#endif
+
+typedef enum
+{
+    SDL_SENSOR_INVALID = -1,
+    SDL_SENSOR_UNKNOWN,
+    SDL_SENSOR_ACCEL,
+    SDL_SENSOR_GYRO
+} SDL_SensorType;
+
+static int SDL_GameControllerGetPlayerIndex(SDL_GameController *gamecontroller)
+{
+	return -1;
+}
+
+static int SDL_GameControllerRumble(SDL_GameController *gamecontroller, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble, Uint32 duration_ms)
+{
+	return -1;
+}
+
+static char *SDL_GameControllerMappingForDeviceIndex(int joystick_index)
+{
+	return NULL;
+}
+
+#endif
+
+
+#if !(SDL_VERSION_ATLEAST(2,0,12))
+
+typedef enum
+{
+    SDL_CONTROLLER_TYPE_UNKNOWN = 0,
+    SDL_CONTROLLER_TYPE_XBOX360,
+    SDL_CONTROLLER_TYPE_XBOXONE,
+    SDL_CONTROLLER_TYPE_PS3,
+    SDL_CONTROLLER_TYPE_PS4,
+    SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_PRO
+} SDL_GameControllerType;
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_GameControllerTypeForIndex is not supported before SDL 2.0.12")
+#pragma message("SDL_GameControllerGetType is not supported before SDL 2.0.12")
+#pragma message("SDL_GameControllerFromPlayerIndex is not supported before SDL 2.0.12")
+#pragma message("SDL_GameControllerSetPlayerIndex is not supported before SDL 2.0.12")
+#endif
+
+static SDL_GameControllerType SDL_GameControllerTypeForIndex(int joystick_index)
+{
+	return SDL_CONTROLLER_TYPE_UNKNOWN;
+}
+
+static SDL_GameControllerType SDL_GameControllerGetType(SDL_GameController *gamecontroller)
+{
+	return SDL_CONTROLLER_TYPE_UNKNOWN;
+}
+
+static SDL_GameController * SDL_GameControllerFromPlayerIndex(int player_index)
+{
+	return NULL;
+}
+
+static void SDL_GameControllerSetPlayerIndex(SDL_GameController *gamecontroller, int player_index)
+{
+	// do nothing
+}
+
+#endif
+
+
+#if !(SDL_VERSION_ATLEAST(2,0,14))
+
+#define SDL_CONTROLLER_TYPE_VIRTUAL (6)
+#define SDL_CONTROLLER_TYPE_PS5 (7)
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_GameControllerGetSerial is not supported before SDL 2.0.14")
+#pragma message("SDL_GameControllerHasAxis is not supported before SDL 2.0.14")
+#pragma message("SDL_GameControllerHasButton is not supported before SDL 2.0.14")
+#pragma message("SDL_GameControllerGetNumTouchpads is not supported before SDL 2.0.14")
+#pragma message("SDL_GameControllerGetNumTouchpadFingers is not supported before SDL 2.0.14")
+#pragma message("SDL_GameControllerGetTouchpadFinger is not supported before SDL 2.0.14")
+#pragma message("SDL_GameControllerHasSensor is not supported before SDL 2.0.14")
+#pragma message("SDL_GameControllerSetSensorEnabled is not supported before SDL 2.0.14")
+#pragma message("SDL_GameControllerIsSensorEnabled is not supported before SDL 2.0.14")
+#pragma message("SDL_GameControllerGetSensorData is not supported before SDL 2.0.14")
+#pragma message("SDL_GameControllerRumbleTriggers is not supported before SDL 2.0.14")
+#pragma message("SDL_GameControllerHasLED is not supported before SDL 2.0.14")
+#pragma message("SDL_GameControllerSetLED is not supported before SDL 2.0.14")
+#endif
+
+static const char * SDLCALL SDL_GameControllerGetSerial(SDL_GameController *gamecontroller)
+{
+	return NULL;
+}
+
+static SDL_bool SDL_GameControllerHasAxis(SDL_GameController *gamecontroller, SDL_GameControllerAxis axis)
+{
+	return SDL_FALSE;
+}
+
+static SDL_bool SDLCALL SDL_GameControllerHasButton(SDL_GameController *gamecontroller, SDL_GameControllerButton button)
+{
+	return SDL_FALSE;
+}
+
+static int SDLCALL SDL_GameControllerGetNumTouchpads(SDL_GameController *gamecontroller)
+{
+	return 0;
+}
+
+static int SDL_GameControllerGetNumTouchpadFingers(SDL_GameController *gamecontroller, int touchpad)
+{
+	return 0;
+}
+
+static int SDL_GameControllerGetTouchpadFinger(SDL_GameController *gamecontroller, int touchpad, int finger, Uint8 *state, float *x, float *y, float *pressure)
+{
+	return -1;
+}
+
+static SDL_bool SDL_GameControllerHasSensor(SDL_GameController *gamecontroller, SDL_SensorType type)
+{
+	return SDL_FALSE;
+}
+
+static int SDL_GameControllerSetSensorEnabled(SDL_GameController *gamecontroller, SDL_SensorType type, SDL_bool enabled)
+{
+	return -1;
+}
+
+static SDL_bool SDL_GameControllerIsSensorEnabled(SDL_GameController *gamecontroller, SDL_SensorType type)
+{
+	return SDL_FALSE;
+}
+
+static int SDL_GameControllerGetSensorData(SDL_GameController *gamecontroller, SDL_SensorType type, float *data, int num_values)
+{
+	return -1;
+}
+
+static int SDL_GameControllerRumbleTriggers(SDL_GameController *gamecontroller, Uint16 left_rumble, Uint16 right_rumble, Uint32 duration_ms)
+{
+	return -1;
+}
+
+static SDL_bool SDL_GameControllerHasLED(SDL_GameController *gamecontroller)
+{
+	return SDL_FALSE;
+}
+
+static int SDL_GameControllerSetLED(SDL_GameController *gamecontroller, Uint8 red, Uint8 green, Uint8 blue)
+{
+	return -1;
+}
+
+#endif
+
+
+#if !(SDL_VERSION_ATLEAST(2,0,16))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_GameControllerSendEffect is not supported before SDL 2.0.16")
+#pragma message("SDL_GameControllerGetSensorDataRate is not supported before SDL 2.0.16")
+#endif
+
+static int SDL_GameControllerSendEffect(SDL_GameController *gamecontroller, const void *data, int size)
+{
+	return -1;
+}
+
+static float SDL_GameControllerGetSensorDataRate(SDL_GameController *gamecontroller, SDL_SensorType type)
+{
+	return 0.0f;
+}
+
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,18))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_GameControllerHasRumble is not supported before SDL 2.0.18")
+#pragma message("SDL_GameControllerHasRumbleTriggers is not supported before SDL 2.0.18")
+#pragma message("SDL_GameControllerGetAppleSFSymbolsNameForButton is not supported before SDL 2.0.18")
+#pragma message("SDL_GameControllerGetAppleSFSymbolsNameForAxis is not supported before SDL 2.0.18")
+#endif
+
+static SDL_bool SDL_GameControllerHasRumble(SDL_GameController *gamecontroller)
+{
+	return SDL_FALSE;
+}
+
+static SDL_bool SDL_GameControllerHasRumbleTriggers(SDL_GameController *gamecontroller)
+{
+	return SDL_FALSE;
+}
+
+static const char* SDL_GameControllerGetAppleSFSymbolsNameForButton(SDL_GameController *gamecontroller, SDL_GameControllerButton button)
+{
+	return NULL;
+}
+
+static const char* SDL_GameControllerGetAppleSFSymbolsNameForAxis(SDL_GameController *gamecontroller, SDL_GameControllerAxis axis)
+{
+	return NULL;
+}
+
+#endif
+*/
+import "C"
+import (
+	"encoding/binary"
+	"unsafe"
+)
+
+// Types of game controller inputs.
+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
+)
+
+// An enumeration of axes available from a controller.
+// (https://wiki.libsdl.org/SDL_GameControllerAxis)
+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 buttons available from a controller.
+// (https://wiki.libsdl.org/SDL_GameControllerButton)
+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
+)
+
+// GameControllerBindType is a type of game controller input.
+type GameControllerBindType C.SDL_GameControllerBindType
+
+// GameControllerAxis is an axis on a game controller.
+// (https://wiki.libsdl.org/SDL_GameControllerAxis)
+type GameControllerAxis C.SDL_GameControllerAxis
+
+// GameControllerButton is a button on a game controller.
+// (https://wiki.libsdl.org/SDL_GameControllerButton)
+type GameControllerButton C.SDL_GameControllerButton
+
+// GameController used to identify an SDL game controller.
+type GameController C.SDL_GameController
+
+// GameControllerButtonBind SDL joystick layer binding for controller button/axis mapping.
+type GameControllerButtonBind C.SDL_GameControllerButtonBind
+
+func (ctrl *GameController) cptr() *C.SDL_GameController {
+	return (*C.SDL_GameController)(unsafe.Pointer(ctrl))
+}
+
+func (axis GameControllerAxis) c() C.SDL_GameControllerAxis {
+	return C.SDL_GameControllerAxis(axis)
+}
+
+func (btn GameControllerButton) c() C.SDL_GameControllerButton {
+	return C.SDL_GameControllerButton(btn)
+}
+
+// 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 GameControllerAddMapping(mappingString string) int {
+	_mappingString := C.CString(mappingString)
+	defer C.free(unsafe.Pointer(_mappingString))
+	return int(C.SDL_GameControllerAddMapping(_mappingString))
+}
+
+// GameControllerNumMappings returns the number of mappings installed.
+func GameControllerNumMappings() int {
+	return int(C.SDL_GameControllerNumMappings())
+}
+
+// GameControllerMappingForIndex returns the game controller mapping string at a particular index.
+func GameControllerMappingForIndex(index int) string {
+	mappingString := C.SDL_GameControllerMappingForIndex(C.int(index))
+	defer C.free(unsafe.Pointer(mappingString))
+	return C.GoString(mappingString)
+}
+
+// GameControllerMappingForGUID returns the game controller mapping string for a given GUID.
+// (https://wiki.libsdl.org/SDL_GameControllerMappingForGUID)
+func GameControllerMappingForGUID(guid JoystickGUID) string {
+	mappingString := C.SDL_GameControllerMappingForGUID(guid.c())
+	defer C.free(unsafe.Pointer(mappingString))
+	return C.GoString(mappingString)
+}
+
+// IsGameController reports whether the given joystick is supported by the game controller interface.
+// (https://wiki.libsdl.org/SDL_IsGameController)
+func IsGameController(index int) bool {
+	return C.SDL_IsGameController(C.int(index)) == C.SDL_TRUE
+}
+
+// GameControllerNameForIndex returns the implementation dependent name for the game controller.
+// (https://wiki.libsdl.org/SDL_GameControllerNameForIndex)
+func GameControllerNameForIndex(index int) string {
+	return C.GoString(C.SDL_GameControllerNameForIndex(C.int(index)))
+}
+
+// GameControllerMappingForDeviceIndex returns the game controller mapping string at a particular index.
+func GameControllerMappingForDeviceIndex(index int) string {
+	mappingString := C.SDL_GameControllerMappingForDeviceIndex(C.int(index))
+	defer C.free(unsafe.Pointer(mappingString))
+	return C.GoString(mappingString)
+}
+
+// GameControllerOpen opens a gamecontroller for use.
+// (https://wiki.libsdl.org/SDL_GameControllerOpen)
+func GameControllerOpen(index int) *GameController {
+	return (*GameController)(C.SDL_GameControllerOpen(C.int(index)))
+}
+
+// GameControllerFromInstanceID returns the GameController associated with an instance id.
+// (https://wiki.libsdl.org/SDL_GameControllerFromInstanceID)
+func GameControllerFromInstanceID(joyid JoystickID) *GameController {
+	return (*GameController)(C.SDL_GameControllerFromInstanceID(joyid.c()))
+}
+
+// Name returns the implementation dependent name for an opened game controller.
+// (https://wiki.libsdl.org/SDL_GameControllerName)
+func (ctrl *GameController) Name() string {
+	return C.GoString(C.SDL_GameControllerName(ctrl.cptr()))
+}
+
+// PlayerIndex the player index of an opened game controller, or -1 if it's not available.
+// TODO: (https://wiki.libsdl.org/SDL_GameControllerGetPlayerIndex)
+func (ctrl *GameController) PlayerIndex() int {
+	return int(C.SDL_GameControllerGetPlayerIndex(ctrl.cptr()))
+}
+
+// Vendor returns the USB vendor ID of an opened controller, if available, 0 otherwise.
+func (ctrl *GameController) Vendor() int {
+	return int(C.SDL_GameControllerGetVendor(ctrl.cptr()))
+}
+
+// Product returns the USB product ID of an opened controller, if available, 0 otherwise.
+func (ctrl *GameController) Product() int {
+	return int(C.SDL_GameControllerGetProduct(ctrl.cptr()))
+}
+
+// ProductVersion returns the product version of an opened controller, if available, 0 otherwise.
+func (ctrl *GameController) ProductVersion() int {
+	return int(C.SDL_GameControllerGetProductVersion(ctrl.cptr()))
+}
+
+// Attached reports whether a controller has been opened and is currently connected.
+// (https://wiki.libsdl.org/SDL_GameControllerGetAttached)
+func (ctrl *GameController) Attached() bool {
+	return C.SDL_GameControllerGetAttached(ctrl.cptr()) == C.SDL_TRUE
+}
+
+// Mapping returns the current mapping of a Game Controller.
+// (https://wiki.libsdl.org/SDL_GameControllerMapping)
+func (ctrl *GameController) Mapping() string {
+	mappingString := C.SDL_GameControllerMapping(ctrl.cptr())
+	defer C.free(unsafe.Pointer(mappingString))
+	return C.GoString(mappingString)
+}
+
+// Joystick 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 (ctrl *GameController) Joystick() *Joystick {
+	return (*Joystick)(unsafe.Pointer(C.SDL_GameControllerGetJoystick(ctrl.cptr())))
+}
+
+// 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 GameControllerEventState(state int) int {
+	return int(C.SDL_GameControllerEventState(C.int(state)))
+}
+
+// GameControllerUpdate manually pumps game controller updates if not using the loop.
+// (https://wiki.libsdl.org/SDL_GameControllerUpdate)
+func GameControllerUpdate() {
+	C.SDL_GameControllerUpdate()
+}
+
+// GameControllerGetAxisFromString converts a string into an enum representation for a GameControllerAxis.
+// (https://wiki.libsdl.org/SDL_GameControllerGetAxisFromString)
+func GameControllerGetAxisFromString(pchString string) GameControllerAxis {
+	_pchString := C.CString(pchString)
+	defer C.free(unsafe.Pointer(_pchString))
+	return GameControllerAxis(C.SDL_GameControllerGetAxisFromString(_pchString))
+}
+
+// GameControllerGetStringForAxis converts from an axis enum to a string.
+// (https://wiki.libsdl.org/SDL_GameControllerGetStringForAxis)
+func GameControllerGetStringForAxis(axis GameControllerAxis) string {
+	return C.GoString(C.SDL_GameControllerGetStringForAxis(axis.c()))
+}
+
+// BindForAxis returns the SDL joystick layer binding for a controller button mapping.
+// (https://wiki.libsdl.org/SDL_GameControllerGetBindForAxis)
+func (ctrl *GameController) BindForAxis(axis GameControllerAxis) GameControllerButtonBind {
+	return GameControllerButtonBind(C.SDL_GameControllerGetBindForAxis(ctrl.cptr(), axis.c()))
+}
+
+// Axis returns the current state of an axis control on a game controller.
+// (https://wiki.libsdl.org/SDL_GameControllerGetAxis)
+func (ctrl *GameController) Axis(axis GameControllerAxis) int16 {
+	return int16(C.SDL_GameControllerGetAxis(ctrl.cptr(), axis.c()))
+}
+
+// GameControllerGetButtonFromString turns a string into a button mapping.
+// (https://wiki.libsdl.org/SDL_GameControllerGetButtonFromString)
+func GameControllerGetButtonFromString(pchString string) GameControllerButton {
+	_pchString := C.CString(pchString)
+	defer C.free(unsafe.Pointer(_pchString))
+	return GameControllerButton(C.SDL_GameControllerGetButtonFromString(_pchString))
+}
+
+// GameControllerGetStringForButton turns a button enum into a string mapping.
+// (https://wiki.libsdl.org/SDL_GameControllerGetStringForButton)
+func GameControllerGetStringForButton(btn GameControllerButton) string {
+	return C.GoString(C.SDL_GameControllerGetStringForButton(btn.c()))
+}
+
+// BindForButton returns the SDL joystick layer binding for this controller button mapping.
+// (https://wiki.libsdl.org/SDL_GameControllerGetBindForButton)
+func (ctrl *GameController) BindForButton(btn GameControllerButton) GameControllerButtonBind {
+	return GameControllerButtonBind(C.SDL_GameControllerGetBindForButton(ctrl.cptr(), btn.c()))
+}
+
+// Rumble triggers a rumble effect
+// Each call to this function cancels any previous rumble effect, and calling it with 0 intensity stops any rumbling.
+//
+// lowFrequencyRumble - The intensity of the low frequency (left) rumble motor, from 0 to 0xFFFF
+// highFrequencyRumble - The intensity of the high frequency (right) rumble motor, from 0 to 0xFFFF
+// durationMS - The duration of the rumble effect, in milliseconds
+//
+// Returns error if rumble isn't supported on this joystick.
+//
+// TODO: (https://wiki.libsdl.org/SDL_GameControllerRumble)
+func (ctrl *GameController) Rumble(lowFrequencyRumble, highFrequencyRumble uint16, durationMS uint32) error {
+	return errorFromInt(int(C.SDL_GameControllerRumble(ctrl.cptr(), C.Uint16(lowFrequencyRumble), C.Uint16(highFrequencyRumble), C.Uint32(durationMS))))
+}
+
+// Button returns the current state of a button on a game controller.
+// (https://wiki.libsdl.org/SDL_GameControllerGetButton)
+func (ctrl *GameController) Button(btn GameControllerButton) byte {
+	return byte(C.SDL_GameControllerGetButton(ctrl.cptr(), btn.c()))
+}
+
+// Close closes a game controller previously opened with GameControllerOpen().
+// (https://wiki.libsdl.org/SDL_GameControllerClose)
+func (ctrl *GameController) Close() {
+	C.SDL_GameControllerClose(ctrl.cptr())
+}
+
+// Type returns the type of game controller input for this SDL joystick layer binding.
+func (bind *GameControllerButtonBind) Type() int {
+	return int(bind.bindType)
+}
+
+// Button returns button mapped for this SDL joystick layer binding.
+func (bind *GameControllerButtonBind) Button() int {
+	val, _ := binary.Varint(bind.value[:4])
+	return int(val)
+}
+
+// Axis returns axis mapped for this SDL joystick layer binding.
+func (bind *GameControllerButtonBind) Axis() int {
+	val, _ := binary.Varint(bind.value[:4])
+	return int(val)
+}
+
+// Hat returns hat mapped for this SDL joystick layer binding.
+func (bind *GameControllerButtonBind) Hat() int {
+	val, _ := binary.Varint(bind.value[:4])
+	return int(val)
+}
+
+// HatMask returns hat mask for this SDL joystick layer binding.
+func (bind *GameControllerButtonBind) HatMask() int {
+	val, _ := binary.Varint(bind.value[4:8])
+	return int(val)
+}
+
+// SendEffect sends a controller specific effect packet.
+// (https://wiki.libsdl.org/SDL_GameControllerSendEffect)
+func (ctrl *GameController) SendEffect(data []byte) (err error) {
+	_size := C.int(len(data))
+	return errorFromInt(int(C.SDL_GameControllerSendEffect(ctrl.cptr(), unsafe.Pointer(&data[0]), _size)))
+}
+
+// GetSensorDataRate gets the data rate (number of events per second) of a game controller sensor.
+// (https://wiki.libsdl.org/SDL_GameControllerGetSensorDataRate)
+func (ctrl *GameController) SensorDataRate(typ SensorType) (rate float32) {
+	return float32(C.SDL_GameControllerGetSensorDataRate(ctrl.cptr(), C.SDL_SensorType(typ)))
+}
+
+// HasRumble queries whether a game controller has rumble support.
+// (https://wiki.libsdl.org/SDL_GameControllerHasRumble)
+func (ctrl *GameController) HasRumble() bool {
+	return C.SDL_GameControllerHasRumble(ctrl.cptr()) == C.SDL_TRUE
+}
+
+// HasRumbleTriggers queries whether a game controller has rumble support on triggers.
+// (https://wiki.libsdl.org/SDL_GameControllerHasRumbleTriggers)
+func (ctrl *GameController) HasRumbleTriggers() bool {
+	return C.SDL_GameControllerHasRumbleTriggers(ctrl.cptr()) == C.SDL_TRUE
+}
+
+// GetAppleSFSymbolsNameForButton returns the sfSymbolsName for a given button on a game controller on Apple platforms.
+// (https://wiki.libsdl.org/SDL_GameControllerGetAppleSFSymbolsNameForButton)
+func (ctrl *GameController) GetAppleSFSymbolsNameForButton(button GameControllerButton) (sfSymbolsName string) {
+	_button := C.SDL_GameControllerButton(button)
+	_sfSymbolsName := C.SDL_GameControllerGetAppleSFSymbolsNameForButton(ctrl.cptr(), _button)
+	sfSymbolsName = C.GoString(_sfSymbolsName)
+	return
+}
+
+// GetAppleSFSymbolsNameForAxis returns the sfSymbolsName for a given axis on a game controller on Apple platforms.
+// (https://wiki.libsdl.org/SDL_GameControllerGetAppleSFSymbolsNameForAxis)
+func (ctrl *GameController) SDL_GameControllerGetAppleSFSymbolsNameForAxis(axis GameControllerAxis) (sfSymbolsName string) {
+	_axis := C.SDL_GameControllerAxis(axis)
+	_sfSymbolsName := C.SDL_GameControllerGetAppleSFSymbolsNameForAxis(ctrl.cptr(), _axis)
+	sfSymbolsName = C.GoString(_sfSymbolsName)
+	return
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/gesture.go

@@ -0,0 +1,35 @@
+package sdl
+
+// #include "sdl_wrapper.h"
+import "C"
+
+// GestureID is the unique id of the closest gesture to the performed stroke.
+type GestureID C.SDL_GestureID
+
+func (g GestureID) c() C.SDL_GestureID {
+	return C.SDL_GestureID(g)
+}
+
+// RecordGesture begins recording a gesture on a specified touch device or all touch devices.
+// (https://wiki.libsdl.org/SDL_RecordGesture)
+func RecordGesture(t TouchID) int {
+	return int(C.SDL_RecordGesture(t.c()))
+}
+
+// SaveAllDollarTemplates saves all currently loaded Dollar Gesture templates.
+// (https://wiki.libsdl.org/SDL_SaveAllDollarTemplates)
+func SaveAllDollarTemplates(src *RWops) int {
+	return int(C.SDL_SaveAllDollarTemplates(src.cptr()))
+}
+
+// SaveDollarTemplate saves a currently loaded Dollar Gesture template.
+// (https://wiki.libsdl.org/SDL_SaveDollarTemplate)
+func SaveDollarTemplate(g GestureID, src *RWops) int {
+	return int(C.SDL_SaveDollarTemplate(g.c(), src.cptr()))
+}
+
+// LoadDollarTemplates loads Dollar Gesture templates from a file.
+// (https://wiki.libsdl.org/SDL_LoadDollarTemplates)
+func LoadDollarTemplates(t TouchID, src *RWops) int {
+	return int(C.SDL_LoadDollarTemplates(t.c(), src.cptr()))
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/guid.go

@@ -0,0 +1,48 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if !SDL_VERSION_ATLEAST(2,24,0)
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_GUIDToString is not supported before SDL 2.24.0")
+#pragma message("SDL_GUIDFromString is not supported before SDL 2.24.0")
+#endif
+
+typedef struct {
+    Uint8 data[16];
+} SDL_GUID;
+
+static inline void SDL_GUIDToString(SDL_GUID guid, char *pszGUID, int cbGUID)
+{
+	return;
+}
+
+static inline SDL_GUID SDL_GUIDFromString(const char *pchGUID)
+{
+	SDL_GUID guid;
+	return guid;
+}
+#endif
+*/
+import "C"
+import (
+	"unsafe"
+)
+
+type GUID C.SDL_GUID
+
+// ToString returns an ASCII string representation for a given GUID.
+func (guid GUID) ToString() (ascii string) {
+	_cap := C.size_t(33)
+	_buf := (*C.char)(C.SDL_malloc(_cap))
+	defer C.SDL_free(unsafe.Pointer(_buf))
+	C.SDL_GUIDToString(C.SDL_GUID(guid), _buf, C.int(_cap))
+	return C.GoString(_buf)
+}
+
+// GUIDFromString converts a GUID string into a GUID structure.
+func GUIDFromString(ascii string) (guid GUID) {
+	_ascii := C.CString(ascii)
+	return GUID(C.SDL_GUIDFromString(_ascii))
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/haptic.go

@@ -0,0 +1,418 @@
+package sdl
+
+// #include "sdl_wrapper.h"
+import "C"
+import "unsafe"
+
+// Haptic effects.
+// (https://wiki.libsdl.org/SDL_HapticEffect)
+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_SQUARE = C.SDL_HAPTIC_SQUARE (back in SDL 2.1)
+)
+
+// Direction encodings.
+// (https://wiki.libsdl.org/SDL_HapticDirection)
+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
+)
+
+// Haptic identifies an SDL haptic.
+// (https://wiki.libsdl.org/CategoryForceFeedback)
+type Haptic C.SDL_Haptic
+
+// HapticDirection contains a haptic direction.
+// (https://wiki.libsdl.org/SDL_HapticDirection)
+type HapticDirection struct {
+	Type byte     // the type of encoding
+	Dir  [3]int32 // the encoded direction
+}
+
+// HapticConstant contains a template for a constant effect.
+// (https://wiki.libsdl.org/SDL_HapticConstant)
+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
+}
+
+func (he *HapticConstant) cHapticEffect() *C.SDL_HapticEffect {
+	return (*C.SDL_HapticEffect)(unsafe.Pointer(he))
+}
+
+// HapticPeriodic contains a template for a periodic effect.
+// (https://wiki.libsdl.org/SDL_HapticPeriodic)
+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
+}
+
+func (he *HapticPeriodic) cHapticEffect() *C.SDL_HapticEffect {
+	return (*C.SDL_HapticEffect)(unsafe.Pointer(he))
+}
+
+// HapticCondition contains a template for a condition effect.
+// (https://wiki.libsdl.org/SDL_HapticCondition)
+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
+}
+
+func (he *HapticCondition) cHapticEffect() *C.SDL_HapticEffect {
+	return (*C.SDL_HapticEffect)(unsafe.Pointer(he))
+}
+
+// HapticRamp contains a template for a ramp effect.
+// (https://wiki.libsdl.org/SDL_HapticRamp)
+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
+}
+
+func (he *HapticRamp) cHapticEffect() *C.SDL_HapticEffect {
+	return (*C.SDL_HapticEffect)(unsafe.Pointer(he))
+}
+
+// HapticLeftRight contains a template for a left/right effect.
+// (https://wiki.libsdl.org/SDL_HapticLeftRight)
+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
+}
+
+func (he *HapticLeftRight) cHapticEffect() *C.SDL_HapticEffect {
+	return (*C.SDL_HapticEffect)(unsafe.Pointer(he))
+}
+
+// HapticCustom contains a template for a custom effect.
+// (https://wiki.libsdl.org/SDL_HapticCustom)
+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
+}
+
+func (he *HapticCustom) cHapticEffect() *C.SDL_HapticEffect {
+	return (*C.SDL_HapticEffect)(unsafe.Pointer(he))
+}
+
+// HapticEffect union that contains the generic template for any haptic effect.
+// (https://wiki.libsdl.org/SDL_HapticEffect)
+type HapticEffect interface {
+	cHapticEffect() *C.SDL_HapticEffect
+}
+
+func (h *Haptic) cptr() *C.SDL_Haptic {
+	return (*C.SDL_Haptic)(unsafe.Pointer(h))
+}
+
+// NumHaptics returns the number of haptic devices attached to the system.
+// (https://wiki.libsdl.org/SDL_NumHaptics)
+func NumHaptics() (int, error) {
+	i := int(C.SDL_NumHaptics())
+	return i, errorFromInt(i)
+}
+
+// HapticName returns the implementation dependent name of a haptic device.
+// (https://wiki.libsdl.org/SDL_HapticName)
+func HapticName(index int) (string, error) {
+	name := C.SDL_HapticName(C.int(index))
+	if name == nil {
+		return "", GetError()
+	}
+	return C.GoString(name), nil
+}
+
+// HapticOpen opens a haptic device for use.
+// (https://wiki.libsdl.org/SDL_HapticOpen)
+func HapticOpen(index int) (*Haptic, error) {
+	haptic := (*Haptic)(unsafe.Pointer(C.SDL_HapticOpen(C.int(index))))
+	if haptic == nil {
+		return nil, GetError()
+	}
+	return haptic, nil
+}
+
+// HapticOpened reports whether the haptic device at the designated index has been opened.
+// (https://wiki.libsdl.org/SDL_HapticOpened)
+func HapticOpened(index int) (bool, error) {
+	ret := int(C.SDL_HapticOpened(C.int(index)))
+	if ret == 0 {
+		return false, GetError()
+	}
+	return ret == 1, nil
+}
+
+// HapticIndex returns the index of a haptic device.
+// (https://wiki.libsdl.org/SDL_HapticIndex)
+func HapticIndex(h *Haptic) (int, error) {
+	i := int(C.SDL_HapticIndex(h.cptr()))
+	return i, errorFromInt(i)
+}
+
+// MouseIsHaptic reports whether or not the current mouse has haptic capabilities.
+// (https://wiki.libsdl.org/SDL_MouseIsHaptic)
+func MouseIsHaptic() (bool, error) {
+	ret := int(C.SDL_MouseIsHaptic())
+	return ret == C.SDL_TRUE, errorFromInt(ret)
+}
+
+// HapticOpenFromMouse open a haptic device from the current mouse.
+// (https://wiki.libsdl.org/SDL_HapticOpenFromMouse)
+func HapticOpenFromMouse() (*Haptic, error) {
+	haptic := (*Haptic)(unsafe.Pointer(C.SDL_HapticOpenFromMouse()))
+	if haptic == nil {
+		return nil, GetError()
+	}
+	return haptic, nil
+}
+
+// JoystickIsHaptic reports whether a joystick has haptic features.
+// (https://wiki.libsdl.org/SDL_JoystickIsHaptic)
+func JoystickIsHaptic(joy *Joystick) (bool, error) {
+	ret := int(C.SDL_JoystickIsHaptic(joy.cptr()))
+	return ret == C.SDL_TRUE, errorFromInt(ret)
+}
+
+// HapticOpenFromJoystick opens a haptic device for use from a joystick device.
+// (https://wiki.libsdl.org/SDL_HapticOpenFromJoystick)
+func HapticOpenFromJoystick(joy *Joystick) (*Haptic, error) {
+	haptic := (*Haptic)(unsafe.Pointer(C.SDL_HapticOpenFromJoystick(joy.cptr())))
+	if haptic == nil {
+		return nil, GetError()
+	}
+	return haptic, nil
+}
+
+// Close closes a haptic device previously opened with HapticOpen().
+// (https://wiki.libsdl.org/SDL_HapticClose)
+func (h *Haptic) Close() {
+	C.SDL_HapticClose(h.cptr())
+}
+
+// NumAxes returns the number of haptic axes the device has.
+// (https://wiki.libsdl.org/SDL_HapticNumAxes)
+func (h *Haptic) NumAxes() (int, error) {
+	i := int(C.SDL_HapticNumAxes(h.cptr()))
+	return i, errorFromInt(i)
+}
+
+// NumEffects returns the number of effects a haptic device can store.
+// (https://wiki.libsdl.org/SDL_HapticNumEffects)
+func (h *Haptic) NumEffects() (int, error) {
+	i := int(C.SDL_HapticNumEffects(h.cptr()))
+	return i, errorFromInt(i)
+}
+
+// NumEffectsPlaying returns the number of effects a haptic device can play at the same time.
+// (https://wiki.libsdl.org/SDL_HapticNumEffectsPlaying)
+func (h *Haptic) NumEffectsPlaying() (int, error) {
+	i := int(C.SDL_HapticNumEffectsPlaying(h.cptr()))
+	return i, errorFromInt(i)
+}
+
+// Query returns haptic device's supported features in bitwise manner.
+// (https://wiki.libsdl.org/SDL_HapticQuery)
+func (h *Haptic) Query() (uint32, error) {
+	i := uint32(C.SDL_HapticQuery(h.cptr()))
+	if i == 0 {
+		return 0, GetError()
+	}
+	return i, nil
+}
+
+// EffectSupported reports whether an effect is supported by a haptic device.
+// Pass pointer to a Haptic struct (Constant|Periodic|Condition|Ramp|LeftRight|Custom) instead of HapticEffect union.
+// (https://wiki.libsdl.org/SDL_HapticEffectSupported)
+func (h *Haptic) EffectSupported(he HapticEffect) (bool, error) {
+	ret := int(C.SDL_HapticEffectSupported(
+		h.cptr(),
+		he.cHapticEffect()))
+	return ret == C.SDL_TRUE, errorFromInt(ret)
+}
+
+// NewEffect creates a new haptic effect on a specified device.
+// Pass pointer to a Haptic struct (Constant|Periodic|Condition|Ramp|LeftRight|Custom) instead of HapticEffect union.
+// (https://wiki.libsdl.org/SDL_HapticNewEffect)
+func (h *Haptic) NewEffect(he HapticEffect) (int, error) {
+	ret := int(C.SDL_HapticNewEffect(
+		h.cptr(),
+		he.cHapticEffect()))
+	return ret, errorFromInt(ret)
+}
+
+// UpdateEffect updates the properties of an effect.
+// Pass pointer to a Haptic struct (Constant|Periodic|Condition|Ramp|LeftRight|Custom) instead of HapticEffect union.
+// (https://wiki.libsdl.org/SDL_HapticUpdateEffect)
+func (h *Haptic) UpdateEffect(effect int, data HapticEffect) error {
+	return errorFromInt(int(
+		C.SDL_HapticUpdateEffect(
+			h.cptr(),
+			C.int(effect),
+			data.cHapticEffect())))
+}
+
+// RunEffect runs the haptic effect on its associated haptic device.
+// (https://wiki.libsdl.org/SDL_HapticRunEffect)
+func (h *Haptic) RunEffect(effect int, iterations uint32) error {
+	return errorFromInt(int(
+		C.SDL_HapticRunEffect(
+			h.cptr(),
+			C.int(effect),
+			C.Uint32(iterations))))
+}
+
+// StopEffect stops the haptic effect on its associated haptic device.
+// (https://wiki.libsdl.org/SDL_HapticStopEffect)
+func (h *Haptic) StopEffect(effect int) error {
+	return errorFromInt(int(
+		C.SDL_HapticStopEffect(h.cptr(), C.int(effect))))
+}
+
+// DestroyEffect destroys a haptic effect on the device.
+// (https://wiki.libsdl.org/SDL_HapticDestroyEffect)
+func (h *Haptic) DestroyEffect(effect int) {
+	C.SDL_HapticDestroyEffect(h.cptr(), C.int(effect))
+}
+
+// GetEffectStatus returns the status of the current effect on the specified haptic device.
+// (https://wiki.libsdl.org/SDL_HapticGetEffectStatus)
+func (h *Haptic) GetEffectStatus(effect int) (int, error) {
+	i := int(C.SDL_HapticGetEffectStatus(h.cptr(), C.int(effect)))
+	return i, errorFromInt(i)
+
+}
+
+// SetGain sets the global gain of the specified haptic device.
+// (https://wiki.libsdl.org/SDL_HapticSetGain)
+func (h *Haptic) SetGain(gain int) error {
+	return errorFromInt(int(
+		C.SDL_HapticSetGain(h.cptr(), C.int(gain))))
+}
+
+// SetAutocenter sets the global autocenter of the device.
+// (https://wiki.libsdl.org/SDL_HapticSetAutocenter)
+func (h *Haptic) SetAutocenter(autocenter int) error {
+	return errorFromInt(int(
+		C.SDL_HapticSetAutocenter(h.cptr(), C.int(autocenter))))
+}
+
+// Pause pauses a haptic device.
+// (https://wiki.libsdl.org/SDL_HapticPause)
+func (h *Haptic) Pause() error {
+	return errorFromInt(int(
+		C.SDL_HapticPause(h.cptr())))
+}
+
+// Unpause unpauses a haptic device.
+// (https://wiki.libsdl.org/SDL_HapticUnpause)
+func (h *Haptic) Unpause() error {
+	return errorFromInt(int(
+		C.SDL_HapticUnpause(h.cptr())))
+}
+
+// StopAll stops all the currently playing effects on a haptic device.
+// (https://wiki.libsdl.org/SDL_HapticStopAll)
+func (h *Haptic) StopAll() error {
+	return errorFromInt(int(
+		C.SDL_HapticStopAll(h.cptr())))
+}
+
+// RumbleSupported reports whether rumble is supported on a haptic device.
+// (https://wiki.libsdl.org/SDL_HapticRumbleSupported)
+func (h *Haptic) RumbleSupported() (bool, error) {
+	ret := int(C.SDL_HapticRumbleSupported(h.cptr()))
+	return ret == C.SDL_TRUE, errorFromInt(ret)
+}
+
+// RumbleInit initializes the haptic device for simple rumble playback.
+// (https://wiki.libsdl.org/SDL_HapticRumbleInit)
+func (h *Haptic) RumbleInit() error {
+	return errorFromInt(int(
+		C.SDL_HapticRumbleInit(h.cptr())))
+}
+
+// RumblePlay runs a simple rumble effect on a haptic device.
+// (https://wiki.libsdl.org/SDL_HapticRumblePlay)
+func (h *Haptic) RumblePlay(strength float32, length uint32) error {
+	return errorFromInt(int(
+		C.SDL_HapticRumblePlay(h.cptr(), C.float(strength), C.Uint32(length))))
+}
+
+// RumbleStop stops the simple rumble on a haptic device.
+// (https://wiki.libsdl.org/SDL_HapticRumbleStop)
+func (h *Haptic) RumbleStop() error {
+	return errorFromInt(int(
+		C.SDL_HapticRumbleStop(h.cptr())))
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/helpers.go

@@ -0,0 +1,10 @@
+package sdl
+
+// Btoi returns 0 or 1 according to the value of b.
+func Btoi(b bool) int {
+	if b == true {
+		return 1
+	}
+
+	return 0
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/hidapi.go

@@ -0,0 +1,358 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if !(SDL_VERSION_ATLEAST(2,0,18))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_hid_init is not supported before SDL 2.0.18")
+#pragma message("SDL_hid_exit is not supported before SDL 2.0.18")
+#pragma message("SDL_hid_device_change_count is not supported before SDL 2.0.18")
+#pragma message("SDL_hid_enumerate is not supported before SDL 2.0.18")
+#pragma message("SDL_hid_free_enumeration is not supported before SDL 2.0.18")
+#pragma message("SDL_hid_open is not supported before SDL 2.0.18")
+#pragma message("SDL_hid_open_path is not supported before SDL 2.0.18")
+#pragma message("SDL_hid_write is not supported before SDL 2.0.18")
+#pragma message("SDL_hid_read_timeout is not supported before SDL 2.0.18")
+#pragma message("SDL_hid_read is not supported before SDL 2.0.18")
+#pragma message("SDL_hid_set_nonblocking is not supported before SDL 2.0.18")
+#pragma message("SDL_hid_send_feature_report is not supported before SDL 2.0.18")
+#pragma message("SDL_hid_get_feature_report is not supported before SDL 2.0.18")
+#pragma message("SDL_hid_close is not supported before SDL 2.0.18")
+#pragma message("SDL_hid_get_manufacturer_string is not supported before SDL 2.0.18")
+#pragma message("SDL_hid_get_product_string is not supported before SDL 2.0.18")
+#pragma message("SDL_hid_get_serial_number_string is not supported before SDL 2.0.18")
+#pragma message("SDL_hid_get_indexed_string is not supported before SDL 2.0.18")
+#pragma message("SDL_hid_ble_scan is not supported before SDL 2.0.18")
+#endif
+
+struct SDL_hid_device_;
+typedef struct SDL_hid_device_ SDL_hid_device; // opaque hidapi structure
+
+// hidapi info structure
+// Information about a connected HID device
+typedef struct SDL_hid_device_info
+{
+    // Platform-specific device path
+    char *path;
+
+    // Device Vendor ID
+    unsigned short vendor_id;
+
+    // Device Product ID
+    unsigned short product_id;
+
+    // Serial Number
+    wchar_t *serial_number;
+
+    // Device Release Number in binary-coded decimal, also known as Device Version Number
+    unsigned short release_number;
+
+    // Manufacturer String
+    wchar_t *manufacturer_string;
+
+    // Product string
+    wchar_t *product_string;
+
+    // Usage Page for this Device/Interface (Windows/Mac only).
+    unsigned short usage_page;
+
+    // Usage for this Device/Interface (Windows/Mac only).
+    unsigned short usage;
+
+    // The USB interface which this logical device represents.
+    // Valid on both Linux implementations in all cases.
+    // Valid on the Windows implementation only if the device
+    // contains more than one interface.
+    int interface_number;
+
+    // Additional information about the USB interface.
+    // Valid on libusb and Android implementations.
+    int interface_class;
+    int interface_subclass;
+    int interface_protocol;
+
+    // Pointer to the next device
+    struct SDL_hid_device_info *next;
+} SDL_hid_device_info;
+
+static int SDL_hid_init(void)
+{
+	return -1;
+}
+
+static int SDL_hid_exit(void)
+{
+	return -1;
+}
+
+static Uint32 SDL_hid_device_change_count(void)
+{
+	return 0;
+}
+
+static SDL_hid_device_info * SDL_hid_enumerate(unsigned short vendor_id, unsigned short product_id)
+{
+	return NULL;
+}
+
+static void SDL_hid_free_enumeration(SDL_hid_device_info *devs)
+{
+}
+
+static SDL_hid_device * SDL_hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)
+{
+	return NULL;
+}
+
+static SDL_hid_device * SDL_hid_open_path(const char *path, int bExclusive)
+{
+	return NULL;
+}
+
+static int SDL_hid_write(SDL_hid_device *dev, const unsigned char *data, size_t length)
+{
+	return -1;
+}
+
+static int SDL_hid_read_timeout(SDL_hid_device *dev, unsigned char *data, size_t length, int milliseconds)
+{
+	return -1;
+}
+
+static int SDL_hid_read(SDL_hid_device *dev, unsigned char *data, size_t length)
+{
+	return -1;
+}
+
+static int SDL_hid_set_nonblocking(SDL_hid_device *dev, int nonblock)
+{
+	return -1;
+}
+
+static int SDL_hid_send_feature_report(SDL_hid_device *dev, const unsigned char *data, size_t length)
+{
+	return -1;
+}
+
+static int SDL_hid_get_feature_report(SDL_hid_device *dev, unsigned char *data, size_t length)
+{
+	return -1;
+}
+
+static void SDL_hid_close(SDL_hid_device *dev)
+{
+}
+
+static int SDL_hid_get_manufacturer_string(SDL_hid_device *dev, wchar_t *string, size_t maxlen)
+{
+	return -1;
+}
+
+static int SDL_hid_get_product_string(SDL_hid_device *dev, wchar_t *string, size_t maxlen)
+{
+	return -1;
+}
+
+static int SDL_hid_get_serial_number_string(SDL_hid_device *dev, wchar_t *string, size_t maxlen)
+{
+	return -1;
+}
+
+static int SDL_hid_get_indexed_string(SDL_hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
+{
+	return -1;
+}
+
+static void SDL_hid_ble_scan(SDL_bool active)
+{
+}
+
+#endif
+*/
+import "C"
+import "unsafe"
+
+type HIDDevice C.SDL_hid_device
+
+type HIDDeviceInfo struct {
+	path               *C.char
+	VendorID           uint16
+	ProductID          uint16
+	SerialNumber       *C.wchar_t
+	ReleaseNumber      uint16
+	ManufacturerString *C.wchar_t
+	ProductString      *C.wchar_t
+	UsagePage          uint16
+	Usage              uint16
+	InterfaceNumber    int32
+	InterfaceClass     int32
+	InterfaceSubclass  int32
+	InterfaceProtocol  int32
+	next               *HIDDeviceInfo
+}
+
+func (info *HIDDeviceInfo) Path() string {
+	return C.GoString(info.path)
+}
+
+// HIDInit initializes the HIDAPI library.
+// (https://wiki.libsdl.org/SDL_hid_init)
+func HIDInit() (err error) {
+	ret := C.SDL_hid_init()
+	return errorFromInt(int(ret))
+}
+
+// HIDExit finalizes the HIDAPI library.
+// (https://wiki.libsdl.org/SDL_hid_exit)
+func HIDExit() (err error) {
+	ret := C.SDL_hid_exit()
+	return errorFromInt(int(ret))
+}
+
+// HIDDeviceChangeCount checks to see if devices may have been added or removed.
+// (https://wiki.libsdl.org/SDL_hid_device_change_count)
+func HIDDeviceChangeCount() (n uint32) {
+	return uint32(C.SDL_hid_device_change_count())
+}
+
+// HIDEnumerate enumerates the HID devices.
+// (https://wiki.libsdl.org/SDL_hid_enumerate)
+func HIDEnumerate(vendorID, productID uint16) (info *HIDDeviceInfo) {
+	_vendorID := C.Uint16(vendorID)
+	_productID := C.Uint16(productID)
+	info = (*HIDDeviceInfo)(unsafe.Pointer(C.SDL_hid_enumerate(_vendorID, _productID)))
+	return
+}
+
+// HIDFreeEnumeration frees an enumeration Linked List.
+// (https://wiki.libsdl.org/SDL_hid_free_enumeration)
+func HIDFreeEnumeration(info *HIDDeviceInfo) {
+	_info := (*C.SDL_hid_device_info)(unsafe.Pointer(info))
+	C.SDL_hid_free_enumeration(_info)
+}
+
+// HIDOpen opens a HID device using a Vendor ID (VID), Product ID (PID) and optionally a serial number.
+// (https://wiki.libsdl.org/SDL_hid_open)
+func HIDOpen(vendorID, productID uint16, _serialNumber *C.wchar_t) (device *HIDDevice) {
+	_vendorID := C.Uint16(vendorID)
+	_productID := C.Uint16(productID)
+	_device := C.SDL_hid_open(_vendorID, _productID, _serialNumber)
+	return (*HIDDevice)(_device)
+}
+
+// HIDOpenPath opens a HID device by its path name.
+// (https://wiki.libsdl.org/SDL_hid_open_path)
+func HIDOpenPath(path string, exclusive bool) (device *HIDDevice) {
+	_path := C.CString(path)
+	defer C.free(unsafe.Pointer(_path))
+	_exclusive := C.int(0)
+	if exclusive {
+		_exclusive = C.int(1)
+	}
+	_device := C.SDL_hid_open_path(_path, _exclusive)
+	return (*HIDDevice)(_device)
+}
+
+// Write writes an Output report to a HID device.
+// (https://wiki.libsdl.org/SDL_hid_write)
+func (device *HIDDevice) Write(data []byte) (n int, err error) {
+	_length := C.size_t(len(data))
+	_data := (*C.uchar)(unsafe.Pointer(&data[0]))
+	_device := (*C.SDL_hid_device)(device)
+	n = int(C.SDL_hid_write(_device, _data, _length))
+	return n, errorFromInt(n)
+}
+
+// ReadTimeout reads an Input report from a HID device with timeout.
+// (https://wiki.libsdl.org/SDL_hid_read_timeout)
+func (device *HIDDevice) ReadTimeout(data []byte, milliseconds int) (n int, err error) {
+	_length := C.size_t(len(data))
+	_data := (*C.uchar)(unsafe.Pointer(&data[0]))
+	_device := (*C.SDL_hid_device)(device)
+	_milliseconds := C.int(milliseconds)
+	n = int(C.SDL_hid_read_timeout(_device, _data, _length, _milliseconds))
+	return n, errorFromInt(n)
+}
+
+// Read an Input report from a HID device.
+// (https://wiki.libsdl.org/SDL_hid_read)
+func (device *HIDDevice) Read(data []byte) (n int, err error) {
+	_length := C.size_t(len(data))
+	_data := (*C.uchar)(unsafe.Pointer(&data[0]))
+	_device := (*C.SDL_hid_device)(device)
+	n = int(C.SDL_hid_read(_device, _data, _length))
+	return n, errorFromInt(n)
+}
+
+// SetNonBlocking sets the device handle to be non-blocking.
+// (https://wiki.libsdl.org/SDL_hid_set_nonblocking)
+func (device *HIDDevice) SetNonBlocking(nonblock bool) (err error) {
+	_device := (*C.SDL_hid_device)(device)
+	_nonblock := C.int(Btoi(nonblock))
+	return errorFromInt(int(C.SDL_hid_set_nonblocking(_device, _nonblock)))
+}
+
+// SendFeatureReport sends a Feature report to the device.
+// (https://wiki.libsdl.org/SDL_hid_send_feature_report)
+func (device *HIDDevice) SendFeatureReport(data []byte) (n int, err error) {
+	_length := C.size_t(len(data))
+	_data := (*C.uchar)(unsafe.Pointer(&data[0]))
+	_device := (*C.SDL_hid_device)(device)
+	n = int(C.SDL_hid_send_feature_report(_device, _data, _length))
+	return n, errorFromInt(n)
+}
+
+// GetFeatureReport gets a feature report from a HID device.
+// (https://wiki.libsdl.org/SDL_hid_get_feature_report)
+func (device *HIDDevice) GetFeatureReport(data []byte) (n int, err error) {
+	_length := C.size_t(len(data))
+	_data := (*C.uchar)(unsafe.Pointer(&data[0]))
+	_device := (*C.SDL_hid_device)(device)
+	n = int(C.SDL_hid_get_feature_report(_device, _data, _length))
+	return n, errorFromInt(n)
+}
+
+// Close closes a HID device.
+// (https://wiki.libsdl.org/SDL_hid_close)
+func (device *HIDDevice) Close() {
+	_device := (*C.SDL_hid_device)(device)
+	C.SDL_hid_close(_device)
+}
+
+// GetManufacturerString gets The Manufacturer String from a HID device.
+// (https://wiki.libsdl.org/SDL_hid_get_manufacturer_string)
+func (device *HIDDevice) GetManufacturerString(_str *C.wchar_t, _maxlen C.size_t) (err error) {
+	_device := (*C.SDL_hid_device)(device)
+	return errorFromInt(int(C.SDL_hid_get_manufacturer_string(_device, _str, _maxlen)))
+}
+
+// GetProductString gets The Product String from a HID device.
+// (https://wiki.libsdl.org/SDL_hid_get_product_string)
+func (device *HIDDevice) GetProductString(_str *C.wchar_t, _maxlen C.size_t) (err error) {
+	_device := (*C.SDL_hid_device)(device)
+	return errorFromInt(int(C.SDL_hid_get_product_string(_device, _str, _maxlen)))
+}
+
+// GetSerialNumberString gets The SerialNumber String from a HID device.
+// (https://wiki.libsdl.org/SDL_hid_get_serial_number_string)
+func (device *HIDDevice) GetSerialNumberString(_str *C.wchar_t, _maxlen C.size_t) (err error) {
+	_device := (*C.SDL_hid_device)(device)
+	return errorFromInt(int(C.SDL_hid_get_serial_number_string(_device, _str, _maxlen)))
+}
+
+// GetIndexedString gets a string from a HID device, based on its string index.
+// (https://wiki.libsdl.org/SDL_hid_get_indexed_string)
+func (device *HIDDevice) GetIndexedString(index int, _str *C.wchar_t, _maxlen C.size_t) (err error) {
+	_device := (*C.SDL_hid_device)(device)
+	_index := C.int(index)
+	return errorFromInt(int(C.SDL_hid_get_indexed_string(_device, _index, _str, _maxlen)))
+}
+
+// HIDBLEScan starts or stops a BLE scan on iOS and tvOS to pair Steam Controllers.
+// (https://wiki.libsdl.org/SDL_hid_ble_scan)
+func (device *HIDDevice) HIDBLEScan(active bool) {
+	_active := C.SDL_bool(Btoi(active))
+	C.SDL_hid_ble_scan(_active)
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/hints.c

@@ -0,0 +1,18 @@
+#include "_cgo_export.h"
+
+#include "sdl_wrapper.h"
+#include "hints.h"
+
+void hintCallback(void *userdata, const char *name, const char *oldValue, const char *newValue)
+{
+	goHintCallback((char *) name, (char *) oldValue, (char *) newValue);
+}
+
+void addHintCallback(const char *name)
+{
+	SDL_AddHintCallback(name, hintCallback, NULL);
+}
+
+void delHintCallback(const char *name)
+{
+	SDL_DelHintCallback(name, hintCallback, NULL);}

archive/vendor/github.com/veandco/go-sdl2/sdl/hints.go

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

archive/vendor/github.com/veandco/go-sdl2/sdl/hints.h

@@ -0,0 +1,3 @@
+void hintCallback(void *userdata, const char *name, const char *oldValue, const char *newValue);
+void addHintCallback(const char *name);
+void delHintCallback(const char *name);

archive/vendor/github.com/veandco/go-sdl2/sdl/joystick.go

@@ -0,0 +1,553 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if !(SDL_VERSION_ATLEAST(2,0,4))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_JoystickPowerLevel is not supported before SDL 2.0.4")
+#endif
+
+typedef enum
+{
+    SDL_JOYSTICK_POWER_UNKNOWN = -1,
+    SDL_JOYSTICK_POWER_EMPTY,
+    SDL_JOYSTICK_POWER_LOW,
+    SDL_JOYSTICK_POWER_MEDIUM,
+    SDL_JOYSTICK_POWER_FULL,
+    SDL_JOYSTICK_POWER_WIRED,
+    SDL_JOYSTICK_POWER_MAX
+} SDL_JoystickPowerLevel;
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_JoystickCurrentPowerLevel is not supported before SDL 2.0.4")
+#endif
+
+static SDL_JoystickPowerLevel SDL_JoystickCurrentPowerLevel(SDL_Joystick* joystick)
+{
+	return SDL_JOYSTICK_POWER_UNKNOWN;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_JoystickFromInstanceID is not supported before SDL 2.0.4")
+#endif
+
+static SDL_Joystick* SDL_JoystickFromInstanceID(SDL_JoystickID joyid)
+{
+	return NULL;
+}
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,6))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_JoystickType is not supported before SDL 2.0.6")
+#endif
+
+typedef enum
+{
+	SDL_JOYSTICK_TYPE_UNKNOWN,
+	SDL_JOYSTICK_TYPE_GAMECONTROLLER,
+	SDL_JOYSTICK_TYPE_WHEEL,
+	SDL_JOYSTICK_TYPE_ARCADE_STICK,
+	SDL_JOYSTICK_TYPE_FLIGHT_STICK,
+	SDL_JOYSTICK_TYPE_DANCE_PAD,
+	SDL_JOYSTICK_TYPE_GUITAR,
+	SDL_JOYSTICK_TYPE_DRUM_KIT,
+	SDL_JOYSTICK_TYPE_ARCADE_PAD,
+	SDL_JOYSTICK_TYPE_THROTTLE
+} SDL_JoystickType;
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_JoystickGetDeviceVendor is not supported before SDL 2.0.6")
+#endif
+
+static Uint16 SDL_JoystickGetDeviceVendor(int device_index)
+{
+	return 0;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_JoystickGetDeviceProduct is not supported before SDL 2.0.6")
+#endif
+
+static Uint16 SDL_JoystickGetDeviceProduct(int device_index)
+{
+	return 0;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_JoystickGetDeviceProductVersion is not supported before SDL 2.0.6")
+#endif
+
+static Uint16 SDL_JoystickGetDeviceProductVersion(int device_index)
+{
+	return 0;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_JoystickGetDeviceType is not supported before SDL 2.0.6")
+#endif
+
+static SDL_JoystickType SDL_JoystickGetDeviceType(int device_index)
+{
+	return SDL_JOYSTICK_TYPE_UNKNOWN;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_JoystickGetDeviceInstanceID is not supported before SDL 2.0.6")
+#endif
+
+static SDL_JoystickID SDL_JoystickGetDeviceInstanceID(int device_index)
+{
+	return 0;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_JoystickGetVendor is not supported before SDL 2.0.6")
+#endif
+
+static Uint16 SDL_JoystickGetVendor(SDL_Joystick* joystick)
+{
+	return 0;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_JoystickGetProduct is not supported before SDL 2.0.6")
+#endif
+
+static Uint16 SDL_JoystickGetProduct(SDL_Joystick* joystick)
+{
+	return 0;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_JoystickGetProductVersion is not supported before SDL 2.0.6")
+#endif
+
+static Uint16 SDL_JoystickGetProductVersion(SDL_Joystick* joystick)
+{
+	return 0;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_JoystickGetType is not supported before SDL 2.0.6")
+#endif
+
+static SDL_JoystickType SDL_JoystickGetType(SDL_Joystick* joystick)
+{
+	return SDL_JOYSTICK_TYPE_UNKNOWN;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_JoystickGetAxisInitialState is not supported before SDL 2.0.6")
+#endif
+
+static SDL_bool SDL_JoystickGetAxisInitialState(SDL_Joystick* joystick, int axis, Sint16* state)
+{
+	return SDL_FALSE;
+}
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,7))
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_LockJoysticks is not supported before SDL 2.0.7")
+#endif
+
+static void SDL_LockJoysticks()
+{
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_UnlockJoysticks is not supported before SDL 2.0.7")
+#endif
+
+static void SDL_UnlockJoysticks()
+{
+}
+
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,9))
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_JoystickGetDevicePlayerIndex is not supported before SDL 2.0.9")
+#endif
+
+static int SDL_JoystickGetDevicePlayerIndex(int device_index)
+{
+	return 0;
+}
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_JoystickGetPlayerIndex is not supported before SDL 2.0.9")
+#endif
+
+static int SDL_JoystickGetPlayerIndex(SDL_Joystick *joystick)
+{
+	return 0;
+}
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_JoystickRumble is not supported before SDL 2.0.9")
+#endif
+
+static int SDL_JoystickRumble(SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble, Uint32 duration_ms)
+{
+	return -1;
+}
+
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,18))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_JoystickHasRumble is not supported before SDL 2.0.18")
+#pragma message("SDL_JoystickHasRumbleTriggers is not supported before SDL 2.0.18")
+#endif
+
+static SDL_bool SDL_JoystickHasRumble(SDL_Joystick *joystick)
+{
+	return SDL_FALSE;
+}
+
+static SDL_bool SDL_JoystickHasRumbleTriggers(SDL_Joystick *joystick)
+{
+	return SDL_FALSE;
+}
+
+#endif
+*/
+import "C"
+import "unsafe"
+
+// Hat positions.
+// (https://wiki.libsdl.org/SDL_JoystickGetHat)
+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
+)
+
+// Types of a joystick.
+const (
+	JOYSTICK_TYPE_UNKNOWN        = C.SDL_JOYSTICK_TYPE_UNKNOWN
+	JOYSTICK_TYPE_GAMECONTROLLER = C.SDL_JOYSTICK_TYPE_GAMECONTROLLER
+	JOYSTICK_TYPE_WHEEL          = C.SDL_JOYSTICK_TYPE_WHEEL
+	JOYSTICK_TYPE_ARCADE_STICK   = C.SDL_JOYSTICK_TYPE_ARCADE_STICK
+	JOYSTICK_TYPE_FLIGHT_STICK   = C.SDL_JOYSTICK_TYPE_FLIGHT_STICK
+	JOYSTICK_TYPE_DANCE_PAD      = C.SDL_JOYSTICK_TYPE_DANCE_PAD
+	JOYSTICK_TYPE_GUITAR         = C.SDL_JOYSTICK_TYPE_GUITAR
+	JOYSTICK_TYPE_DRUM_KIT       = C.SDL_JOYSTICK_TYPE_DRUM_KIT
+	JOYSTICK_TYPE_ARCADE_PAD     = C.SDL_JOYSTICK_TYPE_ARCADE_PAD
+	JOYSTICK_TYPE_THROTTLE       = C.SDL_JOYSTICK_TYPE_THROTTLE
+)
+
+// An enumeration of battery levels of a joystick.
+// (https://wiki.libsdl.org/SDL_JoystickPowerLevel)
+const (
+	JOYSTICK_POWER_UNKNOWN = C.SDL_JOYSTICK_POWER_UNKNOWN
+	JOYSTICK_POWER_EMPTY   = C.SDL_JOYSTICK_POWER_EMPTY
+	JOYSTICK_POWER_LOW     = C.SDL_JOYSTICK_POWER_LOW
+	JOYSTICK_POWER_MEDIUM  = C.SDL_JOYSTICK_POWER_MEDIUM
+	JOYSTICK_POWER_FULL    = C.SDL_JOYSTICK_POWER_FULL
+	JOYSTICK_POWER_WIRED   = C.SDL_JOYSTICK_POWER_WIRED
+	JOYSTICK_POWER_MAX     = C.SDL_JOYSTICK_POWER_MAX
+)
+
+// Joystick is an SDL joystick.
+type Joystick C.SDL_Joystick
+
+// JoystickGUID is a stable unique id for a joystick device.
+type JoystickGUID C.SDL_JoystickGUID
+
+// JoystickID is joystick's instance id.
+type JoystickID C.SDL_JoystickID
+
+// JoystickType is a type of a joystick.
+type JoystickType C.SDL_JoystickType
+
+// JoystickPowerLevel is a battery level of a joystick.
+type JoystickPowerLevel C.SDL_JoystickPowerLevel
+
+func (joy *Joystick) cptr() *C.SDL_Joystick {
+	return (*C.SDL_Joystick)(unsafe.Pointer(joy))
+}
+
+func (guid JoystickGUID) c() C.SDL_JoystickGUID {
+	return C.SDL_JoystickGUID(guid)
+}
+
+func (joyid JoystickID) c() C.SDL_JoystickID {
+	return C.SDL_JoystickID(joyid)
+}
+
+// NumJoysticks returns the number of joysticks attached to the system.
+// (https://wiki.libsdl.org/SDL_NumJoysticks)
+func NumJoysticks() int {
+	return (int)(C.SDL_NumJoysticks())
+}
+
+// JoystickNameForIndex returns the implementation dependent name of a joystick.
+// (https://wiki.libsdl.org/SDL_JoystickNameForIndex)
+func JoystickNameForIndex(index int) string {
+	return (C.GoString)(C.SDL_JoystickNameForIndex(C.int(index)))
+}
+
+// JoystickGetDevicePlayerIndex returns the player index of a joystick, or -1 if it's not available
+// TODO: (https://wiki.libsdl.org/SDL_JoystickGetDevicePlayerIndex)
+func JoystickGetDevicePlayerIndex(index int) int {
+	return int(C.SDL_JoystickGetDevicePlayerIndex(C.int(index)))
+}
+
+// JoystickGetDeviceGUID returns the implementation dependent GUID for the joystick at a given device index.
+// (https://wiki.libsdl.org/SDL_JoystickGetDeviceGUID)
+func JoystickGetDeviceGUID(index int) JoystickGUID {
+	return (JoystickGUID)(C.SDL_JoystickGetDeviceGUID(C.int(index)))
+}
+
+// JoystickGetDeviceVendor returns the USB vendor ID of a joystick, if available, 0 otherwise.
+func JoystickGetDeviceVendor(index int) int {
+	return int(C.SDL_JoystickGetDeviceVendor(C.int(index)))
+}
+
+// JoystickGetDeviceProduct returns the USB product ID of a joystick, if available, 0 otherwise.
+func JoystickGetDeviceProduct(index int) int {
+	return int(C.SDL_JoystickGetDeviceProduct(C.int(index)))
+}
+
+// JoystickGetDeviceProductVersion returns the product version of a joystick, if available, 0 otherwise.
+func JoystickGetDeviceProductVersion(index int) int {
+	return int(C.SDL_JoystickGetDeviceProductVersion(C.int(index)))
+}
+
+// JoystickGetDeviceType returns the type of a joystick.
+func JoystickGetDeviceType(index int) JoystickType {
+	return JoystickType(C.SDL_JoystickGetDeviceType(C.int(index)))
+}
+
+// JoystickGetDeviceInstanceID returns the instance ID of a joystick.
+func JoystickGetDeviceInstanceID(index int) JoystickID {
+	return JoystickID(C.SDL_JoystickGetDeviceInstanceID(C.int(index)))
+}
+
+// JoystickGetGUIDString returns an ASCII string representation for a given JoystickGUID.
+// (https://wiki.libsdl.org/SDL_JoystickGetGUIDString)
+func JoystickGetGUIDString(guid JoystickGUID) string {
+	_pszGUID := make([]rune, 1024)
+	pszGUID := C.CString(string(_pszGUID[:]))
+	defer C.free(unsafe.Pointer(pszGUID))
+	C.SDL_JoystickGetGUIDString(guid.c(), pszGUID, C.int(unsafe.Sizeof(_pszGUID)))
+	return C.GoString(pszGUID)
+}
+
+// JoystickGetGUIDFromString converts a GUID string into a JoystickGUID structure.
+// (https://wiki.libsdl.org/SDL_JoystickGetGUIDFromString)
+func JoystickGetGUIDFromString(pchGUID string) JoystickGUID {
+	_pchGUID := C.CString(pchGUID)
+	defer C.free(unsafe.Pointer(_pchGUID))
+	return (JoystickGUID)(C.SDL_JoystickGetGUIDFromString(_pchGUID))
+}
+
+// JoystickUpdate updates the current state of the open joysticks.
+// (https://wiki.libsdl.org/SDL_JoystickUpdate)
+func JoystickUpdate() {
+	C.SDL_JoystickUpdate()
+}
+
+// JoystickEventState enables or disables joystick event polling.
+// (https://wiki.libsdl.org/SDL_JoystickEventState)
+func JoystickEventState(state int) int {
+	return (int)(C.SDL_JoystickEventState(C.int(state)))
+}
+
+// JoystickOpen opens a joystick for use.
+// (https://wiki.libsdl.org/SDL_JoystickOpen)
+func JoystickOpen(index int) *Joystick {
+	return (*Joystick)(C.SDL_JoystickOpen(C.int(index)))
+}
+
+// JoystickFromInstanceID returns the Joystick associated with an instance id.
+// (https://wiki.libsdl.org/SDL_JoystickFromInstanceID)
+func JoystickFromInstanceID(joyid JoystickID) *Joystick {
+	return (*Joystick)(C.SDL_JoystickFromInstanceID(joyid.c()))
+}
+
+// LockJoysticks locks joysticks for multi-threaded access to the joystick API
+// TODO: (https://wiki.libsdl.org/SDL_LockJoysticks)
+func LockJoysticks() {
+	C.SDL_LockJoysticks()
+}
+
+// UnlockJoysticks unlocks joysticks for multi-threaded access to the joystick API
+// TODO: (https://wiki.libsdl.org/SDL_UnlockJoysticks)
+func UnlockJoysticks() {
+	C.SDL_UnlockJoysticks()
+}
+
+// Name returns the implementation dependent name of a joystick.
+// (https://wiki.libsdl.org/SDL_JoystickName)
+func (joy *Joystick) Name() string {
+	return (C.GoString)(C.SDL_JoystickName(joy.cptr()))
+}
+
+// PlayerIndex returns the player index of an opened joystick, or -1 if it's not available.
+// (https://wiki.libsdl.org/SDL_JoystickGetPlayerIndex)
+func (joy *Joystick) PlayerIndex() int {
+	return int(C.SDL_JoystickGetPlayerIndex(joy.cptr()))
+}
+
+// GUID returns the implementation-dependent GUID for the joystick.
+// (https://wiki.libsdl.org/SDL_JoystickGetGUID)
+func (joy *Joystick) GUID() JoystickGUID {
+	return (JoystickGUID)(C.SDL_JoystickGetGUID(joy.cptr()))
+}
+
+// Vendor returns the USB vendor ID of an opened joystick, if available, 0 otherwise.
+func (joy *Joystick) Vendor() int {
+	return int(C.SDL_JoystickGetVendor(joy.cptr()))
+}
+
+// Product returns the USB product ID of an opened joystick, if available, 0 otherwise.
+func (joy *Joystick) Product() int {
+	return int(C.SDL_JoystickGetProduct(joy.cptr()))
+}
+
+// ProductVersion returns the product version of an opened joystick, if available, 0 otherwise.
+func (joy *Joystick) ProductVersion() int {
+	return int(C.SDL_JoystickGetProductVersion(joy.cptr()))
+}
+
+// Type returns the the type of an opened joystick.
+func (joy *Joystick) Type() JoystickType {
+	return JoystickType(C.SDL_JoystickGetType(joy.cptr()))
+}
+
+// Attached returns the status of a specified joystick.
+// (https://wiki.libsdl.org/SDL_JoystickGetAttached)
+func (joy *Joystick) Attached() bool {
+	return C.SDL_JoystickGetAttached(joy.cptr()) == C.SDL_TRUE
+}
+
+// InstanceID returns the instance ID of an opened joystick.
+// (https://wiki.libsdl.org/SDL_JoystickInstanceID)
+func (joy *Joystick) InstanceID() JoystickID {
+	return (JoystickID)(C.SDL_JoystickInstanceID(joy.cptr()))
+}
+
+// NumAxes returns the number of general axis controls on a joystick.
+// (https://wiki.libsdl.org/SDL_JoystickNumAxes)
+func (joy *Joystick) NumAxes() int {
+	return (int)(C.SDL_JoystickNumAxes(joy.cptr()))
+}
+
+// NumBalls returns the number of trackballs on a joystick.
+// (https://wiki.libsdl.org/SDL_JoystickNumBalls)
+func (joy *Joystick) NumBalls() int {
+	return (int)(C.SDL_JoystickNumBalls(joy.cptr()))
+}
+
+// NumHats returns the number of POV hats on a joystick.
+// (https://wiki.libsdl.org/SDL_JoystickNumHats)
+func (joy *Joystick) NumHats() int {
+	return (int)(C.SDL_JoystickNumHats(joy.cptr()))
+}
+
+// NumButtons returns the number of buttons on a joystick.
+// (https://wiki.libsdl.org/SDL_JoystickNumButtons)
+func (joy *Joystick) NumButtons() int {
+	return (int)(C.SDL_JoystickNumButtons(joy.cptr()))
+}
+
+// Axis returns the current state of an axis control on a joystick.
+// (https://wiki.libsdl.org/SDL_JoystickGetAxis)
+func (joy *Joystick) Axis(axis int) int16 {
+	return (int16)(C.SDL_JoystickGetAxis(joy.cptr(), C.int(axis)))
+}
+
+// AxisInitialState returns the initial state of an axis control on a joystick, ok is true if this axis has any initial value.
+func (joy *Joystick) AxisInitialState(axis int) (state int16, ok bool) {
+	ok = C.SDL_JoystickGetAxisInitialState(joy.cptr(), C.int(axis), (*C.Sint16)(&state)) == C.SDL_TRUE
+	return
+}
+
+// Hat returns the current state of a POV hat on a joystick.
+// (https://wiki.libsdl.org/SDL_JoystickGetHat)
+func (joy *Joystick) Hat(hat int) byte {
+	return (byte)(C.SDL_JoystickGetHat(joy.cptr(), C.int(hat)))
+}
+
+// Ball returns the ball axis change since the last poll.
+// (https://wiki.libsdl.org/SDL_JoystickGetBall)
+func (joy *Joystick) Ball(ball int, dx, dy *int32) int {
+	_dx := (*C.int)(unsafe.Pointer(dx))
+	_dy := (*C.int)(unsafe.Pointer(dy))
+	return (int)(C.SDL_JoystickGetBall(joy.cptr(), C.int(ball), _dx, _dy))
+}
+
+// Button the current state of a button on a joystick.
+// (https://wiki.libsdl.org/SDL_JoystickGetButton)
+func (joy *Joystick) Button(button int) byte {
+	return (byte)(C.SDL_JoystickGetButton(joy.cptr(), C.int(button)))
+}
+
+// Rumble triggers a rumble effect
+// Each call to this function cancels any previous rumble effect, and calling it with 0 intensity stops any rumbling.
+//
+// lowFrequencyRumble - The intensity of the low frequency (left) rumble motor, from 0 to 0xFFFF
+// highFrequencyRumble - The intensity of the high frequency (right) rumble motor, from 0 to 0xFFFF
+// durationMS - The duration of the rumble effect, in milliseconds
+//
+// Returns error if rumble isn't supported on this joystick.
+//
+// TODO: (https://wiki.libsdl.org/SDL_JoystickRumble)
+func (joy *Joystick) Rumble(lowFrequencyRumble, highFrequencyRumble uint16, durationMS uint32) error {
+	return errorFromInt(int(C.SDL_JoystickRumble(joy.cptr(), C.Uint16(lowFrequencyRumble), C.Uint16(highFrequencyRumble), C.Uint32(durationMS))))
+}
+
+// Close closes a joystick previously opened with JoystickOpen().
+// (https://wiki.libsdl.org/SDL_JoystickClose)
+func (joy *Joystick) Close() {
+	C.SDL_JoystickClose(joy.cptr())
+}
+
+// CurrentPowerLevel returns the battery level of a joystick as JoystickPowerLevel.
+// (https://wiki.libsdl.org/SDL_JoystickCurrentPowerLevel)
+func (joy *Joystick) CurrentPowerLevel() JoystickPowerLevel {
+	return JoystickPowerLevel(C.SDL_JoystickCurrentPowerLevel(joy.cptr()))
+}
+
+// HasRumble queries whether a game controller has rumble support.
+// (https://wiki.libsdl.org/SDL_JoystickHasRumble)
+func (ctrl *Joystick) HasRumble() bool {
+	return C.SDL_JoystickHasRumble(ctrl.cptr()) == C.SDL_TRUE
+}
+
+// HasRumbleTriggers queries whether a game controller has rumble support on triggers.
+// (https://wiki.libsdl.org/SDL_JoystickHasRumbleTriggers)
+func (ctrl *Joystick) HasRumbleTriggers() bool {
+	return C.SDL_JoystickHasRumbleTriggers(ctrl.cptr()) == C.SDL_TRUE
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/keyboard.go

@@ -0,0 +1,155 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if !(SDL_VERSION_ATLEAST(2,0,22))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_IsTextInputShown is not supported before SDL 2.0.22")
+#pragma message("SDL_ClearComposition is not supported before SDL 2.0.22")
+#endif
+
+static inline SDL_bool SDL_IsTextInputShown(void)
+{
+	return SDL_FALSE;
+}
+
+static inline void SDL_ClearComposition(void)
+{
+}
+
+#endif
+*/
+import "C"
+import (
+	"reflect"
+	"unsafe"
+)
+
+// Keysym contains key information used in key events.
+// (https://wiki.libsdl.org/SDL_Keysym)
+type Keysym struct {
+	Scancode Scancode // SDL physical key code
+	Sym      Keycode  // SDL virtual key code
+	Mod      uint16   // current key modifiers
+	unused   uint32   // unused
+}
+
+// GetKeyboardFocus returns the window which currently has keyboard focus.
+// (https://wiki.libsdl.org/SDL_GetKeyboardFocus)
+func GetKeyboardFocus() *Window {
+	return (*Window)(unsafe.Pointer(C.SDL_GetKeyboardFocus()))
+}
+
+// GetKeyboardState returns a snapshot of the current state of the keyboard.
+// (https://wiki.libsdl.org/SDL_GetKeyboardState)
+func GetKeyboardState() []uint8 {
+	var numkeys C.int
+	start := C.SDL_GetKeyboardState(&numkeys)
+	sh := reflect.SliceHeader{}
+	sh.Len = int(numkeys)
+	sh.Cap = int(numkeys)
+	sh.Data = uintptr(unsafe.Pointer(start))
+	return *(*[]uint8)(unsafe.Pointer(&sh))
+}
+
+// GetModState returns the current key modifier state for the keyboard.
+// (https://wiki.libsdl.org/SDL_GetModState)
+func GetModState() Keymod {
+	return (Keymod)(C.SDL_GetModState())
+}
+
+// SetModState sets the current key modifier state for the keyboard.
+// (https://wiki.libsdl.org/SDL_SetModState)
+func SetModState(mod Keymod) {
+	C.SDL_SetModState(mod.c())
+}
+
+// GetKeyFromScancode returns the key code corresponding to the given scancode according to the current keyboard layout.
+// (https://wiki.libsdl.org/SDL_GetKeyFromScancode)
+func GetKeyFromScancode(code Scancode) Keycode {
+	return (Keycode)(C.SDL_GetKeyFromScancode(code.c()))
+}
+
+// GetScancodeFromKey returns the scancode corresponding to the given key code according to the current keyboard layout.
+// (https://wiki.libsdl.org/SDL_GetScancodeFromKey)
+func GetScancodeFromKey(code Keycode) Scancode {
+	return (Scancode)(C.SDL_GetScancodeFromKey(code.c()))
+}
+
+// GetScancodeName returns a human-readable name for a scancode
+// (https://wiki.libsdl.org/SDL_GetScancodeName)
+func GetScancodeName(code Scancode) string {
+	return (C.GoString)(C.SDL_GetScancodeName(code.c()))
+}
+
+// GetScancodeFromName returns a scancode from a human-readable name.
+// (https://wiki.libsdl.org/SDL_GetScancodeFromName)
+func GetScancodeFromName(name string) Scancode {
+	_name := C.CString(name)
+	defer C.free(unsafe.Pointer(_name))
+	return (Scancode)(C.SDL_GetScancodeFromName(_name))
+}
+
+// GetKeyName returns a human-readable name for a key.
+// (https://wiki.libsdl.org/SDL_GetKeyName)
+func GetKeyName(code Keycode) string {
+	return (C.GoString)(C.SDL_GetKeyName(code.c()))
+}
+
+// GetKeyFromName returns a key code from a human-readable name.
+// (https://wiki.libsdl.org/SDL_GetKeyFromName)
+func GetKeyFromName(name string) Keycode {
+	_name := C.CString(name)
+	defer C.free(unsafe.Pointer(_name))
+	return (Keycode)(C.SDL_GetKeyFromName(_name))
+}
+
+// StartTextInput starts accepting Unicode text input events.
+// (https://wiki.libsdl.org/SDL_StartTextInput)
+func StartTextInput() {
+	C.SDL_StartTextInput()
+}
+
+// IsTextInputActive checks whether or not Unicode text input events are enabled.
+// (https://wiki.libsdl.org/SDL_IsTextInputActive)
+func IsTextInputActive() bool {
+	return C.SDL_IsTextInputActive() > 0
+}
+
+// StopTextInput stops receiving any text input events.
+// (https://wiki.libsdl.org/SDL_StopTextInput)
+func StopTextInput() {
+	C.SDL_StopTextInput()
+}
+
+// SetTextInputRect sets the rectangle used to type Unicode text inputs.
+// (https://wiki.libsdl.org/SDL_SetTextInputRect)
+func SetTextInputRect(rect *Rect) {
+	C.SDL_SetTextInputRect(rect.cptr())
+}
+
+// HasScreenKeyboardSupport reports whether the platform has some screen keyboard support.
+// (https://wiki.libsdl.org/SDL_HasScreenKeyboardSupport)
+func HasScreenKeyboardSupport() bool {
+	return C.SDL_HasScreenKeyboardSupport() > 0
+}
+
+// IsScreenKeyboardShown reports whether the screen keyboard is shown for given window.
+// (https://wiki.libsdl.org/SDL_IsScreenKeyboardShown)
+func IsScreenKeyboardShown(window *Window) bool {
+	return C.SDL_IsScreenKeyboardShown(window.cptr()) > 0
+}
+
+// IsTextInputShown returns if an IME Composite or Candidate window is currently shown.
+// (https://wiki.libsdl.org/SDL_IsTextInputShown)
+func IsTextInputShown() bool {
+	return C.SDL_IsTextInputShown() > 0
+}
+
+// ClearComposition dismisses the composition window/IME without disabling the subsystem.
+// (https://wiki.libsdl.org/SDL_ClearComposition)
+func ClearComposition() {
+	C.SDL_ClearComposition()
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/keycode.go

@@ -0,0 +1,301 @@
+package sdl
+
+// #include "sdl_wrapper.h"
+import "C"
+
+const K_SCANCODE_MASK = 1 << 30
+
+// The SDL virtual key representation.
+// (https://wiki.libsdl.org/SDL_Keycode)
+// (https://wiki.libsdl.org/SDLKeycodeLookup)
+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)
+)
+
+// An enumeration of key modifier masks.
+// (https://wiki.libsdl.org/SDL_Keymod)
+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
+)
+
+// Keycode is the SDL virtual key representation.
+// (https://wiki.libsdl.org/SDL_Keycode)
+type Keycode C.SDL_Keycode
+
+// Keymod is a key modifier masks.
+// (https://wiki.libsdl.org/SDL_Keymod)
+type Keymod C.SDL_Keymod
+
+func (code Keycode) c() C.SDL_Keycode {
+	return C.SDL_Keycode(code)
+}
+
+func (mod Keymod) c() C.SDL_Keymod {
+	return C.SDL_Keymod(mod)
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/loadso.go

@@ -0,0 +1,30 @@
+package sdl
+
+// #include "sdl_wrapper.h"
+import "C"
+import "unsafe"
+
+// SharedObject is a pointer to the object handle.
+type SharedObject uintptr
+
+// LoadObject dynamically loads a shared object and returns a pointer to the object handle.
+// (https://wiki.libsdl.org/SDL_LoadObject)
+func LoadObject(sofile string) SharedObject {
+	_sofile := C.CString(sofile)
+	defer C.free(unsafe.Pointer(_sofile))
+	return (SharedObject)(C.SDL_LoadObject(_sofile))
+}
+
+// LoadFunction returns a pointer to the named function from the shared object.
+// (https://wiki.libsdl.org/SDL_LoadFunction)
+func (handle SharedObject) LoadFunction(name string) unsafe.Pointer {
+	_name := C.CString(name)
+	defer C.free(unsafe.Pointer(_name))
+	return (unsafe.Pointer)(C.SDL_LoadFunction((unsafe.Pointer)(handle), _name))
+}
+
+// Unload unloads a shared object from memory.
+// (https://wiki.libsdl.org/SDL_UnloadObject)
+func (handle SharedObject) Unload() {
+	C.SDL_UnloadObject((unsafe.Pointer)(handle))
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/log.c

@@ -0,0 +1,6 @@
+#include "_cgo_export.h"
+
+void LogSetOutputFunction(void *data)
+{
+    SDL_LogSetOutputFunction((SDL_LogOutputFunction)logOutputFunction, data);
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/log.go

@@ -0,0 +1,248 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+#include "log.h"
+
+static inline void _SDL_Log(const char *fmt)
+{
+    SDL_Log("%s", fmt);
+}
+
+static inline void _SDL_LogVerbose(int category, const char *fmt)
+{
+    SDL_LogVerbose(category, "%s", fmt);
+}
+
+static inline void _SDL_LogDebug(int category, const char *fmt)
+{
+    SDL_LogDebug(category, "%s", fmt);
+}
+
+static inline void _SDL_LogInfo(int category, const char *fmt)
+{
+    SDL_LogInfo(category, "%s", fmt);
+}
+
+static inline void _SDL_LogWarn(int category, const char *fmt)
+{
+    SDL_LogWarn(category, "%s", fmt);
+}
+
+static inline void _SDL_LogError(int category, const char *fmt)
+{
+    SDL_LogError(category, "%s", fmt);
+}
+
+static inline void _SDL_LogCritical(int category, const char *fmt)
+{
+    SDL_LogCritical(category, "%s", fmt);
+}
+
+static inline void _SDL_LogMessage(int category, SDL_LogPriority priority, const char *fmt)
+{
+    SDL_LogCritical(category, "%s", fmt);
+}
+*/
+import "C"
+import "fmt"
+import "unsafe"
+
+// An enumeration of the predefined log categories.
+// (https://wiki.libsdl.org/SDL_LOG_CATEGORY)
+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 priorities.
+// (https://wiki.libsdl.org/SDL_LogPriority)
+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)
+)
+
+// LogPriority is a predefined log priority.
+// (https://wiki.libsdl.org/SDL_LogPriority)
+type LogPriority C.SDL_LogPriority
+
+func (p LogPriority) c() C.SDL_LogPriority {
+	return C.SDL_LogPriority(p)
+}
+
+// LogSetAllPriority sets the priority of all log categories.
+// (https://wiki.libsdl.org/SDL_LogSetAllPriority)
+func LogSetAllPriority(p LogPriority) {
+	C.SDL_LogSetAllPriority(p.c())
+}
+
+// LogSetPriority sets the priority of a particular log category.
+// (https://wiki.libsdl.org/SDL_LogSetPriority)
+func LogSetPriority(category int, p LogPriority) {
+	C.SDL_LogSetPriority(C.int(category), p.c())
+}
+
+// LogGetPriority returns the priority of a particular log category.
+// (https://wiki.libsdl.org/SDL_LogGetPriority)
+func LogGetPriority(category int) LogPriority {
+	return LogPriority(C.SDL_LogGetPriority(C.int(category)))
+}
+
+// LogResetPriorities resets all priorities to default.
+// (https://wiki.libsdl.org/SDL_LogResetPriorities)
+func LogResetPriorities() {
+	C.SDL_LogResetPriorities()
+}
+
+// Log logs a message with LOG_CATEGORY_APPLICATION and LOG_PRIORITY_INFO.
+// (https://wiki.libsdl.org/SDL_Log)
+func Log(str string, args ...interface{}) {
+	str = fmt.Sprintf(str, args...)
+
+	cstr := C.CString(str)
+	defer C.free(unsafe.Pointer(cstr))
+
+	C._SDL_Log(cstr)
+}
+
+// LogVerbose logs a message with LOG_PRIORITY_VERBOSE.
+// (https://wiki.libsdl.org/SDL_LogVerbose)
+func LogVerbose(category int, str string, args ...interface{}) {
+	str = fmt.Sprintf(str, args...)
+
+	cstr := C.CString(str)
+	defer C.free(unsafe.Pointer(cstr))
+
+	C._SDL_LogVerbose(C.int(category), cstr)
+}
+
+// LogDebug logs a message with LOG_PRIORITY_DEBUG.
+// (https://wiki.libsdl.org/SDL_LogDebug)
+func LogDebug(category int, str string, args ...interface{}) {
+	str = fmt.Sprintf(str, args...)
+
+	cstr := C.CString(str)
+	defer C.free(unsafe.Pointer(cstr))
+
+	C._SDL_LogDebug(C.int(category), cstr)
+}
+
+// LogInfo logs a message with LOG_PRIORITY_INFO.
+// (https://wiki.libsdl.org/SDL_LogInfo)
+func LogInfo(category int, str string, args ...interface{}) {
+	str = fmt.Sprintf(str, args...)
+
+	cstr := C.CString(str)
+	defer C.free(unsafe.Pointer(cstr))
+
+	C._SDL_LogInfo(C.int(category), cstr)
+}
+
+// LogWarn logs a message with LOG_PRIORITY_WARN.
+// (https://wiki.libsdl.org/SDL_LogWarn)
+func LogWarn(category int, str string, args ...interface{}) {
+	str = fmt.Sprintf(str, args...)
+
+	cstr := C.CString(str)
+	defer C.free(unsafe.Pointer(cstr))
+
+	C._SDL_LogWarn(C.int(category), cstr)
+}
+
+// LogError logs a message with LOG_PRIORITY_ERROR.
+// (https://wiki.libsdl.org/SDL_LogError)
+func LogError(category int, str string, args ...interface{}) {
+	str = fmt.Sprintf(str, args...)
+
+	cstr := C.CString(str)
+	defer C.free(unsafe.Pointer(cstr))
+
+	C._SDL_LogError(C.int(category), cstr)
+}
+
+// LogCritical logs a message with LOG_PRIORITY_CRITICAL.
+// (https://wiki.libsdl.org/SDL_LogCritical)
+func LogCritical(category int, str string, args ...interface{}) {
+	str = fmt.Sprintf(str, args...)
+
+	cstr := C.CString(str)
+	defer C.free(unsafe.Pointer(cstr))
+
+	C._SDL_LogCritical(C.int(category), cstr)
+}
+
+// LogMessage logs a message with the specified category and priority.
+// (https://wiki.libsdl.org/SDL_LogMessage)
+func LogMessage(category int, pri LogPriority, str string, args ...interface{}) {
+	str = fmt.Sprintf(str, args...)
+
+	cstr := C.CString(str)
+	defer C.free(unsafe.Pointer(cstr))
+
+	C._SDL_LogMessage(C.int(category), C.SDL_LogPriority(pri), cstr)
+}
+
+// LogOutputFunction is the function to call instead of the default
+type LogOutputFunction func(data interface{}, category int, pri LogPriority, message string)
+
+type logOutputFunctionCtx struct {
+	f LogOutputFunction
+	d interface{}
+}
+
+// Yissakhar Z. Beck (DeedleFake)'s implementation
+//
+//export logOutputFunction
+func logOutputFunction(data unsafe.Pointer, category C.int, pri C.SDL_LogPriority, message *C.char) {
+	ctx := (*logOutputFunctionCtx)(data)
+
+	ctx.f(ctx.d, int(category), LogPriority(pri), C.GoString(message))
+}
+
+var (
+	logOutputFunctionCache LogOutputFunction
+	logOutputDataCache     interface{}
+)
+
+// LogGetOutputFunction returns the current log output function.
+// (https://wiki.libsdl.org/SDL_LogGetOutputFunction)
+func LogGetOutputFunction() (LogOutputFunction, interface{}) {
+	return logOutputFunctionCache, logOutputDataCache
+}
+
+// LogSetOutputFunction replaces the default log output function with one of your own.
+// (https://wiki.libsdl.org/SDL_LogSetOutputFunction)
+func LogSetOutputFunction(f LogOutputFunction, data interface{}) {
+	ctx := &logOutputFunctionCtx{
+		f: f,
+		d: data,
+	}
+
+	C.LogSetOutputFunction(unsafe.Pointer(ctx))
+
+	logOutputFunctionCache = f
+	logOutputDataCache = data
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/log.h

@@ -0,0 +1 @@
+void LogSetOutputFunction(void *data);

archive/vendor/github.com/veandco/go-sdl2/sdl/mouse.go

@@ -0,0 +1,256 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if defined(__WIN32)
+#include <SDL2/SDL_syswm.h>
+#else
+#include <SDL_syswm.h>
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,4))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_CaptureMouse is not supported before SDL 2.0.4")
+#endif
+
+static int SDL_CaptureMouse(SDL_bool enabled)
+{
+	return -1;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_MOUSEWHEEL_NORMAL is not supported before SDL 2.0.4")
+#endif
+
+#define SDL_MOUSEWHEEL_NORMAL (0)
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_MOUSEWHEEL_FLIPPED is not supported before SDL 2.0.4")
+#endif
+
+#define SDL_MOUSEWHEEL_FLIPPED (0)
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_WarpMouseGlobal is not supported before SDL 2.0.4")
+#endif
+
+static int SDL_WarpMouseGlobal(int x, int y)
+{
+	return -1;
+}
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_GetGlobalMouseState is not supported before SDL 2.0.4")
+#endif
+
+static Uint32 SDL_GetGlobalMouseState(int *x, int *y)
+{
+	return 0;
+}
+
+#endif
+*/
+import "C"
+import "unsafe"
+
+// Cursor types for CreateSystemCursor()
+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)
+)
+
+// Scroll direction types for the Scroll event
+const (
+	MOUSEWHEEL_NORMAL  = C.SDL_MOUSEWHEEL_NORMAL  // the scroll direction is normal
+	MOUSEWHEEL_FLIPPED = C.SDL_MOUSEWHEEL_FLIPPED // the scroll direction is flipped / natural
+)
+
+// Used as a mask when testing buttons in buttonstate.
+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
+)
+
+// Cursor is a custom cursor created by CreateCursor() or CreateColorCursor().
+type Cursor C.SDL_Cursor
+
+// SystemCursor is a system cursor created by CreateSystemCursor().
+type SystemCursor C.SDL_SystemCursor
+
+func (c *Cursor) cptr() *C.SDL_Cursor {
+	return (*C.SDL_Cursor)(unsafe.Pointer(c))
+}
+
+func (c SystemCursor) c() C.SDL_SystemCursor {
+	return C.SDL_SystemCursor(c)
+}
+
+// GetMouseFocus returns the window which currently has mouse focus.
+// (https://wiki.libsdl.org/SDL_GetMouseFocus)
+func GetMouseFocus() *Window {
+	return (*Window)(unsafe.Pointer(C.SDL_GetMouseFocus()))
+}
+
+// GetGlobalMouseState returns the current state of the mouse.
+// (https://wiki.libsdl.org/SDL_GetGlobalMouseState)
+func GetGlobalMouseState() (x, y int32, state uint32) {
+	var _x, _y C.int
+	_state := uint32(C.SDL_GetGlobalMouseState(&_x, &_y))
+	return int32(_x), int32(_y), _state
+}
+
+// GetMouseState returns the current state of the mouse.
+// (https://wiki.libsdl.org/SDL_GetMouseState)
+func GetMouseState() (x, y int32, state uint32) {
+	var _x, _y C.int
+	_state := uint32(C.SDL_GetMouseState(&_x, &_y))
+	return int32(_x), int32(_y), _state
+}
+
+// GetRelativeMouseState returns the relative state of the mouse.
+// (https://wiki.libsdl.org/SDL_GetRelativeMouseState)
+func GetRelativeMouseState() (x, y int32, state uint32) {
+	var _x, _y C.int
+	_state := uint32(C.SDL_GetRelativeMouseState(&_x, &_y))
+	return int32(_x), int32(_y), _state
+}
+
+// WarpMouseInWindow moves the mouse to the given position within the window.
+// (https://wiki.libsdl.org/SDL_WarpMouseInWindow)
+func (window *Window) WarpMouseInWindow(x, y int32) {
+	C.SDL_WarpMouseInWindow(window.cptr(), C.int(x), C.int(y))
+}
+
+// SetRelativeMouseMode sets relative mouse mode.
+// (https://wiki.libsdl.org/SDL_SetRelativeMouseMode)
+func SetRelativeMouseMode(enabled bool) int {
+	return int(C.SDL_SetRelativeMouseMode(C.SDL_bool(Btoi(enabled))))
+}
+
+// GetRelativeMouseMode reports where relative mouse mode is enabled.
+// (https://wiki.libsdl.org/SDL_GetRelativeMouseMode)
+func GetRelativeMouseMode() bool {
+	return C.SDL_GetRelativeMouseMode() > 0
+}
+
+// CreateCursor creates a cursor using the specified bitmap data and mask (in MSB format).
+// (https://wiki.libsdl.org/SDL_CreateCursor)
+func CreateCursor(data, mask *uint8, w, h, hotX, hotY int32) *Cursor {
+	_data := (*C.Uint8)(unsafe.Pointer(data))
+	_mask := (*C.Uint8)(unsafe.Pointer(mask))
+	return (*Cursor)(C.SDL_CreateCursor(_data, _mask, C.int(w), C.int(h), C.int(hotX), C.int(hotY)))
+}
+
+// CreateColorCursor creates a color cursor.
+// (https://wiki.libsdl.org/SDL_CreateColorCursor)
+func CreateColorCursor(surface *Surface, hotX, hotY int32) *Cursor {
+	return (*Cursor)(C.SDL_CreateColorCursor(surface.cptr(), C.int(hotX), C.int(hotY)))
+}
+
+// CreateSystemCursor creates a system cursor.
+// (https://wiki.libsdl.org/SDL_CreateSystemCursor)
+func CreateSystemCursor(id SystemCursor) *Cursor {
+	return (*Cursor)(C.SDL_CreateSystemCursor(id.c()))
+}
+
+// SetCursor sets the active cursor.
+// (https://wiki.libsdl.org/SDL_SetCursor)
+func SetCursor(cursor *Cursor) {
+	C.SDL_SetCursor(cursor.cptr())
+}
+
+// GetCursor returns the active cursor.
+// (https://wiki.libsdl.org/SDL_GetCursor)
+func GetCursor() *Cursor {
+	return (*Cursor)(C.SDL_GetCursor())
+}
+
+// GetDefaultCursor returns the default cursor.
+// (https://wiki.libsdl.org/SDL_GetDefaultCursor)
+func GetDefaultCursor() *Cursor {
+	return (*Cursor)(C.SDL_GetDefaultCursor())
+}
+
+// FreeCursor frees a cursor created with CreateCursor(), CreateColorCursor() or CreateSystemCursor().
+// (https://wiki.libsdl.org/SDL_FreeCursor)
+func FreeCursor(cursor *Cursor) {
+	C.SDL_FreeCursor(cursor.cptr())
+}
+
+// ShowCursor toggles whether or not the cursor is shown.
+// (https://wiki.libsdl.org/SDL_ShowCursor)
+func ShowCursor(toggle int) (int, error) {
+	i := int(C.SDL_ShowCursor(C.int(toggle)))
+	return i, errorFromInt(i)
+}
+
+// CaptureMouse captures the mouse and tracks input outside an SDL window.
+// (https://wiki.libsdl.org/SDL_CaptureMouse)
+func CaptureMouse(toggle bool) error {
+	var ierr C.int
+	if toggle {
+		ierr = C.SDL_CaptureMouse(C.SDL_TRUE)
+	} else {
+		ierr = C.SDL_CaptureMouse(C.SDL_FALSE)
+	}
+	if ierr != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// Button is used as a mask when testing buttons in buttonstate.
+func Button(flag uint32) uint32 {
+	return 1 << (flag - 1)
+}
+
+// ButtonLMask is used as a mask when testing buttons in buttonstate.
+func ButtonLMask() uint32 {
+	return Button(BUTTON_LEFT)
+}
+
+// ButtonMMask is used as a mask when testing buttons in buttonstate.
+func ButtonMMask() uint32 {
+	return Button(BUTTON_MIDDLE)
+}
+
+// ButtonRMask is used as a mask when testing buttons in buttonstate.
+func ButtonRMask() uint32 {
+	return Button(BUTTON_RIGHT)
+}
+
+// ButtonX1Mask is used as a mask when testing buttons in buttonstate.
+func ButtonX1Mask() uint32 {
+	return Button(BUTTON_X1)
+}
+
+// ButtonX2Mask is used as a mask when testing buttons in buttonstate.
+func ButtonX2Mask() uint32 {
+	return Button(BUTTON_X2)
+}
+
+// WarpMouseGlobal moves the mouse to the given position in global screen space.
+// (https://wiki.libsdl.org/SDL_WarpMouseGlobal)
+func WarpMouseGlobal(x, y int32) error {
+	i := int(C.SDL_WarpMouseGlobal(C.int(x), C.int(y)))
+	return errorFromInt(i)
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/mutex.go

@@ -0,0 +1,203 @@
+package sdl
+
+// #include "sdl_wrapper.h"
+import "C"
+import "unsafe"
+
+// ThreadID is the thread identifier for a thread.
+type ThreadID uint64
+
+// Mutex is the SDL mutex structure.
+type Mutex struct {
+	Recursive int
+	Owner     ThreadID
+	Sem       *Sem
+}
+
+// Sem is the SDL semaphore structure.
+type Sem struct {
+	Count        uint32
+	WaitersCount uint32
+	CountLock    *Mutex
+	CountNonzero *Cond
+}
+
+// Cond is the SDL condition variable structure.
+type Cond struct {
+	Lock     *Mutex
+	Waiting  int
+	Signals  int
+	WaitSem  *Sem
+	WaitDone *Sem
+}
+
+func (m *Mutex) cptr() *C.SDL_mutex {
+	return (*C.SDL_mutex)(unsafe.Pointer(m))
+}
+
+func (s *Sem) cptr() *C.SDL_sem {
+	return (*C.SDL_sem)(unsafe.Pointer(s))
+}
+
+func (c *Cond) cptr() *C.SDL_cond {
+	return (*C.SDL_cond)(unsafe.Pointer(c))
+}
+
+// CreateMutex creates a new mutex.
+// (https://wiki.libsdl.org/SDL_CreateMutex)
+func CreateMutex() (*Mutex, error) {
+	mutex := C.SDL_CreateMutex()
+	if mutex == nil {
+		return nil, GetError()
+	}
+	return (*Mutex)(unsafe.Pointer(mutex)), nil
+}
+
+// Lock locks a mutex created with CreateMutex().
+// (https://wiki.libsdl.org/SDL_LockMutex)
+func (mutex *Mutex) Lock() error {
+	ret := int(C.SDL_LockMutex(mutex.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// TryLock tries to lock a mutex without blocking.
+// (https://wiki.libsdl.org/SDL_TryLockMutex)
+func (mutex *Mutex) TryLock() error {
+	ret := int(C.SDL_TryLockMutex(mutex.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// Unlock unlocks a mutex created with CreateMutex().
+// (https://wiki.libsdl.org/SDL_UnlockMutex)
+func (mutex *Mutex) Unlock() error {
+	ret := int(C.SDL_UnlockMutex(mutex.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// Destroy destroys a mutex created with CreateMutex().
+// (https://wiki.libsdl.org/SDL_DestroyMutex)
+func (mutex *Mutex) Destroy() {
+	C.SDL_DestroyMutex(mutex.cptr())
+}
+
+// CreateSemaphore creates a semaphore.
+// (https://wiki.libsdl.org/SDL_CreateSemaphore)
+func CreateSemaphore(initialValue uint32) (*Sem, error) {
+	sem := C.SDL_CreateSemaphore(C.Uint32(initialValue))
+	if sem == nil {
+		return nil, GetError()
+	}
+	return (*Sem)(unsafe.Pointer(sem)), nil
+}
+
+// Destroy destroys a semaphore.
+// (https://wiki.libsdl.org/SDL_DestroySemaphore)
+func (sem *Sem) Destroy() {
+	C.SDL_DestroySemaphore(sem.cptr())
+}
+
+// Wait waits until a semaphore has a positive value and then decrements it.
+// (https://wiki.libsdl.org/SDL_SemWait)
+func (sem *Sem) Wait() error {
+	ret := int(C.SDL_SemWait(sem.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// TryWait sees if a semaphore has a positive value and decrement it if it does.
+// (https://wiki.libsdl.org/SDL_SemTryWait)
+func (sem *Sem) TryWait() error {
+	ret := int(C.SDL_SemTryWait(sem.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// WaitTimeout waits until a semaphore has a positive value and then decrements it.
+// (https://wiki.libsdl.org/SDL_SemWaitTimeout)
+func (sem *Sem) WaitTimeout(ms uint32) error {
+	ret := int(C.SDL_SemWaitTimeout(sem.cptr(), C.Uint32(ms)))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// Post atomically increments a semaphore's value and wake waiting threads.
+// (https://wiki.libsdl.org/SDL_SemPost)
+func (sem *Sem) Post() error {
+	ret := int(C.SDL_SemPost(sem.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// Value returns the current value of a semaphore.
+// (https://wiki.libsdl.org/SDL_SemValue)
+func (sem *Sem) Value() uint32 {
+	return uint32(C.SDL_SemValue(sem.cptr()))
+}
+
+// CreateCond (https://wiki.libsdl.org/SDL_CreateCond)
+func CreateCond() *Cond {
+	return (*Cond)(unsafe.Pointer(C.SDL_CreateCond()))
+}
+
+// Destroy creates a condition variable.
+// (https://wiki.libsdl.org/SDL_DestroyCond)
+func (cond *Cond) Destroy() {
+	C.SDL_DestroyCond(cond.cptr())
+}
+
+// Signal restarts one of the threads that are waiting on the condition variable.
+// (https://wiki.libsdl.org/SDL_CondSignal)
+func (cond *Cond) Signal() error {
+	ret := int(C.SDL_CondSignal(cond.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// Broadcast restarts all threads that are waiting on the condition variable.
+// (https://wiki.libsdl.org/SDL_CondBroadcast)
+func (cond *Cond) Broadcast() error {
+	ret := int(C.SDL_CondBroadcast(cond.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// Wait waits until a condition variable is signaled.
+// (https://wiki.libsdl.org/SDL_CondWait)
+func (cond *Cond) Wait(mutex *Mutex) error {
+	ret := int(C.SDL_CondWait(cond.cptr(), mutex.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// WaitTimeout waits until a condition variable is signaled or a specified amount of time has passed.
+// (https://wiki.libsdl.org/SDL_CondWaitTimeout)
+func (cond *Cond) WaitTimeout(mutex *Mutex, ms uint32) error {
+	ret := int(C.SDL_CondWaitTimeout(cond.cptr(), mutex.cptr(), C.Uint32(ms)))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/pixels.go

@@ -0,0 +1,948 @@
+package sdl
+
+// #include "sdl_wrapper.h"
+//
+// #if !(SDL_VERSION_ATLEAST(2,0,5))
+//
+// enum
+// {
+// #if SDL_BYTEORDER == SDL_BIG_ENDIAN
+//     SDL_PIXELFORMAT_RGBA32 = SDL_PIXELFORMAT_RGBA8888,
+//     SDL_PIXELFORMAT_ARGB32 = SDL_PIXELFORMAT_ARGB8888,
+//     SDL_PIXELFORMAT_BGRA32 = SDL_PIXELFORMAT_BGRA8888,
+//     SDL_PIXELFORMAT_ABGR32 = SDL_PIXELFORMAT_ABGR8888
+// #else
+//     SDL_PIXELFORMAT_RGBA32 = SDL_PIXELFORMAT_ABGR8888,
+//     SDL_PIXELFORMAT_ARGB32 = SDL_PIXELFORMAT_BGRA8888,
+//     SDL_PIXELFORMAT_BGRA32 = SDL_PIXELFORMAT_ARGB8888,
+//     SDL_PIXELFORMAT_ABGR32 = SDL_PIXELFORMAT_RGBA8888
+// #endif
+// };
+//
+// #endif
+//
+// int bytesPerPixel(Uint32 format) {
+//   return SDL_BYTESPERPIXEL(format);
+// }
+//
+// int bitsPerPixel(Uint32 format) {
+//   return SDL_BITSPERPIXEL(format);
+// }
+import "C"
+import (
+	"image/color"
+	"unsafe"
+)
+
+// PixelFormat contains pixel format information.
+// (https://wiki.libsdl.org/SDL_PixelFormat)
+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
+	_             [2]uint8     // padding
+	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
+	rLoss         uint8        // (internal use)
+	gLoss         uint8        // (internal use)
+	bLoss         uint8        // (internal use)
+	aLoss         uint8        // (internal use)
+	rShift        uint8        // (internal use)
+	gShift        uint8        // (internal use)
+	bShift        uint8        // (internal use)
+	aShift        uint8        // (internal use)
+	refCount      int32        // (internal use)
+	next          *PixelFormat // (internal use)
+}
+type cPixelFormat C.SDL_PixelFormat
+
+// Palette contains palette information.
+// (https://wiki.libsdl.org/SDL_Palette)
+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)
+	version  uint32 // incrementally tracks changes to the palette (internal use)
+	refCount int32  // reference count (internal use)
+}
+type cPalette C.SDL_Palette
+
+// Color represents a color. This implements image/color.Color interface.
+// (https://wiki.libsdl.org/SDL_Color)
+type Color color.NRGBA
+
+// Uint32 return uint32 representation of RGBA color.
+func (c Color) Uint32() uint32 {
+	var v uint32
+	v |= uint32(c.R) << 24
+	v |= uint32(c.G) << 16
+	v |= uint32(c.B) << 8
+	v |= uint32(c.A)
+	return v
+}
+
+// Pixel types.
+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
+)
+
+// Bitmap pixel order high bit -> low bit.
+const (
+	BITMAPORDER_NONE = C.SDL_BITMAPORDER_NONE
+	BITMAPORDER_4321 = C.SDL_BITMAPORDER_4321
+	BITMAPORDER_1234 = C.SDL_BITMAPORDER_1234
+)
+
+// Packed component 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
+)
+
+// Array component order low byte -> high byte.
+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
+)
+
+// Packed component layout.
+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
+)
+
+// Pixel format values.
+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 variables.
+var (
+	PIXELFORMAT_RGBA32 = C.SDL_PIXELFORMAT_RGBA32
+	PIXELFORMAT_ARGB32 = C.SDL_PIXELFORMAT_ARGB32
+	PIXELFORMAT_BGRA32 = C.SDL_PIXELFORMAT_BGRA32
+	PIXELFORMAT_ABGR32 = C.SDL_PIXELFORMAT_ABGR32
+)
+
+// These define alpha as the opacity of a surface.
+const (
+	ALPHA_OPAQUE      = C.SDL_ALPHA_OPAQUE
+	ALPHA_TRANSPARENT = C.SDL_ALPHA_TRANSPARENT
+)
+
+func (format *PixelFormat) cptr() *C.SDL_PixelFormat {
+	return (*C.SDL_PixelFormat)(unsafe.Pointer(format))
+}
+
+func (palette *Palette) cptr() *C.SDL_Palette {
+	return (*C.SDL_Palette)(unsafe.Pointer(palette))
+}
+
+/*
+ * the following code is modified version of the code from bitbucket.org/dooots/go-sdl2
+ */
+
+// GetPixelFormatName returns the human readable name of a pixel format.
+// (https://wiki.libsdl.org/SDL_GetPixelFormatName)
+func GetPixelFormatName(format uint) string {
+	return C.GoString(C.SDL_GetPixelFormatName(C.Uint32(format)))
+}
+
+// PixelFormatEnumToMasks converts one of the enumerated pixel formats to a bpp value and RGBA masks.
+// (https://wiki.libsdl.org/SDL_PixelFormatEnumToMasks)
+func PixelFormatEnumToMasks(format uint) (bpp int, rmask, gmask, bmask, amask uint32, err error) {
+	result := C.SDL_PixelFormatEnumToMasks(C.Uint32(format), (*C.int)(unsafe.Pointer(&bpp)),
+		(*C.Uint32)(&rmask), (*C.Uint32)(&gmask), (*C.Uint32)(&bmask),
+		(*C.Uint32)(&amask))
+	if result == C.SDL_FALSE {
+		err = GetError()
+	}
+	return
+}
+
+// MasksToPixelFormatEnum converts a bpp value and RGBA masks to an enumerated pixel format.
+// (https://wiki.libsdl.org/SDL_MasksToPixelFormatEnum)
+func MasksToPixelFormatEnum(bpp int, rmask, gmask, bmask, amask uint32) uint {
+	return uint(C.SDL_MasksToPixelFormatEnum(C.int(bpp), C.Uint32(rmask), C.Uint32(gmask),
+		C.Uint32(bmask), C.Uint32(amask)))
+}
+
+// AllocFormat creates a PixelFormat structure corresponding to a pixel format.
+// (https://wiki.libsdl.org/SDL_AllocFormat)
+func AllocFormat(format uint) (*PixelFormat, error) {
+	r := (*PixelFormat)(unsafe.Pointer(C.SDL_AllocFormat(C.Uint32(format))))
+	if r == nil {
+		return nil, GetError()
+	}
+	return r, nil
+}
+
+// Free frees the PixelFormat structure allocated by AllocFormat().
+// (https://wiki.libsdl.org/SDL_FreeFormat)
+func (format *PixelFormat) Free() {
+	C.SDL_FreeFormat((*C.SDL_PixelFormat)(unsafe.Pointer(format)))
+}
+
+// AllocPalette creates a palette structure with the specified number of color entries.
+// (https://wiki.libsdl.org/SDL_AllocPalette)
+func AllocPalette(ncolors int) (*Palette, error) {
+	r := (*Palette)(unsafe.Pointer(C.SDL_AllocPalette(C.int(ncolors))))
+	if r == nil {
+		return nil, GetError()
+	}
+	return r, nil
+}
+
+// SetPalette sets the palette for the pixel format structure.
+// (https://wiki.libsdl.org/SDL_SetPixelFormatPalette)
+func (format *PixelFormat) SetPalette(palette *Palette) error {
+	r := C.SDL_SetPixelFormatPalette((*C.SDL_PixelFormat)(unsafe.Pointer(format)),
+		(*C.SDL_Palette)(unsafe.Pointer(palette)))
+	if r != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// SetColors sets a range of colors in the palette.
+// (https://wiki.libsdl.org/SDL_SetPaletteColors)
+func (palette *Palette) SetColors(colors []Color) error {
+	if colors == nil {
+		return nil
+	}
+	var ptr *C.SDL_Color
+	if len(colors) > 0 {
+		ptr = (*C.SDL_Color)(unsafe.Pointer(&colors[0]))
+	}
+
+	r := C.SDL_SetPaletteColors((*C.SDL_Palette)(unsafe.Pointer(palette)),
+		ptr, 0, C.int(len(colors)))
+	if r != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// Free frees the palette created with AllocPalette().
+// (https://wiki.libsdl.org/SDL_FreePalette)
+func (palette *Palette) Free() {
+	C.SDL_FreePalette((*C.SDL_Palette)(unsafe.Pointer(palette)))
+}
+
+// MapRGB maps an RGB triple to an opaque pixel value for a given pixel format.
+// (https://wiki.libsdl.org/SDL_MapRGB)
+func MapRGB(format *PixelFormat, r, g, b uint8) uint32 {
+	return uint32(C.SDL_MapRGB((*C.SDL_PixelFormat)(unsafe.Pointer(format)),
+		C.Uint8(r), C.Uint8(g), C.Uint8(b)))
+}
+
+// MapRGBA maps an RGBA quadruple to a pixel value for a given pixel format.
+// (https://wiki.libsdl.org/SDL_MapRGBA)
+func MapRGBA(format *PixelFormat, r, g, b, a uint8) uint32 {
+	return uint32(C.SDL_MapRGBA((*C.SDL_PixelFormat)(unsafe.Pointer(format)),
+		C.Uint8(r), C.Uint8(g), C.Uint8(b), C.Uint8(a)))
+}
+
+// GetRGB returns RGB values from a pixel in the specified format.
+// (https://wiki.libsdl.org/SDL_GetRGB)
+func GetRGB(pixel uint32, format *PixelFormat) (r, g, b uint8) {
+	C.SDL_GetRGB(C.Uint32(pixel), (*C.SDL_PixelFormat)(unsafe.Pointer(format)),
+		(*C.Uint8)(&r), (*C.Uint8)(&g), (*C.Uint8)(&b))
+	return
+}
+
+// GetRGBA returns RGBA values from a pixel in the specified format.
+// (https://wiki.libsdl.org/SDL_GetRGBA)
+func GetRGBA(pixel uint32, format *PixelFormat) (r, g, b, a uint8) {
+	C.SDL_GetRGBA(C.Uint32(pixel), (*C.SDL_PixelFormat)(unsafe.Pointer(format)),
+		(*C.Uint8)(&r), (*C.Uint8)(&g), (*C.Uint8)(&b), (*C.Uint8)(&a))
+	return
+}
+
+// CalculateGammaRamp calculates a 256 entry gamma ramp for a gamma value.
+// (https://wiki.libsdl.org/SDL_CalculateGammaRamp)
+func CalculateGammaRamp(gamma float32, ramp *[256]uint16) {
+	C.SDL_CalculateGammaRamp(C.float(gamma), (*C.Uint16)(unsafe.Pointer(&ramp[0])))
+}
+
+// BytesPerPixel returns the number of bytes per pixel for the given format
+func BytesPerPixel(format uint32) int {
+	return int(C.bytesPerPixel(C.Uint32(format)))
+}
+
+// BitsPerPixel returns the number of bits per pixel for the given format
+func BitsPerPixel(format uint32) int {
+	return int(C.bitsPerPixel(C.Uint32(format)))
+}
+
+var (
+	RGB444Model   color.Model = color.ModelFunc(rgb444Model)
+	RGB332Model   color.Model = color.ModelFunc(rgb332Model)
+	RGB565Model   color.Model = color.ModelFunc(rgb565Model)
+	RGB555Model   color.Model = color.ModelFunc(rgb555Model)
+	BGR565Model   color.Model = color.ModelFunc(bgr565Model)
+	BGR555Model   color.Model = color.ModelFunc(bgr555Model)
+	ARGB4444Model color.Model = color.ModelFunc(argb4444Model)
+	ABGR4444Model color.Model = color.ModelFunc(abgr4444Model)
+	RGBA4444Model color.Model = color.ModelFunc(rgba4444Model)
+	BGRA4444Model color.Model = color.ModelFunc(bgra4444Model)
+	ARGB1555Model color.Model = color.ModelFunc(argb1555Model)
+	RGBA5551Model color.Model = color.ModelFunc(rgba5551Model)
+	ABGR1555Model color.Model = color.ModelFunc(abgr1555Model)
+	BGRA5551Model color.Model = color.ModelFunc(bgra5551Model)
+	RGBA8888Model color.Model = color.ModelFunc(rgba8888Model)
+	BGRA8888Model color.Model = color.ModelFunc(bgra8888Model)
+)
+
+type RGB444 struct {
+	R, G, B byte
+}
+
+func (c RGB444) RGBA() (r, g, b, a uint32) {
+	nrgba := color.NRGBA{
+		R: upscale4to8bit(c.R),
+		G: upscale4to8bit(c.G),
+		B: upscale4to8bit(c.B),
+		A: 0xFF,
+	}
+	return nrgba.RGBA()
+}
+
+func rgb444Model(c color.Color) color.Color {
+	if _, ok := c.(RGB444); ok {
+		return c
+	}
+	nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
+	return RGB444{
+		R: downscale8to4bit(nrgba.R),
+		G: downscale8to4bit(nrgba.G),
+		B: downscale8to4bit(nrgba.B),
+	}
+}
+
+type RGB332 struct {
+	R, G, B byte
+}
+
+func (c RGB332) RGBA() (r, g, b, a uint32) {
+	nrgba := color.NRGBA{
+		R: upscale3to8bit(c.R),
+		G: upscale3to8bit(c.G),
+		B: upscale2to8bit(c.B),
+		A: 0xFF,
+	}
+	return nrgba.RGBA()
+}
+
+func rgb332Model(c color.Color) color.Color {
+	if _, ok := c.(RGB332); ok {
+		return c
+	}
+	nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
+	return RGB332{
+		R: downscale8to3bit(nrgba.R),
+		G: downscale8to3bit(nrgba.G),
+		B: downscale8to2bit(nrgba.B),
+	}
+}
+
+type RGB565 struct {
+	R, G, B byte
+}
+
+func (c RGB565) RGBA() (r, g, b, a uint32) {
+	nrgba := color.NRGBA{
+		R: upscale5to8bit(c.R),
+		G: upscale6to8bit(c.G),
+		B: upscale5to8bit(c.B),
+		A: 0xFF,
+	}
+	return nrgba.RGBA()
+}
+
+func rgb565Model(c color.Color) color.Color {
+	if _, ok := c.(RGB565); ok {
+		return c
+	}
+	nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
+	return RGB565{
+		R: downscale8to5bit(nrgba.R),
+		G: downscale8to6bit(nrgba.G),
+		B: downscale8to5bit(nrgba.B),
+	}
+}
+
+type RGB555 struct {
+	R, G, B byte
+}
+
+func (c RGB555) RGBA() (r, g, b, a uint32) {
+	nrgba := color.NRGBA{
+		R: upscale5to8bit(c.R),
+		G: upscale5to8bit(c.G),
+		B: upscale5to8bit(c.B),
+		A: 0xFF,
+	}
+	return nrgba.RGBA()
+}
+
+func rgb555Model(c color.Color) color.Color {
+	if _, ok := c.(RGB555); ok {
+		return c
+	}
+	nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
+	return RGB555{
+		R: downscale8to5bit(nrgba.R),
+		G: downscale8to5bit(nrgba.G),
+		B: downscale8to5bit(nrgba.B),
+	}
+}
+
+type BGR565 struct {
+	B, G, R byte
+}
+
+func (c BGR565) RGBA() (r, g, b, a uint32) {
+	nrgba := color.NRGBA{
+		R: upscale5to8bit(c.R),
+		G: upscale6to8bit(c.G),
+		B: upscale5to8bit(c.B),
+		A: 0xFF,
+	}
+	return nrgba.RGBA()
+}
+
+func bgr565Model(c color.Color) color.Color {
+	if _, ok := c.(BGR565); ok {
+		return c
+	}
+	nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
+	return BGR565{
+		B: downscale8to5bit(nrgba.B),
+		G: downscale8to6bit(nrgba.G),
+		R: downscale8to5bit(nrgba.R),
+	}
+}
+
+type BGR555 struct {
+	B, G, R byte
+}
+
+func (c BGR555) RGBA() (r, g, b, a uint32) {
+	nrgba := color.NRGBA{
+		R: upscale5to8bit(c.R),
+		G: upscale5to8bit(c.G),
+		B: upscale5to8bit(c.B),
+		A: 0xFF,
+	}
+	return nrgba.RGBA()
+}
+
+func bgr555Model(c color.Color) color.Color {
+	if _, ok := c.(BGR555); ok {
+		return c
+	}
+	nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
+	return BGR555{
+		B: downscale8to5bit(nrgba.B),
+		G: downscale8to5bit(nrgba.G),
+		R: downscale8to5bit(nrgba.R),
+	}
+}
+
+type RGB888 struct {
+	R, G, B byte
+}
+
+func (c RGB888) RGBA() (r, g, b, a uint32) {
+	nrgba := color.NRGBA{
+		R: c.R,
+		G: c.G,
+		B: c.B,
+		A: 0xFF,
+	}
+	return nrgba.RGBA()
+}
+
+func rgb888Model(c color.Color) color.Color {
+	if _, ok := c.(RGB888); ok {
+		return c
+	}
+	nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
+	return RGB888{
+		R: nrgba.R,
+		G: nrgba.G,
+		B: nrgba.B,
+	}
+}
+
+type BGR888 struct {
+	B, G, R byte
+}
+
+func (c BGR888) RGBA() (r, g, b, a uint32) {
+	nrgba := color.NRGBA{
+		R: c.R,
+		G: c.G,
+		B: c.B,
+		A: 0xFF,
+	}
+	return nrgba.RGBA()
+}
+
+func bgr888Model(c color.Color) color.Color {
+	if _, ok := c.(BGR888); ok {
+		return c
+	}
+	nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
+	return BGR888{
+		B: nrgba.B,
+		G: nrgba.G,
+		R: nrgba.R,
+	}
+}
+
+type ARGB4444 struct {
+	A, R, G, B byte
+}
+
+func (c ARGB4444) RGBA() (r, g, b, a uint32) {
+	nrgba := color.NRGBA{
+		R: upscale4to8bit(c.R),
+		G: upscale4to8bit(c.G),
+		B: upscale4to8bit(c.B),
+		A: upscale4to8bit(c.A),
+	}
+	return nrgba.RGBA()
+}
+
+func argb4444Model(c color.Color) color.Color {
+	if _, ok := c.(ARGB4444); ok {
+		return c
+	}
+	nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
+	return ARGB4444{
+		A: downscale8to4bit(nrgba.A),
+		R: downscale8to4bit(nrgba.R),
+		G: downscale8to4bit(nrgba.G),
+		B: downscale8to4bit(nrgba.B),
+	}
+}
+
+type ABGR4444 struct {
+	A, B, G, R byte
+}
+
+func (c ABGR4444) RGBA() (r, g, b, a uint32) {
+	nrgba := color.NRGBA{
+		R: upscale4to8bit(c.R),
+		G: upscale4to8bit(c.G),
+		B: upscale4to8bit(c.B),
+		A: upscale4to8bit(c.A),
+	}
+	return nrgba.RGBA()
+}
+
+func abgr4444Model(c color.Color) color.Color {
+	if _, ok := c.(ABGR4444); ok {
+		return c
+	}
+	nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
+	return ABGR4444{
+		A: downscale8to4bit(nrgba.A),
+		B: downscale8to4bit(nrgba.B),
+		G: downscale8to4bit(nrgba.G),
+		R: downscale8to4bit(nrgba.R),
+	}
+}
+
+type RGBA4444 struct {
+	R, G, B, A byte
+}
+
+func (c RGBA4444) RGBA() (r, g, b, a uint32) {
+	nrgba := color.NRGBA{
+		R: upscale4to8bit(c.R),
+		G: upscale4to8bit(c.G),
+		B: upscale4to8bit(c.B),
+		A: upscale4to8bit(c.A),
+	}
+	return nrgba.RGBA()
+}
+
+func rgba4444Model(c color.Color) color.Color {
+	if _, ok := c.(RGBA4444); ok {
+		return c
+	}
+	nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
+	return RGBA4444{
+		R: downscale8to4bit(nrgba.R),
+		G: downscale8to4bit(nrgba.G),
+		B: downscale8to4bit(nrgba.B),
+		A: downscale8to4bit(nrgba.A),
+	}
+}
+
+type BGRA4444 struct {
+	B, G, R, A byte
+}
+
+func (c BGRA4444) RGBA() (r, g, b, a uint32) {
+	nrgba := color.NRGBA{
+		R: upscale4to8bit(c.R),
+		G: upscale4to8bit(c.G),
+		B: upscale4to8bit(c.B),
+		A: upscale4to8bit(c.A),
+	}
+	return nrgba.RGBA()
+}
+
+func bgra4444Model(c color.Color) color.Color {
+	if _, ok := c.(BGRA4444); ok {
+		return c
+	}
+	nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
+	return BGRA4444{
+		B: downscale8to4bit(nrgba.B),
+		G: downscale8to4bit(nrgba.G),
+		R: downscale8to4bit(nrgba.R),
+		A: downscale8to4bit(nrgba.A),
+	}
+}
+
+type ARGB1555 struct {
+	A, R, G, B byte
+}
+
+func (c ARGB1555) RGBA() (r, g, b, a uint32) {
+	nrgba := color.NRGBA{
+		R: upscale5to8bit(c.R),
+		G: upscale5to8bit(c.G),
+		B: upscale5to8bit(c.B),
+		A: upscale1to8bit(c.A),
+	}
+	return nrgba.RGBA()
+}
+
+func argb1555Model(c color.Color) color.Color {
+	if _, ok := c.(ARGB1555); ok {
+		return c
+	}
+	nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
+	return ARGB1555{
+		A: downscale8to1bit(nrgba.A),
+		R: downscale8to5bit(nrgba.R),
+		G: downscale8to5bit(nrgba.G),
+		B: downscale8to5bit(nrgba.B),
+	}
+}
+
+type RGBA5551 struct {
+	R, G, B, A byte
+}
+
+func (c RGBA5551) RGBA() (r, g, b, a uint32) {
+	nrgba := color.NRGBA{
+		R: upscale5to8bit(c.R),
+		G: upscale5to8bit(c.G),
+		B: upscale5to8bit(c.B),
+		A: upscale1to8bit(c.A),
+	}
+	return nrgba.RGBA()
+}
+
+func rgba5551Model(c color.Color) color.Color {
+	if _, ok := c.(RGBA5551); ok {
+		return c
+	}
+	nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
+	return RGBA5551{
+		R: downscale8to5bit(nrgba.R),
+		G: downscale8to5bit(nrgba.G),
+		B: downscale8to5bit(nrgba.B),
+		A: downscale8to1bit(nrgba.A),
+	}
+}
+
+type ABGR1555 struct {
+	A, R, G, B byte
+}
+
+func (c ABGR1555) RGBA() (r, g, b, a uint32) {
+	nrgba := color.NRGBA{
+		R: upscale5to8bit(c.R),
+		G: upscale5to8bit(c.G),
+		B: upscale5to8bit(c.B),
+		A: upscale1to8bit(c.A),
+	}
+	return nrgba.RGBA()
+}
+
+func abgr1555Model(c color.Color) color.Color {
+	if _, ok := c.(ABGR1555); ok {
+		return c
+	}
+	nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
+	return ABGR1555{
+		A: downscale8to1bit(nrgba.A),
+		R: downscale8to5bit(nrgba.R),
+		G: downscale8to5bit(nrgba.G),
+		B: downscale8to5bit(nrgba.B),
+	}
+}
+
+type BGRA5551 struct {
+	B, G, R, A byte
+}
+
+func (c BGRA5551) RGBA() (r, g, b, a uint32) {
+	nrgba := color.NRGBA{
+		R: upscale5to8bit(c.R),
+		G: upscale5to8bit(c.G),
+		B: upscale5to8bit(c.B),
+		A: upscale1to8bit(c.A),
+	}
+	return nrgba.RGBA()
+}
+
+func bgra5551Model(c color.Color) color.Color {
+	if _, ok := c.(BGRA5551); ok {
+		return c
+	}
+	nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
+	return BGRA5551{
+		B: downscale8to5bit(nrgba.B),
+		G: downscale8to5bit(nrgba.G),
+		R: downscale8to5bit(nrgba.R),
+		A: downscale8to1bit(nrgba.A),
+	}
+}
+
+type RGBA8888 struct {
+	R, G, B, A byte
+}
+
+func (c RGBA8888) RGBA() (r, g, b, a uint32) {
+	nrgba := color.NRGBA{
+		R: c.R,
+		G: c.G,
+		B: c.B,
+		A: c.A,
+	}
+	return nrgba.RGBA()
+}
+
+func rgba8888Model(c color.Color) color.Color {
+	if _, ok := c.(RGBA8888); ok {
+		return c
+	}
+	nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
+	return RGBA8888{
+		R: nrgba.R,
+		G: nrgba.G,
+		B: nrgba.B,
+		A: nrgba.A,
+	}
+}
+
+type BGRA8888 struct {
+	B, G, R, A byte
+}
+
+func (c BGRA8888) RGBA() (r, g, b, a uint32) {
+	nrgba := color.NRGBA{
+		R: c.R,
+		G: c.G,
+		B: c.B,
+		A: c.A,
+	}
+	return nrgba.RGBA()
+}
+
+func bgra8888Model(c color.Color) color.Color {
+	if _, ok := c.(BGRA8888); ok {
+		return c
+	}
+	nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
+	return BGRA8888{
+		B: nrgba.B,
+		G: nrgba.G,
+		R: nrgba.R,
+		A: nrgba.A,
+	}
+}
+
+type ARGB8888 struct {
+	A, R, G, B byte
+}
+
+func (c ARGB8888) RGBA() (r, g, b, a uint32) {
+	nrgba := color.NRGBA{
+		R: c.R,
+		G: c.G,
+		B: c.B,
+		A: c.A,
+	}
+	return nrgba.RGBA()
+}
+
+func argb8888Model(c color.Color) color.Color {
+	if _, ok := c.(ARGB8888); ok {
+		return c
+	}
+	nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
+	return ARGB8888{
+		A: nrgba.A,
+		R: nrgba.R,
+		G: nrgba.G,
+		B: nrgba.B,
+	}
+}
+
+type ABGR8888 struct {
+	A, B, G, R byte
+}
+
+func (c ABGR8888) RGBA() (r, g, b, a uint32) {
+	nrgba := color.NRGBA{
+		R: c.R,
+		G: c.G,
+		B: c.B,
+		A: c.A,
+	}
+	return nrgba.RGBA()
+}
+
+func abgr8888Model(c color.Color) color.Color {
+	if _, ok := c.(ABGR8888); ok {
+		return c
+	}
+	nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
+	return ABGR8888{
+		A: nrgba.A,
+		B: nrgba.B,
+		G: nrgba.G,
+		R: nrgba.R,
+	}
+}
+
+func downscale8to1bit(alpha byte) byte {
+	if alpha == 0 {
+		return 0
+	}
+	return 1
+}
+
+func downscale8to2bit(in byte) byte {
+	return in >> 6
+}
+
+func downscale8to3bit(in byte) byte {
+	return in >> 5
+}
+
+func downscale8to4bit(in byte) byte {
+	return in >> 4
+}
+
+func downscale8to5bit(in byte) byte {
+	return in >> 3
+}
+
+func downscale8to6bit(in byte) byte {
+	return in >> 2
+}
+
+func upscale1to8bit(alphaBit byte) byte {
+	if alphaBit == 0 {
+		return 0
+	}
+	return 0xFF
+}
+
+func upscale2to8bit(in byte) byte {
+	return in<<6 | in<<4 | in<<2 | in
+}
+
+func upscale3to8bit(in byte) byte {
+	return in<<5 | in<<2 | (in>>1)&0b11
+}
+
+func upscale4to8bit(in byte) byte {
+	return in<<4 | in
+}
+
+func upscale5to8bit(in byte) byte {
+	return in<<3 | (in>>2)&0b111
+}
+
+func upscale6to8bit(in byte) byte {
+	return in<<2 | (in>>4)&0b11
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/power.go

@@ -0,0 +1,27 @@
+package sdl
+
+// #include "sdl_wrapper.h"
+import "C"
+
+// An enumeration of the basic state of the system's power supply.
+// (https://wiki.libsdl.org/SDL_PowerState)
+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
+)
+
+// PowerState is the basic state for the system's power supply.
+// (https://wiki.libsdl.org/SDL_PowerState)
+type PowerState C.SDL_PowerState
+
+// GetPowerInfo returns the current power supply details.
+// (https://wiki.libsdl.org/SDL_GetPowerInfo)
+func GetPowerInfo() (int, int, int) {
+	_secs := C.int(0)
+	_percent := C.int(0)
+	_state := C.SDL_GetPowerInfo(&_secs, &_percent)
+	return (int)(_state), (int)(_secs), (int)(_percent)
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/rect.go

@@ -0,0 +1,780 @@
+package sdl
+
+// #include "sdl_wrapper.h"
+import "C"
+import (
+	"math"
+	"unsafe"
+)
+
+// Point defines a two dimensional point.
+// (https://wiki.libsdl.org/SDL_Point)
+type Point struct {
+	X int32 // the x coordinate of the point
+	Y int32 // the y coordinate of the point
+}
+
+// Rect contains the definition of a rectangle, with the origin at the upper left.
+// (https://wiki.libsdl.org/SDL_Rect)
+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
+}
+
+// FPoint defines a two dimensional point.
+// TODO: (https://wiki.libsdl.org/SDL_FPoint)
+type FPoint struct {
+	X float32 // the x coordinate of the point
+	Y float32 // the y coordinate of the point
+}
+
+// FRect contains the definition of a rectangle, with the origin at the upper left.
+// TODO: (https://wiki.libsdl.org/SDL_FRect)
+type FRect struct {
+	X float32 // the x location of the rectangle's upper left corner
+	Y float32 // the y location of the rectangle's upper left corner
+	W float32 // the width of the rectangle
+	H float32 // the height of the rectangle
+}
+
+func (p *Point) cptr() *C.SDL_Point {
+	return (*C.SDL_Point)(unsafe.Pointer(p))
+}
+
+func (a *Rect) cptr() *C.SDL_Rect {
+	return (*C.SDL_Rect)(unsafe.Pointer(a))
+}
+
+func (p *FPoint) cptr() *C.SDL_FPoint {
+	return (*C.SDL_FPoint)(unsafe.Pointer(p))
+}
+
+func (a *FRect) cptr() *C.SDL_FRect {
+	return (*C.SDL_FRect)(unsafe.Pointer(a))
+}
+
+// InRect reports whether the point resides inside a rectangle.
+// (https://wiki.libsdl.org/SDL_PointInRect)
+func (p *Point) InRect(r *Rect) bool {
+	if (p.X >= r.X) && (p.X < (r.X + r.W)) &&
+		(p.Y >= r.Y) && (p.Y < (r.Y + r.H)) {
+		return true
+	}
+	return false
+}
+
+// InRect reports whether the point resides inside a rectangle.
+// (https://wiki.libsdl.org/SDL_PointInRect)
+func (p *FPoint) InRect(r *FRect) bool {
+	if (p.X >= r.X) && (p.X < (r.X + r.W)) &&
+		(p.Y >= r.Y) && (p.Y < (r.Y + r.H)) {
+		return true
+	}
+	return false
+}
+
+// Empty reports whether a rectangle has no area.
+// (https://wiki.libsdl.org/SDL_RectEmpty)
+func (a *Rect) Empty() bool {
+	return a == nil || a.W <= 0 || a.H <= 0
+}
+
+// Equals reports whether two rectangles are equal.
+// (https://wiki.libsdl.org/SDL_RectEquals)
+func (a *Rect) Equals(b *Rect) bool {
+	if (a != nil) && (b != nil) &&
+		(a.X == b.X) && (a.Y == b.Y) &&
+		(a.W == b.W) && (a.H == b.H) {
+		return true
+	}
+	return false
+}
+
+// HasIntersection reports whether two rectangles intersect.
+// (https://wiki.libsdl.org/SDL_HasIntersection)
+func (a *Rect) HasIntersection(b *Rect) bool {
+	if a == nil || b == nil {
+		return false
+	}
+
+	// Special case for empty rects
+	if a.Empty() || b.Empty() {
+		return false
+	}
+
+	if a.X >= b.X+b.W || a.X+a.W <= b.X || a.Y >= b.Y+b.H || a.Y+a.H <= b.Y {
+		return false
+	}
+
+	return true
+}
+
+// Intersect calculates the intersection of two rectangles.
+// (https://wiki.libsdl.org/SDL_IntersectRect)
+func (a *Rect) Intersect(b *Rect) (Rect, bool) {
+	var result Rect
+
+	if a == nil || b == nil {
+		return result, false
+	}
+
+	// Special case for empty rects
+	if a.Empty() || b.Empty() {
+		result.W = 0
+		result.H = 0
+		return result, false
+	}
+
+	aMin := a.X
+	aMax := aMin + a.W
+	bMin := b.X
+	bMax := bMin + b.W
+	if bMin > aMin {
+		aMin = bMin
+	}
+	result.X = aMin
+	if bMax < aMax {
+		aMax = bMax
+	}
+	result.W = aMax - aMin
+
+	aMin = a.Y
+	aMax = aMin + a.H
+	bMin = b.Y
+	bMax = bMin + b.H
+	if bMin > aMin {
+		aMin = bMin
+	}
+	result.Y = aMin
+	if bMax < aMax {
+		aMax = bMax
+	}
+	result.H = aMax - aMin
+
+	return result, !result.Empty()
+}
+
+// Union calculates the union of two rectangles.
+// (https://wiki.libsdl.org/SDL_UnionRect)
+func (a *Rect) Union(b *Rect) Rect {
+	var result Rect
+
+	if a == nil || b == nil {
+		return result
+	}
+
+	// Special case for empty rects
+	if a.Empty() {
+		return *b
+	} else if b.Empty() {
+		return *a
+	} else if a.Empty() && b.Empty() {
+		return result
+	}
+
+	aMin := a.X
+	aMax := aMin + a.W
+	bMin := b.X
+	bMax := bMin + b.W
+	if bMin < aMin {
+		aMin = bMin
+	}
+	result.X = aMin
+	if bMax > aMax {
+		aMax = bMax
+	}
+	result.W = aMax - aMin
+
+	aMin = a.Y
+	aMax = aMin + a.H
+	bMin = b.Y
+	bMax = bMin + b.H
+	if bMin < aMin {
+		aMin = bMin
+	}
+	result.Y = aMin
+	if bMax > aMax {
+		aMax = bMax
+	}
+	result.H = aMax - aMin
+
+	return result
+}
+
+// Empty reports whether a rectangle has no area.
+// (https://wiki.libsdl.org/SDL_RectEmpty)
+func (a *FRect) Empty() bool {
+	return a == nil || a.W <= 0 || a.H <= 0
+}
+
+// Equals reports whether two rectangles are equal.
+// (https://wiki.libsdl.org/SDL_RectEquals)
+func (a *FRect) Equals(b *FRect) bool {
+	if (a != nil) && (b != nil) &&
+		(a.X == b.X) && (a.Y == b.Y) &&
+		(a.W == b.W) && (a.H == b.H) {
+		return true
+	}
+	return false
+}
+
+// EqualsEpsilon returns true if the two rectangles are equal, within some given epsilon.
+// (https://wiki.libsdl.org/SDL_FRectEqualsEpsilon)
+func (a *FRect) EqualsEpsilon(b *FRect, epsilon float32) bool {
+	if (a != nil) && (b != nil) && (a == b ||
+		(float32(math.Abs(float64(a.X-b.X))) <= epsilon) &&
+			(float32(math.Abs(float64(a.Y-b.Y))) <= epsilon) &&
+			(float32(math.Abs(float64(a.W-b.W))) <= epsilon) &&
+			(float32(math.Abs(float64(a.H-b.H))) <= epsilon)) {
+		return true
+	}
+	return false
+}
+
+// HasIntersection reports whether two rectangles intersect.
+// (https://wiki.libsdl.org/SDL_HasIntersection)
+func (a *FRect) HasIntersection(b *FRect) bool {
+	if a == nil || b == nil {
+		return false
+	}
+
+	// Special case for empty rects
+	if a.Empty() || b.Empty() {
+		return false
+	}
+
+	if a.X >= b.X+b.W || a.X+a.W <= b.X || a.Y >= b.Y+b.H || a.Y+a.H <= b.Y {
+		return false
+	}
+
+	return true
+}
+
+// Intersect calculates the intersection of two rectangles.
+// (https://wiki.libsdl.org/SDL_IntersectRect)
+func (a *FRect) Intersect(b *FRect) (FRect, bool) {
+	var result FRect
+
+	if a == nil || b == nil {
+		return result, false
+	}
+
+	// Special case for empty rects
+	if a.Empty() || b.Empty() {
+		result.W = 0
+		result.H = 0
+		return result, false
+	}
+
+	aMin := a.X
+	aMax := aMin + a.W
+	bMin := b.X
+	bMax := bMin + b.W
+	if bMin > aMin {
+		aMin = bMin
+	}
+	result.X = aMin
+	if bMax < aMax {
+		aMax = bMax
+	}
+	result.W = aMax - aMin
+
+	aMin = a.Y
+	aMax = aMin + a.H
+	bMin = b.Y
+	bMax = bMin + b.H
+	if bMin > aMin {
+		aMin = bMin
+	}
+	result.Y = aMin
+	if bMax < aMax {
+		aMax = bMax
+	}
+	result.H = aMax - aMin
+
+	return result, !result.Empty()
+}
+
+// Union calculates the union of two rectangles.
+// (https://wiki.libsdl.org/SDL_UnionRect)
+func (a *FRect) Union(b *FRect) FRect {
+	var result FRect
+
+	if a == nil || b == nil {
+		return result
+	}
+
+	// Special case for empty rects
+	if a.Empty() {
+		return *b
+	} else if b.Empty() {
+		return *a
+	} else if a.Empty() && b.Empty() {
+		return result
+	}
+
+	aMin := a.X
+	aMax := aMin + a.W
+	bMin := b.X
+	bMax := bMin + b.W
+	if bMin < aMin {
+		aMin = bMin
+	}
+	result.X = aMin
+	if bMax > aMax {
+		aMax = bMax
+	}
+	result.W = aMax - aMin
+
+	aMin = a.Y
+	aMax = aMin + a.H
+	bMin = b.Y
+	bMax = bMin + b.H
+	if bMin < aMin {
+		aMin = bMin
+	}
+	result.Y = aMin
+	if bMax > aMax {
+		aMax = bMax
+	}
+	result.H = aMax - aMin
+
+	return result
+}
+
+// EnclosePoints calculates a minimal rectangle that encloses a set of points.
+// (https://wiki.libsdl.org/SDL_EnclosePoints)
+func EnclosePoints(points []Point, clip *Rect) (Rect, bool) {
+	var result Rect
+
+	if len(points) == 0 {
+		return result, false
+	}
+
+	var minX, minY, maxX, maxY int32
+	if clip != nil {
+		added := false
+		clipMinX := clip.X
+		clipMinY := clip.Y
+		clipMaxX := clip.X + clip.W - 1
+		clipMaxY := clip.Y + clip.H - 1
+
+		// If the clip has no size, we're done
+		if clip.Empty() {
+			return result, false
+		}
+
+		for _, val := range points {
+			// Check if the point is inside the clip rect
+			if val.X < clipMinX || val.X > clipMaxX || val.Y < clipMinY || val.Y > clipMaxY {
+				continue
+			}
+
+			if !added {
+				// If it's the first point
+				minX = val.X
+				maxX = val.X
+				minY = val.Y
+				maxY = val.Y
+				added = true
+			}
+
+			// Find mins and maxes
+			if val.X < minX {
+				minX = val.X
+			} else if val.X > maxX {
+				maxX = val.X
+			}
+			if val.Y < minY {
+				minY = val.Y
+			} else if val.Y > maxY {
+				maxY = val.Y
+			}
+		}
+	} else {
+		for i, val := range points {
+			if i == 0 {
+				// Populate the first point
+				minX = val.X
+				maxX = val.X
+				minY = val.Y
+				maxY = val.Y
+				continue
+			}
+
+			// Find mins and maxes
+			if val.X < minX {
+				minX = val.X
+			} else if val.X > maxX {
+				maxX = val.X
+			}
+			if val.Y < minY {
+				minY = val.Y
+			} else if val.Y > maxY {
+				maxY = val.Y
+			}
+		}
+	}
+
+	result.X = minX
+	result.Y = minY
+	result.W = (maxX - minX) + 1
+	result.H = (maxY - minY) + 1
+
+	return result, true
+}
+
+// EncloseFPoints calculates a minimal rectangle that encloses a set of points with float precision.
+// (https://wiki.libsdl.org/SDL_EncloseFPoints)
+func EncloseFPoints(points []FPoint, clip *FRect) (result FRect, enclosed bool) {
+	if len(points) == 0 {
+		return result, false
+	}
+
+	var minX, minY, maxX, maxY float32
+	if clip != nil {
+		added := false
+		clipMinX := clip.X
+		clipMinY := clip.Y
+		clipMaxX := clip.X + clip.W - 1
+		clipMaxY := clip.Y + clip.H - 1
+
+		// If the clip has no size, we're done
+		if clip.Empty() {
+			return result, false
+		}
+
+		for _, val := range points {
+			// Check if the point is inside the clip rect
+			if val.X < clipMinX || val.X > clipMaxX || val.Y < clipMinY || val.Y > clipMaxY {
+				continue
+			}
+
+			if !added {
+				// If it's the first point
+				minX = val.X
+				maxX = val.X
+				minY = val.Y
+				maxY = val.Y
+				added = true
+			}
+
+			// Find mins and maxes
+			if val.X < minX {
+				minX = val.X
+			} else if val.X > maxX {
+				maxX = val.X
+			}
+			if val.Y < minY {
+				minY = val.Y
+			} else if val.Y > maxY {
+				maxY = val.Y
+			}
+		}
+	} else {
+		for i, val := range points {
+			if i == 0 {
+				// Populate the first point
+				minX = val.X
+				maxX = val.X
+				minY = val.Y
+				maxY = val.Y
+				continue
+			}
+
+			// Find mins and maxes
+			if val.X < minX {
+				minX = val.X
+			} else if val.X > maxX {
+				maxX = val.X
+			}
+			if val.Y < minY {
+				minY = val.Y
+			} else if val.Y > maxY {
+				maxY = val.Y
+			}
+		}
+	}
+
+	result.X = minX
+	result.Y = minY
+	result.W = (maxX - minX) + 1
+	result.H = (maxY - minY) + 1
+
+	return result, true
+}
+
+const (
+	codeBottom = 1
+	codeTop    = 2
+	codeLeft   = 4
+	codeRight  = 8
+)
+
+func computeOutCode(rect *Rect, x, y int32) int {
+	code := 0
+	if y < rect.Y {
+		code |= codeTop
+	} else if y >= rect.Y+rect.H {
+		code |= codeBottom
+	}
+	if x < rect.X {
+		code |= codeLeft
+	} else if x >= rect.X+rect.W {
+		code |= codeRight
+	}
+
+	return code
+}
+
+func computeFOutCode(rect *FRect, x, y float32) int {
+	code := 0
+	if y < rect.Y {
+		code |= codeTop
+	} else if y >= rect.Y+rect.H {
+		code |= codeBottom
+	}
+	if x < rect.X {
+		code |= codeLeft
+	} else if x >= rect.X+rect.W {
+		code |= codeRight
+	}
+
+	return code
+}
+
+// IntersectLine calculates the intersection of a rectangle and a line segment.
+// (https://wiki.libsdl.org/SDL_IntersectRectAndLine)
+func (a *Rect) IntersectLine(X1, Y1, X2, Y2 *int32) bool {
+	if a.Empty() {
+		return false
+	}
+
+	x1 := *X1
+	y1 := *Y1
+	x2 := *X2
+	y2 := *Y2
+	rectX1 := a.X
+	rectY1 := a.Y
+	rectX2 := a.X + a.W - 1
+	rectY2 := a.Y + a.H - 1
+
+	// Check if the line is entirely inside the rect
+	if x1 >= rectX1 && x1 <= rectX2 && x2 >= rectX1 && x2 <= rectX2 &&
+		y1 >= rectY1 && y1 <= rectY2 && y2 >= rectY1 && y2 <= rectY2 {
+		return true
+	}
+
+	// Check if the line is entirely outside the rect
+	if (x1 < rectX1 && x2 < rectX1) || (x1 > rectX2 && x2 > rectX2) ||
+		(y1 < rectY1 && y2 < rectY1) || (y1 > rectY2 && y2 > rectY2) {
+		return false
+	}
+
+	// Check if the line is horizontal
+	if y1 == y2 {
+		if x1 < rectX1 {
+			*X1 = rectX1
+		} else if x1 > rectX2 {
+			*X1 = rectX2
+		}
+		if x2 < rectX1 {
+			*X2 = rectX1
+		} else if x2 > rectX2 {
+			*X2 = rectX2
+		}
+
+		return true
+	}
+
+	// Check if the line is vertical
+	if x1 == x2 {
+		if y1 < rectY1 {
+			*Y1 = rectY1
+		} else if y1 > rectY2 {
+			*Y1 = rectY2
+		}
+		if y2 < rectY1 {
+			*Y2 = rectY1
+		} else if y2 > rectY2 {
+			*Y2 = rectY2
+		}
+
+		return true
+	}
+
+	// Use Cohen-Sutherland algorithm when all shortcuts fail
+	outCode1 := computeOutCode(a, x1, y1)
+	outCode2 := computeOutCode(a, x2, y2)
+	for outCode1 != 0 || outCode2 != 0 {
+		if outCode1&outCode2 != 0 {
+			return false
+		}
+
+		if outCode1 != 0 {
+			var x, y int32
+			if outCode1&codeTop != 0 {
+				y = rectY1
+				x = x1 + ((x2-x1)*(y-y1))/(y2-y1)
+			} else if outCode1&codeBottom != 0 {
+				y = rectY2
+				x = x1 + ((x2-x1)*(y-y1))/(y2-y1)
+			} else if outCode1&codeLeft != 0 {
+				x = rectX1
+				y = y1 + ((y2-y1)*(x-x1))/(x2-x1)
+			} else if outCode1&codeRight != 0 {
+				x = rectX2
+				y = y1 + ((y2-y1)*(x-x1))/(x2-x1)
+			}
+
+			x1 = x
+			y1 = y
+			outCode1 = computeOutCode(a, x, y)
+		} else {
+			var x, y int32
+			if outCode2&codeTop != 0 {
+				y = rectY1
+				x = x1 + ((x2-x1)*(y-y1))/(y2-y1)
+			} else if outCode2&codeBottom != 0 {
+				y = rectY2
+				x = x1 + ((x2-x1)*(y-y1))/(y2-y1)
+			} else if outCode2&codeLeft != 0 {
+				x = rectX1
+				y = y1 + ((y2-y1)*(x-x1))/(x2-x1)
+			} else if outCode2&codeRight != 0 {
+				x = rectX2
+				y = y1 + ((y2-y1)*(x-x1))/(x2-x1)
+			}
+
+			x2 = x
+			y2 = y
+			outCode2 = computeOutCode(a, x, y)
+		}
+	}
+
+	*X1 = x1
+	*Y1 = y1
+	*X2 = x2
+	*Y2 = y2
+
+	return true
+}
+
+// IntersectLine calculates the intersection of a rectangle and a line segment.
+// (https://wiki.libsdl.org/SDL_IntersectFRectAndLine)
+func (a *FRect) IntersectLine(X1, Y1, X2, Y2 *float32) bool {
+	if a.Empty() {
+		return false
+	}
+
+	x1 := *X1
+	y1 := *Y1
+	x2 := *X2
+	y2 := *Y2
+	rectX1 := a.X
+	rectY1 := a.Y
+	rectX2 := a.X + a.W - 1
+	rectY2 := a.Y + a.H - 1
+
+	// Check if the line is entirely inside the rect
+	if x1 >= rectX1 && x1 <= rectX2 && x2 >= rectX1 && x2 <= rectX2 &&
+		y1 >= rectY1 && y1 <= rectY2 && y2 >= rectY1 && y2 <= rectY2 {
+		return true
+	}
+
+	// Check if the line is entirely outside the rect
+	if (x1 < rectX1 && x2 < rectX1) || (x1 > rectX2 && x2 > rectX2) ||
+		(y1 < rectY1 && y2 < rectY1) || (y1 > rectY2 && y2 > rectY2) {
+		return false
+	}
+
+	// Check if the line is horizontal
+	if y1 == y2 {
+		if x1 < rectX1 {
+			*X1 = rectX1
+		} else if x1 > rectX2 {
+			*X1 = rectX2
+		}
+		if x2 < rectX1 {
+			*X2 = rectX1
+		} else if x2 > rectX2 {
+			*X2 = rectX2
+		}
+
+		return true
+	}
+
+	// Check if the line is vertical
+	if x1 == x2 {
+		if y1 < rectY1 {
+			*Y1 = rectY1
+		} else if y1 > rectY2 {
+			*Y1 = rectY2
+		}
+		if y2 < rectY1 {
+			*Y2 = rectY1
+		} else if y2 > rectY2 {
+			*Y2 = rectY2
+		}
+
+		return true
+	}
+
+	// Use Cohen-Sutherland algorithm when all shortcuts fail
+	outCode1 := computeFOutCode(a, x1, y1)
+	outCode2 := computeFOutCode(a, x2, y2)
+	for outCode1 != 0 || outCode2 != 0 {
+		if outCode1&outCode2 != 0 {
+			return false
+		}
+
+		if outCode1 != 0 {
+			var x, y float32
+			if outCode1&codeTop != 0 {
+				y = rectY1
+				x = x1 + ((x2-x1)*(y-y1))/(y2-y1)
+			} else if outCode1&codeBottom != 0 {
+				y = rectY2
+				x = x1 + ((x2-x1)*(y-y1))/(y2-y1)
+			} else if outCode1&codeLeft != 0 {
+				x = rectX1
+				y = y1 + ((y2-y1)*(x-x1))/(x2-x1)
+			} else if outCode1&codeRight != 0 {
+				x = rectX2
+				y = y1 + ((y2-y1)*(x-x1))/(x2-x1)
+			}
+
+			x1 = x
+			y1 = y
+			outCode1 = computeFOutCode(a, x, y)
+		} else {
+			var x, y float32
+			if outCode2&codeTop != 0 {
+				y = rectY1
+				x = x1 + ((x2-x1)*(y-y1))/(y2-y1)
+			} else if outCode2&codeBottom != 0 {
+				y = rectY2
+				x = x1 + ((x2-x1)*(y-y1))/(y2-y1)
+			} else if outCode2&codeLeft != 0 {
+				x = rectX1
+				y = y1 + ((y2-y1)*(x-x1))/(x2-x1)
+			} else if outCode2&codeRight != 0 {
+				x = rectX2
+				y = y1 + ((y2-y1)*(x-x1))/(x2-x1)
+			}
+
+			x2 = x
+			y2 = y
+			outCode2 = computeFOutCode(a, x, y)
+		}
+	}
+
+	*X1 = x1
+	*Y1 = y1
+	*X2 = x2
+	*Y2 = y2
+
+	return true
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/rwops.go

@@ -0,0 +1,359 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+static Sint64 RWsize(SDL_RWops *ctx)
+{
+	return ctx->size(ctx);
+}
+
+static Sint64 RWseek(SDL_RWops *ctx, Sint64 offset, int whence)
+{
+	return ctx->seek(ctx, offset, whence);
+}
+
+static size_t RWread(SDL_RWops *ctx, void *ptr, size_t size, size_t maxnum)
+{
+	return ctx->read(ctx, ptr, size, maxnum);
+}
+
+static size_t RWwrite(SDL_RWops *ctx, void *ptr, size_t size, size_t num)
+{
+	return ctx->write(ctx, ptr, size, num);
+}
+
+static int RWclose(SDL_RWops *ctx)
+{
+	return ctx->close(ctx);
+}
+
+#if !(SDL_VERSION_ATLEAST(2,0,6))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_LoadFile_RW is not supported before SDL 2.0.6")
+#endif
+
+static void * SDL_LoadFile_RW(SDL_RWops * src, size_t *datasize, int freesrc)
+{
+	return 0;
+}
+#endif
+*/
+import "C"
+import (
+	"reflect"
+	"unsafe"
+)
+
+// RWops types
+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 seek from
+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 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)
+type RWops C.SDL_RWops
+
+func (rwops *RWops) cptr() *C.SDL_RWops {
+	return (*C.SDL_RWops)(rwops)
+}
+
+// RWFromFile creates a new RWops structure for reading from and/or writing to a named file.
+// (https://wiki.libsdl.org/SDL_RWFromFile)
+func RWFromFile(file, mode string) *RWops {
+	_file := C.CString(file)
+	_mode := C.CString(mode)
+	defer C.free(unsafe.Pointer(_file))
+	defer C.free(unsafe.Pointer(_mode))
+	return (*RWops)(unsafe.Pointer(C.SDL_RWFromFile(_file, _mode)))
+}
+
+// RWFromMem prepares a read-write memory buffer for use with RWops.
+// (https://wiki.libsdl.org/SDL_RWFromMem)
+func RWFromMem(mem []byte) (*RWops, error) {
+	if mem == nil {
+		return nil, ErrInvalidParameters
+	}
+
+	header := (*reflect.SliceHeader)(unsafe.Pointer(&mem))
+	_mem := unsafe.Pointer(header.Data)
+
+	rwops := (*RWops)(unsafe.Pointer(C.SDL_RWFromMem(_mem, C.int(len(mem)))))
+	if rwops == nil {
+		return nil, GetError()
+	}
+	return rwops, nil
+}
+
+// AllocRW allocates an empty, unpopulated RWops structure.
+// (https://wiki.libsdl.org/SDL_AllocRW)
+func AllocRW() *RWops {
+	return (*RWops)(unsafe.Pointer(C.SDL_AllocRW()))
+}
+
+// Free frees the RWops structure allocated by AllocRW().
+// (https://wiki.libsdl.org/SDL_FreeRW)
+func (rwops *RWops) Free() error {
+	if rwops == nil {
+		return ErrInvalidParameters
+	}
+
+	C.SDL_FreeRW(rwops.cptr())
+	return nil
+}
+
+// Size returns the size of the data stream in the RWops.
+// (https://wiki.libsdl.org/SDL_RWsize)
+func (rwops *RWops) Size() (int64, error) {
+	n := int64(C.RWsize(rwops.cptr()))
+	if n < 0 {
+		return n, GetError()
+	}
+	return n, nil
+}
+
+// Seek seeks within the RWops data stream.
+// (https://wiki.libsdl.org/SDL_RWseek)
+func (rwops *RWops) Seek(offset int64, whence int) (int64, error) {
+	if rwops == nil {
+		return -1, ErrInvalidParameters
+	}
+
+	ret := int64(C.RWseek(rwops.cptr(), C.Sint64(offset), C.int(whence)))
+	if ret < 0 {
+		return ret, GetError()
+	}
+	return ret, nil
+}
+
+// Read reads from a data source.
+// (https://wiki.libsdl.org/SDL_RWread)
+func (rwops *RWops) Read(buf []byte) (n int, err error) {
+	return rwops.Read2(buf, 1, uint(len(buf)))
+}
+
+// Read2 reads from a data source (native).
+// (https://wiki.libsdl.org/SDL_RWread)
+func (rwops *RWops) Read2(buf []byte, size, maxnum uint) (n int, err error) {
+	if rwops == nil || buf == nil {
+		return 0, ErrInvalidParameters
+	}
+
+	header := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
+	_data := unsafe.Pointer(header.Data)
+
+	n = int(C.RWread(rwops.cptr(), _data, C.size_t(size), C.size_t(maxnum)))
+	if n == 0 {
+		err = GetError()
+	}
+	return
+}
+
+// Tell returns the current read/write offset in the RWops data stream.
+// (https://wiki.libsdl.org/SDL_RWtell)
+func (rwops *RWops) Tell() (int64, error) {
+	if rwops == nil {
+		return 0, ErrInvalidParameters
+	}
+
+	ret := int64(C.RWseek(rwops.cptr(), 0, C.int(RW_SEEK_CUR)))
+	if ret < 0 {
+		return ret, GetError()
+	}
+	return ret, nil
+}
+
+// Write writes to the RWops data stream.
+// (https://wiki.libsdl.org/SDL_RWwrite)
+func (rwops *RWops) Write(buf []byte) (n int, err error) {
+	return rwops.Write2(buf, 1, uint(len(buf)))
+}
+
+// Write2 writes to the RWops data stream (native).
+// (https://wiki.libsdl.org/SDL_RWwrite)
+func (rwops *RWops) Write2(buf []byte, size, num uint) (n int, err error) {
+	if rwops == nil || buf == nil {
+		return 0, ErrInvalidParameters
+	}
+
+	header := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
+	_data := unsafe.Pointer(header.Data)
+
+	n = int(C.RWwrite(rwops.cptr(), _data, C.size_t(size), C.size_t(num)))
+	if n < int(num) {
+		err = GetError()
+	}
+	return
+}
+
+// Close closes and frees the allocated RWops structure.
+// (https://wiki.libsdl.org/SDL_RWclose)
+func (rwops *RWops) Close() error {
+	if rwops != nil && C.RWclose(rwops.cptr()) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// ReadU8 reads a byte from the RWops.
+// (https://wiki.libsdl.org/SDL_ReadU8)
+func (rwops *RWops) ReadU8() uint8 {
+	if rwops == nil {
+		return 0
+	}
+	return uint8(C.SDL_ReadU8(rwops.cptr()))
+}
+
+// ReadLE16 reads 16 bits of little-endian data from the RWops and returns in native format.
+// (https://wiki.libsdl.org/SDL_ReadLE16)
+func (rwops *RWops) ReadLE16() uint16 {
+	if rwops == nil {
+		return 0
+	}
+	return uint16(C.SDL_ReadLE16(rwops.cptr()))
+}
+
+// ReadBE16 read 16 bits of big-endian data from the RWops and returns in native format.
+// (https://wiki.libsdl.org/SDL_ReadBE16)
+func (rwops *RWops) ReadBE16() uint16 {
+	if rwops == nil {
+		return 0
+	}
+	return uint16(C.SDL_ReadBE16(rwops.cptr()))
+}
+
+// ReadLE32 reads 32 bits of little-endian data from the RWops and returns in native format.
+// (https://wiki.libsdl.org/SDL_ReadLE32)
+func (rwops *RWops) ReadLE32() uint32 {
+	if rwops == nil {
+		return 0
+	}
+	return uint32(C.SDL_ReadLE32(rwops.cptr()))
+}
+
+// ReadBE32 reads 32 bits of big-endian data from the RWops and returns in native format.
+// (https://wiki.libsdl.org/SDL_ReadBE32)
+func (rwops *RWops) ReadBE32() uint32 {
+	if rwops == nil {
+		return 0
+	}
+	return uint32(C.SDL_ReadBE32(rwops.cptr()))
+}
+
+// ReadLE64 reads 64 bits of little-endian data from the RWops and returns in native format.
+// (https://wiki.libsdl.org/SDL_ReadLE64)
+func (rwops *RWops) ReadLE64() uint64 {
+	if rwops == nil {
+		return 0
+	}
+	return uint64(C.SDL_ReadLE64(rwops.cptr()))
+}
+
+// ReadBE64 reads 64 bits of big-endian data from the RWops and returns in native format.
+// (https://wiki.libsdl.org/SDL_ReadBE64)
+func (rwops *RWops) ReadBE64() uint64 {
+	if rwops == nil {
+		return 0
+	}
+	return uint64(C.SDL_ReadBE64(rwops.cptr()))
+}
+
+// LoadFile_RW loads all the data from an SDL data stream.
+// (https://wiki.libsdl.org/SDL_LoadFile_RW)
+func (src *RWops) LoadFileRW(freesrc bool) (data []byte, size int) {
+	var _size C.size_t
+	var _freesrc C.int = 0
+
+	if freesrc {
+		_freesrc = 1
+	}
+
+	_data := C.SDL_LoadFile_RW(src.cptr(), &_size, _freesrc)
+	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&data))
+	sliceHeader.Cap = int(_size)
+	sliceHeader.Len = int(_size)
+	sliceHeader.Data = uintptr(_data)
+	size = int(_size)
+	return
+}
+
+// LoadFile loads an entire file
+// (https://wiki.libsdl.org/SDL_LoadFile)
+func LoadFile(file string) (data []byte, size int) {
+	return RWFromFile(file, "rb").LoadFileRW(true)
+}
+
+// WriteU8 writes a byte to the RWops.
+// (https://wiki.libsdl.org/SDL_WriteU8)
+func (rwops *RWops) WriteU8(value uint8) uint {
+	if rwops == nil {
+		return 0
+	}
+	return uint(C.SDL_WriteU8(rwops.cptr(), C.Uint8(value)))
+}
+
+// WriteLE16 writes 16 bits in native format to the RWops as little-endian data.
+// (https://wiki.libsdl.org/SDL_WriteLE16)
+func (rwops *RWops) WriteLE16(value uint16) uint {
+	if rwops == nil {
+		return 0
+	}
+	return uint(C.SDL_WriteLE16(rwops.cptr(), C.Uint16(value)))
+}
+
+// WriteBE16 writes 16 bits in native format to the RWops as big-endian data.
+// (https://wiki.libsdl.org/SDL_WriteBE16)
+func (rwops *RWops) WriteBE16(value uint16) uint {
+	if rwops == nil {
+		return 0
+	}
+	return uint(C.SDL_WriteBE16(rwops.cptr(), C.Uint16(value)))
+}
+
+// WriteLE32 writes 32 bits in native format to the RWops as little-endian data.
+// (https://wiki.libsdl.org/SDL_WriteLE32)
+func (rwops *RWops) WriteLE32(value uint32) uint {
+	if rwops == nil {
+		return 0
+	}
+	return uint(C.SDL_WriteLE32(rwops.cptr(), C.Uint32(value)))
+}
+
+// WriteBE32 writes 32 bits in native format to the RWops as big-endian data.
+// (https://wiki.libsdl.org/SDL_WriteBE32)
+func (rwops *RWops) WriteBE32(value uint32) uint {
+	if rwops == nil {
+		return 0
+	}
+	return uint(C.SDL_WriteBE32(rwops.cptr(), C.Uint32(value)))
+}
+
+// WriteLE64 writes 64 bits in native format to the RWops as little-endian data.
+// (https://wiki.libsdl.org/SDL_WriteLE64)
+func (rwops *RWops) WriteLE64(value uint64) uint {
+	if rwops == nil {
+		return 0
+	}
+	return uint(C.SDL_WriteLE64(rwops.cptr(), C.Uint64(value)))
+}
+
+// WriteBE64 writes 64 bits in native format to the RWops as big-endian data.
+// (https://wiki.libsdl.org/SDL_WriteBE64)
+func (rwops *RWops) WriteBE64(value uint64) uint {
+	if rwops == nil {
+		return 0
+	}
+	return uint(C.SDL_WriteBE64(rwops.cptr(), C.Uint64(value)))
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/scancode.go

@@ -0,0 +1,270 @@
+package sdl
+
+// #include "sdl_wrapper.h"
+import "C"
+
+// The SDL keyboard scancode representation.
+// (https://wiki.libsdl.org/SDL_Scancode)
+// (https://wiki.libsdl.org/SDLScancodeLookup)
+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
+)
+
+// Scancode is an SDL keyboard scancode representation.
+// (https://wiki.libsdl.org/SDL_Scancode)
+type Scancode uint32
+
+func (code Scancode) c() C.SDL_Scancode {
+	return C.SDL_Scancode(code)
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/sdl.go

@@ -0,0 +1,156 @@
+// 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.
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if !(SDL_VERSION_ATLEAST(2,0,9))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_INIT_SENSOR is not supported before SDL 2.0.9")
+#endif
+
+#define SDL_INIT_SENSOR (0x00008000u)
+#endif
+*/
+import "C"
+
+import (
+	"runtime"
+)
+
+// These are the flags which may be passed to SDL_Init().
+// (https://wiki.libsdl.org/SDL_Init)
+const (
+	INIT_TIMER          = C.SDL_INIT_TIMER          // timer subsystem
+	INIT_AUDIO          = C.SDL_INIT_AUDIO          // audio subsystem
+	INIT_VIDEO          = C.SDL_INIT_VIDEO          // video subsystem; automatically initializes the events subsystem
+	INIT_JOYSTICK       = C.SDL_INIT_JOYSTICK       // joystick subsystem; automatically initializes the events subsystem
+	INIT_HAPTIC         = C.SDL_INIT_HAPTIC         // haptic (force feedback) subsystem
+	INIT_GAMECONTROLLER = C.SDL_INIT_GAMECONTROLLER // controller subsystem; automatically initializes the joystick subsystem
+	INIT_EVENTS         = C.SDL_INIT_EVENTS         // events subsystem
+	INIT_NOPARACHUTE    = C.SDL_INIT_NOPARACHUTE    // compatibility; this flag is ignored
+	INIT_SENSOR         = C.SDL_INIT_SENSOR         // sensor subsystem
+	INIT_EVERYTHING     = C.SDL_INIT_EVERYTHING     // all of the above subsystems
+)
+
+const (
+	RELEASED = 0
+	PRESSED  = 1
+)
+
+// Calls a function in the main thread. It is only properly initialized inside
+// sdl.Main(..). As a default, it panics. It is used by sdl.Do(..) below.
+var callInMain = func(f func()) {
+	panic("sdl.Main(main func()) must be called before sdl.Do(f func())")
+}
+
+func init() {
+	// Make sure the main goroutine is bound to the main thread.
+	runtime.LockOSThread()
+}
+
+// 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 Main(main func()) {
+	// Queue of functions that are thread-sensitive
+	callQueue := make(chan func())
+
+	// Properly initialize callInMain for use by sdl.Do(..)
+	callInMain = func(f func()) {
+		done := make(chan bool, 1)
+		callQueue <- func() {
+			f()
+			done <- true
+		}
+		<-done
+	}
+
+	go func() {
+		main()
+		// fmt.Println("END") // to check if os.Exit(..) is called by main() above
+		close(callQueue)
+	}()
+
+	for f := range callQueue {
+		f()
+	}
+}
+
+// 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 Do(f func()) {
+	callInMain(f)
+}
+
+// Init initialize the SDL library. This must be called before using most other SDL functions.
+// (https://wiki.libsdl.org/SDL_Init)
+func Init(flags uint32) error {
+	if C.SDL_Init(C.Uint32(flags)) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// Quit cleans up all initialized subsystems. You should call it upon all exit conditions.
+// (https://wiki.libsdl.org/SDL_Quit)
+func Quit() {
+	C.SDL_Quit()
+
+	eventFilterCache = nil
+	for k := range eventWatches {
+		delete(eventWatches, k)
+	}
+}
+
+// InitSubSystem initializes specific SDL subsystems.
+// (https://wiki.libsdl.org/SDL_InitSubSystem)
+func InitSubSystem(flags uint32) error {
+	if C.SDL_InitSubSystem(C.Uint32(flags)) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// QuitSubSystem shuts down specific SDL subsystems.
+// (https://wiki.libsdl.org/SDL_QuitSubSystem)
+func QuitSubSystem(flags uint32) {
+	C.SDL_QuitSubSystem(C.Uint32(flags))
+}
+
+// WasInit returns a mask of the specified subsystems which have previously been initialized.
+// (https://wiki.libsdl.org/SDL_WasInit)
+func WasInit(flags uint32) uint32 {
+	return uint32(C.SDL_WasInit(C.Uint32(flags)))
+}
+
+// GetPlatform returns the name of the platform.
+// (https://wiki.libsdl.org/SDL_GetPlatform)
+func GetPlatform() string {
+	return string(C.GoString(C.SDL_GetPlatform()))
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/sdl_cgo.go

@@ -0,0 +1,7 @@
+// +build !static
+
+package sdl
+
+//#cgo windows LDFLAGS: -lSDL2
+//#cgo linux freebsd darwin openbsd pkg-config: sdl2
+import "C"

archive/vendor/github.com/veandco/go-sdl2/sdl/sdl_cgo_static.go

@@ -0,0 +1,19 @@
+// +build static
+
+package sdl
+
+//#cgo CFLAGS: -I${SRCDIR}/../_libs/include -I${SRCDIR}/../_libs/include/SDL2
+//#cgo LDFLAGS: -L${SRCDIR}/../_libs
+//#cgo linux,386 LDFLAGS: -lSDL2_linux_386 -lm -ldl -lasound -lm -ldl -lpthread -lX11 -lXext -lXcursor -lXinerama -lXi -lXrandr -lXss -lXxf86vm -lpthread -lrt
+//#cgo linux,amd64 LDFLAGS: -lSDL2_linux_amd64 -lm -ldl -lasound -lm -ldl -lpthread -lX11 -lXext -lXcursor -lXinerama -lXi -lXrandr -lXss -lXxf86vm -lpthread -lrt
+//#cgo windows,386 LDFLAGS: -lSDL2_windows_386 -lSDL2main_windows_386 -lm -ldinput8 -ldxguid -ldxerr8 -luser32 -lgdi32 -lwinmm -limm32 -lole32 -loleaut32 -lshell32 -lsetupapi -lversion -luuid -static-libgcc
+//#cgo windows,amd64 LDFLAGS: -lSDL2_windows_amd64 -lSDL2main_windows_amd64 -lm -ldinput8 -ldxguid -ldxerr8 -luser32 -lgdi32 -lwinmm -limm32 -lole32 -loleaut32 -lshell32 -lversion -luuid -lsetupapi -static-libgcc
+//#cgo darwin,amd64 LDFLAGS: -lSDL2_darwin_amd64 -lm -liconv -Wl,-framework,OpenGL -Wl,-framework,CoreAudio -Wl,-framework,AudioToolbox -Wl,-framework,ForceFeedback -lobjc -Wl,-framework,CoreVideo -Wl,-framework,Cocoa -Wl,-framework,Carbon -Wl,-framework,IOKit -Wl,-framework,Metal
+//#cgo darwin,arm64 LDFLAGS: -lSDL2_darwin_arm64 -lm -liconv -Wl,-framework,OpenGL -Wl,-framework,CoreAudio -Wl,-framework,AudioToolbox -Wl,-framework,ForceFeedback -lobjc -Wl,-framework,CoreVideo -Wl,-framework,Cocoa -Wl,-framework,Carbon -Wl,-framework,IOKit -Wl,-framework,Metal
+//#cgo android,arm LDFLAGS: -lSDL2_android_arm -lm -ldl -llog -landroid -lGLESv2 -lGLESv1_CM
+//#cgo linux,arm,!android LDFLAGS: -L/opt/vc/lib -L/opt/vc/lib64 -lSDL2_linux_arm -lm -ldl -liconv -lbcm_host -lvcos -lvchiq_arm -pthread
+import "C"
+import (
+       _ "github.com/veandco/go-sdl2/_libs"
+       _ "github.com/veandco/go-sdl2/_libs"
+)

archive/vendor/github.com/veandco/go-sdl2/sdl/sdl_wrapper.h

@@ -0,0 +1,38 @@
+#if defined(_WIN32)
+	#include <SDL2/SDL.h>
+	#include <stdlib.h>
+#else
+	#include <SDL.h>
+#endif
+
+#if !defined(SDL_2_0_10)
+#define SDL_2_0_10
+
+#if !(SDL_VERSION_ATLEAST(2,0,10))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_FPoint is not supported before SDL 2.0.10")
+#endif
+
+typedef struct SDL_FPoint
+{
+    float x;
+    float y;
+} SDL_FPoint;
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_FRect is not supported before SDL 2.0.10")
+#endif
+
+typedef struct SDL_FRect
+{
+    float x;
+    float y;
+    float w;
+    float h;
+} SDL_FRect;
+
+
+#endif
+
+#endif

archive/vendor/github.com/veandco/go-sdl2/sdl/sensor.go

@@ -0,0 +1,320 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if !(SDL_VERSION_ATLEAST(2,0,9))
+typedef struct _SDL_Sensor SDL_Sensor;
+
+typedef Sint32 SDL_SensorID;
+
+typedef enum
+{
+    SDL_SENSOR_INVALID = -1,
+    SDL_SENSOR_UNKNOWN,
+    SDL_SENSOR_ACCEL,
+    SDL_SENSOR_GYRO
+} SDL_SensorType;
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_NumSensors is not supported before SDL 2.0.9")
+#endif
+
+static inline int SDL_NumSensors()
+{
+	return 0;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_SensorGetDeviceName is not supported before SDL 2.0.9")
+#endif
+
+static const char * SDL_SensorGetDeviceName(int device_index)
+{
+	return NULL;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_SensorGetDeviceType is not supported before SDL 2.0.9")
+#endif
+
+static SDL_SensorType SDL_SensorGetDeviceType(int device_index)
+{
+	return SDL_SENSOR_INVALID;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_SensorGetDeviceNonPortableType is not supported before SDL 2.0.9")
+#endif
+
+static int SDL_SensorGetDeviceNonPortableType(int device_index)
+{
+	return -1;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_SensorGetDeviceInstanceID is not supported before SDL 2.0.9")
+#endif
+
+static SDL_SensorID SDL_SensorGetDeviceInstanceID(int device_index)
+{
+	return -1;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_SensorOpen is not supported before SDL 2.0.9")
+#endif
+
+static SDL_Sensor * SDL_SensorOpen(int device_index)
+{
+	return NULL;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_SensorFromInstanceID is not supported before SDL 2.0.9")
+#endif
+
+static SDL_Sensor * SDL_SensorFromInstanceID(SDL_SensorID instance_id)
+{
+	return NULL;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_SensorGetName is not supported before SDL 2.0.9")
+#endif
+
+static const char * SDL_SensorGetName(SDL_Sensor *sensor)
+{
+	return NULL;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_SensorGetType is not supported before SDL 2.0.9")
+#endif
+
+static SDL_SensorType SDL_SensorGetType(SDL_Sensor *sensor)
+{
+	return SDL_SENSOR_INVALID;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_SensorGetNonPortableType is not supported before SDL 2.0.9")
+#endif
+
+static int SDL_SensorGetNonPortableType(SDL_Sensor *sensor)
+{
+	return -1;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_SensorGetInstanceID is not supported before SDL 2.0.9")
+#endif
+
+static SDL_SensorID SDL_SensorGetInstanceID(SDL_Sensor *sensor)
+{
+	return -1;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_SensorGetData is not supported before SDL 2.0.9")
+#endif
+
+static int SDL_SensorGetData(SDL_Sensor *sensor, float *data, int num_values)
+{
+	return -1;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_SensorClose is not supported before SDL 2.0.9")
+#endif
+
+static void SDL_SensorClose(SDL_Sensor *sensor)
+{
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_SensorUpdate is not supported before SDL 2.0.9")
+#endif
+
+static void SDL_SensorUpdate()
+{
+}
+#endif
+*/
+import "C"
+import "unsafe"
+
+const (
+	STANDARD_GRAVITY = 9.80665
+)
+
+// The different sensors defined by SDL
+//
+// Additional sensors may be available, using platform dependent semantics.
+//
+// Here are the additional Android sensors:
+// https://developer.android.com/reference/android/hardware/SensorEvent.html#values
+const (
+	SENSOR_INVALID SensorType = C.SDL_SENSOR_INVALID // Returned for an invalid sensor
+	SENSOR_UNKNOWN SensorType = C.SDL_SENSOR_UNKNOWN // Unknown sensor type
+	SENSOR_ACCEL   SensorType = C.SDL_SENSOR_ACCEL   // Accelerometer
+	SENSOR_GYRO    SensorType = C.SDL_SENSOR_GYRO    // Gyroscope
+)
+
+type Sensor C.SDL_Sensor
+type SensorID int32
+type SensorType int
+
+// NumSensors counts the number of sensors attached to the system right now
+// (https://wiki.libsdl.org/SDL_NumSensors)
+func NumSensors() int {
+	return int(C.SDL_NumSensors())
+}
+
+// SensorGetDeviceName gets the implementation dependent name of a sensor.
+//
+// This can be called before any sensors are opened.
+//
+// Returns the sensor name, or empty string if deviceIndex is out of range.
+// (https://wiki.libsdl.org/SDL_SensorGetDeviceName)
+func SensorGetDeviceName(deviceIndex int) (name string) {
+	name = C.GoString(C.SDL_SensorGetDeviceName(C.int(deviceIndex)))
+	return
+}
+
+//  SensorGetDeviceType gets the type of a sensor.
+//
+//  This can be called before any sensors are opened.
+//
+//  Returns the sensor type, or SDL_SENSOR_INVALID if deviceIndex is out of range.
+// (https://wiki.libsdl.org/SDL_SensorGetDeviceType)
+func SensorGetDeviceType(deviceIndex int) (typ SensorType) {
+	typ = SensorType(C.SDL_SensorGetDeviceType(C.int(deviceIndex)))
+	return
+}
+
+// SensorGetDeviceNonPortableType gets the platform dependent type of a sensor.
+//
+// This can be called before any sensors are opened.
+//
+// Returns the sensor platform dependent type, or -1 if deviceIndex is out of range.
+// (https://wiki.libsdl.org/SDL_SensorGetDeviceNonPortableType)
+func SensorGetDeviceNonPortableType(deviceIndex int) (typ int) {
+	typ = int(C.SDL_SensorGetDeviceNonPortableType(C.int(deviceIndex)))
+	return
+}
+
+// SensorGetDeviceInstanceID gets the instance ID of a sensor.
+//
+// This can be called before any sensors are opened.
+//
+// Returns the sensor instance ID, or -1 if deviceIndex is out of range.
+// (https://wiki.libsdl.org/SDL_SensorGetDeviceInstanceID)
+func SensorGetDeviceInstanceID(deviceIndex int) (id SensorID) {
+	id = SensorID(C.SDL_SensorGetDeviceInstanceID(C.int(deviceIndex)))
+	return
+}
+
+// SensorOpen opens a sensor for use.
+//
+// The index passed as an argument refers to the N'th sensor on the system.
+//
+// Returns a sensor identifier, or nil if an error occurred.
+// (https://wiki.libsdl.org/SDL_SensorOpen)
+func SensorOpen(deviceIndex int) (sensor *Sensor) {
+	sensor = (*Sensor)(unsafe.Pointer(C.SDL_SensorOpen(C.int(deviceIndex))))
+	return
+}
+
+// SensorFromInstanceID returns the Sensor associated with an instance id.
+// (https://wiki.libsdl.org/SDL_SensorFromInstanceID)
+func SensorFromInstanceID(id SensorID) (sensor *Sensor) {
+	sensor = (*Sensor)(unsafe.Pointer(C.SDL_SensorFromInstanceID(C.SDL_SensorID(id))))
+	return
+}
+
+// GetName gets the implementation dependent name of a sensor.
+//
+// Returns the sensor name, or empty string if the sensor is nil.
+// (https://wiki.libsdl.org/SDL_SensorGetName)
+func (sensor *Sensor) GetName() (name string) {
+	name = C.GoString(C.SDL_SensorGetName((*C.SDL_Sensor)(sensor)))
+	return
+}
+
+// GetType gets the type of a sensor.
+//
+// This can be called before any sensors are opened.
+//
+// Returns the sensor type, or SENSOR_INVALID if the sensor is nil.
+// (https://wiki.libsdl.org/SDL_SensorGetType)
+func (sensor *Sensor) GetType() (typ SensorType) {
+	typ = SensorType(C.SDL_SensorGetType((*C.SDL_Sensor)(sensor)))
+	return
+}
+
+// GetNonPortableType gets the platform dependent type of a sensor.
+//
+// This can be called before any sensors are opened.
+//
+// Returns the sensor platform dependent type, or -1 if the sensor is nil.
+// (https://wiki.libsdl.org/SDL_SensorGetNonPortableType)
+func (sensor *Sensor) GetNonPortableType() (typ int) {
+	typ = int(C.SDL_SensorGetNonPortableType((*C.SDL_Sensor)(sensor)))
+	return
+}
+
+// GetInstanceID gets the instance ID of a sensor.
+//
+// This can be called before any sensors are opened.
+//
+// Returns the sensor instance ID, or -1 if the sensor is nil.
+// (https://wiki.libsdl.org/SDL_SensorGetInstanceID)
+func (sensor *Sensor) GetInstanceID() (id SensorID) {
+	id = SensorID(C.SDL_SensorGetInstanceID((*C.SDL_Sensor)(sensor)))
+	return
+}
+
+// GetData gets the current state of an opened sensor.
+//
+// The number of values and interpretation of the data is sensor dependent.
+// (https://wiki.libsdl.org/SDL_SensorGetData)
+func (sensor *Sensor) GetData(data []float32) (err error) {
+	if data == nil {
+		return nil
+	}
+	_data := (*C.float)(unsafe.Pointer(&data[0]))
+	_numValues := C.int(len(data))
+	err = errorFromInt(int(C.SDL_SensorGetData((*C.SDL_Sensor)(sensor), _data, _numValues)))
+	return
+}
+
+// Close closes a sensor previously opened with SensorOpen()
+// (https://wiki.libsdl.org/SDL_SensorClose)
+func (sensor *Sensor) Close() {
+	C.SDL_SensorClose((*C.SDL_Sensor)(sensor))
+}
+
+// SensorUpdate updates the current state of the open sensors.
+//
+// This is called automatically by the event loop if sensor events are enabled.
+//
+// This needs to be called from the thread that initialized the sensor subsystem.
+// (https://wiki.libsdl.org/SDL_SensorUpdate)
+func SensorUpdate() {
+	C.SDL_SensorUpdate()
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/shape.go

@@ -0,0 +1,182 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+// until SDL 2.0.6 SDL_shape.h was not included in SDL.h
+#if !(SDL_VERSION_ATLEAST(2,0,6))
+#if defined(_WIN32)
+	#include <SDL2/SDL_shape.h>
+#else
+	#include <SDL_shape.h>
+#endif
+#endif
+*/
+import "C"
+import "unsafe"
+
+const (
+	NONSHAPEABLE_WINDOW    = C.SDL_NONSHAPEABLE_WINDOW
+	INVALID_SHAPE_ARGUMENT = C.SDL_INVALID_SHAPE_ARGUMENT
+	WINDOW_LACKS_SHAPE     = C.SDL_WINDOW_LACKS_SHAPE
+)
+
+type WindowShapeModeKind C.WindowShapeMode
+
+const (
+	ShapeModeDefaultKind              WindowShapeModeKind = C.ShapeModeDefault              // the default mode, a binarized alpha cutoff of 1
+	ShapeModeBinarizeAlphaKind        WindowShapeModeKind = C.ShapeModeBinarizeAlpha        // a binarized alpha cutoff with a given integer value
+	ShapeModeReverseBinarizeAlphaKind WindowShapeModeKind = C.ShapeModeReverseBinarizeAlpha // a binarized alpha cutoff with a given integer value, but with the opposite comparison
+	ShapeModeColorKeyKind             WindowShapeModeKind = C.ShapeModeColorKey             // a color key is applied
+)
+
+func SHAPEMODEALPHA(mode WindowShapeModeKind) bool {
+	return (mode == ShapeModeDefaultKind ||
+		mode == ShapeModeBinarizeAlphaKind ||
+		mode == ShapeModeReverseBinarizeAlphaKind)
+}
+
+// A union containing parameters for shaped windows
+// uint8 or Color
+type cWindowShapeParams C.SDL_WindowShapeParams
+
+type cWindowShapeMode struct {
+	mode       WindowShapeModeKind
+	parameters cWindowShapeParams
+}
+
+type WindowShapeMode interface {
+	Mode() WindowShapeModeKind
+	cWSM() cWindowShapeMode
+}
+
+type ShapeModeDefault struct{}
+
+func (smd ShapeModeDefault) Mode() WindowShapeModeKind {
+	return ShapeModeDefaultKind
+}
+
+func (smd ShapeModeDefault) cWSM() cWindowShapeMode {
+	return cWindowShapeMode{
+		mode:       ShapeModeDefaultKind,
+		parameters: [4]uint8{1, 0, 0, 0},
+	}
+}
+
+type ShapeModeBinarizeAlpha struct {
+	Cutoff uint8
+}
+
+func (smba ShapeModeBinarizeAlpha) Mode() WindowShapeModeKind {
+	return ShapeModeBinarizeAlphaKind
+}
+
+func (smba ShapeModeBinarizeAlpha) cWSM() cWindowShapeMode {
+	return cWindowShapeMode{
+		mode:       ShapeModeBinarizeAlphaKind,
+		parameters: [4]uint8{smba.Cutoff, 0, 0, 0},
+	}
+}
+
+type ShapeModeReverseBinarizeAlpha struct {
+	Cutoff uint8
+}
+
+func (smba ShapeModeReverseBinarizeAlpha) Mode() WindowShapeModeKind {
+	return ShapeModeReverseBinarizeAlphaKind
+}
+
+func (smba ShapeModeReverseBinarizeAlpha) cWSM() cWindowShapeMode {
+	return cWindowShapeMode{
+		mode:       ShapeModeReverseBinarizeAlphaKind,
+		parameters: [4]uint8{smba.Cutoff, 0, 0, 0},
+	}
+}
+
+type ShapeModeColorKey struct {
+	Color Color
+}
+
+func (smck ShapeModeColorKey) Mode() WindowShapeModeKind {
+	return ShapeModeColorKeyKind
+}
+
+func (smck ShapeModeColorKey) cWSM() cWindowShapeMode {
+	return cWindowShapeMode{
+		mode:       ShapeModeReverseBinarizeAlphaKind,
+		parameters: [4]uint8{smck.Color.R, smck.Color.G, smck.Color.B, smck.Color.A},
+	}
+}
+
+func (cwsm cWindowShapeMode) goWSM() WindowShapeMode {
+	switch cwsm.mode {
+	case ShapeModeDefaultKind:
+		return ShapeModeDefault{}
+
+	case ShapeModeBinarizeAlphaKind:
+		return ShapeModeBinarizeAlpha{
+			Cutoff: ([4]uint8)(cwsm.parameters)[0],
+		}
+
+	case ShapeModeReverseBinarizeAlphaKind:
+		return ShapeModeReverseBinarizeAlpha{
+			Cutoff: ([4]uint8)(cwsm.parameters)[0],
+		}
+
+	case ShapeModeColorKeyKind:
+		return ShapeModeColorKey{
+			Color: Color{
+				R: ([4]uint8)(cwsm.parameters)[0],
+				G: ([4]uint8)(cwsm.parameters)[1],
+				B: ([4]uint8)(cwsm.parameters)[2],
+				A: ([4]uint8)(cwsm.parameters)[3],
+			},
+		}
+
+	default:
+		panic("Unknown WindowShapeModeKind")
+
+	}
+}
+
+func (wsm *cWindowShapeMode) cptr() *C.SDL_WindowShapeMode {
+	return (*C.SDL_WindowShapeMode)(unsafe.Pointer(wsm))
+}
+
+// CreateShapedWindow creates a window that can be shaped with the specified position, dimensions, and flags
+// (https://wiki.libsdl.org/SDL_CreateShapedWindow)
+func CreateShapedWindow(title string, x, y, w, h uint32, flags uint32) (*Window, error) {
+	var _window = C.SDL_CreateShapedWindow(C.CString(title), C.uint(x), C.uint(y), C.uint(w), C.uint(h), C.Uint32(flags))
+	if _window == nil {
+		return nil, GetError()
+	}
+	return (*Window)(unsafe.Pointer(_window)), nil
+}
+
+// IsShapedWindow returns whether the given window is a shaped window.
+// (https://wiki.libsdl.org/SDL_IsShapedWindow)
+func (window *Window) IsShaped() bool {
+	return (C.SDL_IsShapedWindow(window.cptr()) & 1) == 1
+}
+
+// SetShape sets the shape and parameters of a shaped window
+// (https://wiki.libsdl.org/SDL_SetWindowShape)
+func (window *Window) SetShape(shape *Surface, shape_mode WindowShapeMode) int32 {
+	if shape_mode == nil {
+		panic("shape_mode can not be nil")
+	}
+	var _cWSM cWindowShapeMode = shape_mode.cWSM()
+
+	return (int32)(C.SDL_SetWindowShape(window.cptr(), shape.cptr(), _cWSM.cptr()))
+}
+
+// GetShapeMode gets the shape parameters of a shaped window
+// (https://wiki.libsdl.org/SDL_GetShapedWindowMode)
+func (window *Window) GetShapeMode() (WindowShapeMode, int32) {
+	var _cWSM cWindowShapeMode
+	var _resInt32 = (int32)(C.SDL_GetShapedWindowMode(window.cptr(), _cWSM.cptr()))
+	if _resInt32 != 0 {
+		return nil, _resInt32
+	}
+	return _cWSM.goWSM(), _resInt32
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/surface.go

@@ -0,0 +1,806 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if !(SDL_VERSION_ATLEAST(2,0,9))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_HasColorKey is not supported before SDL 2.0.9")
+#endif
+
+static SDL_bool SDL_HasColorKey(SDL_Surface * surface)
+{
+	return SDL_FALSE;
+}
+
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,8))
+typedef enum {
+	SDL_YUV_CONVERSION_JPEG,
+	SDL_YUV_CONVERSION_BT601,
+	SDL_YUV_CONVERSION_BT709,
+	SDL_YUV_CONVERSION_AUTOMATIC
+} SDL_YUV_CONVERSION_MODE;
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_SetYUVConversionMode is not supported before SDL 2.0.8")
+#endif
+
+void SDL_SetYUVConversionMode(SDL_YUV_CONVERSION_MODE mode)
+{
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_GetYUVConversionMode is not supported before SDL 2.0.8")
+#endif
+
+SDL_YUV_CONVERSION_MODE SDL_GetYUVConversionMode(void)
+{
+	return -1;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_GetYUVConversionModeForResolution is not supported before SDL 2.0.8")
+#endif
+
+SDL_YUV_CONVERSION_MODE SDL_GetYUVConversionModeForResolution(int width, int height)
+{
+	return -1;
+}
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,6))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_DuplicateSurface is not supported before SDL 2.0.6")
+#endif
+
+static inline SDL_Surface* SDL_DuplicateSurface(SDL_Surface *surface)
+{
+	return NULL;
+}
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,5))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_CreateRGBSurfaceWithFormat is not supported before SDL 2.0.5")
+#endif
+
+static inline SDL_Surface* SDL_CreateRGBSurfaceWithFormat(Uint32 flags, int width, int height, int depth, Uint32 format)
+{
+	return NULL;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_CreateRGBSurfaceWithFormatFrom is not supported before SDL 2.0.5")
+#endif
+
+static inline SDL_Surface* SDL_CreateRGBSurfaceWithFormatFrom(void* pixels, int width, int height, int depth, int pitch, Uint32 format)
+{
+	return NULL;
+}
+#endif
+
+
+#if !(SDL_VERSION_ATLEAST(2,0,16))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_SoftStretchLinear is not supported before SDL 2.0.16")
+#endif
+
+static int SDL_SoftStretchLinear(SDL_Surface * src, const SDL_Rect * srcrect, SDL_Surface * dst, const SDL_Rect * dstrect)
+{
+	return -1;
+}
+
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,18))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_PremultiplyAlpha is not supported before SDL 2.0.18")
+#endif
+
+static int SDL_PremultiplyAlpha(int width, int height, Uint32 src_format, const void * src, int src_pitch, Uint32 dst_format, void * dst, int dst_pitch)
+{
+	return -1;
+}
+
+#endif
+*/
+import "C"
+import (
+	"image"
+	"image/color"
+	"reflect"
+	"unsafe"
+)
+
+// Surface flags (internal use)
+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
+)
+
+type YUV_CONVERSION_MODE C.SDL_YUV_CONVERSION_MODE
+
+// YUV Conversion Modes
+const (
+	YUV_CONVERSION_JPEG      YUV_CONVERSION_MODE = C.SDL_YUV_CONVERSION_JPEG      // Full range JPEG
+	YUV_CONVERSION_BT601                         = C.SDL_YUV_CONVERSION_BT601     // BT.601 (the default)
+	YUV_CONVERSION_BT709                         = C.SDL_YUV_CONVERSION_BT709     // BT.709
+	YUV_CONVERSION_AUTOMATIC                     = C.SDL_YUV_CONVERSION_AUTOMATIC // BT.601 for SD content, BT.709 for HD content
+)
+
+// Surface contains a collection of pixels used in software blitting.
+// (https://wiki.libsdl.org/SDL_Surface)
+type Surface struct {
+	flags    uint32         // (internal use)
+	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)
+	pixels   unsafe.Pointer // the pointer to the actual pixel data; use Pixels() for access
+	UserData unsafe.Pointer // an arbitrary pointer you can set
+	locked   int32          // used for surfaces that require locking (internal use)
+	lockData unsafe.Pointer // used for surfaces that require locking (internal use)
+	ClipRect Rect           // a Rect structure used to clip blits to the surface which can be set by SetClipRect() (read-only)
+	_        unsafe.Pointer // map; info for fast blit mapping to other surfaces (internal use)
+	RefCount int32          // reference count that can be incremented by the application
+}
+type cSurface C.SDL_Surface
+
+func (surface *Surface) cptr() *C.SDL_Surface {
+	return (*C.SDL_Surface)(unsafe.Pointer(surface))
+}
+
+// MustLock reports whether the surface must be locked for access.
+// (https://wiki.libsdl.org/SDL_MUSTLOCK)
+func (surface *Surface) MustLock() bool {
+	return (surface.flags & RLEACCEL) != 0
+}
+
+// CreateRGBSurface allocates a new RGB surface.
+// (https://wiki.libsdl.org/SDL_CreateRGBSurface)
+func CreateRGBSurface(flags uint32, width, height, depth int32, Rmask, Gmask, Bmask, Amask uint32) (*Surface, error) {
+	surface := (*Surface)(unsafe.Pointer(C.SDL_CreateRGBSurface(
+		C.Uint32(flags),
+		C.int(width),
+		C.int(height),
+		C.int(depth),
+		C.Uint32(Rmask),
+		C.Uint32(Gmask),
+		C.Uint32(Bmask),
+		C.Uint32(Amask))))
+	if surface == nil {
+		return nil, GetError()
+	}
+	return surface, nil
+}
+
+// CreateRGBSurfaceFrom allocate a new RGB surface with existing pixel data.
+// (https://wiki.libsdl.org/SDL_CreateRGBSurfaceFrom)
+func CreateRGBSurfaceFrom(pixels unsafe.Pointer, width, height int32, depth, pitch int, Rmask, Gmask, Bmask, Amask uint32) (*Surface, error) {
+	surface := (*Surface)(unsafe.Pointer(C.SDL_CreateRGBSurfaceFrom(
+		pixels,
+		C.int(width),
+		C.int(height),
+		C.int(depth),
+		C.int(pitch),
+		C.Uint32(Rmask),
+		C.Uint32(Gmask),
+		C.Uint32(Bmask),
+		C.Uint32(Amask))))
+	if surface == nil {
+		return nil, GetError()
+	}
+	return surface, nil
+}
+
+// CreateRGBSurfaceWithFormat allocates an RGB surface.
+// (https://wiki.libsdl.org/SDL_CreateRGBSurfaceWithFormat)
+func CreateRGBSurfaceWithFormat(flags uint32, width, height, depth int32, format uint32) (*Surface, error) {
+	surface := (*Surface)(unsafe.Pointer(C.SDL_CreateRGBSurfaceWithFormat(
+		C.Uint32(flags),
+		C.int(width),
+		C.int(height),
+		C.int(depth),
+		C.Uint32(format))))
+	if surface == nil {
+		return nil, GetError()
+	}
+	return surface, nil
+}
+
+// CreateRGBSurfaceWithFormatFrom allocates an RGB surface from provided pixel data.
+// (https://wiki.libsdl.org/SDL_CreateRGBSurfaceWithFormatFrom)
+func CreateRGBSurfaceWithFormatFrom(pixels unsafe.Pointer, width, height, depth, pitch int32, format uint32) (*Surface, error) {
+	surface := (*Surface)(unsafe.Pointer(C.SDL_CreateRGBSurfaceWithFormatFrom(
+		pixels,
+		C.int(width),
+		C.int(height),
+		C.int(depth),
+		C.int(pitch),
+		C.Uint32(format))))
+	if surface == nil {
+		return nil, GetError()
+	}
+	return surface, nil
+}
+
+// SetYUVConversionMode sets the YUV conversion mode
+// TODO: (https://wiki.libsdl.org/SDL_SetYUVConversionMode)
+func SetYUVConversionMode(mode YUV_CONVERSION_MODE) {
+	_mode := C.SDL_YUV_CONVERSION_MODE(mode)
+	C.SDL_SetYUVConversionMode(_mode)
+}
+
+// GetYUVConversionMode gets the YUV conversion mode
+// TODO: (https://wiki.libsdl.org/SDL_GetYUVConversionMode)
+func GetYUVConversionMode() YUV_CONVERSION_MODE {
+	return YUV_CONVERSION_MODE(C.SDL_GetYUVConversionMode())
+}
+
+// GetYUVConversionModeForResolution gets the YUV conversion mode
+// TODO: (https://wiki.libsdl.org/SDL_GetYUVConversionModeForResolution)
+func GetYUVConversionModeForResolution(width, height int) YUV_CONVERSION_MODE {
+	_width := C.int(width)
+	_height := C.int(height)
+	return YUV_CONVERSION_MODE(C.SDL_GetYUVConversionModeForResolution(_width, _height))
+}
+
+// Free frees the RGB surface.
+// (https://wiki.libsdl.org/SDL_FreeSurface)
+func (surface *Surface) Free() {
+	C.SDL_FreeSurface(surface.cptr())
+}
+
+// SetPalette sets the palette used by the surface.
+// (https://wiki.libsdl.org/SDL_SetSurfacePalette)
+func (surface *Surface) SetPalette(palette *Palette) error {
+	if C.SDL_SetSurfacePalette(surface.cptr(), palette.cptr()) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// Lock sets up the surface for directly accessing the pixels.
+// (https://wiki.libsdl.org/SDL_LockSurface)
+func (surface *Surface) Lock() error {
+	if C.SDL_LockSurface(surface.cptr()) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// Unlock releases the surface after directly accessing the pixels.
+// (https://wiki.libsdl.org/SDL_UnlockSurface)
+func (surface *Surface) Unlock() {
+	C.SDL_UnlockSurface(surface.cptr())
+}
+
+// LoadBMPRW loads a BMP image from a seekable SDL data stream (memory or file).
+// (https://wiki.libsdl.org/SDL_LoadBMP_RW)
+func LoadBMPRW(src *RWops, freeSrc bool) (*Surface, error) {
+	surface := (*Surface)(unsafe.Pointer(C.SDL_LoadBMP_RW(src.cptr(), C.int(Btoi(freeSrc)))))
+	if surface == nil {
+		return nil, GetError()
+	}
+	return surface, nil
+}
+
+// LoadBMP loads a surface from a BMP file.
+// (https://wiki.libsdl.org/SDL_LoadBMP)
+func LoadBMP(file string) (*Surface, error) {
+	return LoadBMPRW(RWFromFile(file, "rb"), true)
+}
+
+// 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 *Surface) SaveBMPRW(dst *RWops, freeDst bool) error {
+	if C.SDL_SaveBMP_RW(surface.cptr(), dst.cptr(), C.int(Btoi(freeDst))) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// SaveBMP saves the surface to a BMP file.
+// (https://wiki.libsdl.org/SDL_SaveBMP)
+func (surface *Surface) SaveBMP(file string) error {
+	return surface.SaveBMPRW(RWFromFile(file, "wb"), true)
+}
+
+// SetRLE sets the RLE acceleration hint for the surface.
+// (https://wiki.libsdl.org/SDL_SetSurfaceRLE)
+func (surface *Surface) SetRLE(flag bool) error {
+	if C.SDL_SetSurfaceRLE(surface.cptr(), C.int(Btoi(flag))) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// SetColorKey sets the color key (transparent pixel) in the surface.
+// (https://wiki.libsdl.org/SDL_SetColorKey)
+func (surface *Surface) SetColorKey(flag bool, key uint32) error {
+	if C.SDL_SetColorKey(surface.cptr(), C.int(Btoi(flag)), C.Uint32(key)) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// HasColorKey returns the color key (transparent pixel) for the surface.
+// TODO: (https://wiki.libsdl.org/SDL_HasColorKey)
+func (surface *Surface) HasColorKey() bool {
+	return C.SDL_HasColorKey(surface.cptr()) == C.SDL_TRUE
+}
+
+// GetColorKey returns the color key (transparent pixel) for the surface.
+// (https://wiki.libsdl.org/SDL_GetColorKey)
+func (surface *Surface) GetColorKey() (key uint32, err error) {
+	_key := (*C.Uint32)(unsafe.Pointer(&key))
+	if C.SDL_GetColorKey(surface.cptr(), _key) != 0 {
+		return key, GetError()
+	}
+	return key, nil
+}
+
+// SetColorMod sets an additional color value multiplied into blit operations.
+// (https://wiki.libsdl.org/SDL_SetSurfaceColorMod)
+func (surface *Surface) SetColorMod(r, g, b uint8) error {
+	if C.SDL_SetSurfaceColorMod(surface.cptr(), C.Uint8(r), C.Uint8(g), C.Uint8(b)) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// GetColorMod returns the additional color value multiplied into blit operations.
+// (https://wiki.libsdl.org/SDL_GetSurfaceColorMod)
+func (surface *Surface) GetColorMod() (r, g, b uint8, err error) {
+	_r := (*C.Uint8)(unsafe.Pointer(&r))
+	_g := (*C.Uint8)(unsafe.Pointer(&g))
+	_b := (*C.Uint8)(unsafe.Pointer(&b))
+	if C.SDL_GetSurfaceColorMod(surface.cptr(), _r, _g, _b) != 0 {
+		return r, g, b, GetError()
+	}
+	return r, g, b, nil
+}
+
+// SetAlphaMod sets an additional alpha value used in blit operations.
+// (https://wiki.libsdl.org/SDL_SetSurfaceAlphaMod)
+func (surface *Surface) SetAlphaMod(alpha uint8) error {
+	if C.SDL_SetSurfaceAlphaMod(surface.cptr(), C.Uint8(alpha)) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// GetAlphaMod returns the additional alpha value used in blit operations.
+// (https://wiki.libsdl.org/SDL_GetSurfaceAlphaMod)
+func (surface *Surface) GetAlphaMod() (alpha uint8, err error) {
+	_alpha := (*C.Uint8)(unsafe.Pointer(&alpha))
+	if C.SDL_GetSurfaceAlphaMod(surface.cptr(), _alpha) != 0 {
+		return alpha, GetError()
+	}
+	return alpha, nil
+}
+
+// SetBlendMode sets the blend mode used for blit operations.
+// (https://wiki.libsdl.org/SDL_SetSurfaceBlendMode)
+func (surface *Surface) SetBlendMode(bm BlendMode) error {
+	if C.SDL_SetSurfaceBlendMode(surface.cptr(), bm.c()) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// GetBlendMode returns the blend mode used for blit operations.
+// (https://wiki.libsdl.org/SDL_GetSurfaceBlendMode)
+func (surface *Surface) GetBlendMode() (bm BlendMode, err error) {
+	if C.SDL_GetSurfaceBlendMode(surface.cptr(), bm.cptr()) != 0 {
+		return bm, GetError()
+	}
+	return bm, nil
+}
+
+// SetClipRect sets the clipping rectangle for the surface
+// (https://wiki.libsdl.org/SDL_SetClipRect)
+func (surface *Surface) SetClipRect(rect *Rect) bool {
+	return C.SDL_SetClipRect(surface.cptr(), rect.cptr()) > 0
+}
+
+// GetClipRect returns the clipping rectangle for a surface.
+// (https://wiki.libsdl.org/SDL_GetClipRect)
+func (surface *Surface) GetClipRect(rect *Rect) {
+	C.SDL_GetClipRect(surface.cptr(), rect.cptr())
+}
+
+// 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 *Surface) Convert(fmt *PixelFormat, flags uint32) (*Surface, error) {
+	_surface := (*Surface)(unsafe.Pointer(C.SDL_ConvertSurface(surface.cptr(), fmt.cptr(), C.Uint32(flags))))
+	if _surface == nil {
+		return nil, GetError()
+	}
+	return _surface, nil
+}
+
+// ConvertFormat copies the existing surface to a new surface of the specified format.
+// (https://wiki.libsdl.org/SDL_ConvertSurfaceFormat)
+func (surface *Surface) ConvertFormat(pixelFormat uint32, flags uint32) (*Surface, error) {
+	_surface := (*Surface)(unsafe.Pointer(C.SDL_ConvertSurfaceFormat(surface.cptr(), C.Uint32(pixelFormat), C.Uint32(flags))))
+	if _surface == nil {
+		return nil, GetError()
+	}
+	return _surface, nil
+}
+
+// ConvertPixels copies a block of pixels of one format to another format.
+// (https://wiki.libsdl.org/SDL_ConvertPixels)
+func ConvertPixels(width, height int32, srcFormat uint32, src unsafe.Pointer, srcPitch int,
+	dstFormat uint32, dst unsafe.Pointer, dstPitch int) error {
+	if C.SDL_ConvertPixels(C.int(width), C.int(height), C.Uint32(srcFormat), src, C.int(srcPitch), C.Uint32(dstFormat), dst, C.int(dstPitch)) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// FillRect performs a fast fill of a rectangle with a specific color.
+// (https://wiki.libsdl.org/SDL_FillRect)
+func (surface *Surface) FillRect(rect *Rect, color uint32) error {
+	if C.SDL_FillRect(surface.cptr(), rect.cptr(), C.Uint32(color)) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// FillRects performs a fast fill of a set of rectangles with a specific color.
+// (https://wiki.libsdl.org/SDL_FillRects)
+func (surface *Surface) FillRects(rects []Rect, color uint32) error {
+	if C.SDL_FillRects(surface.cptr(), rects[0].cptr(), C.int(len(rects)), C.Uint32(color)) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// Blit performs a fast surface copy to a destination surface.
+// (https://wiki.libsdl.org/SDL_BlitSurface)
+func (surface *Surface) Blit(srcRect *Rect, dst *Surface, dstRect *Rect) error {
+	if C.SDL_BlitSurface(surface.cptr(), srcRect.cptr(), dst.cptr(), dstRect.cptr()) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// BlitScaled performs a scaled surface copy to a destination surface.
+// (https://wiki.libsdl.org/SDL_BlitScaled)
+func (surface *Surface) BlitScaled(srcRect *Rect, dst *Surface, dstRect *Rect) error {
+	if C.SDL_BlitScaled(surface.cptr(), srcRect.cptr(), dst.cptr(), dstRect.cptr()) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// UpperBlit has been replaced by Blit().
+// (https://wiki.libsdl.org/SDL_UpperBlit)
+func (surface *Surface) UpperBlit(srcRect *Rect, dst *Surface, dstRect *Rect) error {
+	if C.SDL_UpperBlit(surface.cptr(), srcRect.cptr(), dst.cptr(), dstRect.cptr()) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// LowerBlit performs low-level surface blitting only.
+// (https://wiki.libsdl.org/SDL_LowerBlit)
+func (surface *Surface) LowerBlit(srcRect *Rect, dst *Surface, dstRect *Rect) error {
+	if C.SDL_LowerBlit(surface.cptr(), srcRect.cptr(), dst.cptr(), dstRect.cptr()) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// SoftStretch has been replaced by BlitScaled().
+// (https://wiki.libsdl.org/SDL_SoftStretch)
+func (surface *Surface) SoftStretch(srcRect *Rect, dst *Surface, dstRect *Rect) error {
+	if C.SDL_SoftStretch(surface.cptr(), srcRect.cptr(), dst.cptr(), dstRect.cptr()) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// UpperBlitScaled has been replaced by BlitScaled().
+// (https://wiki.libsdl.org/SDL_UpperBlitScaled)
+func (surface *Surface) UpperBlitScaled(srcRect *Rect, dst *Surface, dstRect *Rect) error {
+	if C.SDL_UpperBlitScaled(surface.cptr(), srcRect.cptr(), dst.cptr(), dstRect.cptr()) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// LowerBlitScaled performs low-level surface scaled blitting only.
+// (https://wiki.libsdl.org/SDL_LowerBlitScaled)
+func (surface *Surface) LowerBlitScaled(srcRect *Rect, dst *Surface, dstRect *Rect) error {
+	if C.SDL_LowerBlitScaled(surface.cptr(), srcRect.cptr(), dst.cptr(), dstRect.cptr()) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// PixelNum returns the number of pixels stored in the surface.
+func (surface *Surface) PixelNum() int {
+	return int(surface.W * surface.H)
+}
+
+// BytesPerPixel return the number of significant bits in a pixel values of the surface.
+func (surface *Surface) BytesPerPixel() int {
+	return int(surface.Format.BytesPerPixel)
+}
+
+// Pixels returns the actual pixel data of the surface.
+func (surface *Surface) Pixels() []byte {
+	var b []byte
+	length := int(surface.H) * int(surface.Pitch)
+	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+	sliceHeader.Cap = int(length)
+	sliceHeader.Len = int(length)
+	sliceHeader.Data = uintptr(surface.pixels)
+	return b
+}
+
+// Data returns the pointer to the actual pixel data of the surface.
+func (surface *Surface) Data() unsafe.Pointer {
+	return surface.pixels
+}
+
+// Duplicate creates a new surface identical to the existing surface
+func (surface *Surface) Duplicate() (newSurface *Surface, err error) {
+	_newSurface := C.SDL_DuplicateSurface(surface.cptr())
+	if _newSurface == nil {
+		err = GetError()
+		return
+	}
+
+	newSurface = (*Surface)(unsafe.Pointer(_newSurface))
+	return
+}
+
+// ColorModel returns the color model used by this Surface.
+func (surface *Surface) ColorModel() color.Model {
+	switch surface.Format.Format {
+	case PIXELFORMAT_ARGB8888, PIXELFORMAT_ABGR8888:
+		return color.RGBAModel
+	case PIXELFORMAT_RGB888:
+		return color.RGBAModel
+	case PIXELFORMAT_RGB444:
+		return RGB444Model
+	case PIXELFORMAT_RGB332:
+		return RGB332Model
+	case PIXELFORMAT_RGB555:
+		return RGB555Model
+	case PIXELFORMAT_RGB565:
+		return RGB565Model
+	case PIXELFORMAT_BGR555:
+		return BGR555Model
+	case PIXELFORMAT_BGR565:
+		return BGR565Model
+	case PIXELFORMAT_ARGB4444:
+		return ARGB4444Model
+	case PIXELFORMAT_ABGR4444:
+		return ABGR4444Model
+	case PIXELFORMAT_RGBA4444:
+		return RGBA4444Model
+	case PIXELFORMAT_BGRA4444:
+		return BGRA4444Model
+	case PIXELFORMAT_ARGB1555:
+		return ARGB1555Model
+	case PIXELFORMAT_RGBA5551:
+		return RGBA5551Model
+	case PIXELFORMAT_ABGR1555:
+		return ABGR1555Model
+	case PIXELFORMAT_BGRA5551:
+		return BGRA5551Model
+	case PIXELFORMAT_RGBA8888:
+		return RGBA8888Model
+	case PIXELFORMAT_BGRA8888:
+		return BGRA8888Model
+	default:
+		panic("Not implemented yet")
+	}
+}
+
+// Bounds return the bounds of this surface. Currently, it always starts at
+// (0,0), but this is not guaranteed in the future so don't rely on it.
+func (surface *Surface) Bounds() image.Rectangle {
+	return image.Rect(0, 0, int(surface.W), int(surface.H))
+}
+
+// At returns the pixel color at (x, y)
+func (surface *Surface) At(x, y int) color.Color {
+	pix := surface.Pixels()
+	i := int32(y)*surface.Pitch + int32(x)*int32(surface.Format.BytesPerPixel)
+	r, g, b, a := GetRGBA(*((*uint32)(unsafe.Pointer(&pix[i]))), surface.Format)
+	return color.NRGBA{R: r, G: g, B: b, A: a}
+}
+
+// Set the color of the pixel at (x, y) using this surface's color format to
+// convert c to the appropriate byte sequence. This method is required for the
+// draw.Image interface. The surface may require locking before calling Set.
+func (surface *Surface) Set(x, y int, c color.Color) {
+	// All sdl2 colors are a subset of NRGBA so it is safe precision-wise to
+	// convert to NRGBA and use the color components from there.
+	nrgbaColor := color.NRGBAModel.Convert(c).(color.NRGBA)
+	colR, colG, colB, colA := nrgbaColor.R, nrgbaColor.G, nrgbaColor.B, nrgbaColor.A
+
+	pix := surface.Pixels()
+	i := int32(y)*surface.Pitch + int32(x)*int32(surface.Format.BytesPerPixel)
+	switch surface.Format.Format {
+	case PIXELFORMAT_ARGB8888:
+		pix[i+3] = colA
+		pix[i+2] = colR
+		pix[i+1] = colG
+		pix[i+0] = colB
+	case PIXELFORMAT_ABGR8888:
+		pix[i+3] = colA
+		pix[i+2] = colB
+		pix[i+1] = colG
+		pix[i+0] = colR
+	case PIXELFORMAT_RGB24, PIXELFORMAT_RGB888:
+		pix[i+2] = colR
+		pix[i+1] = colG
+		pix[i+0] = colB
+	case PIXELFORMAT_BGR24, PIXELFORMAT_BGR888:
+		pix[i+2] = colB
+		pix[i+1] = colG
+		pix[i+0] = colR
+	case PIXELFORMAT_RGB444:
+		buf := (*uint32)(unsafe.Pointer(&pix[i]))
+		r := uint32(colR) >> 4 & 0x0F
+		g := uint32(colG) >> 4 & 0x0F
+		b := uint32(colB) >> 4 & 0x0F
+		*buf = r<<8 | g<<4 | b
+	case PIXELFORMAT_RGB332:
+		buf := (*uint32)(unsafe.Pointer(&pix[i]))
+		r := uint32(colR) >> 5 & 0x0F
+		g := uint32(colG) >> 5 & 0x0F
+		b := uint32(colB) >> 6 & 0x0F
+		*buf = r<<5 | g<<2 | b
+	case PIXELFORMAT_RGB565:
+		buf := (*uint32)(unsafe.Pointer(&pix[i]))
+		r := uint32(colR) >> 3 & 0xFF
+		g := uint32(colG) >> 2 & 0xFF
+		b := uint32(colB) >> 3 & 0xFF
+		*buf = r<<11 | g<<5 | b
+	case PIXELFORMAT_RGB555:
+		buf := (*uint32)(unsafe.Pointer(&pix[i]))
+		r := uint32(colR) >> 3 & 0xFF
+		g := uint32(colG) >> 3 & 0xFF
+		b := uint32(colB) >> 3 & 0xFF
+		*buf = r<<10 | g<<5 | b
+	case PIXELFORMAT_BGR565:
+		buf := (*uint32)(unsafe.Pointer(&pix[i]))
+		r := uint32(colR) >> 3 & 0xFF
+		g := uint32(colG) >> 2 & 0xFF
+		b := uint32(colB) >> 3 & 0xFF
+		*buf = b<<11 | g<<5 | r
+	case PIXELFORMAT_BGR555:
+		buf := (*uint32)(unsafe.Pointer(&pix[i]))
+		r := uint32(colR) >> 3 & 0xFF
+		g := uint32(colG) >> 3 & 0xFF
+		b := uint32(colB) >> 3 & 0xFF
+		*buf = b<<10 | g<<5 | r
+	case PIXELFORMAT_ARGB4444:
+		buf := (*uint32)(unsafe.Pointer(&pix[i]))
+		a := uint32(colA) >> 4 & 0x0F
+		r := uint32(colR) >> 4 & 0x0F
+		g := uint32(colG) >> 4 & 0x0F
+		b := uint32(colB) >> 4 & 0x0F
+		*buf = a<<12 | r<<8 | g<<4 | b
+	case PIXELFORMAT_ABGR4444:
+		buf := (*uint32)(unsafe.Pointer(&pix[i]))
+		a := uint32(colA) >> 4 & 0x0F
+		r := uint32(colR) >> 4 & 0x0F
+		g := uint32(colG) >> 4 & 0x0F
+		b := uint32(colB) >> 4 & 0x0F
+		*buf = a<<12 | b<<8 | g<<4 | r
+	case PIXELFORMAT_RGBA4444:
+		buf := (*uint32)(unsafe.Pointer(&pix[i]))
+		r := uint32(colR) >> 4 & 0x0F
+		g := uint32(colG) >> 4 & 0x0F
+		b := uint32(colB) >> 4 & 0x0F
+		a := uint32(colA) >> 4 & 0x0F
+		*buf = r<<12 | g<<8 | b<<4 | a
+	case PIXELFORMAT_BGRA4444:
+		buf := (*uint32)(unsafe.Pointer(&pix[i]))
+		r := uint32(colR) >> 4 & 0x0F
+		g := uint32(colG) >> 4 & 0x0F
+		b := uint32(colB) >> 4 & 0x0F
+		a := uint32(colA) >> 4 & 0x0F
+		*buf = b<<12 | g<<8 | r<<4 | a
+	case PIXELFORMAT_ARGB1555:
+		buf := (*uint32)(unsafe.Pointer(&pix[i]))
+		r := uint32(colR) >> 3 & 0xFF
+		g := uint32(colG) >> 3 & 0xFF
+		b := uint32(colB) >> 3 & 0xFF
+		a := uint32(0)
+		if colA > 0 {
+			a = 1
+		}
+		*buf = a<<15 | r<<10 | g<<5 | b
+	case PIXELFORMAT_RGBA5551:
+		buf := (*uint32)(unsafe.Pointer(&pix[i]))
+		r := uint32(colR) >> 3 & 0xFF
+		g := uint32(colG) >> 3 & 0xFF
+		b := uint32(colB) >> 3 & 0xFF
+		a := uint32(0)
+		if colA > 0 {
+			a = 1
+		}
+		*buf = r<<11 | g<<6 | b<<1 | a
+	case PIXELFORMAT_ABGR1555:
+		buf := (*uint32)(unsafe.Pointer(&pix[i]))
+		r := uint32(colR) >> 3 & 0xFF
+		g := uint32(colG) >> 3 & 0xFF
+		b := uint32(colB) >> 3 & 0xFF
+		a := uint32(0)
+		if colA > 0 {
+			a = 1
+		}
+		*buf = a<<15 | b<<10 | g<<5 | r
+	case PIXELFORMAT_BGRA5551:
+		buf := (*uint32)(unsafe.Pointer(&pix[i]))
+		r := uint32(colR) >> 3 & 0xFF
+		g := uint32(colG) >> 3 & 0xFF
+		b := uint32(colB) >> 3 & 0xFF
+		a := uint32(0)
+		if colA > 0 {
+			a = 1
+		}
+		*buf = b<<11 | g<<6 | r<<1 | a
+	case PIXELFORMAT_RGBA8888:
+		pix[i+3] = colR
+		pix[i+2] = colG
+		pix[i+1] = colB
+		pix[i+0] = colA
+	case PIXELFORMAT_BGRA8888:
+		pix[i+3] = colB
+		pix[i+2] = colG
+		pix[i+1] = colR
+		pix[i+0] = colA
+	default:
+		panic("Unknown pixel format!")
+	}
+}
+
+// SoftStretchLinear performs bilinear scaling between two surfaces of the same format, 32BPP.
+// (https://wiki.libsdl.org/SDL_SoftStretchLinear)
+func (surface *Surface) SoftStretchLinear(srcRect *Rect, dst *Surface, dstRect *Rect) (err error) {
+	return errorFromInt(int(C.SDL_SoftStretchLinear(surface.cptr(), srcRect.cptr(), dst.cptr(), dstRect.cptr())))
+}
+
+// PremultiplyAlpha premultiplies the alpha on a block of pixels.
+//
+// This is safe to use with src == dst, but not for other overlapping areas.
+//
+// This function is currently only implemented for SDL_PIXELFORMAT_ARGB8888.
+//
+// (https://wiki.libsdl.org/SDL_PremultiplyAlpha)
+func PremultiplyAlpha(width, height int, srcFormat uint32, src []byte, srcPitch int, dstFormat uint32, dst []byte, dstPitch int) (err error) {
+	_width := C.int(width)
+	_height := C.int(height)
+	_srcFormat := C.Uint32(srcFormat)
+	_src := unsafe.Pointer(&src[0])
+	_srcPitch := C.int(srcPitch)
+	_dstFormat := C.Uint32(dstFormat)
+	_dst := unsafe.Pointer(&dst[0])
+	_dstPitch := C.int(dstPitch)
+	err = errorFromInt(int(C.SDL_PremultiplyAlpha(_width, _height, _srcFormat, _src, _srcPitch, _dstFormat, _dst, _dstPitch)))
+	return
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/sysrender.go

@@ -0,0 +1,21 @@
+package sdl
+
+// #include "sdl_wrapper.h"
+import "C"
+import "unsafe"
+
+// Texture contains an efficient, driver-specific representation of pixel data.
+// (https://wiki.libsdl.org/SDL_Texture)
+type Texture C.SDL_Texture
+
+// Renderer contains a rendering state.
+// (https://wiki.libsdl.org/SDL_Renderer)
+type Renderer C.SDL_Renderer
+
+func (t *Texture) cptr() *C.SDL_Texture {
+	return (*C.SDL_Texture)(unsafe.Pointer(t))
+}
+
+func (r *Renderer) cptr() *C.SDL_Renderer {
+	return (*C.SDL_Renderer)(unsafe.Pointer(r))
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/system.c

@@ -0,0 +1,9 @@
+#include "_cgo_export.h"
+#include "system.h"
+
+#if defined(_WIN32)
+void SetWindowsMessageHook()
+{
+	SDL_SetWindowsMessageHook((SDL_WindowsMessageHook) goWindowsMessageHook, NULL);
+}
+#endif

archive/vendor/github.com/veandco/go-sdl2/sdl/system.go

@@ -0,0 +1,25 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if !(SDL_VERSION_ATLEAST(2,0,9))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_IsTablet is not supported before SDL 2.0.9")
+#endif
+
+static inline SDL_bool SDL_IsTablet()
+{
+	return SDL_FALSE;
+}
+
+#endif
+*/
+import "C"
+
+// IsTablet returns true if the current device is a tablet
+// TODO: (https://wiki.libsdl.org/SDL_IsTablet)
+func IsTablet() bool {
+	return C.SDL_IsTablet() == C.SDL_TRUE
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/system.h

@@ -0,0 +1,8 @@
+#ifndef _GO_SDL_SYSTEM_H
+#define _GO_SDL_SYSTEM_H
+
+#if defined(_WIN32)
+	extern void SetWindowsMessageHook();
+#endif
+
+#endif

archive/vendor/github.com/veandco/go-sdl2/sdl/system_android.go

@@ -0,0 +1,88 @@
+// +build go1.4
+
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if !(SDL_VERSION_ATLEAST(2,0,8))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_IsAndroidTV is not supported before SDL 2.0.8")
+#endif
+
+static int SDL_IsAndroidTV(void)
+{
+	return -1;
+}
+
+#endif
+
+
+#if !(SDL_VERSION_ATLEAST(2,0,16))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_AndroidShowToast is not supported before SDL 2.0.16")
+#endif
+
+static int SDL_AndroidShowToast(const char* message, int duration, int gravity, int xoffset, int yoffset)
+{
+	return -1;
+}
+
+#endif
+
+*/
+import "C"
+import "unsafe"
+
+// External storage states. See the official Android developer guide for more information.
+// (http://developer.android.com/guide/topics/data/data-storage.html)
+const (
+	ANDROID_EXTERNAL_STORAGE_READ  = C.SDL_ANDROID_EXTERNAL_STORAGE_READ
+	ANDROID_EXTERNAL_STORAGE_WRITE = C.SDL_ANDROID_EXTERNAL_STORAGE_WRITE
+)
+
+// AndroidGetInternalStoragePath returns the path used for internal storage for this application.
+// (https://wiki.libsdl.org/SDL_AndroidGetInternalStoragePath)
+func AndroidGetInternalStoragePath() string {
+	return C.GoString(C.SDL_AndroidGetInternalStoragePath())
+}
+
+// AndroidGetExternalStoragePath returns the path used for external storage for this application.
+// (https://wiki.libsdl.org/SDL_AndroidGetExternalStoragePath)
+func AndroidGetExternalStoragePath() string {
+	return C.GoString(C.SDL_AndroidGetExternalStoragePath())
+}
+
+// AndroidGetExternalStorageState returns the current state of external storage.
+// (https://wiki.libsdl.org/SDL_AndroidGetExternalStorageState)
+func AndroidGetExternalStorageState() int {
+	return int(C.SDL_AndroidGetExternalStorageState())
+}
+
+// AndroidGetJNIEnv returns the Java native interface object (JNIEnv) of the current thread on Android builds.
+// (https://wiki.libsdl.org/SDL_AndroidGetJNIEnv)
+func AndroidGetJNIEnv() unsafe.Pointer {
+	return unsafe.Pointer(C.SDL_AndroidGetJNIEnv())
+}
+
+// AndroidGetActivity returns the Java instance of the activity class in an Android application.
+// (https://wiki.libsdl.org/SDL_AndroidGetActivity)
+func AndroidGetActivity() unsafe.Pointer {
+	return unsafe.Pointer(C.SDL_AndroidGetActivity())
+}
+
+// IsAndroidTV returns true if the application is running on Android TV
+// (https://wiki.libsdl.org/SDL_IsAndroidTV)
+func IsAndroidTV() bool {
+	return C.SDL_IsAndroidTV() >= 0
+}
+
+// AndroidShowToast shows an Android toast notification.
+// (https://wiki.libsdl.org/SDL_AndroidShowToast)
+func AndroidShowToast(message string, duration, gravity, xoffset, yoffset int) (err error) {
+	_message := C.CString(message)
+	defer C.free(unsafe.Pointer(_message))
+	return errorFromInt(int(C.SDL_AndroidShowToast(_message, C.int(duration), C.int(gravity), C.int(xoffset), C.int(yoffset))))
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/system_linux.go

@@ -0,0 +1,57 @@
+// +build !android
+
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if !(SDL_VERSION_ATLEAST(2,0,9))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_LinuxSetThreadPriority is not supported before SDL 2.0.9")
+#endif
+
+static int SDL_LinuxSetThreadPriority(Sint64 threadID, int priority)
+{
+	return -1;
+}
+
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,18))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_LinuxSetThreadPriorityAndPolicy is not supported before SDL 2.0.18")
+#endif
+
+static int SDL_LinuxSetThreadPriorityAndPolicy(Sint64 threadID, int sdlPriority, int schedPolicy)
+{
+	return -1;
+}
+
+#endif
+*/
+import "C"
+
+// LinuxSetThreadPriority sets the UNIX nice value for a thread.
+//
+// This uses setpriority() if possible, and RealtimeKit if available.
+//
+// (https://wiki.libsdl.org/SDL_LinuxSetThreadPriority)
+func LinuxSetThreadPriority(threadID int64, priority int) (err error) {
+	_threadID := C.Sint64(threadID)
+	_priority := C.int(priority)
+	return errorFromInt(int(C.SDL_LinuxSetThreadPriority(_threadID, _priority)))
+}
+
+// LinuxSetThreadPriority sets the priority (not nice level) and scheduling policy for a thread.
+//
+// This uses setpriority() if possible, and RealtimeKit if available.
+//
+// (https://wiki.libsdl.org/SDL_LinuxSetThreadPriorityAndPolicy)
+func LinuxSetThreadPriorityAndPolicy(threadID int64, sdlPriority, schedPolicy int) (err error) {
+	_threadID := C.Sint64(threadID)
+	_sdlPriority := C.int(sdlPriority)
+	_schedPolicy := C.int(schedPolicy)
+	return errorFromInt(int(C.SDL_LinuxSetThreadPriorityAndPolicy(_threadID, _sdlPriority, _schedPolicy)))
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/system_windows.go

@@ -0,0 +1,55 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+#include "system.h"
+
+#if !(SDL_VERSION_ATLEAST(2,0,16))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_RenderGetD3D11Device is not supported before SDL 2.0.16")
+#endif
+
+typedef struct ID3D11Device ID3D11Device;
+
+static ID3D11Device* SDL_RenderGetD3D11Device(SDL_Renderer * renderer)
+{
+	return NULL;
+}
+
+#endif
+*/
+import "C"
+import (
+	"unsafe"
+)
+
+type WindowsMessageHook func(userdata interface{}, hWnd unsafe.Pointer, message uint32, wParam uint64, lParam int64)
+var windowsMessageHook WindowsMessageHook
+
+type ID3D11Device C.ID3D11Device;
+
+// SetWindowsMessageHook sets a callback for every Windows message, run before TranslateMessage().
+// (https://wiki.libsdl.org/SDL_SetWindowsMessageHook)
+func SetWindowsMessageHook(callback WindowsMessageHook, userdata interface{}) {
+	windowsMessageHook = callback
+	C.SetWindowsMessageHook()
+}
+
+//export goWindowsMessageHook
+func goWindowsMessageHook(userdata interface{}, hWnd unsafe.Pointer, message uint32, wParam uint64, lParam int64) {
+	if windowsMessageHook == nil {
+		return
+	}
+	windowsMessageHook(userdata, hWnd, message, wParam, lParam)
+}
+
+// SDL_RenderGetD3D11Device gets the D3D11 device associated with a renderer.
+// (https://wiki.libsdl.org/SDL_RenderGetD3D11Device)
+func (renderer *Renderer) GetD3D11Device() (device *ID3D11Device, err error) {
+	device = (*ID3D11Device)(C.SDL_RenderGetD3D11Device(renderer.cptr()))
+	if device == nil {
+		err = GetError()
+	}
+	return
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/syswm.go

@@ -0,0 +1,146 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if defined(__WIN32)
+#include <SDL2/SDL_syswm.h>
+#else
+#include <SDL_syswm.h>
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,2))
+#define SDL_SYSWM_WAYLAND SDL_SYSWM_UNKNOWN
+#define SDL_SYSWM_MIR SDL_SYSWM_UNKNOWN
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,3))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_SYSWM_WINRT is not supported before SDL 2.0.3")
+#endif
+
+#define SDL_SYSWM_WINRT (0)
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,4))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_SYSWM_ANDROID is not supported before SDL 2.0.4")
+#endif
+
+#define SDL_SYSWM_ANDROID (0)
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,5))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_SYSWM_VIVANTE is not supported before SDL 2.0.5")
+#endif
+
+#define SDL_SYSWM_VIVANTE (0)
+#endif
+*/
+import "C"
+import "unsafe"
+
+// Various supported windowing subsystems.
+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)
+)
+
+// SysWMInfo contains system-dependent information about a window.
+// (https://wiki.libsdl.org/SDL_SysWMinfo)
+type SysWMInfo struct {
+	Version   Version  // a Version structure that contains the current SDL version
+	Subsystem uint32   // the windowing system type
+	dummy     [24]byte // unused (to help compilers when no specific system is available)
+}
+
+// WindowsInfo contains Microsoft Windows window information.
+type WindowsInfo struct {
+	Window unsafe.Pointer // the window handle
+	DeviceContext unsafe.Pointer // the device context handle
+	Instance unsafe.Pointer // the instance handle
+}
+
+// X11Info contains X Window System window information.
+type X11Info struct {
+	Display unsafe.Pointer // the X11 display
+	Window  uint           // the X11 window
+}
+
+// DFBInfo contains DirectFB window information.
+type DFBInfo struct {
+	Dfb     unsafe.Pointer // the DirectFB main interface
+	Window  unsafe.Pointer // the DirectFB window handle
+	Surface unsafe.Pointer // the DirectFB client surface
+}
+
+// CocoaInfo contains Apple Mac OS X window information.
+type CocoaInfo struct {
+	Window unsafe.Pointer // the Cocoa window
+}
+
+// UIKitInfo contains Apple iOS window information.
+type UIKitInfo struct {
+	Window unsafe.Pointer // the UIKit window
+}
+
+// SysWMmsg contains system-dependent window manager messages.
+// (https://wiki.libsdl.org/SDL_SysWMmsg)
+type SysWMmsg struct {
+	Version   Version  // a Version structure that contains the current SDL version
+	Subsystem uint32   // the windowing system type
+	data      [24]byte // internal data
+}
+
+func (info *SysWMInfo) cptr() *C.SDL_SysWMinfo {
+	return (*C.SDL_SysWMinfo)(unsafe.Pointer(info))
+}
+
+// GetWMInfo returns driver specific information about a window.
+// (https://wiki.libsdl.org/SDL_GetWindowWMInfo)
+func (window *Window) GetWMInfo() (*SysWMInfo, error) {
+	var info SysWMInfo
+	VERSION(&info.Version)
+	if C.SDL_GetWindowWMInfo(window.cptr(), info.cptr()) == 0 {
+		return nil, GetError()
+	}
+	return &info, nil
+}
+
+// GetWindowsInfo returns Microsoft Windows window information.
+func (info *SysWMInfo) GetWindowsInfo() *WindowsInfo {
+	return (*WindowsInfo)(unsafe.Pointer(&info.dummy[0]))
+}
+
+// GetX11Info returns X Window System window information.
+func (info *SysWMInfo) GetX11Info() *X11Info {
+	return (*X11Info)(unsafe.Pointer(&info.dummy[0]))
+}
+
+// GetDFBInfo returns DirectFB window information.
+func (info *SysWMInfo) GetDFBInfo() *DFBInfo {
+	return (*DFBInfo)(unsafe.Pointer(&info.dummy[0]))
+}
+
+// GetCocoaInfo returns Apple Mac OS X window information.
+func (info *SysWMInfo) GetCocoaInfo() *CocoaInfo {
+	return (*CocoaInfo)(unsafe.Pointer(&info.dummy[0]))
+}
+
+// GetUIKitInfo returns Apple iOS window information.
+func (info *SysWMInfo) GetUIKitInfo() *UIKitInfo {
+	return (*UIKitInfo)(unsafe.Pointer(&info.dummy[0]))
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/syswm_cocoa.go

@@ -0,0 +1,16 @@
+// +build cocoa OR darwin
+
+package sdl
+
+import "C"
+import "unsafe"
+
+// CocoaMsg contains Apple Mac OS X window information.
+type CocoaMsg struct {
+	dummy C.int
+}
+
+// Cocoa() returns Apple Mac OS X message.
+func (msg *SysWMmsg) Cocoa() *CocoaMsg {
+	return (*CocoaMsg)(unsafe.Pointer(&msg.data[0]))
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/syswm_dfb.go

@@ -0,0 +1,16 @@
+// +build dfb
+
+package sdl
+
+import "C"
+import "unsafe"
+
+// DFBMsg contains DirectFB window information.
+type DFBMsg struct {
+	Event C.DFBEvent
+}
+
+// DFB() returns DirectFB message.
+func (msg *SysWMmsg) DFB() *DFBMsg {
+	return (*DFBMsg)(unsafe.Pointer(&msg.data[0]))
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/syswm_uikit.go

@@ -0,0 +1,16 @@
+// +build uikit
+
+package sdl
+
+import "C"
+import "unsafe"
+
+// UIKitMsg contains Apple iOS window information.
+type UIKitMsg struct {
+	dummy C.int
+}
+
+// UIKit() returns Apple iOS message.
+func (msg *SysWMmsg) UIKit() *UIKitMsg {
+	return (*UIKitMsg)(unsafe.Pointer(&msg.data[0]))
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/syswm_vivante.go

@@ -0,0 +1,16 @@
+// +build vivante
+
+package sdl
+
+import "C"
+import "unsafe"
+
+// VivanteKitMsg contains Vivante window information.
+type VivanteKitMsg struct {
+	dummy C.int
+}
+
+// Vivante() returns Vivante message.
+func (msg *SysWMmsg) Vivante() *VivanteMsg {
+	return (*VivanteMsg)(unsafe.Pointer(&msg.data[0]))
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/syswm_windows.go

@@ -0,0 +1,22 @@
+// +build windows
+
+package sdl
+
+/*
+#include <windef.h>
+*/
+import "C"
+import "unsafe"
+
+// WindowsMsg contains Microsoft Windows window information.
+type WindowsMsg struct {
+	Hwnd   C.HWND
+	Msg    C.UINT
+	WParam C.WPARAM
+	LParam C.LPARAM
+}
+
+// Windows() returns Microsoft Windows message.
+func (msg *SysWMmsg) Windows() *WindowsMsg {
+	return (*WindowsMsg)(unsafe.Pointer(&msg.data[0]))
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/syswm_x11.go

@@ -0,0 +1,19 @@
+// +build x11
+
+package sdl
+
+/*
+#include <X11/Xlib.h>
+*/
+import "C"
+import "unsafe"
+
+// X11Msg contains X Window System window information.
+type X11Msg struct {
+	Event C.XEvent
+}
+
+// X11() returns X Window System message.
+func (msg *SysWMmsg) X11() *X11Msg {
+	return (*X11Msg)(unsafe.Pointer(&msg.data[0]))
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/thread.go

@@ -0,0 +1,10 @@
+package sdl
+
+// #include "sdl_wrapper.h"
+import "C"
+
+// CurrentThreadID gets the thread identifier for the current thread.
+// (https://wiki.libsdl.org/SDL_ThreadID)
+func CurrentThreadID() uint {
+	return uint(C.SDL_ThreadID())
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/timer.go

@@ -0,0 +1,55 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if !(SDL_VERSION_ATLEAST(2,0,18))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_GetTicks64 is not supported before SDL 2.0.18")
+#endif
+
+static inline Uint64 SDLCALL SDL_GetTicks64(void)
+{
+	return 0;
+}
+#endif
+*/
+import "C"
+
+// GetTicks returns the number of milliseconds since the SDL library initialization.
+//
+// Deprecated: This function is not recommended as of SDL 2.0.18; use GetTicks64()
+// instead, where the value doesn't wrap every ~49 days. There are places in
+// SDL where we provide a 32-bit timestamp that can not change without
+// breaking binary compatibility, though, so this function isn't officially
+// deprecated.
+//
+// (https://wiki.libsdl.org/SDL_GetTicks)
+func GetTicks() uint32 {
+	return uint32(C.SDL_GetTicks())
+}
+
+// GetTicks64 returns the number of milliseconds since the SDL library initialization.
+// (https://wiki.libsdl.org/SDL_GetTicks64)
+func GetTicks64() uint64 {
+	return uint64(C.SDL_GetTicks64())
+}
+
+// GetPerformanceCounter returns the current value of the high resolution counter.
+// (https://wiki.libsdl.org/SDL_GetPerformanceCounter)
+func GetPerformanceCounter() uint64 {
+	return uint64(C.SDL_GetPerformanceCounter())
+}
+
+// GetPerformanceFrequency returns the count per second of the high resolution counter.
+// (https://wiki.libsdl.org/SDL_GetPerformanceFrequency)
+func GetPerformanceFrequency() uint64 {
+	return uint64(C.SDL_GetPerformanceFrequency())
+}
+
+// Delay waits a specified number of milliseconds before returning.
+// (https://wiki.libsdl.org/SDL_Delay)
+func Delay(ms uint32) {
+	C.SDL_Delay(C.Uint32(ms))
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/touch.go

@@ -0,0 +1,90 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if !(SDL_VERSION_ATLEAST(2,0,10))
+
+typedef enum
+{
+    SDL_TOUCH_DEVICE_INVALID = -1,
+    SDL_TOUCH_DEVICE_DIRECT,            // touch screen with window-relative coordinates
+    SDL_TOUCH_DEVICE_INDIRECT_ABSOLUTE, // trackpad with absolute device coordinates
+    SDL_TOUCH_DEVICE_INDIRECT_RELATIVE  // trackpad with screen cursor-relative coordinates
+} SDL_TouchDeviceType;
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_GetTouchDeviceType is not supported before SDL 2.0.10")
+#endif
+
+static inline SDL_TouchDeviceType SDL_GetTouchDeviceType(SDL_TouchID touchID)
+{
+	return SDL_TOUCH_DEVICE_INVALID;
+}
+
+#endif
+
+*/
+import "C"
+import "unsafe"
+
+// TOUCH_MOUSEID is the device ID for mouse events simulated with touch input
+const TOUCH_MOUSEID = C.SDL_TOUCH_MOUSEID
+
+// TouchID is the ID of a touch device.
+type TouchID C.SDL_TouchID
+
+// FingerID is a finger id.
+type FingerID C.SDL_FingerID
+
+// TouchDeviceType is a touch device type.
+type TouchDeviceType C.SDL_TouchDeviceType
+
+const (
+	TOUCH_DEVICE_INVALID           TouchDeviceType = C.SDL_TOUCH_DEVICE_INVALID
+	TOUCH_DEVICE_DIRECT                            = C.SDL_TOUCH_DEVICE_DIRECT            // touch screen with window-relative coordinates
+	TOUCH_DEVICE_INDIRECT_ABSOLUTE                 = C.SDL_TOUCH_DEVICE_INDIRECT_ABSOLUTE // trackpad with absolute device coordinates
+	TOUCH_DEVICE_INDIRECT_RELATIVE                 = C.SDL_TOUCH_DEVICE_INDIRECT_RELATIVE // trackpad with screen cursor-relative coordinates
+)
+
+// Finger contains touch information.
+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)
+}
+
+func (t TouchID) c() C.SDL_TouchID {
+	return C.SDL_TouchID(t)
+}
+
+// GetNumTouchDevices returns the number of registered touch devices.
+// (https://wiki.libsdl.org/SDL_GetNumTouchDevices)
+func GetNumTouchDevices() int {
+	return int(C.SDL_GetNumTouchDevices())
+}
+
+// GetTouchDevice returns the touch ID with the given index.
+// (https://wiki.libsdl.org/SDL_GetTouchDevice)
+func GetTouchDevice(index int) TouchID {
+	return TouchID(C.SDL_GetTouchDevice(C.int(index)))
+}
+
+// GetTouchDeviceType returns the type of the given touch device.
+// TODO: (https://wiki.libsdl.org/SDL_GetTouchDeviceType)
+func GetTouchDeviceType(id TouchID) TouchDeviceType {
+	return TouchDeviceType(C.SDL_GetTouchDeviceType(C.SDL_TouchID(id)))
+}
+
+// GetNumTouchFingers returns the number of active fingers for a given touch device.
+// (https://wiki.libsdl.org/SDL_GetNumTouchFingers)
+func GetNumTouchFingers(t TouchID) int {
+	return int(C.SDL_GetNumTouchFingers(t.c()))
+}
+
+// GetTouchFinger returns the finger object for specified touch device ID and finger index.
+// (https://wiki.libsdl.org/SDL_GetTouchFinger)
+func GetTouchFinger(t TouchID, index int) *Finger {
+	return (*Finger)(unsafe.Pointer(C.SDL_GetTouchFinger(t.c(), C.int(index))))
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/version.go

@@ -0,0 +1,86 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if SDL_VERSION_ATLEAST(2,0,16)
+
+static inline int GetRevisionNumber(void)
+{
+	return 0;
+}
+
+#else
+
+static inline int GetRevisionNumber(void)
+{
+	return SDL_GetRevisionNumber();
+}
+
+#endif
+*/
+import "C"
+import "unsafe"
+
+// The version of SDL in use.
+const (
+	MAJOR_VERSION = C.SDL_MAJOR_VERSION // major version
+	MINOR_VERSION = C.SDL_MINOR_VERSION // minor version
+	PATCHLEVEL    = C.SDL_PATCHLEVEL    // update version (patchlevel)
+)
+
+// Version contains information about the version of SDL in use.
+// (https://wiki.libsdl.org/SDL_version)
+type Version struct {
+	Major uint8 // major version
+	Minor uint8 // minor version
+	Patch uint8 // update version (patchlevel)
+}
+type cVersion C.SDL_version
+
+func (v *Version) cptr() *C.SDL_version {
+	return (*C.SDL_version)(unsafe.Pointer(v))
+}
+
+// VERSION fills the selected struct with the version of SDL in use.
+// (https://wiki.libsdl.org/SDL_VERSION)
+func VERSION(v *Version) {
+	v.Major = MAJOR_VERSION
+	v.Minor = MINOR_VERSION
+	v.Patch = PATCHLEVEL
+}
+
+// VERSIONNUM converts separate version components into a single numeric value.
+// (https://wiki.libsdl.org/SDL_VERSIONNUM)
+func VERSIONNUM(x, y, z int) int {
+	return (x*1000 + y*100 + z)
+}
+
+// COMPILEDVERSION returns the SDL version number that you compiled against.
+// (https://wiki.libsdl.org/SDL_COMPILEDVERSION)
+func COMPILEDVERSION() int {
+	return VERSIONNUM(MAJOR_VERSION, MINOR_VERSION, PATCHLEVEL)
+}
+
+// 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 VERSION_ATLEAST(x, y, z int) bool {
+	return COMPILEDVERSION() >= VERSIONNUM(x, y, z)
+}
+
+// GetVersion returns the version of SDL that is linked against your program.
+// (https://wiki.libsdl.org/SDL_GetVersion)
+func GetVersion(v *Version) {
+	C.SDL_GetVersion(v.cptr())
+}
+
+// GetRevision returns the code revision of SDL that is linked against your program.
+// (https://wiki.libsdl.org/SDL_GetRevision)
+func GetRevision() string {
+	return (string)(C.GoString(C.SDL_GetRevision()))
+}
+
+// Deprecated: GetRevisionNumber is deprecated in SDL2 2.0.16 and will return 0. Users should use GetRevision instead.
+func GetRevisionNumber() int {
+	return (int)(C.GetRevisionNumber())
+}

archive/vendor/github.com/veandco/go-sdl2/sdl/vulkan.go

@@ -0,0 +1,165 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if (SDL_VERSION_ATLEAST(2,0,6))
+#if defined(_WIN32)
+	#include <SDL2/SDL_vulkan.h>
+#else
+	#include <SDL_vulkan.h>
+#endif
+#else //!SDL_VERSION_ATLEAST(2,0,6)
+
+#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
+#if defined(__LP64__) || defined(_WIN64) || defined(__x86_64__) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
+#define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;
+#else
+#define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
+#endif
+
+VK_DEFINE_HANDLE(VkInstance)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)
+typedef VkInstance SDL_vulkanInstance;
+typedef VkSurfaceKHR SDL_vulkanSurface;
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_Vulkan_LoadLibrary is not supported before SDL 2.0.6")
+#endif
+
+static int SDL_Vulkan_LoadLibrary(const char *path)
+{
+	return 0;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_Vulkan_GetVkGetInstanceProcAddr is not supported before SDL 2.0.6")
+#endif
+
+static void* SDL_Vulkan_GetVkGetInstanceProcAddr(void)
+{
+	return NULL;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_Vulkan_UnloadLibrary is not supported before SDL 2.0.6")
+#endif
+
+static void SDL_Vulkan_UnloadLibrary(void) {}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_Vulkan_GetInstanceExtensions is not supported before SDL 2.0.6")
+#endif
+
+static int SDL_Vulkan_GetInstanceExtensions(SDL_Window *window, unsigned int *pCount, const char **pNames)
+{
+	return 0;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_Vulkan_CreateSurface is not supported before SDL 2.0.6")
+#endif
+
+static int SDL_Vulkan_CreateSurface(SDL_Window *window, VkInstance instance, VkSurfaceKHR *surface)
+{
+	return 0;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_Vulkan_GetDrawableSize is not supported before SDL 2.0.6")
+#endif
+
+static void SDL_Vulkan_GetDrawableSize(SDL_Window *window, int *w, int *h) {
+	*w = 0;
+	*h = 0;
+}
+
+#endif
+*/
+import "C"
+import (
+	"errors"
+	"reflect"
+	"unsafe"
+)
+
+// VulkanLoadLibrary dynamically loads a Vulkan loader library.
+// (https://wiki.libsdl.org/SDL_Vulkan_LoadLibrary)
+func VulkanLoadLibrary(path string) error {
+	var ret C.int
+	if path == "" {
+		ret = C.SDL_Vulkan_LoadLibrary(nil)
+	} else {
+		cpath := C.CString(path)
+		defer C.free(unsafe.Pointer(cpath))
+		ret = C.SDL_Vulkan_LoadLibrary(cpath)
+	}
+	if int(ret) == -1 {
+		return GetError()
+	}
+	return nil
+}
+
+// VulkanGetVkGetInstanceProcAddr gets the address of the vkGetInstanceProcAddr function.
+// (https://wiki.libsdl.org/SDL_Vulkan_GetVkInstanceProcAddr)
+func VulkanGetVkGetInstanceProcAddr() unsafe.Pointer {
+	return C.SDL_Vulkan_GetVkGetInstanceProcAddr()
+}
+
+// VulkanUnloadLibrary unloads the Vulkan loader library previously loaded by VulkanLoadLibrary().
+// (https://wiki.libsdl.org/SDL_Vulkan_UnloadLibrary)
+func VulkanUnloadLibrary() {
+	C.SDL_Vulkan_UnloadLibrary()
+}
+
+// VulkanGetInstanceExtensions gets the names of the Vulkan instance extensions needed to create a surface with VulkanCreateSurface().
+// (https://wiki.libsdl.org/SDL_Vulkan_GetInstanceExtensions)
+func (window *Window) VulkanGetInstanceExtensions() []string {
+	var count C.uint
+	C.SDL_Vulkan_GetInstanceExtensions(window.cptr(), &count, nil)
+	if count == 0 {
+		return nil
+	}
+
+	strptrs := make([]*C.char, uint(count))
+	C.SDL_Vulkan_GetInstanceExtensions(window.cptr(), &count, &strptrs[0])
+	extensions := make([]string, uint(count))
+	for i := range strptrs {
+		extensions[i] = C.GoString(strptrs[i])
+	}
+	return extensions
+}
+
+// VulkanCreateSurface creates a Vulkan rendering surface for a window.
+// (https://wiki.libsdl.org/SDL_Vulkan_CreateSurface)
+func (window *Window) VulkanCreateSurface(instance interface{}) (surface unsafe.Pointer, err error) {
+	if instance == nil {
+		return nil, errors.New("vulkan: instance is nil")
+	}
+	val := reflect.ValueOf(instance)
+	if val.Kind() != reflect.Ptr {
+		return nil, errors.New("vulkan: instance is not a VkInstance (expected kind Ptr, got " + val.Kind().String() + ")")
+	}
+	var vulkanSurface C.VkSurfaceKHR
+	if C.SDL_Vulkan_CreateSurface(window.cptr(),
+		(C.VkInstance)(unsafe.Pointer(val.Pointer())),
+		(*C.VkSurfaceKHR)(unsafe.Pointer(&vulkanSurface))) == C.SDL_FALSE {
+
+		return nil, GetError()
+	}
+	return unsafe.Pointer(&vulkanSurface), nil
+}
+
+// VulkanGetDrawableSize gets the size of a window's underlying drawable in pixels (for use with setting viewport, scissor & etc).
+// (https://wiki.libsdl.org/SDL_Vulkan_GetDrawableSize)
+func (window *Window) VulkanGetDrawableSize() (w, h int32) {
+	var _w, _h C.int
+	C.SDL_Vulkan_GetDrawableSize(window.cptr(), &_w, &_h)
+	return int32(_w), int32(_h)
+}