move to modules and vendor dependencies

bird.go

@@ -18,7 +18,7 @@ import (
 	"sync"
 
 	"github.com/veandco/go-sdl2/sdl"
-	img "github.com/veandco/go-sdl2/sdl_image"
+	img "github.com/veandco/go-sdl2/img"
 )
 
 const (

go.mod

@@ -0,0 +1,5 @@
+module github.com/campoy/flappy-gopher
+
+go 1.12
+
+require github.com/veandco/go-sdl2 v0.3.0

go.sum

@@ -0,0 +1,2 @@
+github.com/veandco/go-sdl2 v0.3.0 h1:IWYkHMp8V3v37NsKjszln8FFnX2+ab0538J371t+rss=
+github.com/veandco/go-sdl2 v0.3.0/go.mod h1:FB+kTpX9YTE+urhYiClnRzpOXbiWgaU3+5F2AB78DPg=

main.go

@@ -20,7 +20,7 @@ import (
 	"time"
 
 	"github.com/veandco/go-sdl2/sdl"
-	ttf "github.com/veandco/go-sdl2/sdl_ttf"
+	ttf "github.com/veandco/go-sdl2/ttf"
 )
 
 func main() {
@@ -83,7 +83,7 @@ func drawTitle(r *sdl.Renderer, text string) error {
 	defer f.Close()
 
 	c := sdl.Color{R: 255, G: 100, B: 0, A: 255}
-	s, err := f.RenderUTF8_Solid(text, c)
+	s, err := f.RenderUTF8Solid(text, c)
 	if err != nil {
 		return fmt.Errorf("could not render title: %v", err)
 	}

pipes.go

@@ -20,7 +20,7 @@ import (
 	"time"
 
 	"github.com/veandco/go-sdl2/sdl"
-	img "github.com/veandco/go-sdl2/sdl_image"
+	img "github.com/veandco/go-sdl2/img"
 )
 
 type pipes struct {

scene.go

@@ -19,7 +19,7 @@ import (
 	"time"
 
 	"github.com/veandco/go-sdl2/sdl"
-	img "github.com/veandco/go-sdl2/sdl_image"
+	img "github.com/veandco/go-sdl2/img"
 )
 
 type scene struct {

vendor/github.com/veandco/go-sdl2/CONTRIBUTORS.md

@@ -0,0 +1,64 @@
+Contributors
+============
+Here's the list of contributors with their respective Github URLs.
+* [Jacky Boen](https://github.com/jackyb)
+* [HardWareGuy](https://github.com/HardWareGuy)
+* [akovaski](https://github.com/akovaski)
+* [Jeromy Johnson](https://github.com/whyrusleeping)
+* [Cai Lei](https://github.com/ccll)
+* [Arne Döring](https://github.com/krux02)
+* [Marcus von Appen](https://github.com/marcusva)
+* [Tom Murray](https://github.com/TomMurray)
+* [Ian Davis](https://github.com/iand)
+* [hschendel](https://github.com/hschendel)
+* [Ingo Oeser](https://github.com/nightlyone)
+* [nlordell](https://github.com/nlordell)
+* [Ben Davies](https://github.com/JalfResi)
+* [Bastien Dejean](https://github.com/baskerville)
+* [Pirmin Tapken](https://github.com/PirminTapken)
+* [Robert Lillack](https://github.com/roblillack)
+* [Marcell Jusztin](https://github.com/morcmarc)
+* [Stan Schwertly](https://github.com/Stantheman)
+* [Michael Vetter](https://github.com/jubalh)
+* [Tom Fogal](https://github.com/tfogal)
+* [Philipp Meinen](https://github.com/PhiCode)
+* [Thomas McGrew](https://github.com/mcgrew)
+* [Geoff Catlin](https://github.com/gcatlin)
+* [Schobers](https://github.com/Schobers)
+* [Jan Tuitman](https://github.com/jantuitman)
+* [Nick Powell](https://github.com/THUNDERGROOVE)
+* [Steven R. Wiley](https://github.com/srwiley)
+* [Franco Lazzarino](https://github.com/flazz)
+* [Jason Alan Palmer](https://github.com/jalan)
+* [Seuk Won Kang](https://github.com/kasworld)
+* [Brandon Mulcahy](https://github.com/jangler)
+* [Tim Anema](https://github.com/tanema)
+* [Tyler Compton](https://github.com/velovix)
+* [Nicolas Hess](https://github.com/n0dev)
+* [Stephen Noonan](https://github.com/tycho)
+* [Guilherme Freitas Nemeth](https://github.com/glhrmfrts)
+* [Charney Kaye](https://github.com/charneykaye)
+* [Lars Scheme](https://github.com/gonutz)
+* [Emil Laine](https://github.com/emlai)
+* [Sergey Parshukov](https://github.com/jBugman)
+* [Casey DeLorme](https://github.com/cdelorme)
+* [Andreas T. Jonsson](https://github.com/andreas-jonsson)
+* [Milan Nikolic](https://github.com/gen2brain)
+* [Mike Gerow](https://github.com/gerow)
+* [Lilis Iskandar](https://github.com/veeableful)
+* [tfriedel6](https://github.com/tfriedel6)
+* [Eric Bronner](https://github.com/MoonWatcher582)
+* [Julien Castelain](https://github.com/julien)
+* [Robert Wallis](https://github.com/robert-wallis)
+* [Chae-Young Song](https://github.com/chaeyoungsong)
+* [Robert Wallis](https://github.com/robert-wallis)
+* [Lennart Buhl](https://github.com/r41d)
+* [Giovanni Bajo](https://github.com/rasky)
+* [Laurent Vaucher](https://github.com/slowfrog)
+* [Mike](https://github.com/barbeque)
+* [Tomas Virgl](https://github.com/tvi)
+* [Aye Aye Maung](https://github.com/ZeroXLR)
+* [Anton Malashin](https://github.com/malashin)
+* [John Perkins](https://github.com/mpath)
+
+_if anyone is missing, let me know!.. or you can add yourself in :)_

vendor/github.com/veandco/go-sdl2/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2013, Go-SDL2 Authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+	* Neither the name of Go-SDL2 nor the names of its contributors may be
+used to endorse or promote products derived from this software without specific
+prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/github.com/veandco/go-sdl2/img/sdl_image.go

@@ -0,0 +1,405 @@
+// Package img is a simple library to load images of various formats as SDL surfaces.
+package img
+
+//#include <stdlib.h>
+//#include "sdl_image_wrapper.h"
+import "C"
+import "unsafe"
+import "errors"
+import "github.com/veandco/go-sdl2/sdl"
+
+// Flags which may be passed to img.Init() to load support of image formats, can be bitwise OR'd together.
+const (
+	INIT_JPG  = 0x00000001 // JPG
+	INIT_PNG  = 0x00000002 // PNG
+	INIT_TIF  = 0x00000004 // TIF
+	INIT_WEBP = 0x00000008 // WebP
+)
+
+// LinkedVersion returns the version of the dynamically linked SDL_image library.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_7.html)
+func LinkedVersion() *sdl.Version {
+	return (*sdl.Version)(unsafe.Pointer(C.IMG_Linked_Version()))
+}
+
+// Init loads dynamic libraries and prepares them for use. Flags should be one or more flags from IMG_InitFlags OR'd together. It returns the flags successfully initialized, or 0 on failure.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_8.html)
+func Init(flags int) int {
+	_flags := (C.int)(flags)
+	return int(C.IMG_Init(_flags))
+}
+
+// Quit unloads libraries loaded with img.Init().
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_9.html)
+func Quit() {
+	C.IMG_Quit()
+}
+
+// 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 sdl.ClearError().
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_45.html)
+func GetError() error {
+	e := C.IMG_GetError()
+	if e == nil {
+		return nil
+	}
+	return errors.New(C.GoString(e))
+}
+
+// LoadTypedRW loads an image from an SDL data source. The 'type' may be one of: "BMP", "GIF", "PNG", etc. If the image format supports a transparent pixel, SDL will set the colorkey for the surface.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_13.html)
+func LoadTypedRW(src *sdl.RWops, freesrc bool, type_ string) (*sdl.Surface, error) {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	_freesrc := (C.int)(sdl.Btoi(freesrc))
+	_type := C.CString(type_)
+	defer C.free(unsafe.Pointer(_type))
+	_surface := C.IMG_LoadTyped_RW(_src, _freesrc, _type)
+	if _surface == nil {
+		return nil, GetError()
+	}
+	return (*sdl.Surface)(unsafe.Pointer(_surface)), nil
+}
+
+// Load loads a file for use as an image in a new surface.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_11.html)
+func Load(file string) (*sdl.Surface, error) {
+	_file := C.CString(file)
+	defer C.free(unsafe.Pointer(_file))
+	_surface := C.IMG_Load(_file)
+	if _surface == nil {
+		return nil, GetError()
+	}
+	return (*sdl.Surface)(unsafe.Pointer(_surface)), nil
+}
+
+// LoadRW loads an image from an SDL data source for use as a surface.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_12.html)
+func LoadRW(src *sdl.RWops, freesrc bool) (*sdl.Surface, error) {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	_freesrc := (C.int)(sdl.Btoi(freesrc))
+	_surface := C.IMG_Load_RW(_src, _freesrc)
+	if _surface == nil {
+		return nil, GetError()
+	}
+	return (*sdl.Surface)(unsafe.Pointer(_surface)), nil
+}
+
+// LoadTexture loads an image directly into a render texture.
+func LoadTexture(renderer *sdl.Renderer, file string) (*sdl.Texture, error) {
+	_renderer := (*C.SDL_Renderer)(unsafe.Pointer(renderer))
+	_file := C.CString(file)
+	defer C.free(unsafe.Pointer(_file))
+	_surface := C.IMG_LoadTexture(_renderer, _file)
+	if _surface == nil {
+		return nil, GetError()
+	}
+	return (*sdl.Texture)(unsafe.Pointer(_surface)), nil
+}
+
+// LoadTextureRW loads an image from an SDL data source directly into a render texture.
+func LoadTextureRW(renderer *sdl.Renderer, src *sdl.RWops, freesrc bool) (*sdl.Texture, error) {
+	_renderer := (*C.SDL_Renderer)(unsafe.Pointer(renderer))
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	_freesrc := (C.int)(sdl.Btoi(freesrc))
+	_surface := C.IMG_LoadTexture_RW(_renderer, _src, _freesrc)
+	if _surface == nil {
+		return nil, GetError()
+	}
+	return (*sdl.Texture)(unsafe.Pointer(_surface)), nil
+}
+
+// IsICO reports whether ICO format is supported and image data is readable as an ICO.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_31.html)
+func IsICO(src *sdl.RWops) bool {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	return int(C.IMG_isICO(_src)) > 0
+}
+
+// IsCUR reports whether CUR format is supported and image data is readable as a CUR.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_30.html)
+func IsCUR(src *sdl.RWops) bool {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	return int(C.IMG_isCUR(_src)) > 0
+}
+
+// IsBMP reports whether BMP format is supported and image data is readable as a BMP.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_32.html)
+func IsBMP(src *sdl.RWops) bool {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	return int(C.IMG_isBMP(_src)) > 0
+}
+
+// IsGIF reports whether GIF format is supported and image data is readable as a GIF.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_37.html)
+func IsGIF(src *sdl.RWops) bool {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	return int(C.IMG_isGIF(_src)) > 0
+}
+
+// IsJPG reports whether JPG format is supported and image data is readable as a JPG.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_38.html)
+func IsJPG(src *sdl.RWops) bool {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	return int(C.IMG_isJPG(_src)) > 0
+}
+
+// IsLBM reports whether LBM format is supported and image data is readable as an LBM.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_41.html)
+func IsLBM(src *sdl.RWops) bool {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	return int(C.IMG_isLBM(_src)) > 0
+}
+
+// IsPCX reports whether PCX format is supported and image data is readable as a PCX.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_36.html)
+func IsPCX(src *sdl.RWops) bool {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	return int(C.IMG_isPCX(_src)) > 0
+}
+
+// IsPNG reports whether PNG format is supported and image data is readable as a PNG.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_40.html)
+func IsPNG(src *sdl.RWops) bool {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	return int(C.IMG_isPNG(_src)) > 0
+}
+
+// IsPNM reports whether PNM format is supported and image data is readable as a PNM.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_33.html)
+func IsPNM(src *sdl.RWops) bool {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	return int(C.IMG_isPNM(_src)) > 0
+}
+
+// IsTIF reports whether TIF format is supported and image data is readable as a TIF.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_39.html)
+func IsTIF(src *sdl.RWops) bool {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	return int(C.IMG_isTIF(_src)) > 0
+}
+
+// IsXCF reports whether XCF format is supported and image data is readable as an XCF.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_35.html)
+func IsXCF(src *sdl.RWops) bool {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	return int(C.IMG_isXCF(_src)) > 0
+}
+
+// IsXPM reports whether XPM format is supported and image data is readable as an XPM.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_34.html)
+func IsXPM(src *sdl.RWops) bool {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	return int(C.IMG_isXPM(_src)) > 0
+}
+
+// IsXV reports whether XV format is supported and image data is readable as an XV thumbnail.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_42.html)
+func IsXV(src *sdl.RWops) bool {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	return int(C.IMG_isXV(_src)) > 0
+}
+
+// IsWEBP reports whether WEBP format is supported and image data is readable as a WEBP.
+func IsWEBP(src *sdl.RWops) bool {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	return int(C.IMG_isWEBP(_src)) > 0
+}
+
+// LoadICORW loads an ICO image from an SDL data source for use as a surface.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_15.html)
+func LoadICORW(src *sdl.RWops) (*sdl.Surface, error) {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	_surface := C.IMG_LoadICO_RW(_src)
+	if _surface == nil {
+		return nil, GetError()
+	}
+	return (*sdl.Surface)(unsafe.Pointer(_surface)), nil
+}
+
+// LoadCURRW loads a CUR image from an SDL data source for use as a surface.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_14.html)
+func LoadCURRW(src *sdl.RWops) (*sdl.Surface, error) {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	_surface := C.IMG_LoadCUR_RW(_src)
+	if _surface == nil {
+		return nil, GetError()
+	}
+	return (*sdl.Surface)(unsafe.Pointer(_surface)), nil
+}
+
+// LoadBMPRW loads a BMP image from an SDL data source for use as a surface.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_16.html)
+func LoadBMPRW(src *sdl.RWops) (*sdl.Surface, error) {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	_surface := C.IMG_LoadBMP_RW(_src)
+	if _surface == nil {
+		return nil, GetError()
+	}
+	return (*sdl.Surface)(unsafe.Pointer(_surface)), nil
+}
+
+// LoadGIFRW loads a GIF image from an SDL data source for use as a surface.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_21.html)
+func LoadGIFRW(src *sdl.RWops) (*sdl.Surface, error) {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	_surface := C.IMG_LoadGIF_RW(_src)
+	if _surface == nil {
+		return nil, GetError()
+	}
+	return (*sdl.Surface)(unsafe.Pointer(_surface)), nil
+}
+
+// LoadJPGRW loads a JPG image from an SDL data source for use as a surface.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_22.html)
+func LoadJPGRW(src *sdl.RWops) (*sdl.Surface, error) {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	_surface := C.IMG_LoadJPG_RW(_src)
+	if _surface == nil {
+		return nil, GetError()
+	}
+	return (*sdl.Surface)(unsafe.Pointer(_surface)), nil
+}
+
+// LoadLBMRW loads an LBM image from an SDL data source for use as a surface.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_26.html)
+func LoadLBMRW(src *sdl.RWops) (*sdl.Surface, error) {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	_surface := C.IMG_LoadLBM_RW(_src)
+	if _surface == nil {
+		return nil, GetError()
+	}
+	return (*sdl.Surface)(unsafe.Pointer(_surface)), nil
+}
+
+// LoadPCXRW loads a PCX image from an SDL data source for use as a surface.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_20.html)
+func LoadPCXRW(src *sdl.RWops) (*sdl.Surface, error) {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	_surface := C.IMG_LoadPCX_RW(_src)
+	if _surface == nil {
+		return nil, GetError()
+	}
+	return (*sdl.Surface)(unsafe.Pointer(_surface)), nil
+}
+
+// LoadPNGRW loads a PNG image from an SDL data source for use as a surface.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_24.html)
+func LoadPNGRW(src *sdl.RWops) (*sdl.Surface, error) {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	_surface := C.IMG_LoadPNG_RW(_src)
+	if _surface == nil {
+		return nil, GetError()
+	}
+	return (*sdl.Surface)(unsafe.Pointer(_surface)), nil
+}
+
+// LoadPNMRW loads a PNM image from an SDL data source for use as a surface.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_17.html)
+func LoadPNMRW(src *sdl.RWops) (*sdl.Surface, error) {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	_surface := C.IMG_LoadPNM_RW(_src)
+	if _surface == nil {
+		return nil, GetError()
+	}
+	return (*sdl.Surface)(unsafe.Pointer(_surface)), nil
+}
+
+// LoadTGARW loads a TGA image from an SDL data source for use as a surface.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_25.html)
+func LoadTGARW(src *sdl.RWops) (*sdl.Surface, error) {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	_surface := C.IMG_LoadTGA_RW(_src)
+	if _surface == nil {
+		return nil, GetError()
+	}
+	return (*sdl.Surface)(unsafe.Pointer(_surface)), nil
+}
+
+// LoadTIFRW loads a TIF image from an SDL data source for use as a surface.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_23.html)
+func LoadTIFRW(src *sdl.RWops) (*sdl.Surface, error) {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	_surface := C.IMG_LoadTIF_RW(_src)
+	if _surface == nil {
+		return nil, GetError()
+	}
+	return (*sdl.Surface)(unsafe.Pointer(_surface)), nil
+}
+
+// LoadXCFRW loads an XCF image from an SDL data source for use as a surface.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_19.html)
+func LoadXCFRW(src *sdl.RWops) (*sdl.Surface, error) {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	_surface := C.IMG_LoadXCF_RW(_src)
+	if _surface == nil {
+		return nil, GetError()
+	}
+	return (*sdl.Surface)(unsafe.Pointer(_surface)), nil
+}
+
+// LoadXPMRW loads an XPM image from an SDL data source for use as a surface.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_18.html)
+func LoadXPMRW(src *sdl.RWops) (*sdl.Surface, error) {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	_surface := C.IMG_LoadXPM_RW(_src)
+	if _surface == nil {
+		return nil, GetError()
+	}
+	return (*sdl.Surface)(unsafe.Pointer(_surface)), nil
+}
+
+// LoadXVRW loads an XV thumbnail image from an SDL data source for use as a surface.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_27.html)
+func LoadXVRW(src *sdl.RWops) (*sdl.Surface, error) {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	_surface := C.IMG_LoadXV_RW(_src)
+	if _surface == nil {
+		return nil, GetError()
+	}
+	return (*sdl.Surface)(unsafe.Pointer(_surface)), nil
+}
+
+// LoadWEBPRW loads a WEBP image from an SDL data source for use as a surface.
+func LoadWEBPRW(src *sdl.RWops) (*sdl.Surface, error) {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	_surface := C.IMG_LoadWEBP_RW(_src)
+	if _surface == nil {
+		return nil, GetError()
+	}
+	return (*sdl.Surface)(unsafe.Pointer(_surface)), nil
+}
+
+// ReadXPMFromArray loads an XPM image from xpm data for use as a surface.
+// (http://www.libsdl.org/projects/SDL_image/docs/SDL_image_28.html)
+func ReadXPMFromArray(xpm string) (*sdl.Surface, error) {
+	_xpm := C.CString(xpm)
+	defer C.free(unsafe.Pointer(_xpm))
+	_surface := C.IMG_ReadXPMFromArray(&_xpm)
+	if _surface == nil {
+		return nil, GetError()
+	}
+	return (*sdl.Surface)(unsafe.Pointer(_surface)), nil
+}
+
+// SavePNG saves a surface as PNG file.
+func SavePNG(surface *sdl.Surface, file string) error {
+	_surface := (*C.SDL_Surface)(unsafe.Pointer(surface))
+	_file := C.CString(file)
+	defer C.free(unsafe.Pointer(_file))
+	_ret := C.IMG_SavePNG(_surface, _file)
+	if _ret < 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// SavePNGRW saves a surface to an SDL data source.
+func SavePNGRW(surface *sdl.Surface, dst *sdl.RWops, freedst int) error {
+	_surface := (*C.SDL_Surface)(unsafe.Pointer(surface))
+	_dst := (*C.SDL_RWops)(unsafe.Pointer(dst))
+	_freedst := (C.int)(freedst)
+	_ret := C.IMG_SavePNG_RW(_surface, _dst, _freedst)
+	if _ret < 0 {
+		return GetError()
+	}
+	return nil
+}

vendor/github.com/veandco/go-sdl2/img/sdl_image_cgo.go

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

vendor/github.com/veandco/go-sdl2/img/sdl_image_cgo_static.go

@@ -0,0 +1,14 @@
+// +build static
+
+package img
+
+//#cgo CFLAGS: -I${SRCDIR}/../.go-sdl2-libs/include -I${SRCDIR}/../.go-sdl2-libs/include/SDL2
+//#cgo LDFLAGS: -L${SRCDIR}/../.go-sdl2-libs
+//#cgo linux,386 LDFLAGS: -lSDL2_image_linux_386 -Wl,--no-undefined -lpng_linux_386 -ljpeg_linux_386 -lSDL2_linux_386 -lm -ldl -lz -lasound -lm -ldl -lpthread -lX11 -lXext -lXcursor -lXinerama -lXi -lXrandr -lXss -lXxf86vm -lpthread -lrt
+//#cgo linux,amd64 LDFLAGS: -lSDL2_image_linux_amd64 -Wl,--no-undefined -lpng_linux_amd64 -ljpeg_linux_amd64 -lSDL2_linux_amd64 -lm -ldl -lz -lasound -lm -ldl -lpthread -lX11 -lXext -lXcursor -lXinerama -lXi -lXrandr -lXss -lXxf86vm -lpthread -lrt
+//#cgo windows,386 LDFLAGS: -lSDL2_image_windows_386 -Wl,--no-undefined -lpng_windows_386 -ljpeg_windows_386 -lz_windows_386 -lSDL2_windows_386 -lSDL2main_windows_386 -mwindows -Wl,--no-undefined -lm -ldinput8 -ldxguid -ldxerr8 -luser32 -lgdi32 -lwinmm -limm32 -lole32 -loleaut32 -lshell32 -lversion -luuid -static-libgcc
+//#cgo windows,amd64 LDFLAGS: -lSDL2_image_windows_amd64 -Wl,--no-undefined -lpng_windows_amd64 -ljpeg_windows_amd64 -lz_windows_amd64 -lSDL2_windows_amd64 -lSDL2main_windows_amd64 -mwindows -Wl,--no-undefined -lm -ldinput8 -ldxguid -ldxerr8 -luser32 -lgdi32 -lwinmm -limm32 -lole32 -loleaut32 -lshell32 -lversion -luuid -static-libgcc
+//#cgo darwin,amd64 LDFLAGS: -lSDL2_image_darwin_amd64 -lSDL2_darwin_amd64 -lpng_darwin_amd64 -ljpeg_darwin_amd64 -lm -lz -liconv -Wl,-framework,CoreAudio -Wl,-framework,AudioToolbox -Wl,-framework,ForceFeedback -lobjc -Wl,-framework,CoreVideo -Wl,-framework,Cocoa -Wl,-framework,Carbon -Wl,-framework,IOKit
+//#cgo android,arm LDFLAGS: -lSDL2_image_android_arm -Wl,--no-undefined -lpng_android_arm -ljpeg_android_arm -lSDL2_android_arm -lm -ldl -lz -llog -landroid -lGLESv2
+//#cgo linux,arm LDFLAGS: -lSDL2_image_linux_arm -Wl,--no-undefined -lpng_linux_arm -ljpeg_linux_arm -lSDL2_linux_arm -lm -ldl -lz -liconv
+import "C"

vendor/github.com/veandco/go-sdl2/img/sdl_image_wrapper.h

@@ -0,0 +1,6 @@
+#if defined(__WIN32)
+	#include <SDL2/SDL_image.h>
+	#include <stdlib.h>
+#else
+	#include <SDL_image.h>
+#endif

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

@@ -0,0 +1,69 @@
+## 2.0.6
+
+### General
+
+Blend Mode
+
+- [ ] SDL_ComposeCustomBlendMode()
+
+CPU Info
+
+- [ ] SDL_HasNEON()
+
+Game Controller
+
+- [x] SDL_GameControllerGetVendor()
+- [x] SDL_GameControllerGetProduct()
+- [x] SDL_GameControllerGetProductVersion()
+- [x] SDL_GameControllerNumMappings()
+- [x] SDL_GameControllerMappingForIndex()
+
+Hints
+
+- [ ] SDL_HINT_AUDIO_RESAMPLING_MODE
+- [ ] SDL_HINT_RENDER_LOGICAL_SIZE_MODE
+- [ ] SDL_HINT_MOUSE_NORMAL_SPEED_SCALE
+- [ ] SDL_HINT_MOUSE_RELATIVE_SPEED_SCALE
+- [ ] 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
+
+- [ ] SDL_LoadFile()
+- [ ] SDL_LoadFile_RW()
+
+Surface
+
+- [ ] SDL_DuplicateSurface()
+
+Vulkan
+
+- [ ] SDL_Vulkan_LoadLibrary()
+- [ ] SDL_Vulkan_GetVkGetInstanceProcAddr()
+- [ ] SDL_Vulkan_GetInstanceExtensions()
+- [ ] SDL_Vulkan_CreateSurface()
+- [ ] SDL_Vulkan_GetDrawableSize()
+- [ ] SDL_Vulkan_UnloadLibrary()
+
+### Windows
+
+Hints
+
+- [ ] SDL_HINT_WINDOWS_INTRESOURCE_ICON
+- [ ] SDL_HINT_WINDOWS_INTRESOURCE_ICON_SMALL
+
+## Miscellaneous
+
+- [ ] Add ability to set window title bar color on runtime

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

@@ -0,0 +1,475 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if !(SDL_VERSION_ATLEAST(2,0,4))
+#pragma message("SDL_QueueAudio is not supported before SDL 2.0.4")
+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))
+#pragma message("SDL_DequeueAudio is not supported before SDL 2.0.5")
+static int SDL_DequeueAudio(SDL_AudioDeviceID dev, const void *data, Uint32 len)
+{
+	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 // unsigned 8-bit samples
+	AUDIO_U8 = C.AUDIO_U8 // signed 8-bit samples
+
+	AUDIO_S16LSB = C.AUDIO_S16LSB // signed 16-bit samples in little-endian byte order
+	AUDIO_S16MSB = C.AUDIO_S16MSB // signed 16-bit samples in big-endian byte order
+	AUDIO_S16SYS = C.AUDIO_S16SYS // signed 16-bit samples in native byte order
+	AUDIO_S16    = C.AUDIO_S16    // AUDIO_S16LSB
+	AUDIO_U16LSB = C.AUDIO_U16LSB // unsigned 16-bit samples in little-endian byte order
+	AUDIO_U16MSB = C.AUDIO_U16MSB // unsigned 16-bit samples in big-endian byte order
+	AUDIO_U16SYS = C.AUDIO_U16SYS // unsigned 16-bit samples in native byte order
+	AUDIO_U16    = C.AUDIO_U16    // AUDIO_U16LSB
+
+	AUDIO_S32LSB = C.AUDIO_S32LSB // 32-bit integer samples in little-endian byte order
+	AUDIO_S32MSB = C.AUDIO_S32MSB // 32-bit integer samples in big-endian byte order
+	AUDIO_S32SYS = C.AUDIO_S32SYS // 32-bit integer samples in native byte order
+	AUDIO_S32    = C.AUDIO_S32    // AUDIO_S32LSB
+
+	AUDIO_F32LSB = C.AUDIO_F32LSB // 32-bit floating point samples in little-endian byte order
+	AUDIO_F32MSB = C.AUDIO_F32MSB // 32-bit floating point samples in big-endian byte order
+	AUDIO_F32SYS = C.AUDIO_F32SYS // 32-bit floating point samples in native byte order
+	AUDIO_F32    = C.AUDIO_F32    // AUDIO_F32LSB
+)
+
+// 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
+
+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))
+}
+
+// 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.
+// (https://wiki.libsdl.org/SDL_DequeueAudio)
+func DequeueAudio(dev AudioDeviceID, data []byte) error {
+	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&data))
+	_data := unsafe.Pointer(sliceHeader.Data)
+	_len := (C.Uint32)(sliceHeader.Len)
+	if C.SDL_DequeueAudio(dev.c(), _data, _len) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// 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())
+}
+
+/*
+func AudioDeviceConnected(dev AudioDeviceID) int {
+	_dev := (C.SDL_AudioDeviceID) (dev)
+	return int (C.SDL_AudioDeviceConnected(_dev))
+}
+*/

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

@@ -0,0 +1,26 @@
+package sdl
+
+// #include "sdl_wrapper.h"
+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
+
+// BlendMode is an enumeration of blend modes used in Render.Copy() and drawing operations.
+// (https://wiki.libsdl.org/SDL_BlendMode)
+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
+)
+
+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))
+}

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

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

@@ -0,0 +1,104 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if !(SDL_VERSION_ATLEAST(2,0,1))
+#pragma message("SDL_GetSystemRAM is not supported before SDL 2.0.1")
+static inline int SDL_GetSystemRAM()
+{
+	return -1;
+}
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,2))
+#pragma message("SDL_HasAVX is not supported before SDL 2.0.2")
+static inline SDL_bool SDL_HasAVX()
+{
+	return SDL_FALSE;
+}
+#endif
+
+*/
+import "C"
+
+// 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
+}

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

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

@@ -0,0 +1,74 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+void GoSetError(const char *fmt) {
+  SDL_SetError("%s", fmt);
+}
+*/
+// #include "sdl_wrapper.h"
+import "C"
+import "errors"
+
+// 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(nil)
+}
+
+// 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)
+}

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

@@ -0,0 +1,27 @@
+#include "_cgo_export.h"
+#include "events.h"
+
+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);
+}

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

@@ -0,0 +1,10 @@
+#ifndef _GO_SDL_EVENTS_H
+#define _GO_SDL_EVENTS_H
+
+extern void setEventFilter();
+extern void clearEventFilter();
+extern void filterEvents(void *userdata);
+extern void addEventWatch(void *userdata);
+extern void delEventWatch(void *userdata);
+
+#endif

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

@@ -0,0 +1,42 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if !(SDL_VERSION_ATLEAST(2,0,1))
+#pragma message("SDL_GetBasePath is not supported before SDL 2.0.1")
+static inline char* SDL_GetBasePath()
+{
+	return NULL;
+}
+
+#pragma message("SDL_GetPrefPath is not supported before SDL 2.0.1")
+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)
+}

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

@@ -0,0 +1,312 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if !(SDL_VERSION_ATLEAST(2,0,4))
+#pragma message("SDL_GameControllerFromInstanceID is not supported before SDL 2.0.4")
+static SDL_GameController* SDL_GameControllerFromInstanceID(SDL_JoystickID joyid)
+{
+	return NULL;
+}
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,6))
+#pragma message("SDL_GameControllerGetVendor is not supported before SDL 2.0.6")
+static Uint16 SDL_GameControllerGetVendor(SDL_GameController* gamecontroller)
+{
+	return 0;
+}
+
+#pragma message("SDL_GameControllerGetProduct is not supported before SDL 2.0.6")
+static Uint16 SDL_GameControllerGetProduct(SDL_GameController* gamecontroller)
+{
+	return 0;
+}
+
+#pragma message("SDL_GameControllerGetProductVersion is not supported before SDL 2.0.6")
+static Uint16 SDL_GameControllerGetProductVersion(SDL_GameController* gamecontroller)
+{
+	return 0;
+}
+
+#pragma message("SDL_GameControllerNumMappings is not supported before SDL 2.0.6")
+static int SDL_GameControllerNumMappings(void)
+{
+	return 0;
+}
+
+#pragma message("SDL_GameControllerMappingForIndex is not supported before SDL 2.0.6")
+static char* SDL_GameControllerMappingForIndex(int mapping_index)
+{
+	return NULL;
+}
+#endif
+*/
+import "C"
+import "unsafe"
+import "encoding/binary"
+
+// 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)))
+}
+
+// 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()))
+}
+
+// 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()))
+}
+
+// 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)
+}

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

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

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

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

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

@@ -0,0 +1,179 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+#include "hints.h"
+
+#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
+*/
+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_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
+)
+
+// 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)
+	}
+}

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

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

@@ -0,0 +1,374 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if !(SDL_VERSION_ATLEAST(2,0,4))
+#pragma message("SDL_JoystickPowerLevel is not supported before SDL 2.0.4")
+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;
+
+#pragma message("SDL_JoystickCurrentPowerLevel is not supported before SDL 2.0.4")
+static SDL_JoystickPowerLevel SDL_JoystickCurrentPowerLevel(SDL_Joystick* joystick)
+{
+	return SDL_JOYSTICK_POWER_UNKNOWN;
+}
+
+#pragma message("SDL_JoystickFromInstanceID is not supported before SDL 2.0.4")
+static SDL_Joystick* SDL_JoystickFromInstanceID(SDL_JoystickID joyid)
+{
+	return NULL;
+}
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,6))
+#pragma message("SDL_JoystickType is not supported before SDL 2.0.6")
+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;
+
+#pragma message("SDL_JoystickGetDeviceVendor is not supported before SDL 2.0.6")
+static Uint16 SDL_JoystickGetDeviceVendor(int device_index)
+{
+	return 0;
+}
+
+#pragma message("SDL_JoystickGetDeviceProduct is not supported before SDL 2.0.6")
+static Uint16 SDL_JoystickGetDeviceProduct(int device_index)
+{
+	return 0;
+}
+
+#pragma message("SDL_JoystickGetDeviceProductVersion is not supported before SDL 2.0.6")
+static Uint16 SDL_JoystickGetDeviceProductVersion(int device_index)
+{
+	return 0;
+}
+
+#pragma message("SDL_JoystickGetDeviceType is not supported before SDL 2.0.6")
+static SDL_JoystickType SDL_JoystickGetDeviceType(int device_index)
+{
+	return SDL_JOYSTICK_TYPE_UNKNOWN;
+}
+
+#pragma message("SDL_JoystickGetDeviceInstanceID is not supported before SDL 2.0.6")
+static SDL_JoystickID SDL_JoystickGetDeviceInstanceID(int device_index)
+{
+	return 0;
+}
+
+#pragma message("SDL_JoystickGetVendor is not supported before SDL 2.0.6")
+static Uint16 SDL_JoystickGetVendor(SDL_Joystick* joystick)
+{
+	return 0;
+}
+
+#pragma message("SDL_JoystickGetProduct is not supported before SDL 2.0.6")
+static Uint16 SDL_JoystickGetProduct(SDL_Joystick* joystick)
+{
+	return 0;
+}
+
+#pragma message("SDL_JoystickGetProductVersion is not supported before SDL 2.0.6")
+static Uint16 SDL_JoystickGetProductVersion(SDL_Joystick* joystick)
+{
+	return 0;
+}
+
+#pragma message("SDL_JoystickGetType is not supported before SDL 2.0.6")
+static SDL_JoystickType SDL_JoystickGetType(SDL_Joystick* joystick)
+{
+	return SDL_JOYSTICK_TYPE_UNKNOWN;
+}
+
+#pragma message("SDL_JoystickGetAxisInitialState is not supported before SDL 2.0.6")
+static SDL_bool SDL_JoystickGetAxisInitialState(SDL_Joystick* joystick, int axis, Sint16* state)
+{
+	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)))
+}
+
+// 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()))
+}
+
+// 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()))
+}
+
+// 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)))
+}
+
+// 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()))
+}

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

@@ -0,0 +1,121 @@
+package sdl
+
+// #include "sdl_wrapper.h"
+import "C"
+import "unsafe"
+import "reflect"
+
+// 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
+}

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

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

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);
+}

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

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

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

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

@@ -0,0 +1,209 @@
+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))
+#pragma message("SDL_CaptureMouse is not supported before SDL 2.0.4")
+static int SDL_CaptureMouse(SDL_bool enabled)
+{
+	return -1;
+}
+
+#pragma message("SDL_MOUSEWHEEL_NORMAL is not supported before SDL 2.0.4")
+#define SDL_MOUSEWHEEL_NORMAL (0)
+
+#pragma message("SDL_MOUSEWHEEL_FLIPPED is not supported before SDL 2.0.4")
+#define SDL_MOUSEWHEEL_FLIPPED (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()))
+}
+
+// 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)
+}

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

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

@@ -0,0 +1,338 @@
+package sdl
+
+// #include "sdl_wrapper.h"
+import "C"
+import "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.
+// (https://wiki.libsdl.org/SDL_Color)
+type Color struct {
+	R uint8 // the red component in the range 0-255
+	G uint8 // the green component in the range 0-255
+	B uint8 // the blue component in the range 0-255
+	A uint8 // the alpha component in the range 0-255
+}
+
+// Uint32 return uint32 representation of RGBA color.
+func (c Color) Uint32() uint32 {
+	var v uint32
+	v |= uint32(c.A) << 24
+	v |= uint32(c.R) << 16
+	v |= uint32(c.G) << 8
+	v |= uint32(c.B)
+	return v
+}
+
+// RGBA returns the alpha-premultiplied red, green, blue and alpha values
+// for the color. Each value ranges within [0, 0xffff], but is represented
+// by a uint32 so that multiplying by a blend factor up to 0xffff will not
+// overflow.
+//
+// An alpha-premultiplied color component c has been scaled by alpha (a),
+// so has valid values 0 <= c <= a.
+func (c Color) RGBA() (r, g, b, a uint32) {
+	r = uint32(c.R)
+	r |= r << 8
+	g = uint32(c.G)
+	g |= g << 8
+	b = uint32(c.B)
+	b |= b << 8
+	a = uint32(c.A)
+	a |= a << 8
+	return
+}
+
+// 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 int
+	PIXELFORMAT_ARGB32 int
+	PIXELFORMAT_BGRA32 int
+	PIXELFORMAT_ABGR32 int
+)
+
+// These define alpha as the opacity of a surface.
+const (
+	ALPHA_OPAQUE      = C.SDL_ALPHA_OPAQUE
+	ALPHA_TRANSPARENT = C.SDL_ALPHA_TRANSPARENT
+)
+
+func init() {
+	if BYTEORDER == BIG_ENDIAN {
+		PIXELFORMAT_RGBA32 = PIXELFORMAT_RGBA8888
+		PIXELFORMAT_ARGB32 = PIXELFORMAT_ARGB8888
+		PIXELFORMAT_BGRA32 = PIXELFORMAT_BGRA8888
+		PIXELFORMAT_ABGR32 = PIXELFORMAT_ABGR8888
+	} else {
+		PIXELFORMAT_RGBA32 = PIXELFORMAT_ABGR8888
+		PIXELFORMAT_ARGB32 = PIXELFORMAT_BGRA8888
+		PIXELFORMAT_BGRA32 = PIXELFORMAT_ARGB8888
+		PIXELFORMAT_ABGR32 = PIXELFORMAT_RGBA8888
+	}
+}
+
+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 {
+	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])))
+}

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

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

@@ -0,0 +1,389 @@
+package sdl
+
+// #include "sdl_wrapper.h"
+import "C"
+import "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
+}
+
+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))
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+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
+}
+
+// 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
+}

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

@@ -0,0 +1,633 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if !(SDL_VERSION_ATLEAST(2,0,1))
+#pragma message("SDL_UpdateYUVTexture is not supported before SDL 2.0.1")
+static inline int SDL_UpdateYUVTexture(SDL_Texture* texture, const SDL_Rect* rect, const Uint8* Yplane, int Ypitch, const Uint8* Uplane, int Upitch, const Uint8* Vplane, int Vpitch)
+{
+	return -1;
+}
+#endif
+*/
+import "C"
+import (
+	"reflect"
+	"unsafe"
+)
+
+// An enumeration of flags used when creating a rendering context.
+// (https://wiki.libsdl.org/SDL_RendererFlags)
+const (
+	RENDERER_SOFTWARE      = C.SDL_RENDERER_SOFTWARE      // the renderer is a software fallback
+	RENDERER_ACCELERATED   = C.SDL_RENDERER_ACCELERATED   // the renderer uses hardware acceleration
+	RENDERER_PRESENTVSYNC  = C.SDL_RENDERER_PRESENTVSYNC  // present is synchronized with the refresh rate
+	RENDERER_TARGETTEXTURE = C.SDL_RENDERER_TARGETTEXTURE // the renderer supports rendering to texture
+)
+
+// An enumeration of texture access patterns..
+// (https://wiki.libsdl.org/SDL_TextureAccess)
+const (
+	TEXTUREACCESS_STATIC    = C.SDL_TEXTUREACCESS_STATIC    // changes rarely, not lockable
+	TEXTUREACCESS_STREAMING = C.SDL_TEXTUREACCESS_STREAMING // changes frequently, lockable
+	TEXTUREACCESS_TARGET    = C.SDL_TEXTUREACCESS_TARGET    // can be used as a render target
+)
+
+// An enumeration of the texture channel modulation used in Renderer.Copy().
+// (https://wiki.libsdl.org/SDL_TextureModulate)
+const (
+	TEXTUREMODULATE_NONE  = C.SDL_TEXTUREMODULATE_NONE  // no modulation
+	TEXTUREMODULATE_COLOR = C.SDL_TEXTUREMODULATE_COLOR // srcC = srcC * color
+	TEXTUREMODULATE_ALPHA = C.SDL_TEXTUREMODULATE_ALPHA // srcA = srcA * alpha
+)
+
+// An enumeration of flags that can be used in the flip parameter for Renderer.CopyEx().
+// (https://wiki.libsdl.org/SDL_RendererFlip)
+const (
+	FLIP_NONE       RendererFlip = C.SDL_FLIP_NONE       // do not flip
+	FLIP_HORIZONTAL              = C.SDL_FLIP_HORIZONTAL // flip horizontally
+	FLIP_VERTICAL                = C.SDL_FLIP_VERTICAL   // flip vertically
+)
+
+// RendererInfo contains information on the capabilities of a render driver or the current render context.
+// (https://wiki.libsdl.org/SDL_RendererInfo)
+type RendererInfo struct {
+	Name string // the name of the renderer
+	RendererInfoData
+}
+
+type cRendererInfo struct {
+	Name *C.char
+	RendererInfoData
+}
+
+// RendererInfoData contains information on the capabilities of a render driver or the current render context.
+// (https://wiki.libsdl.org/SDL_RendererInfo)
+type RendererInfoData struct {
+	Flags             uint32    // a mask of supported renderer flags
+	NumTextureFormats uint32    // the number of available texture formats
+	TextureFormats    [16]int32 // the available texture formats
+	MaxTextureWidth   int32     // the maximum texture width
+	MaxTextureHeight  int32     // the maximum texture height
+}
+
+func (info *RendererInfo) cptr() *C.SDL_RendererInfo {
+	return (*C.SDL_RendererInfo)(unsafe.Pointer(info))
+}
+
+func (info *cRendererInfo) cptr() *C.SDL_RendererInfo {
+	return (*C.SDL_RendererInfo)(unsafe.Pointer(info))
+}
+
+// RendererFlip is an enumeration of flags that can be used in the flip parameter for Renderer.CopyEx().
+// (https://wiki.libsdl.org/SDL_RendererFlip)
+type RendererFlip uint32
+type cRendererFlip C.SDL_RendererFlip
+
+func (flip RendererFlip) c() C.SDL_RendererFlip {
+	return C.SDL_RendererFlip(flip)
+}
+
+// GetNumRenderDrivers returns the number of 2D rendering drivers available for the current display.
+// (https://wiki.libsdl.org/SDL_GetNumRenderDrivers)
+func GetNumRenderDrivers() (int, error) {
+	i := int(C.SDL_GetNumRenderDrivers())
+	return i, errorFromInt(i)
+}
+
+// GetRenderDriverInfo returns information about a specific 2D rendering driver for the current display.
+// (https://wiki.libsdl.org/SDL_GetRenderDriverInfo)
+func GetRenderDriverInfo(index int, info *RendererInfo) (int, error) {
+	var cinfo cRendererInfo
+	ret := int(C.SDL_GetRenderDriverInfo(C.int(index), cinfo.cptr()))
+	if ret < 0 {
+		return ret, GetError()
+	}
+	info.RendererInfoData = cinfo.RendererInfoData
+	// No need to free, it's done by DestroyRenderer
+	info.Name = C.GoString(cinfo.Name)
+	return ret, nil
+}
+
+// CreateWindowAndRenderer returns a new window and default renderer.
+// (https://wiki.libsdl.org/SDL_CreateWindowAndRenderer)
+func CreateWindowAndRenderer(w, h int32, flags uint32) (*Window, *Renderer, error) {
+	var window *C.SDL_Window
+	var renderer *C.SDL_Renderer
+	ret := C.SDL_CreateWindowAndRenderer(
+		C.int(w),
+		C.int(h),
+		C.Uint32(flags),
+		&window,
+		&renderer)
+	if ret == -1 {
+		return nil, nil, GetError()
+	}
+	return (*Window)(unsafe.Pointer(window)), (*Renderer)(unsafe.Pointer(renderer)), nil
+}
+
+// CreateRenderer returns a new 2D rendering context for a window.
+// (https://wiki.libsdl.org/SDL_CreateRenderer)
+func CreateRenderer(window *Window, index int, flags uint32) (*Renderer, error) {
+	renderer := C.SDL_CreateRenderer(window.cptr(), C.int(index), C.Uint32(flags))
+	if renderer == nil {
+		return nil, GetError()
+	}
+	return (*Renderer)(unsafe.Pointer(renderer)), nil
+}
+
+// CreateSoftwareRenderer returns a new 2D software rendering context for a surface.
+// (https://wiki.libsdl.org/SDL_CreateSoftwareRenderer)
+func CreateSoftwareRenderer(surface *Surface) (*Renderer, error) {
+	renderer := C.SDL_CreateSoftwareRenderer(surface.cptr())
+	if renderer == nil {
+		return nil, GetError()
+	}
+	return (*Renderer)(unsafe.Pointer(renderer)), nil
+}
+
+// GetRenderer returns the renderer associated with a window.
+// (https://wiki.libsdl.org/SDL_GetRenderer)
+func (window *Window) GetRenderer() (*Renderer, error) {
+	renderer := C.SDL_GetRenderer(window.cptr())
+	if renderer == nil {
+		return nil, GetError()
+	}
+	return (*Renderer)(unsafe.Pointer(renderer)), nil
+}
+
+// GetInfo returns information about a rendering context.
+// (https://wiki.libsdl.org/SDL_GetRendererInfo)
+func (renderer *Renderer) GetInfo() (RendererInfo, error) {
+	var cinfo cRendererInfo
+	var info RendererInfo
+	ret := int(C.SDL_GetRendererInfo(renderer.cptr(), cinfo.cptr()))
+	if ret < 0 {
+		return info, GetError()
+	}
+	info.RendererInfoData = cinfo.RendererInfoData
+	// No need to free, it's done by DestroyRenderer
+	info.Name = C.GoString(cinfo.Name)
+	return info, nil
+}
+
+// GetOutputSize returns the output size in pixels of a rendering context.
+// (https://wiki.libsdl.org/SDL_GetRendererOutputSize)
+func (renderer *Renderer) GetOutputSize() (w, h int32, err error) {
+	ret := C.SDL_GetRendererOutputSize(
+		renderer.cptr(),
+		(*C.int)(unsafe.Pointer(&w)),
+		(*C.int)(unsafe.Pointer(&h)))
+	err = errorFromInt(int(ret))
+	return
+}
+
+// CreateTexture returns a new texture for a rendering context.
+// (https://wiki.libsdl.org/SDL_CreateTexture)
+func (renderer *Renderer) CreateTexture(format uint32, access int, w, h int32) (*Texture, error) {
+	texture := C.SDL_CreateTexture(
+		renderer.cptr(),
+		C.Uint32(format),
+		C.int(access),
+		C.int(w),
+		C.int(h))
+	if texture == nil {
+		return nil, GetError()
+	}
+	return (*Texture)(unsafe.Pointer(texture)), nil
+}
+
+// CreateTextureFromSurface returns a new texture from an existing surface.
+// (https://wiki.libsdl.org/SDL_CreateTextureFromSurface)
+func (renderer *Renderer) CreateTextureFromSurface(surface *Surface) (*Texture, error) {
+	texture := C.SDL_CreateTextureFromSurface(renderer.cptr(), surface.cptr())
+	if texture == nil {
+		return nil, GetError()
+	}
+	return (*Texture)(unsafe.Pointer(texture)), nil
+}
+
+// Query returns the attributes of a texture.
+// (https://wiki.libsdl.org/SDL_QueryTexture)
+func (texture *Texture) Query() (uint32, int, int32, int32, error) {
+	var format C.Uint32
+	var access C.int
+	var width C.int
+	var height C.int
+	ret := C.SDL_QueryTexture(texture.cptr(), &format, &access, &width, &height)
+	if ret < 0 {
+		return 0, 0, 0, 0, GetError()
+	}
+	return uint32(format), int(access), int32(width), int32(height), nil
+}
+
+// SetColorMod sets an additional color value multiplied into render copy operations.
+// (https://wiki.libsdl.org/SDL_SetTextureColorMod)
+func (texture *Texture) SetColorMod(r uint8, g uint8, b uint8) error {
+	return errorFromInt(int(
+		C.SDL_SetTextureColorMod(
+			texture.cptr(),
+			C.Uint8(r),
+			C.Uint8(g),
+			C.Uint8(b))))
+}
+
+// SetAlphaMod sets an additional alpha value multiplied into render copy operations.
+// (https://wiki.libsdl.org/SDL_SetTextureAlphaMod)
+func (texture *Texture) SetAlphaMod(alpha uint8) error {
+	return errorFromInt(int(
+		C.SDL_SetTextureAlphaMod(texture.cptr(), C.Uint8(alpha))))
+}
+
+// GetAlphaMod returns the additional alpha value multiplied into render copy operations.
+// (https://wiki.libsdl.org/SDL_GetTextureAlphaMod)
+func (texture *Texture) GetAlphaMod() (alpha uint8, err error) {
+	ret := C.SDL_GetTextureAlphaMod(texture.cptr(), (*C.Uint8)(unsafe.Pointer(&alpha)))
+	return alpha, errorFromInt(int(ret))
+}
+
+// SetBlendMode sets the blend mode for a texture, used by Renderer.Copy().
+// (https://wiki.libsdl.org/SDL_SetTextureBlendMode)
+func (texture *Texture) SetBlendMode(bm BlendMode) error {
+	return errorFromInt(int(
+		C.SDL_SetTextureBlendMode(texture.cptr(), bm.c())))
+}
+
+// GetBlendMode returns the blend mode used for texture copy operations.
+// (https://wiki.libsdl.org/SDL_GetTextureBlendMode)
+func (texture *Texture) GetBlendMode() (bm BlendMode, err error) {
+	ret := C.SDL_GetTextureBlendMode(texture.cptr(), bm.cptr())
+	return bm, errorFromInt(int(ret))
+}
+
+// Update updates the given texture rectangle with new pixel data.
+// (https://wiki.libsdl.org/SDL_UpdateTexture)
+func (texture *Texture) Update(rect *Rect, pixels []byte, pitch int) error {
+	return errorFromInt(int(
+		C.SDL_UpdateTexture(
+			texture.cptr(),
+			rect.cptr(),
+			unsafe.Pointer(&pixels[0]),
+			C.int(pitch))))
+}
+
+// UpdateYUV updates a rectangle within a planar YV12 or IYUV texture with new pixel data.
+// (https://wiki.libsdl.org/SDL_UpdateYUVTexture)
+func (texture *Texture) UpdateYUV(rect *Rect, yPlane []byte, yPitch int, uPlane []byte, uPitch int, vPlane []byte, vPitch int) error {
+	return errorFromInt(int(
+		C.SDL_UpdateYUVTexture(
+			texture.cptr(),
+			rect.cptr(),
+			(*C.Uint8)(unsafe.Pointer(&yPlane[0])),
+			C.int(yPitch),
+			(*C.Uint8)(unsafe.Pointer(&uPlane[0])),
+			C.int(uPitch),
+			(*C.Uint8)(unsafe.Pointer(&vPlane[0])),
+			C.int(vPitch))))
+}
+
+// Lock locks a portion of the texture for write-only pixel access.
+// (https://wiki.libsdl.org/SDL_LockTexture)
+func (texture *Texture) Lock(rect *Rect) ([]byte, int, error) {
+	var _pitch C.int
+	var _pixels unsafe.Pointer
+	var b []byte
+	var length int
+
+	ret := C.SDL_LockTexture(texture.cptr(), rect.cptr(), &_pixels, &_pitch)
+	if ret < 0 {
+		return b, int(_pitch), GetError()
+	}
+
+	_, _, w, h, err := texture.Query()
+	if err != nil {
+		return b, int(_pitch), GetError()
+	}
+
+	pitch := int32(_pitch)
+	if rect != nil {
+		bytesPerPixel := pitch / w
+		length = int(bytesPerPixel * (w*rect.H - rect.X - (w - rect.X - rect.W)))
+	} else {
+		length = int(pitch * h)
+	}
+	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+	sliceHeader.Cap = int(length)
+	sliceHeader.Len = int(length)
+	sliceHeader.Data = uintptr(_pixels)
+
+	return b, int(pitch), nil
+}
+
+// Unlock unlocks a texture, uploading the changes to video memory, if needed.
+// (https://wiki.libsdl.org/SDL_UnlockTexture)
+func (texture *Texture) Unlock() {
+	C.SDL_UnlockTexture(texture.cptr())
+}
+
+// RenderTargetSupported reports whether a window supports the use of render targets.
+// (https://wiki.libsdl.org/SDL_RenderTargetSupported)
+func (renderer *Renderer) RenderTargetSupported() bool {
+	return C.SDL_RenderTargetSupported(renderer.cptr()) != 0
+}
+
+// SetRenderTarget sets a texture as the current rendering target.
+// (https://wiki.libsdl.org/SDL_SetRenderTarget)
+func (renderer *Renderer) SetRenderTarget(texture *Texture) error {
+	return errorFromInt(int(
+		C.SDL_SetRenderTarget(renderer.cptr(), texture.cptr())))
+
+}
+
+// GetRenderTarget returns the current render target.
+// (https://wiki.libsdl.org/SDL_GetRenderTarget)
+func (renderer *Renderer) GetRenderTarget() *Texture {
+	return (*Texture)(unsafe.Pointer(C.SDL_GetRenderTarget(renderer.cptr())))
+}
+
+// SetLogicalSize sets a device independent resolution for rendering.
+// (https://wiki.libsdl.org/SDL_RenderSetLogicalSize)
+func (renderer *Renderer) SetLogicalSize(w, h int32) error {
+	return errorFromInt(int(
+		C.SDL_RenderSetLogicalSize(renderer.cptr(), C.int(w), C.int(h))))
+}
+
+// GetLogicalSize returns device independent resolution for rendering.
+// (https://wiki.libsdl.org/SDL_RenderGetLogicalSize)
+func (renderer *Renderer) GetLogicalSize() (w, h int32) {
+	C.SDL_RenderGetLogicalSize(
+		renderer.cptr(),
+		(*C.int)(unsafe.Pointer(&w)),
+		(*C.int)(unsafe.Pointer(&h)))
+	return
+}
+
+// SetViewport sets the drawing area for rendering on the current target.
+// (https://wiki.libsdl.org/SDL_RenderSetViewport)
+func (renderer *Renderer) SetViewport(rect *Rect) error {
+	return errorFromInt(int(
+		C.SDL_RenderSetViewport(renderer.cptr(), rect.cptr())))
+}
+
+// GetViewport returns the drawing area for the current target.
+// (https://wiki.libsdl.org/SDL_RenderGetViewport)
+func (renderer *Renderer) GetViewport() (rect Rect) {
+	C.SDL_RenderGetViewport(renderer.cptr(), rect.cptr())
+	return
+}
+
+// SetClipRect sets the clip rectangle for rendering on the specified target.
+// (https://wiki.libsdl.org/SDL_RenderSetClipRect)
+func (renderer *Renderer) SetClipRect(rect *Rect) error {
+	return errorFromInt(int(
+		C.SDL_RenderSetClipRect(renderer.cptr(), rect.cptr())))
+}
+
+// GetClipRect returns the clip rectangle for the current target.
+// (https://wiki.libsdl.org/SDL_RenderGetClipRect)
+func (renderer *Renderer) GetClipRect() (rect Rect) {
+	C.SDL_RenderGetClipRect(renderer.cptr(), rect.cptr())
+	return
+}
+
+// SetScale sets the drawing scale for rendering on the current target.
+// (https://wiki.libsdl.org/SDL_RenderSetScale)
+func (renderer *Renderer) SetScale(scaleX, scaleY float32) error {
+	return errorFromInt(int(
+		C.SDL_RenderSetScale(
+			renderer.cptr(),
+			C.float(scaleX),
+			C.float(scaleY))))
+}
+
+// GetScale returns the drawing scale for the current target.
+// (https://wiki.libsdl.org/SDL_RenderGetScale)
+func (renderer *Renderer) GetScale() (scaleX, scaleY float32) {
+	C.SDL_RenderGetScale(
+		renderer.cptr(),
+		(*C.float)(unsafe.Pointer(&scaleX)),
+		(*C.float)(unsafe.Pointer(&scaleY)))
+	return
+}
+
+// SetDrawColor sets the color used for drawing operations (Rect, Line and Clear).
+// (https://wiki.libsdl.org/SDL_SetRenderDrawColor)
+func (renderer *Renderer) SetDrawColor(r, g, b, a uint8) error {
+	return errorFromInt(int(
+		C.SDL_SetRenderDrawColor(
+			renderer.cptr(),
+			C.Uint8(r),
+			C.Uint8(g),
+			C.Uint8(b),
+			C.Uint8(a))))
+}
+
+// SetDrawColorArray is a custom variant of SetDrawColor.
+func (renderer *Renderer) SetDrawColorArray(bs ...uint8) error {
+	_bs := []C.Uint8{0, 0, 0, 255}
+	for i := 0; i < len(_bs) && i < len(bs); i++ {
+		_bs[i] = C.Uint8(bs[i])
+	}
+	return errorFromInt(int(
+		C.SDL_SetRenderDrawColor(
+			renderer.cptr(),
+			_bs[0],
+			_bs[1],
+			_bs[2],
+			_bs[3])))
+}
+
+// GetDrawColor returns the color used for drawing operations (Rect, Line and Clear).
+// (https://wiki.libsdl.org/SDL_GetRenderDrawColor)
+func (renderer *Renderer) GetDrawColor() (r, g, b, a uint8, err error) {
+	ret := C.SDL_GetRenderDrawColor(
+		renderer.cptr(),
+		(*C.Uint8)(unsafe.Pointer(&r)),
+		(*C.Uint8)(unsafe.Pointer(&g)),
+		(*C.Uint8)(unsafe.Pointer(&b)),
+		(*C.Uint8)(unsafe.Pointer(&a)))
+	return r, g, b, a, errorFromInt(int(ret))
+}
+
+// SetDrawBlendMode sets the blend mode used for drawing operations (Fill and Line).
+// (https://wiki.libsdl.org/SDL_SetRenderDrawBlendMode)
+func (renderer *Renderer) SetDrawBlendMode(bm BlendMode) error {
+	return errorFromInt(int(
+		C.SDL_SetRenderDrawBlendMode(renderer.cptr(), bm.c())))
+}
+
+// GetDrawBlendMode returns the blend mode used for drawing operations.
+// (https://wiki.libsdl.org/SDL_GetRenderDrawBlendMode)
+func (renderer *Renderer) GetDrawBlendMode(bm *BlendMode) error {
+	return errorFromInt(int(
+		C.SDL_GetRenderDrawBlendMode(renderer.cptr(), bm.cptr())))
+}
+
+// Clear clears the current rendering target with the drawing color.
+// (https://wiki.libsdl.org/SDL_RenderClear)
+func (renderer *Renderer) Clear() error {
+	return errorFromInt(int(
+		C.SDL_RenderClear(renderer.cptr())))
+}
+
+// DrawPoint draws a point on the current rendering target.
+// (https://wiki.libsdl.org/SDL_RenderDrawPoint)
+func (renderer *Renderer) DrawPoint(x, y int32) error {
+	return errorFromInt(int(
+		C.SDL_RenderDrawPoint(renderer.cptr(), C.int(x), C.int(y))))
+}
+
+// DrawPoints draws multiple points on the current rendering target.
+// (https://wiki.libsdl.org/SDL_RenderDrawPoints)
+func (renderer *Renderer) DrawPoints(points []Point) error {
+	return errorFromInt(int(
+		C.SDL_RenderDrawPoints(
+			renderer.cptr(),
+			points[0].cptr(),
+			C.int(len(points)))))
+}
+
+// DrawLine draws a line on the current rendering target.
+// (https://wiki.libsdl.org/SDL_RenderDrawLine)
+func (renderer *Renderer) DrawLine(x1, y1, x2, y2 int32) error {
+	return errorFromInt(int(
+		C.SDL_RenderDrawLine(
+			renderer.cptr(),
+			C.int(x1),
+			C.int(y1),
+			C.int(x2),
+			C.int(y2))))
+}
+
+// DrawLines draws a series of connected lines on the current rendering target.
+// (https://wiki.libsdl.org/SDL_RenderDrawLines)
+func (renderer *Renderer) DrawLines(points []Point) error {
+	return errorFromInt(int(
+		C.SDL_RenderDrawLines(
+			renderer.cptr(),
+			points[0].cptr(),
+			C.int(len(points)))))
+}
+
+// DrawRect draws a rectangle on the current rendering target.
+// (https://wiki.libsdl.org/SDL_RenderDrawRect)
+func (renderer *Renderer) DrawRect(rect *Rect) error {
+	return errorFromInt(int(
+		C.SDL_RenderDrawRect(renderer.cptr(), rect.cptr())))
+}
+
+// DrawRects draws some number of rectangles on the current rendering target.
+// (https://wiki.libsdl.org/SDL_RenderDrawRects)
+func (renderer *Renderer) DrawRects(rects []Rect) error {
+	return errorFromInt(int(
+		C.SDL_RenderDrawRects(
+			renderer.cptr(),
+			rects[0].cptr(),
+			C.int(len(rects)))))
+}
+
+// FillRect fills a rectangle on the current rendering target with the drawing color.
+// (https://wiki.libsdl.org/SDL_RenderFillRect)
+func (renderer *Renderer) FillRect(rect *Rect) error {
+	return errorFromInt(int(
+		C.SDL_RenderFillRect(renderer.cptr(), rect.cptr())))
+}
+
+// FillRects fills some number of rectangles on the current rendering target with the drawing color.
+// (https://wiki.libsdl.org/SDL_RenderFillRects)
+func (renderer *Renderer) FillRects(rects []Rect) error {
+	return errorFromInt(int(
+		C.SDL_RenderFillRects(
+			renderer.cptr(),
+			rects[0].cptr(),
+			C.int(len(rects)))))
+}
+
+// Copy copies a portion of the texture to the current rendering target.
+// (https://wiki.libsdl.org/SDL_RenderCopy)
+func (renderer *Renderer) Copy(texture *Texture, src, dst *Rect) error {
+	return errorFromInt(int(
+		C.SDL_RenderCopy(
+			renderer.cptr(),
+			texture.cptr(),
+			src.cptr(),
+			dst.cptr())))
+}
+
+// CopyEx copies a portion of the texture to the current rendering target, optionally rotating it by angle around the given center and also flipping it top-bottom and/or left-right.
+// (https://wiki.libsdl.org/SDL_RenderCopyEx)
+func (renderer *Renderer) CopyEx(texture *Texture, src, dst *Rect, angle float64, center *Point, flip RendererFlip) error {
+	return errorFromInt(int(
+		C.SDL_RenderCopyEx(
+			renderer.cptr(),
+			texture.cptr(),
+			src.cptr(),
+			dst.cptr(),
+			C.double(angle),
+			center.cptr(),
+			flip.c())))
+}
+
+// ReadPixels reads pixels from the current rendering target.
+// (https://wiki.libsdl.org/SDL_RenderReadPixels)
+func (renderer *Renderer) ReadPixels(rect *Rect, format uint32, pixels unsafe.Pointer, pitch int) error {
+	return errorFromInt(int(
+		C.SDL_RenderReadPixels(
+			renderer.cptr(),
+			rect.cptr(),
+			C.Uint32(format),
+			pixels,
+			C.int(pitch))))
+}
+
+// Present updates the screen with any rendering performed since the previous call.
+// (https://wiki.libsdl.org/SDL_RenderPresent)
+func (renderer *Renderer) Present() {
+	C.SDL_RenderPresent(renderer.cptr())
+}
+
+// Destroy destroys the specified texture.
+// (https://wiki.libsdl.org/SDL_DestroyTexture)
+func (texture *Texture) Destroy() error {
+	lastErr := GetError()
+	ClearError()
+	C.SDL_DestroyTexture(texture.cptr())
+	err := GetError()
+	if err != nil {
+		return err
+	}
+	SetError(lastErr)
+	return nil
+}
+
+// Destroy destroys the rendering context for a window and free associated textures.
+// (https://wiki.libsdl.org/SDL_DestroyRenderer)
+func (renderer *Renderer) Destroy() error {
+	lastErr := GetError()
+	ClearError()
+	C.SDL_DestroyRenderer(renderer.cptr())
+	err := GetError()
+	if err != nil {
+		return err
+	}
+	SetError(lastErr)
+	return nil
+}
+
+// GLBind binds an OpenGL/ES/ES2 texture to the current context for use with OpenGL instructions when rendering OpenGL primitives directly.
+// (https://wiki.libsdl.org/SDL_GL_BindTexture)
+func (texture *Texture) GLBind(texw, texh *float32) error {
+	return errorFromInt(int(
+		C.SDL_GL_BindTexture(
+			texture.cptr(),
+			(*C.float)(unsafe.Pointer(texw)),
+			(*C.float)(unsafe.Pointer(texh)))))
+}
+
+// GLUnbind unbinds an OpenGL/ES/ES2 texture from the current context.
+// (https://wiki.libsdl.org/SDL_GL_UnbindTexture)
+func (texture *Texture) GLUnbind() error {
+	return errorFromInt(int(
+		C.SDL_GL_UnbindTexture(texture.cptr())))
+}

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

@@ -0,0 +1,270 @@
+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);
+}
+*/
+import "C"
+import "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 unsafe.Pointer, size int) *RWops {
+	if mem == nil {
+		return nil
+	}
+	return (*RWops)(unsafe.Pointer(C.SDL_RWFromMem(mem, C.int(size))))
+}
+
+// AllocRW allocates an empty, unpopulated RWops structure.
+// (https://wiki.libsdl.org/SDL_AllocRW)
+func AllocRW() *RWops {
+	return (*RWops)(unsafe.Pointer(C.SDL_AllocRW()))
+}
+
+// FreeRW frees the RWops structure allocated by AllocRW().
+// (https://wiki.libsdl.org/SDL_FreeRW)
+func (rwops *RWops) FreeRW() {
+	if rwops == nil {
+		return
+	}
+	C.SDL_FreeRW(rwops.cptr())
+}
+
+// RWsize returns the size of the data stream in the RWops.
+// (https://wiki.libsdl.org/SDL_RWsize)
+func (rwops *RWops) RWsize() int64 {
+	return int64(C.RWsize(rwops.cptr()))
+}
+
+// RWseek seek within the RWops data stream.
+// (https://wiki.libsdl.org/SDL_RWseek)
+func (rwops *RWops) RWseek(offset int64, whence int) int64 {
+	if rwops == nil {
+		return -1
+	}
+	return int64(C.RWseek(rwops.cptr(), C.Sint64(offset), C.int(whence)))
+}
+
+// RWread read from a data source.
+// (https://wiki.libsdl.org/SDL_RWread)
+func (rwops *RWops) RWread(ptr unsafe.Pointer, size, maxnum uint) uint {
+	if rwops == nil {
+		return 0
+	}
+	return uint(C.RWread(rwops.cptr(), ptr, C.size_t(size), C.size_t(maxnum)))
+}
+
+// RWtell returns the current read/write offset in the RWops data stream.
+// (https://wiki.libsdl.org/SDL_RWtell)
+func (rwops *RWops) RWtell() int64 {
+	if rwops == nil {
+		return 0
+	}
+	return int64(C.RWseek(rwops.cptr(), 0, RW_SEEK_CUR))
+}
+
+// RWwrite writes to the RWops data stream.
+// (https://wiki.libsdl.org/SDL_RWwrite)
+func (rwops *RWops) RWwrite(ptr unsafe.Pointer, size, num uint) uint {
+	if rwops == nil {
+		return 0
+	}
+	if ptr == nil {
+		return 0
+	}
+	return uint(C.RWwrite(rwops.cptr(), ptr, C.size_t(size), C.size_t(size)))
+}
+
+// RWclose closes and frees the allocated RWops structure.
+// (https://wiki.libsdl.org/SDL_RWclose)
+func (rwops *RWops) RWclose() 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()))
+}
+
+// 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)))
+}

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

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

@@ -0,0 +1,153 @@
+// 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"
+import "C"
+
+import (
+	"runtime"
+)
+
+// These are the flags which may be passed to SDL_Init().
+// (https://wiki.libsdl.org/SDL_Init)
+const (
+	INIT_TIMER          = 0x00000001 // timer subsystem
+	INIT_AUDIO          = 0x00000010 // audio subsystem
+	INIT_VIDEO          = 0x00000020 // video subsystem; automatically initializes the events subsystem
+	INIT_JOYSTICK       = 0x00000200 // joystick subsystem; automatically initializes the events subsystem
+	INIT_HAPTIC         = 0x00001000 // haptic (force feedback) subsystem
+	INIT_GAMECONTROLLER = 0x00002000 // controller subsystem; automatically initializes the joystick subsystem
+	INIT_EVENTS         = 0x00004000 // events subsystem
+	INIT_NOPARACHUTE    = 0x00100000 // compatibility; this flag is ignored
+
+	INIT_EVERYTHING = INIT_TIMER | INIT_AUDIO | INIT_VIDEO | INIT_EVENTS | INIT_JOYSTICK | INIT_HAPTIC | INIT_GAMECONTROLLER // 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()))
+}
+
+// errorFromInt returns GetError() if passed negative value, otherwise it returns nil.
+func errorFromInt(code int) error {
+	if code < 0 {
+		return GetError()
+	}
+	return nil
+}

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 pkg-config: sdl2
+import "C"

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

@@ -0,0 +1,14 @@
+// +build static
+
+package sdl
+
+//#cgo CFLAGS: -I${SRCDIR}/../.go-sdl2-libs/include -I${SRCDIR}/../.go-sdl2-libs/include/SDL2
+//#cgo LDFLAGS: -L${SRCDIR}/../.go-sdl2-libs
+//#cgo linux,386 LDFLAGS: -lSDL2_linux_386 -Wl,--no-undefined -lm -ldl -lasound -lm -ldl -lpthread -lX11 -lXext -lXcursor -lXinerama -lXi -lXrandr -lXss -lXxf86vm -lpthread -lrt
+//#cgo linux,amd64 LDFLAGS: -lSDL2_linux_amd64 -Wl,--no-undefined -lm -ldl -lasound -lm -ldl -lpthread -lX11 -lXext -lXcursor -lXinerama -lXi -lXrandr -lXss -lXxf86vm -lpthread -lrt
+//#cgo windows,386 LDFLAGS: -lSDL2_windows_386 -Wl,--no-undefined -lSDL2main_windows_386 -mwindows -Wl,--no-undefined -lm -ldinput8 -ldxguid -ldxerr8 -luser32 -lgdi32 -lwinmm -limm32 -lole32 -loleaut32 -lshell32 -lversion -luuid -static-libgcc
+//#cgo windows,amd64 LDFLAGS: -lSDL2_windows_amd64 -Wl,--no-undefined -lSDL2main_windows_amd64 -mwindows -Wl,--no-undefined -lm -ldinput8 -ldxguid -ldxerr8 -luser32 -lgdi32 -lwinmm -limm32 -lole32 -loleaut32 -lshell32 -lversion -luuid -static-libgcc
+//#cgo darwin,amd64 LDFLAGS: -lSDL2_darwin_amd64 -lm -liconv -Wl,-framework,CoreAudio -Wl,-framework,AudioToolbox -Wl,-framework,ForceFeedback -lobjc -Wl,-framework,CoreVideo -Wl,-framework,Cocoa -Wl,-framework,Carbon -Wl,-framework,IOKit
+//#cgo android,arm LDFLAGS: -lSDL2_android_arm -Wl,--no-undefined -lm -ldl -llog -landroid -lGLESv2
+//#cgo linux,arm LDFLAGS: -lSDL2_linux_arm -Wl,--no-undefined -lm -ldl -liconv
+import "C"

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

@@ -0,0 +1,6 @@
+#if defined(_WIN32)
+	#include <SDL2/SDL.h>
+	#include <stdlib.h>
+#else
+	#include <SDL.h>
+#endif

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

@@ -0,0 +1,422 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if !(SDL_VERSION_ATLEAST(2,0,5))
+#pragma message("SDL_CreateRGBSurfaceWithFormat is not supported before SDL 2.0.5")
+static inline SDL_Surface* SDL_CreateRGBSurfaceWithFormat(Uint32 flags, int width, int height, int depth, Uint32 format)
+{
+	return NULL;
+}
+
+#pragma message("SDL_CreateRGBSurfaceWithFormatFrom is not supported before SDL 2.0.5")
+static inline SDL_Surface* SDL_CreateRGBSurfaceWithFormatFrom(void* pixels, int width, int height, int depth, int pitch, Uint32 format)
+{
+	return NULL;
+}
+#endif
+*/
+import "C"
+import "unsafe"
+import "reflect"
+
+// 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
+)
+
+// 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
+}
+
+// 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
+}
+
+// GetColorKey retruns 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.W*surface.H) * int(surface.Format.BytesPerPixel)
+	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
+}

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

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

@@ -0,0 +1,44 @@
+// +build go1.4
+
+package sdl
+
+// #include "sdl_wrapper.h"
+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())
+}

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

@@ -0,0 +1,124 @@
+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))
+#pragma message("SDL_SYSWM_WINRT is not supported before SDL 2.0.3")
+#define SDL_SYSWM_WINRT (0)
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,4))
+#pragma message("SDL_SYSWM_ANDROID is not supported before SDL 2.0.4")
+#define SDL_SYSWM_ANDROID (0)
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,5))
+#pragma message("SDL_SYSWM_VIVANTE is not supported before SDL 2.0.5")
+#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
+}
+
+// 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
+}
+
+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]))
+}

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

@@ -0,0 +1,28 @@
+package sdl
+
+// #include "sdl_wrapper.h"
+import "C"
+
+// GetTicks returns the number of milliseconds since the SDL library initialization.
+// (https://wiki.libsdl.org/SDL_GetTicks)
+func GetTicks() uint32 {
+	return uint32(C.SDL_GetTicks())
+}
+
+// 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))
+}

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

@@ -0,0 +1,50 @@
+package sdl
+
+// #include "sdl_wrapper.h"
+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
+
+// 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)))
+}
+
+// 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))))
+}

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

@@ -0,0 +1,69 @@
+package sdl
+
+// #include "sdl_wrapper.h"
+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()))
+}
+
+// GetRevisionNumber returns the revision number of SDL that is linked against your program.
+// (https://wiki.libsdl.org/SDL_GetRevisionNumber)
+func GetRevisionNumber() int {
+	return (int)(C.SDL_GetRevisionNumber())
+}

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

@@ -0,0 +1,904 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+static inline Sint32 ShowMessageBox(SDL_MessageBoxData data)
+{
+	Sint32 buttonid;
+	SDL_ShowMessageBox(&data, &buttonid);
+	return buttonid;
+}
+
+#if !(SDL_VERSION_ATLEAST(2,0,1))
+static void SDL_GL_GetDrawableSize(SDL_Window *window, int *w, int *h)
+{
+	*w = 0;
+	*h = 0;
+}
+
+#pragma message("SDL_WINDOW_ALLOW_HIGHDPI is not supported before SDL 2.0.1")
+#define SDL_WINDOW_ALLOW_HIGHDPI (0)
+
+#pragma message("SDL_GL_FRAMEBUFFER_SRGB_CAPABLE is not supported before SDL 2.0.1")
+#define SDL_GL_FRAMEBUFFER_SRGB_CAPABLE (0)
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,4))
+#pragma message("SDL_WINDOW_MOUSE_CAPTURE is not supported before SDL 2.0.4")
+#define SDL_WINDOW_MOUSE_CAPTURE (0)
+
+#pragma message("SDL_GL_CONTEXT_RELEASE_BEHAVIOR is not supported before SDL 2.0.4")
+#define SDL_GL_CONTEXT_RELEASE_BEHAVIOR (0)
+
+#pragma message("SDL_GetDisplayDPI is not supported before SDL 2.0.4")
+static int SDL_GetDisplayDPI(int displayIndex, float* ddpi, float* hdpi, float* vdpi)
+{
+	return -1;
+}
+
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,5))
+#pragma message("SDL_SetWindowResizable is not supported before SDL 2.0.5")
+static void SDL_SetWindowResizable(SDL_Window *window, SDL_bool resizable)
+{
+}
+
+#pragma message("SDL_SetWindowOpacity is not supported before SDL 2.0.5")
+static int SDL_SetWindowOpacity(SDL_Window *window, float opacity)
+{
+	return -1;
+}
+
+#pragma message("SDL_GetWindowOpacity is not supported before SDL 2.0.5")
+static int SDL_GetWindowOpacity(SDL_Window *window, float *opacity)
+{
+	return -1;
+}
+
+#pragma message("SDL_GetDisplayUsableBounds is not supported before SDL 2.0.5")
+static int SDL_GetDisplayUsableBounds(int displayIndex, SDL_Rect* rect)
+{
+	return -1;
+}
+
+#pragma message("SDL_WINDOW_ALWAYS_ON_TOP is not supported before SDL 2.0.5")
+#define SDL_WINDOW_ALWAYS_ON_TOP (0)
+
+#pragma message("SDL_WINDOW_SKIP_TASKBAR is not supported before SDL 2.0.5")
+#define SDL_WINDOW_SKIP_TASKBAR (0)
+
+#pragma message("SDL_WINDOW_UTILITY is not supported before SDL 2.0.5")
+#define SDL_WINDOW_UTILITY (0)
+
+#pragma message("SDL_WINDOW_TOOLTIP is not supported before SDL 2.0.5")
+#define SDL_WINDOW_TOOLTIP (0)
+
+#pragma message("SDL_WINDOW_POPUP_MENU is not supported before SDL 2.0.5")
+#define SDL_WINDOW_POPUP_MENU (0)
+
+#pragma message("SDL_WINDOWEVENT_TAKE_FOCUS is not supported before SDL 2.0.5")
+#define SDL_WINDOWEVENT_TAKE_FOCUS (0)
+
+#pragma message("SDL_WINDOWEVENT_HIT_TEST is not supported before SDL 2.0.5")
+#define SDL_WINDOWEVENT_HIT_TEST (0)
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,6))
+#pragma message("SDL_WINDOW_VULKAN is not supported before SDL 2.0.6")
+#define SDL_WINDOW_VULKAN (0)
+
+#pragma message("SDL_GL_CONTEXT_RESET_NOTIFICATION is not supported before SDL 2.0.6")
+#define SDL_GL_CONTEXT_RESET_NOTIFICATION (0)
+
+#pragma message("SDL_GL_CONTEXT_NO_ERROR is not supported before SDL 2.0.6")
+#define SDL_GL_CONTEXT_NO_ERROR (0)
+#endif
+*/
+import "C"
+import "unsafe"
+
+// An enumeration of window states.
+// (https://wiki.libsdl.org/SDL_WindowFlags)
+const (
+	WINDOW_FULLSCREEN         = C.SDL_WINDOW_FULLSCREEN         // fullscreen window
+	WINDOW_OPENGL             = C.SDL_WINDOW_OPENGL             // window usable with OpenGL context
+	WINDOW_SHOWN              = C.SDL_WINDOW_SHOWN              // window is visible
+	WINDOW_HIDDEN             = C.SDL_WINDOW_HIDDEN             // window is not visible
+	WINDOW_BORDERLESS         = C.SDL_WINDOW_BORDERLESS         // no window decoration
+	WINDOW_RESIZABLE          = C.SDL_WINDOW_RESIZABLE          // window can be resized
+	WINDOW_MINIMIZED          = C.SDL_WINDOW_MINIMIZED          // window is minimized
+	WINDOW_MAXIMIZED          = C.SDL_WINDOW_MAXIMIZED          // window is maximized
+	WINDOW_INPUT_GRABBED      = C.SDL_WINDOW_INPUT_GRABBED      // window has grabbed input focus
+	WINDOW_INPUT_FOCUS        = C.SDL_WINDOW_INPUT_FOCUS        // window has input focus
+	WINDOW_MOUSE_FOCUS        = C.SDL_WINDOW_MOUSE_FOCUS        // window has mouse focus
+	WINDOW_FULLSCREEN_DESKTOP = C.SDL_WINDOW_FULLSCREEN_DESKTOP // fullscreen window at the current desktop resolution
+	WINDOW_FOREIGN            = C.SDL_WINDOW_FOREIGN            // window not created by SDL
+	WINDOW_ALLOW_HIGHDPI      = C.SDL_WINDOW_ALLOW_HIGHDPI      // window should be created in high-DPI mode if supported (>= SDL 2.0.1)
+	WINDOW_MOUSE_CAPTURE      = C.SDL_WINDOW_MOUSE_CAPTURE      // window has mouse captured (unrelated to INPUT_GRABBED, >= SDL 2.0.4)
+	WINDOW_ALWAYS_ON_TOP      = C.SDL_WINDOW_ALWAYS_ON_TOP      // window should always be above others (X11 only, >= SDL 2.0.5)
+	WINDOW_SKIP_TASKBAR       = C.SDL_WINDOW_SKIP_TASKBAR       // window should not be added to the taskbar (X11 only, >= SDL 2.0.5)
+	WINDOW_UTILITY            = C.SDL_WINDOW_UTILITY            // window should be treated as a utility window (X11 only, >= SDL 2.0.5)
+	WINDOW_TOOLTIP            = C.SDL_WINDOW_TOOLTIP            // window should be treated as a tooltip (X11 only, >= SDL 2.0.5)
+	WINDOW_POPUP_MENU         = C.SDL_WINDOW_POPUP_MENU         // window should be treated as a popup menu (X11 only, >= SDL 2.0.5)
+	WINDOW_VULKAN             = C.SDL_WINDOW_VULKAN             // window usable for Vulkan surface (>= SDL 2.0.6)
+)
+
+// An enumeration of window events.
+// (https://wiki.libsdl.org/SDL_WindowEventID)
+const (
+	WINDOWEVENT_NONE         = C.SDL_WINDOWEVENT_NONE         // (never used)
+	WINDOWEVENT_SHOWN        = C.SDL_WINDOWEVENT_SHOWN        // window has been shown
+	WINDOWEVENT_HIDDEN       = C.SDL_WINDOWEVENT_HIDDEN       // window has been hidden
+	WINDOWEVENT_EXPOSED      = C.SDL_WINDOWEVENT_EXPOSED      // window has been exposed and should be redrawn
+	WINDOWEVENT_MOVED        = C.SDL_WINDOWEVENT_MOVED        // window has been moved to data1, data2
+	WINDOWEVENT_RESIZED      = C.SDL_WINDOWEVENT_RESIZED      // window has been resized to data1xdata2; this event is always preceded by WINDOWEVENT_SIZE_CHANGED
+	WINDOWEVENT_SIZE_CHANGED = C.SDL_WINDOWEVENT_SIZE_CHANGED // window size has changed, either as a result of an API call or through the system or user changing the window size; this event is followed by WINDOWEVENT_RESIZED if the size was changed by an external event, i.e. the user or the window manager
+	WINDOWEVENT_MINIMIZED    = C.SDL_WINDOWEVENT_MINIMIZED    // window has been minimized
+	WINDOWEVENT_MAXIMIZED    = C.SDL_WINDOWEVENT_MAXIMIZED    // window has been maximized
+	WINDOWEVENT_RESTORED     = C.SDL_WINDOWEVENT_RESTORED     // window has been restored to normal size and position
+	WINDOWEVENT_ENTER        = C.SDL_WINDOWEVENT_ENTER        // window has gained mouse focus
+	WINDOWEVENT_LEAVE        = C.SDL_WINDOWEVENT_LEAVE        // window has lost mouse focus
+	WINDOWEVENT_FOCUS_GAINED = C.SDL_WINDOWEVENT_FOCUS_GAINED // window has gained keyboard focus
+	WINDOWEVENT_FOCUS_LOST   = C.SDL_WINDOWEVENT_FOCUS_LOST   // window has lost keyboard focus
+	WINDOWEVENT_CLOSE        = C.SDL_WINDOWEVENT_CLOSE        // the window manager requests that the window be closed
+	WINDOWEVENT_TAKE_FOCUS   = C.SDL_WINDOWEVENT_TAKE_FOCUS   // window is being offered a focus (should SDL_SetWindowInputFocus() on itself or a subwindow, or ignore) (>= SDL 2.0.5)
+	WINDOWEVENT_HIT_TEST     = C.SDL_WINDOWEVENT_HIT_TEST     // window had a hit test that wasn't SDL_HITTEST_NORMAL (>= SDL 2.0.5)
+)
+
+// Window position flags.
+// (https://wiki.libsdl.org/SDL_CreateWindow)
+const (
+	WINDOWPOS_UNDEFINED_MASK = C.SDL_WINDOWPOS_UNDEFINED_MASK // used to indicate that you don't care what the window position is
+	WINDOWPOS_UNDEFINED      = C.SDL_WINDOWPOS_UNDEFINED      // used to indicate that you don't care what the window position is
+	WINDOWPOS_CENTERED_MASK  = C.SDL_WINDOWPOS_CENTERED_MASK  // used to indicate that the window position should be centered
+	WINDOWPOS_CENTERED       = C.SDL_WINDOWPOS_CENTERED       // used to indicate that the window position should be centered
+)
+
+// An enumeration of message box flags (e.g. if supported message box will display warning icon).
+// (https://wiki.libsdl.org/SDL_MessageBoxFlags)
+const (
+	MESSAGEBOX_ERROR       = C.SDL_MESSAGEBOX_ERROR       // error dialog
+	MESSAGEBOX_WARNING     = C.SDL_MESSAGEBOX_WARNING     // warning dialog
+	MESSAGEBOX_INFORMATION = C.SDL_MESSAGEBOX_INFORMATION // informational dialog
+)
+
+// Flags for MessageBoxButtonData.
+const (
+	MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT = C.SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT // marks the default button when return is hit
+	MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT = C.SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT // marks the default button when escape is hit
+)
+
+// OpenGL configuration attributes.
+// (https://wiki.libsdl.org/SDL_GL_SetAttribute)
+const (
+	GL_RED_SIZE                   = C.SDL_GL_RED_SIZE                   // the minimum number of bits for the red channel of the color buffer; defaults to 3
+	GL_GREEN_SIZE                 = C.SDL_GL_GREEN_SIZE                 // the minimum number of bits for the green channel of the color buffer; defaults to 3
+	GL_BLUE_SIZE                  = C.SDL_GL_BLUE_SIZE                  // the minimum number of bits for the blue channel of the color buffer; defaults to 2
+	GL_ALPHA_SIZE                 = C.SDL_GL_ALPHA_SIZE                 // the minimum number of bits for the alpha channel of the color buffer; defaults to 0
+	GL_BUFFER_SIZE                = C.SDL_GL_BUFFER_SIZE                // the minimum number of bits for frame buffer size; defaults to 0
+	GL_DOUBLEBUFFER               = C.SDL_GL_DOUBLEBUFFER               // whether the output is single or double buffered; defaults to double buffering on
+	GL_DEPTH_SIZE                 = C.SDL_GL_DEPTH_SIZE                 // the minimum number of bits in the depth buffer; defaults to 16
+	GL_STENCIL_SIZE               = C.SDL_GL_STENCIL_SIZE               // the minimum number of bits in the stencil buffer; defaults to 0
+	GL_ACCUM_RED_SIZE             = C.SDL_GL_ACCUM_RED_SIZE             // the minimum number of bits for the red channel of the accumulation buffer; defaults to 0
+	GL_ACCUM_GREEN_SIZE           = C.SDL_GL_ACCUM_GREEN_SIZE           // the minimum number of bits for the green channel of the accumulation buffer; defaults to 0
+	GL_ACCUM_BLUE_SIZE            = C.SDL_GL_ACCUM_BLUE_SIZE            // the minimum number of bits for the blue channel of the accumulation buffer; defaults to 0
+	GL_ACCUM_ALPHA_SIZE           = C.SDL_GL_ALPHA_SIZE                 // the minimum number of bits for the alpha channel of the accumulation buffer; defaults to 0
+	GL_STEREO                     = C.SDL_GL_STEREO                     // whether the output is stereo 3D; defaults to off
+	GL_MULTISAMPLEBUFFERS         = C.SDL_GL_MULTISAMPLEBUFFERS         // the number of buffers used for multisample anti-aliasing; defaults to 0; see Remarks for details
+	GL_MULTISAMPLESAMPLES         = C.SDL_GL_MULTISAMPLESAMPLES         // the number of samples used around the current pixel used for multisample anti-aliasing; defaults to 0; see Remarks for details
+	GL_ACCELERATED_VISUAL         = C.SDL_GL_ACCELERATED_VISUAL         // set to 1 to require hardware acceleration, set to 0 to force software rendering; defaults to allow either
+	GL_RETAINED_BACKING           = C.SDL_GL_RETAINED_BACKING           // not used (deprecated)
+	GL_CONTEXT_MAJOR_VERSION      = C.SDL_GL_CONTEXT_MAJOR_VERSION      // OpenGL context major version
+	GL_CONTEXT_MINOR_VERSION      = C.SDL_GL_CONTEXT_MINOR_VERSION      // OpenGL context minor version
+	GL_CONTEXT_EGL                = C.SDL_GL_CONTEXT_EGL                // not used (deprecated)
+	GL_CONTEXT_FLAGS              = C.SDL_GL_CONTEXT_FLAGS              // some combination of 0 or more of elements of the GLcontextFlag enumeration; defaults to 0 (https://wiki.libsdl.org/SDL_GLcontextFlag)
+	GL_CONTEXT_PROFILE_MASK       = C.SDL_GL_CONTEXT_PROFILE_MASK       // type of GL context (Core, Compatibility, ES); default value depends on platform (https://wiki.libsdl.org/SDL_GLprofile)
+	GL_SHARE_WITH_CURRENT_CONTEXT = C.SDL_GL_SHARE_WITH_CURRENT_CONTEXT // OpenGL context sharing; defaults to 0
+	GL_FRAMEBUFFER_SRGB_CAPABLE   = C.SDL_GL_FRAMEBUFFER_SRGB_CAPABLE   // requests sRGB capable visual; defaults to 0 (>= SDL 2.0.1)
+	GL_CONTEXT_RELEASE_BEHAVIOR   = C.SDL_GL_CONTEXT_RELEASE_BEHAVIOR   // sets context the release behavior; defaults to 1 (>= SDL 2.0.4)
+	GL_CONTEXT_RESET_NOTIFICATION = C.SDL_GL_CONTEXT_RESET_NOTIFICATION // (>= SDL 2.0.6)
+	GL_CONTEXT_NO_ERROR           = C.SDL_GL_CONTEXT_NO_ERROR           // (>= SDL 2.0.6)
+)
+
+// An enumeration of OpenGL profiles.
+// (https://wiki.libsdl.org/SDL_GLprofile)
+const (
+	GL_CONTEXT_PROFILE_CORE          = C.SDL_GL_CONTEXT_PROFILE_CORE          // OpenGL core profile - deprecated functions are disabled
+	GL_CONTEXT_PROFILE_COMPATIBILITY = C.SDL_GL_CONTEXT_PROFILE_COMPATIBILITY // OpenGL compatibility profile - deprecated functions are allowed
+	GL_CONTEXT_PROFILE_ES            = C.SDL_GL_CONTEXT_PROFILE_ES            // OpenGL ES profile - only a subset of the base OpenGL functionality is available
+)
+
+// An enumeration of OpenGL context configuration flags.
+// (https://wiki.libsdl.org/SDL_GLcontextFlag)
+const (
+	GL_CONTEXT_DEBUG_FLAG              = C.SDL_GL_CONTEXT_DEBUG_FLAG              // intended to put the GL into a "debug" mode which might offer better developer insights, possibly at a loss of performance
+	GL_CONTEXT_FORWARD_COMPATIBLE_FLAG = C.SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG // intended to put the GL into a "forward compatible" mode, which means that no deprecated functionality will be supported, possibly at a gain in performance, and only applies to GL 3.0 and later contexts
+	GL_CONTEXT_ROBUST_ACCESS_FLAG      = C.SDL_GL_CONTEXT_ROBUST_ACCESS_FLAG      // intended to require a GL context that supports the GL_ARB_robustness extension--a mode that offers a few APIs that are safer than the usual defaults (think snprintf() vs sprintf())
+	GL_CONTEXT_RESET_ISOLATION_FLAG    = C.SDL_GL_CONTEXT_RESET_ISOLATION_FLAG    // intended to require the GL to make promises about what to do in the face of driver or hardware failure
+)
+
+// DisplayMode contains the description of a display mode.
+// (https://wiki.libsdl.org/SDL_DisplayMode)
+type DisplayMode struct {
+	Format      uint32         // one of the PixelFormatEnum values (https://wiki.libsdl.org/SDL_PixelFormatEnum)
+	W           int32          // width, in screen coordinates
+	H           int32          // height, in screen coordinates
+	RefreshRate int32          // refresh rate (in Hz), or 0 for unspecified
+	DriverData  unsafe.Pointer // driver-specific data, initialize to 0
+}
+type cDisplayMode C.SDL_DisplayMode
+
+// Window is a type used to identify a window.
+type Window C.SDL_Window
+
+// GLContext is an opaque handle to an OpenGL context.
+type GLContext C.SDL_GLContext
+
+// GLattr is an OpenGL configuration attribute.
+//(https://wiki.libsdl.org/SDL_GLattr)
+type GLattr C.SDL_GLattr
+
+// MessageBoxColor contains RGB value used in an MessageBoxColorScheme.
+// (https://wiki.libsdl.org/SDL_MessageBoxColor)
+type MessageBoxColor struct {
+	R uint8 // the red component in the range 0-255
+	G uint8 // the green component in the range 0-255
+	B uint8 // the blue component in the range 0-255
+}
+type cMessageBoxColor C.SDL_MessageBoxColor
+
+// MessageBoxColorScheme contains a set of colors to use for message box dialogs.
+// (https://wiki.libsdl.org/SDL_MessageBoxColorScheme)
+type MessageBoxColorScheme struct {
+	Colors [5]MessageBoxColor // background, text, button border, button background, button selected
+}
+type cMessageBoxColorScheme C.SDL_MessageBoxColorScheme
+
+// MessageBoxButtonData contains individual button data for a message box.
+// (https://wiki.libsdl.org/SDL_MessageBoxButtonData)
+type MessageBoxButtonData struct {
+	Flags    uint32 // MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT, MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT
+	ButtonID int32  // user defined button id (value returned via ShowMessageBox())
+	Text     string // the UTF-8 button text
+}
+
+// MessageBoxData contains title, text, window and other data for a message box.
+// (https://wiki.libsdl.org/SDL_MessageBoxData)
+type MessageBoxData struct {
+	Flags       uint32                 // MESSAGEBOX_ERROR, MESSAGEBOX_WARNING, MESSAGEBOX_INFORMATION
+	Window      *Window                // an parent window, can be nil
+	Title       string                 // an UTF-8 title
+	Message     string                 // an UTF-8 message text
+	NumButtons  int32                  // the number of buttons
+	Buttons     []MessageBoxButtonData // an array of MessageBoxButtonData with size of numbuttons
+	ColorScheme *MessageBoxColorScheme // a MessageBoxColorScheme, can be nil to use system settings
+}
+
+func (window *Window) cptr() *C.SDL_Window {
+	return (*C.SDL_Window)(unsafe.Pointer(window))
+}
+
+func (dm *DisplayMode) cptr() *C.SDL_DisplayMode {
+	return (*C.SDL_DisplayMode)(unsafe.Pointer(dm))
+}
+
+func (mc *MessageBoxColor) cptr() *C.SDL_MessageBoxColor {
+	return (*C.SDL_MessageBoxColor)(unsafe.Pointer(mc))
+}
+
+func (mcs *MessageBoxColorScheme) cptr() *C.SDL_MessageBoxColorScheme {
+	return (*C.SDL_MessageBoxColorScheme)(unsafe.Pointer(mcs))
+}
+
+func (mbd *MessageBoxButtonData) cptr() *C.SDL_MessageBoxButtonData {
+	return (*C.SDL_MessageBoxButtonData)(unsafe.Pointer(mbd))
+}
+
+func (md *MessageBoxData) cptr() *C.SDL_MessageBoxData {
+	return (*C.SDL_MessageBoxData)(unsafe.Pointer(md))
+}
+
+func (attr GLattr) c() C.SDL_GLattr {
+	return C.SDL_GLattr(attr)
+}
+
+// GetDisplayName returns the name of a display in UTF-8 encoding.
+// (https://wiki.libsdl.org/SDL_GetDisplayName)
+func GetDisplayName(displayIndex int) (string, error) {
+	name := C.SDL_GetDisplayName(C.int(displayIndex))
+	if name == nil {
+		return "", GetError()
+	}
+	return C.GoString(name), nil
+}
+
+// GetNumVideoDisplays returns the number of available video displays.
+// (https://wiki.libsdl.org/SDL_GetNumVideoDisplays)
+func GetNumVideoDisplays() (int, error) {
+	n := int(C.SDL_GetNumVideoDisplays())
+	return n, errorFromInt(n)
+}
+
+// GetNumVideoDrivers returns the number of video drivers compiled into SDL.
+// (https://wiki.libsdl.org/SDL_GetNumVideoDrivers)
+func GetNumVideoDrivers() (int, error) {
+	n := int(C.SDL_GetNumVideoDrivers())
+	return n, errorFromInt(n)
+}
+
+// GetVideoDriver returns the name of a built in video driver.
+// (https://wiki.libsdl.org/SDL_GetVideoDriver)
+func GetVideoDriver(index int) string {
+	return string(C.GoString(C.SDL_GetVideoDriver(C.int(index))))
+}
+
+// VideoInit initializes the video subsystem, optionally specifying a video driver.
+// (https://wiki.libsdl.org/SDL_VideoInit)
+func VideoInit(driverName string) error {
+	return errorFromInt(int(
+		C.SDL_VideoInit(C.CString(driverName))))
+}
+
+// VideoQuit shuts down the video subsystem, if initialized with VideoInit().
+// (https://wiki.libsdl.org/SDL_VideoQuit)
+func VideoQuit() {
+	C.SDL_VideoQuit()
+}
+
+// GetCurrentVideoDriver returns the name of the currently initialized video driver.
+// (https://wiki.libsdl.org/SDL_GetCurrentVideoDriver)
+func GetCurrentVideoDriver() (string, error) {
+	name := C.SDL_GetCurrentVideoDriver()
+	if name == nil {
+		return "", GetError()
+	}
+	return C.GoString(name), nil
+}
+
+// GetNumDisplayModes returns the number of available display modes.
+// (https://wiki.libsdl.org/SDL_GetNumDisplayModes)
+func GetNumDisplayModes(displayIndex int) (int, error) {
+	n := int(C.SDL_GetNumDisplayModes(C.int(displayIndex)))
+	return n, errorFromInt(n)
+}
+
+// GetDisplayBounds returns the desktop area represented by a display, with the primary display located at 0,0.
+// (https://wiki.libsdl.org/SDL_GetDisplayBounds)
+func GetDisplayBounds(displayIndex int) (rect Rect, err error) {
+	err = errorFromInt(int(
+		C.SDL_GetDisplayBounds(C.int(displayIndex), (&rect).cptr())))
+	return
+}
+
+// GetDisplayUsableBounds returns the usable desktop area represented by a display, with the primary display located at 0,0.
+// (https://wiki.libsdl.org/SDL_GetDisplayUsableBounds)
+func GetDisplayUsableBounds(displayIndex int) (rect Rect, err error) {
+	err = errorFromInt(int(
+		C.SDL_GetDisplayUsableBounds(C.int(displayIndex), rect.cptr())))
+	return
+}
+
+// GetDisplayMode retruns information about a specific display mode.
+// (https://wiki.libsdl.org/SDL_GetDisplayMode)
+func GetDisplayMode(displayIndex int, modeIndex int) (mode DisplayMode, err error) {
+	err = errorFromInt(int(
+		C.SDL_GetDisplayMode(C.int(displayIndex), C.int(modeIndex), (&mode).cptr())))
+	return
+}
+
+// GetDesktopDisplayMode returns information about the desktop display mode.
+// (https://wiki.libsdl.org/SDL_GetDesktopDisplayMode)
+func GetDesktopDisplayMode(displayIndex int) (mode DisplayMode, err error) {
+	err = errorFromInt(int(
+		C.SDL_GetDesktopDisplayMode(C.int(displayIndex), (&mode).cptr())))
+	return
+}
+
+// GetCurrentDisplayMode returns information about the current display mode.
+// (https://wiki.libsdl.org/SDL_GetCurrentDisplayMode)
+func GetCurrentDisplayMode(displayIndex int) (mode DisplayMode, err error) {
+	err = errorFromInt(int(
+		C.SDL_GetCurrentDisplayMode(C.int(displayIndex), (&mode).cptr())))
+	return
+}
+
+// GetClosestDisplayMode returns the closest match to the requested display mode.
+// (https://wiki.libsdl.org/SDL_GetClosestDisplayMode)
+func GetClosestDisplayMode(displayIndex int, mode *DisplayMode, closest *DisplayMode) (*DisplayMode, error) {
+	m := (*DisplayMode)(unsafe.Pointer((C.SDL_GetClosestDisplayMode(C.int(displayIndex), mode.cptr(), closest.cptr()))))
+	if m == nil {
+		return nil, GetError()
+	}
+	return m, nil
+}
+
+// GetDisplayDPI returns the dots/pixels-per-inch for a display.
+// (https://wiki.libsdl.org/SDL_GetDisplayDPI)
+func GetDisplayDPI(displayIndex int) (ddpi, hdpi, vdpi float32, err error) {
+	err = errorFromInt(int(
+		C.SDL_GetDisplayDPI(C.int(displayIndex), (*C.float)(unsafe.Pointer(&ddpi)), (*C.float)(unsafe.Pointer(&hdpi)), (*C.float)(unsafe.Pointer(&vdpi)))))
+	return
+}
+
+// GetDisplayIndex returns the index of the display associated with the window.
+// (https://wiki.libsdl.org/SDL_GetWindowDisplayIndex)
+func (window *Window) GetDisplayIndex() (int, error) {
+	i := int(C.SDL_GetWindowDisplayIndex(window.cptr()))
+	return i, errorFromInt(i)
+}
+
+// SetDisplayMode sets the display mode to use when the window is visible at fullscreen.
+// (https://wiki.libsdl.org/SDL_SetWindowDisplayMode)
+func (window *Window) SetDisplayMode(mode *DisplayMode) error {
+	return errorFromInt(int(
+		C.SDL_SetWindowDisplayMode(window.cptr(), mode.cptr())))
+}
+
+// GetDisplayMode fills in information about the display mode to use when the window is visible at fullscreen.
+// (https://wiki.libsdl.org/SDL_GetWindowDisplayMode)
+func (window *Window) GetDisplayMode() (mode DisplayMode, err error) {
+	err = errorFromInt(int(
+		C.SDL_GetWindowDisplayMode(window.cptr(), (&mode).cptr())))
+	return
+}
+
+// GetPixelFormat returns the pixel format associated with the window.
+// (https://wiki.libsdl.org/SDL_GetWindowPixelFormat)
+func (window *Window) GetPixelFormat() (uint32, error) {
+	f := (uint32)(C.SDL_GetWindowPixelFormat(window.cptr()))
+	if f == PIXELFORMAT_UNKNOWN {
+		return f, GetError()
+	}
+	return f, nil
+}
+
+// CreateWindow creates a window with the specified position, dimensions, and flags.
+// (https://wiki.libsdl.org/SDL_CreateWindow)
+func CreateWindow(title string, x, y, w, h int32, flags uint32) (*Window, error) {
+	var _window = C.SDL_CreateWindow(C.CString(title), C.int(x), C.int(y), C.int(w), C.int(h), C.Uint32(flags))
+	if _window == nil {
+		return nil, GetError()
+	}
+	return (*Window)(unsafe.Pointer(_window)), nil
+}
+
+// CreateWindowFrom creates an SDL window from an existing native window.
+// (https://wiki.libsdl.org/SDL_CreateWindowFrom)
+func CreateWindowFrom(data unsafe.Pointer) (*Window, error) {
+	_window := C.SDL_CreateWindowFrom(data)
+	if _window == nil {
+		return nil, GetError()
+	}
+	return (*Window)(unsafe.Pointer(_window)), nil
+}
+
+// Destroy destroys the window.
+// (https://wiki.libsdl.org/SDL_DestroyWindow)
+func (window *Window) Destroy() error {
+	lastErr := GetError()
+	ClearError()
+	C.SDL_DestroyWindow(window.cptr())
+	err := GetError()
+	if err != nil {
+		return err
+	}
+	SetError(lastErr)
+	return nil
+}
+
+// GetID returns the numeric ID of the window, for logging purposes.
+//  (https://wiki.libsdl.org/SDL_GetWindowID)
+func (window *Window) GetID() (uint32, error) {
+	id := uint32(C.SDL_GetWindowID(window.cptr()))
+	if id == 0 {
+		return 0, GetError()
+	}
+	return id, nil
+}
+
+// GetWindowFromID returns a window from a stored ID.
+// (https://wiki.libsdl.org/SDL_GetWindowFromID)
+func GetWindowFromID(id uint32) (*Window, error) {
+	_window := C.SDL_GetWindowFromID(C.Uint32(id))
+	if _window == nil {
+		return nil, GetError()
+	}
+	return (*Window)(unsafe.Pointer((_window))), nil
+}
+
+// GetFlags returns the window flags.
+// (https://wiki.libsdl.org/SDL_GetWindowFlags)
+func (window *Window) GetFlags() uint32 {
+	return (uint32)(C.SDL_GetWindowFlags(window.cptr()))
+}
+
+// SetTitle sets the title of the window.
+// (https://wiki.libsdl.org/SDL_SetWindowTitle)
+func (window *Window) SetTitle(title string) {
+	C.SDL_SetWindowTitle(window.cptr(), C.CString(title))
+}
+
+// GetTitle returns the title of the window.
+// (https://wiki.libsdl.org/SDL_GetWindowTitle)
+func (window *Window) GetTitle() string {
+	return C.GoString(C.SDL_GetWindowTitle(window.cptr()))
+}
+
+// SetIcon sets the icon for the window.
+// (https://wiki.libsdl.org/SDL_SetWindowIcon)
+func (window *Window) SetIcon(icon *Surface) {
+	C.SDL_SetWindowIcon(window.cptr(), icon.cptr())
+}
+
+// SetData associates an arbitrary named pointer with the window.
+// (https://wiki.libsdl.org/SDL_SetWindowData)
+func (window *Window) SetData(name string, userdata unsafe.Pointer) unsafe.Pointer {
+	return unsafe.Pointer(C.SDL_SetWindowData(window.cptr(), C.CString(name), userdata))
+}
+
+// GetData returns the data pointer associated with the window.
+// (https://wiki.libsdl.org/SDL_GetWindowData)
+func (window *Window) GetData(name string) unsafe.Pointer {
+	return unsafe.Pointer(C.SDL_GetWindowData(window.cptr(), C.CString(name)))
+}
+
+// SetPosition sets the position of the window.
+// (https://wiki.libsdl.org/SDL_SetWindowPosition)
+func (window *Window) SetPosition(x, y int32) {
+	C.SDL_SetWindowPosition(window.cptr(), C.int(x), C.int(y))
+}
+
+// GetPosition returns the position of the window.
+// (https://wiki.libsdl.org/SDL_GetWindowPosition)
+func (window *Window) GetPosition() (x, y int32) {
+	var _x, _y C.int
+	C.SDL_GetWindowPosition(window.cptr(), &_x, &_y)
+	return int32(_x), int32(_y)
+}
+
+// SetResizable sets the user-resizable state of the window.
+// (https://wiki.libsdl.org/SDL_SetWindowResizable)
+func (window *Window) SetResizable(resizable bool) {
+	C.SDL_SetWindowResizable(window.cptr(), C.SDL_bool(Btoi(resizable)))
+}
+
+// SetSize sets the size of the window's client area.
+// (https://wiki.libsdl.org/SDL_SetWindowSize)
+func (window *Window) SetSize(w, h int32) {
+	C.SDL_SetWindowSize(window.cptr(), C.int(w), C.int(h))
+}
+
+// GetSize returns the size of the window's client area.
+// (https://wiki.libsdl.org/SDL_GetWindowSize)
+func (window *Window) GetSize() (w, h int32) {
+	var _w, _h C.int
+	C.SDL_GetWindowSize(window.cptr(), &_w, &_h)
+	return int32(_w), int32(_h)
+}
+
+// SetMinimumSize sets the minimum size of the window's client area.
+// (https://wiki.libsdl.org/SDL_SetWindowMinimumSize)
+func (window *Window) SetMinimumSize(minW, minH int32) {
+	C.SDL_SetWindowMinimumSize(window.cptr(), C.int(minW), C.int(minH))
+}
+
+// GetMinimumSize returns the minimum size of the window's client area.
+// (https://wiki.libsdl.org/SDL_GetWindowMinimumSize)
+func (window *Window) GetMinimumSize() (w, h int32) {
+	var _w, _h C.int
+	C.SDL_GetWindowMinimumSize(window.cptr(), &_w, &_h)
+	return int32(_w), int32(_h)
+}
+
+// SetMaximumSize sets the maximum size of the window's client area.
+// (https://wiki.libsdl.org/SDL_SetWindowMaximumSize)
+func (window *Window) SetMaximumSize(maxW, maxH int32) {
+	C.SDL_SetWindowMaximumSize(window.cptr(), C.int(maxW), C.int(maxH))
+}
+
+// GetMaximumSize returns the maximum size of the window's client area.
+// (https://wiki.libsdl.org/SDL_GetWindowMaximumSize)
+func (window *Window) GetMaximumSize() (w, h int32) {
+	var _w, _h C.int
+	C.SDL_GetWindowMaximumSize(window.cptr(), &_w, &_h)
+	return int32(_w), int32(_h)
+}
+
+// SetBordered sets the border state of the window.
+// (https://wiki.libsdl.org/SDL_SetWindowBordered)
+func (window *Window) SetBordered(bordered bool) {
+	C.SDL_SetWindowBordered(window.cptr(), C.SDL_bool(Btoi(bordered)))
+}
+
+// Show shows the window.
+// (https://wiki.libsdl.org/SDL_ShowWindow)
+func (window *Window) Show() {
+	C.SDL_ShowWindow(window.cptr())
+}
+
+// Hide hides the window.
+// (https://wiki.libsdl.org/SDL_HideWindow)
+func (window *Window) Hide() {
+	C.SDL_HideWindow(window.cptr())
+}
+
+// Raise raises the window above other windows and set the input focus.
+// (https://wiki.libsdl.org/SDL_RaiseWindow)
+func (window *Window) Raise() {
+	C.SDL_RaiseWindow(window.cptr())
+}
+
+// Maximize makes the window as large as possible.
+// (https://wiki.libsdl.org/SDL_MaximizeWindow)
+func (window *Window) Maximize() {
+	C.SDL_MaximizeWindow(window.cptr())
+}
+
+// Minimize minimizes the window to an iconic representation.
+// (https://wiki.libsdl.org/SDL_MinimizeWindow)
+func (window *Window) Minimize() {
+	C.SDL_MinimizeWindow(window.cptr())
+}
+
+// Restore restores the size and position of a minimized or maximized window.
+// (https://wiki.libsdl.org/SDL_RestoreWindow)
+func (window *Window) Restore() {
+	C.SDL_RestoreWindow(window.cptr())
+}
+
+// SetFullscreen sets the window's fullscreen state.
+// (https://wiki.libsdl.org/SDL_SetWindowFullscreen)
+func (window *Window) SetFullscreen(flags uint32) error {
+	return errorFromInt(int(
+		C.SDL_SetWindowFullscreen(window.cptr(), C.Uint32(flags))))
+}
+
+// GetSurface returns the SDL surface associated with the window.
+// (https://wiki.libsdl.org/SDL_GetWindowSurface)
+func (window *Window) GetSurface() (*Surface, error) {
+	surface := (*Surface)(unsafe.Pointer(C.SDL_GetWindowSurface(window.cptr())))
+	if surface == nil {
+		return nil, GetError()
+	}
+	return surface, nil
+}
+
+// UpdateSurface copies the window surface to the screen.
+// (https://wiki.libsdl.org/SDL_UpdateWindowSurface)
+func (window *Window) UpdateSurface() error {
+	return errorFromInt(int(
+		C.SDL_UpdateWindowSurface(window.cptr())))
+}
+
+// UpdateSurfaceRects copies areas of the window surface to the screen.
+// (https://wiki.libsdl.org/SDL_UpdateWindowSurfaceRects)
+func (window *Window) UpdateSurfaceRects(rects []Rect) error {
+	return errorFromInt(int(
+		C.SDL_UpdateWindowSurfaceRects(window.cptr(), rects[0].cptr(), C.int(len(rects)))))
+}
+
+// SetGrab sets the window's input grab mode.
+// (https://wiki.libsdl.org/SDL_SetWindowGrab)
+func (window *Window) SetGrab(grabbed bool) {
+	C.SDL_SetWindowGrab(window.cptr(), C.SDL_bool((Btoi(grabbed))))
+}
+
+// GetGrab returns the window's input grab mode.
+// (https://wiki.libsdl.org/SDL_GetWindowGrab)
+func (window *Window) GetGrab() bool {
+	return C.SDL_GetWindowGrab(window.cptr()) != 0
+}
+
+// SetBrightness sets the brightness (gamma multiplier) for the display that owns the given window.
+// (https://wiki.libsdl.org/SDL_SetWindowBrightness)
+func (window *Window) SetBrightness(brightness float32) error {
+	return errorFromInt(int(
+		C.SDL_SetWindowBrightness(window.cptr(), C.float(brightness))))
+}
+
+// GetBrightness returns the brightness (gamma multiplier) for the display that owns the given window.
+// (https://wiki.libsdl.org/SDL_GetWindowBrightness)
+func (window *Window) GetBrightness() float32 {
+	return float32(C.SDL_GetWindowBrightness(window.cptr()))
+}
+
+// SetGammaRamp sets the gamma ramp for the display that owns the given window.
+// (https://wiki.libsdl.org/SDL_SetWindowGammaRamp)
+func (window *Window) SetGammaRamp(red, green, blue *[256]uint16) error {
+	return errorFromInt(int(
+		C.SDL_SetWindowGammaRamp(
+			window.cptr(),
+			(*C.Uint16)(unsafe.Pointer(red)),
+			(*C.Uint16)(unsafe.Pointer(green)),
+			(*C.Uint16)(unsafe.Pointer(blue)))))
+}
+
+// GetGammaRamp returns the gamma ramp for the display that owns a given window.
+// (https://wiki.libsdl.org/SDL_GetWindowGammaRamp)
+func (window *Window) GetGammaRamp() (red, green, blue *[256]uint16, err error) {
+	code := int(C.SDL_GetWindowGammaRamp(
+		window.cptr(),
+		(*C.Uint16)(unsafe.Pointer(red)),
+		(*C.Uint16)(unsafe.Pointer(green)),
+		(*C.Uint16)(unsafe.Pointer(blue))))
+	return red, green, blue, errorFromInt(code)
+}
+
+// SetWindowOpacity sets the opacity of the window.
+// (https://wiki.libsdl.org/SDL_SetWindowOpacity)
+func (window *Window) SetWindowOpacity(opacity float32) error {
+	return errorFromInt(int(
+		C.SDL_SetWindowOpacity(window.cptr(), C.float(opacity))))
+}
+
+// GetWindowOpacity returns the opacity of the window.
+// (https://wiki.libsdl.org/SDL_GetWindowOpacity)
+func (window *Window) GetWindowOpacity() (opacity float32, err error) {
+	return opacity, errorFromInt(int(
+		C.SDL_GetWindowOpacity(window.cptr(), (*C.float)(unsafe.Pointer(&opacity)))))
+}
+
+// ShowSimpleMessageBox displays a simple modal message box.
+// (https://wiki.libsdl.org/SDL_ShowSimpleMessageBox)
+func ShowSimpleMessageBox(flags uint32, title, message string, window *Window) error {
+	_title := C.CString(title)
+	defer C.free(unsafe.Pointer(_title))
+	_message := C.CString(message)
+	defer C.free(unsafe.Pointer(_message))
+	return errorFromInt(int(
+		C.SDL_ShowSimpleMessageBox(C.Uint32(flags), _title, _message, window.cptr())))
+}
+
+// ShowMessageBox creates a modal message box.
+// (https://wiki.libsdl.org/SDL_ShowMessageBox)
+func ShowMessageBox(data *MessageBoxData) (buttonid int32, err error) {
+	_title := C.CString(data.Title)
+	defer C.free(unsafe.Pointer(_title))
+	_message := C.CString(data.Message)
+	defer C.free(unsafe.Pointer(_message))
+
+	var cbuttons []C.SDL_MessageBoxButtonData
+	var cbtntexts []*C.char
+	defer func(texts []*C.char) {
+		for _, t := range texts {
+			C.free(unsafe.Pointer(t))
+		}
+	}(cbtntexts)
+
+	for _, btn := range data.Buttons {
+		ctext := C.CString(btn.Text)
+		cbtn := C.SDL_MessageBoxButtonData{
+			flags:    C.Uint32(btn.Flags),
+			buttonid: C.int(btn.ButtonID),
+			text:     ctext,
+		}
+
+		cbuttons = append(cbuttons, cbtn)
+		cbtntexts = append(cbtntexts, ctext)
+	}
+
+	cdata := C.SDL_MessageBoxData{
+		flags:       C.Uint32(data.Flags),
+		window:      data.Window.cptr(),
+		title:       _title,
+		message:     _message,
+		numbuttons:  C.int(data.NumButtons),
+		buttons:     &cbuttons[0],
+		colorScheme: data.ColorScheme.cptr(),
+	}
+
+	buttonid = int32(C.ShowMessageBox(cdata))
+	return buttonid, errorFromInt(int(buttonid))
+}
+
+// IsScreenSaverEnabled reports whether the screensaver is currently enabled.
+// (https://wiki.libsdl.org/SDL_IsScreenSaverEnabled)
+func IsScreenSaverEnabled() bool {
+	return C.SDL_IsScreenSaverEnabled() != 0
+}
+
+// EnableScreenSaver allows the screen to be blanked by a screen saver.
+// (https://wiki.libsdl.org/SDL_EnableScreenSaver)
+func EnableScreenSaver() {
+	C.SDL_EnableScreenSaver()
+}
+
+// DisableScreenSaver prevents the screen from being blanked by a screen saver.
+// (https://wiki.libsdl.org/SDL_DisableScreenSaver)
+func DisableScreenSaver() {
+	C.SDL_DisableScreenSaver()
+}
+
+// GLLoadLibrary dynamically loads an OpenGL library.
+// (https://wiki.libsdl.org/SDL_GL_LoadLibrary)
+func GLLoadLibrary(path string) error {
+	return errorFromInt(int(
+		C.SDL_GL_LoadLibrary(C.CString(path))))
+}
+
+// GLGetProcAddress returns an OpenGL function by name.
+// (https://wiki.libsdl.org/SDL_GL_GetProcAddress)
+func GLGetProcAddress(proc string) unsafe.Pointer {
+	return unsafe.Pointer(C.SDL_GL_GetProcAddress(C.CString(proc)))
+}
+
+// GLUnloadLibrary unloads the OpenGL library previously loaded by GLLoadLibrary().
+// (https://wiki.libsdl.org/SDL_GL_UnloadLibrary)
+func GLUnloadLibrary() {
+	C.SDL_GL_UnloadLibrary()
+}
+
+// GLExtensionSupported reports whether an OpenGL extension is supported for the current context.
+// (https://wiki.libsdl.org/SDL_GL_ExtensionSupported)
+func GLExtensionSupported(extension string) bool {
+	return C.SDL_GL_ExtensionSupported(C.CString(extension)) != 0
+}
+
+// GLSetAttribute sets an OpenGL window attribute before window creation.
+// (https://wiki.libsdl.org/SDL_GL_SetAttribute)
+func GLSetAttribute(attr GLattr, value int) error {
+	return errorFromInt(int(
+		C.SDL_GL_SetAttribute(attr.c(), C.int(value))))
+}
+
+// GLGetAttribute returns the actual value for an attribute from the current context.
+// (https://wiki.libsdl.org/SDL_GL_GetAttribute)
+func GLGetAttribute(attr GLattr) (int, error) {
+	var _value C.int
+	if C.SDL_GL_GetAttribute(attr.c(), &_value) != 0 {
+		return int(_value), GetError()
+	}
+	return int(_value), nil
+}
+
+// GLCreateContext creates an OpenGL context for use with an OpenGL window, and make it current.
+// (https://wiki.libsdl.org/SDL_GL_CreateContext)
+func (window *Window) GLCreateContext() (GLContext, error) {
+	c := GLContext(C.SDL_GL_CreateContext(window.cptr()))
+	if c == nil {
+		return nil, GetError()
+	}
+	return c, nil
+}
+
+// GLMakeCurrent sets up an OpenGL context for rendering into an OpenGL window.
+// (https://wiki.libsdl.org/SDL_GL_MakeCurrent)
+func (window *Window) GLMakeCurrent(glcontext GLContext) error {
+	return errorFromInt(int(
+		C.SDL_GL_MakeCurrent(window.cptr(), C.SDL_GLContext(glcontext))))
+}
+
+// GLSetSwapInterval sets the swap interval for the current OpenGL context.
+// (https://wiki.libsdl.org/SDL_GL_SetSwapInterval)
+func GLSetSwapInterval(interval int) error {
+	return errorFromInt(int(
+		C.SDL_GL_SetSwapInterval(C.int(interval))))
+}
+
+// GLGetSwapInterval returns the swap interval for the current OpenGL context.
+// (https://wiki.libsdl.org/SDL_GL_GetSwapInterval)
+func GLGetSwapInterval() (int, error) {
+	i := int(C.SDL_GL_GetSwapInterval())
+	return i, errorFromInt(i)
+}
+
+// GLGetDrawableSize returns the size of a window's underlying drawable in pixels (for use with glViewport).
+// (https://wiki.libsdl.org/SDL_GL_GetDrawableSize)
+func (window *Window) GLGetDrawableSize() (w, h int32) {
+	var _w, _h C.int
+	C.SDL_GL_GetDrawableSize(window.cptr(), &_w, &_h)
+	return int32(_w), int32(_h)
+}
+
+// GLSwap updates a window with OpenGL rendering.
+// (https://wiki.libsdl.org/SDL_GL_SwapWindow)
+func (window *Window) GLSwap() {
+	C.SDL_GL_SwapWindow(window.cptr())
+}
+
+// GLDeleteContext deletes an OpenGL context.
+// (https://wiki.libsdl.org/SDL_GL_DeleteContext)
+func GLDeleteContext(context GLContext) {
+	C.SDL_GL_DeleteContext(C.SDL_GLContext(context))
+}

vendor/github.com/veandco/go-sdl2/ttf/sdl_ttf.go

@@ -0,0 +1,292 @@
+// Package ttf is a TrueType font rendering library that is used with the SDL library, and almost as portable. It depends on freetype2 to handle the TrueType font data. It allows a programmer to use multiple TrueType fonts without having to code a font rendering routine themselves. With the power of outline fonts and antialiasing, high quality text output can be obtained without much effort.
+package ttf
+
+//#include <stdlib.h>
+//#include "sdl_ttf_wrapper.h"
+//void Do_TTF_SetError(const char *str) {
+//    TTF_SetError("%s", str);
+//}
+import "C"
+import "github.com/veandco/go-sdl2/sdl"
+import "unsafe"
+import "errors"
+
+// Hinting settings.
+const (
+	HINTING_NORMAL = int(C.TTF_HINTING_NORMAL)
+	HINTING_LIGHT  = int(C.TTF_HINTING_LIGHT)
+	HINTING_MONO   = int(C.TTF_HINTING_MONO)
+	HINTING_NONE   = int(C.TTF_HINTING_NONE)
+)
+
+// Font rendering styles.
+const (
+	STYLE_NORMAL        = 0
+	STYLE_BOLD          = 0x01
+	STYLE_ITALIC        = 0x02
+	STYLE_UNDERLINE     = 0x04
+	STYLE_STRIKETHROUGH = 0x08
+)
+
+// Font contains font information.
+type Font struct {
+	f *C.TTF_Font
+}
+
+// Init initializes the truetype font API. This must be called before using other functions in this library, except ttf.WasInit(). SDL does not have to be initialized before this call.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_8.html)
+func Init() error {
+	if C.TTF_Init() == -1 {
+		return GetError()
+	}
+	return nil
+}
+
+// WasInit reports whether the truetype font API is initialized. Use this before ttf.Init() to avoid initializing twice in a row. Or use this to determine if you need to call ttf.Quit().
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_9.html)
+func WasInit() bool {
+	return int(C.TTF_WasInit()) != 0
+}
+
+// Quit shuts down and cleanups the truetype font API. After calling this the SDL_ttf functions should not be used, excepting ttf.WasInit(). You may, of course, use ttf.Init() to use the functionality again.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_10.html)
+func Quit() {
+	C.TTF_Quit()
+}
+
+// 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 sdl.ClearError().
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_12.html)
+func GetError() error {
+	e := C.TTF_GetError()
+	if e == nil {
+		return nil
+	}
+	return errors.New(C.GoString(e))
+}
+
+// SetError sets the SDL error message to the specified string.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_11.html)
+func SetError(err string) {
+	_err := C.CString(err)
+	defer C.free(unsafe.Pointer(_err))
+	C.Do_TTF_SetError(_err)
+}
+
+// ByteSwappedUnicode tells SDL_ttf whether UNICODE (Uint16 per character) text is generally byteswapped.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_20.html)
+func ByteSwappedUnicode(swap bool) {
+	val := 0
+	if swap {
+		val = 1
+	}
+	C.TTF_ByteSwappedUNICODE(C.int(val))
+}
+
+// OpenFont loads file for use as a font, at the specified size. This is actually OpenFontIndex(file, size, 0). This can load TTF and FON files.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_14.html)
+func OpenFont(file string, size int) (*Font, error) {
+	_file := C.CString(file)
+	defer C.free(unsafe.Pointer(_file))
+	_size := (C.int)(size)
+	f := (*C.TTF_Font)(C.TTF_OpenFont(_file, _size))
+
+	if f == nil {
+		return nil, GetError()
+	}
+	return &Font{f}, nil
+}
+
+// OpenFontIndex loads file, face index, for use as a font, at the specified size. This is actually OpenFontIndexRW(RWFromFile(file), size, index), but checks that the RWops it creates is not NULL. This can load TTF and FON files.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_16.html)
+func OpenFontIndex(file string, size int, index int) (*Font, error) {
+	_file := C.CString(file)
+	defer C.free(unsafe.Pointer(_file))
+	_size := (C.int)(size)
+	_index := (C.long)(index)
+	f := (*C.TTF_Font)(C.TTF_OpenFontIndex(_file, _size, _index))
+
+	if f == nil {
+		return nil, GetError()
+	}
+	return &Font{f}, nil
+}
+
+// OpenFontRW loads src for use as a font, at specified size. This is actually OpenFontIndexRW(src, freesrc, size, 0). This can load TTF and FON formats. Using SDL_RWops is not covered here, but they enable you to load from almost any source.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_15.html)
+func OpenFontRW(src *sdl.RWops, freesrc, size int) (*Font, error) {
+	return OpenFontIndexRW(src, freesrc, size, 0)
+}
+
+// OpenFontIndexRW loads src, face index, for use as a font, at the specified size. This can load TTF and FON formats. Using SDL_RWops is not covered here, but they enable you to load from almost any source.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_17.html)
+func OpenFontIndexRW(src *sdl.RWops, freesrc, size, index int) (*Font, error) {
+	_src := (*C.SDL_RWops)(unsafe.Pointer(src))
+	_freesrc := (C.int)(freesrc)
+	_size := (C.int)(size)
+	_index := (C.long)(index)
+	f := (*C.TTF_Font)(C.TTF_OpenFontIndexRW(_src, _freesrc, _size, _index))
+
+	if f == nil {
+		return nil, GetError()
+	}
+	return &Font{f}, nil
+}
+
+// RenderUTF8Solid creates an 8-bit palettized surface and render the given text at fast quality with the given font and color.  The 0 pixel is the colorkey, giving a transparent background, and the 1 pixel is set to the text color.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_44.html)
+func (f *Font) RenderUTF8Solid(text string, color sdl.Color) (*sdl.Surface, error) {
+	_text := C.CString(text)
+	defer C.free(unsafe.Pointer(_text))
+	_c := C.SDL_Color{C.Uint8(color.R), C.Uint8(color.G), C.Uint8(color.B), C.Uint8(color.A)}
+	surface := (*sdl.Surface)(unsafe.Pointer(C.TTF_RenderUTF8_Solid(f.f, _text, _c)))
+	if surface == nil {
+		return nil, GetError()
+	}
+	return surface, nil
+}
+
+// RenderUTF8Shaded creates an 8-bit palettized surface and render the given text at high quality with the given font and colors. The 0 pixel is background, while other pixels have varying degrees of the foreground color.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_48.html)
+func (f *Font) RenderUTF8Shaded(text string, fg, bg sdl.Color) (*sdl.Surface, error) {
+	_text := C.CString(text)
+	defer C.free(unsafe.Pointer(_text))
+	_fg := C.SDL_Color{C.Uint8(fg.R), C.Uint8(fg.G), C.Uint8(fg.B), C.Uint8(fg.A)}
+	_bg := C.SDL_Color{C.Uint8(bg.R), C.Uint8(bg.G), C.Uint8(bg.B), C.Uint8(bg.A)}
+	surface := (*sdl.Surface)(unsafe.Pointer(C.TTF_RenderUTF8_Shaded(f.f, _text, _fg, _bg)))
+	if surface == nil {
+		return nil, GetError()
+	}
+	return surface, nil
+}
+
+// RenderUTF8Blended creates a 32-bit ARGB surface and render the given text at high quality, using alpha blending to dither the font with the given color.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_52.html)
+func (f *Font) RenderUTF8Blended(text string, color sdl.Color) (*sdl.Surface, error) {
+	_text := C.CString(text)
+	defer C.free(unsafe.Pointer(_text))
+	_c := C.SDL_Color{C.Uint8(color.R), C.Uint8(color.G), C.Uint8(color.B), C.Uint8(color.A)}
+	surface := (*sdl.Surface)(unsafe.Pointer(C.TTF_RenderUTF8_Blended(f.f, _text, _c)))
+	if surface == nil {
+		return nil, GetError()
+	}
+	return surface, nil
+}
+
+// RenderUTF8BlendedWrapped creates a 32-bit ARGB surface and render the given text at high quality, using alpha blending to dither the font with the given color. Text is wrapped to multiple lines on line endings and on word boundaries if it extends beyond wrapLength in pixels.
+func (f *Font) RenderUTF8BlendedWrapped(text string, fg sdl.Color, wrapLength int) (*sdl.Surface, error) {
+	_text := C.CString(text)
+	defer C.free(unsafe.Pointer(_text))
+	_c := C.SDL_Color{C.Uint8(fg.R), C.Uint8(fg.G), C.Uint8(fg.B), C.Uint8(fg.A)}
+	surface := (*sdl.Surface)(unsafe.Pointer(C.TTF_RenderUTF8_Blended_Wrapped(f.f, _text, _c, C.Uint32(wrapLength))))
+	if surface == nil {
+		return nil, GetError()
+	}
+	return surface, nil
+}
+
+// SizeUTF8 returns the resulting surface size (width and height) of the UTF8 encoded text rendered using font. No actual rendering is done, however correct kerning is done to get the actual width. The height returned in h is the same as you can get using ttf.Height().
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_40.html)
+func (f *Font) SizeUTF8(text string) (int, int, error) {
+	_text := C.CString(text)
+	defer C.free(unsafe.Pointer(_text))
+	var w C.int
+	var h C.int
+	result := C.TTF_SizeUTF8(f.f, _text, &w, &h)
+	if result == 0 {
+		return int(w), int(h), nil
+	}
+	return int(w), int(h), GetError()
+}
+
+// Close frees the memory used by font, and frees font itself as well. Do not use font after this without loading a new font to it.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_18.html)
+func (f *Font) Close() {
+	C.TTF_CloseFont(f.f)
+	f.f = nil
+}
+
+// Height returns the maximum pixel height of all glyphs of the loaded font.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_29.html)
+func (f *Font) Height() int { return int(C.TTF_FontHeight(f.f)) }
+
+// Ascent returns the maximum pixel ascent of all glyphs of the loaded font. This can also be interpreted as the distance from the top of the font to the baseline.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_30.html)
+func (f *Font) Ascent() int { return int(C.TTF_FontAscent(f.f)) }
+
+// Descent returns the maximum pixel descent of all glyphs of the loaded font. This can also be interpreted as the distance from the baseline to the bottom of the font.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_31.html)
+func (f *Font) Descent() int { return int(C.TTF_FontDescent(f.f)) }
+
+// LineSkip returns the recommended pixel height of a rendered line of text of the loaded font.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_32.html)
+func (f *Font) LineSkip() int { return int(C.TTF_FontLineSkip(f.f)) }
+
+// Faces returns the number of faces ("sub-fonts") available in the loaded font.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_33.html)
+func (f *Font) Faces() int { return int(C.TTF_FontFaces(f.f)) }
+
+// GetStyle returns the rendering style of the loaded font.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_21.html)
+func (f *Font) GetStyle() int {
+	return int(C.TTF_GetFontStyle(f.f))
+}
+
+// SetStyle sets the rendering style of the loaded font.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_22.html)
+func (f *Font) SetStyle(style int) {
+	C.TTF_SetFontStyle(f.f, C.int(style))
+}
+
+// GetHinting returns the current hinting setting of the loaded font.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_25.html)
+func (f *Font) GetHinting() int {
+	return int(C.TTF_GetFontHinting(f.f))
+}
+
+// SetHinting sets the hinting of the loaded font.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_26.html)
+func (f *Font) SetHinting(hinting int) {
+	C.TTF_SetFontHinting(f.f, C.int(hinting))
+}
+
+// GetKerning returns the current kerning setting of the loaded font.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_27.html)
+func (f *Font) GetKerning() bool {
+	return int(C.TTF_GetFontKerning(f.f)) == 1
+}
+
+// SetKerning sets whther to use kerning when rendering the loaded font. This has no effect on individual glyphs, but rather when rendering whole strings of characters, at least a word at a time. Perhaps the only time to disable this is when kerning is not working for a specific font, resulting in overlapping glyphs or abnormal spacing within words.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_28.html)
+func (f *Font) SetKerning(allowed bool) {
+	val := 0
+	if allowed {
+		val = 1
+	}
+	C.TTF_SetFontKerning(f.f, C.int(val))
+}
+
+// GetOutline returns the current outline size of the loaded font.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_23.html)
+func (f *Font) GetOutline() int {
+	return int(C.TTF_GetFontOutline(f.f))
+}
+
+// SetOutline sets the outline pixel width of the loaded font.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_24.html)
+func (f *Font) SetOutline(outline int) {
+	C.TTF_SetFontOutline(f.f, C.int(outline))
+}
+
+// FaceIsFixedWidth reports whether the current font face of the loaded font is a fixed width font. Fixed width fonts are monospace, meaning every character that exists in the font is the same width, thus you can assume that a rendered string's width is going to be the result of a simple calculation: glyph_width * string_length.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_34.html)
+func (f *Font) FaceIsFixedWidth() bool {
+	return int(C.TTF_FontFaceIsFixedWidth(f.f)) != 0
+}
+
+// FaceFamilyName returns the current font face family name from the loaded font.
+// (https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_35.html)
+func (f *Font) FaceFamilyName() string {
+	_fname := C.TTF_FontFaceFamilyName(f.f)
+	fname := C.GoString(_fname)
+	return fname
+}

vendor/github.com/veandco/go-sdl2/ttf/sdl_ttf_cgo.go

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

vendor/github.com/veandco/go-sdl2/ttf/sdl_ttf_cgo_static.go

@@ -0,0 +1,14 @@
+// +build static
+
+package ttf
+
+//#cgo CFLAGS: -I${SRCDIR}/../.go-sdl2-libs/include -I${SRCDIR}/../.go-sdl2-libs/include/SDL2
+//#cgo LDFLAGS: -L${SRCDIR}/../.go-sdl2-libs
+//#cgo linux,386 LDFLAGS: -lSDL2_ttf_linux_386 -Wl,--no-undefined -lfreetype_linux_386 -lSDL2_linux_386 -lm -ldl -lasound -lm -ldl -lpthread -lX11 -lXext -lXcursor -lXinerama -lXi -lXrandr -lXss -lXxf86vm -lpthread -lrt
+//#cgo linux,amd64 LDFLAGS: -lSDL2_ttf_linux_amd64 -Wl,--no-undefined -lfreetype_linux_amd64 -lSDL2_linux_amd64 -lm -ldl -lasound -lm -ldl -lpthread -lX11 -lXext -lXcursor -lXinerama -lXi -lXrandr -lXss -lXxf86vm -lpthread -lrt
+//#cgo windows,386 LDFLAGS: -lSDL2_ttf_windows_386 -Wl,--no-undefined -lfreetype_windows_386 -lSDL2_windows_386 -lSDL2main_windows_386 -mwindows -Wl,--no-undefined -lm -ldinput8 -ldxguid -ldxerr8 -luser32 -lgdi32 -lwinmm -limm32 -lole32 -loleaut32 -lshell32 -lversion -luuid -static-libgcc
+//#cgo windows,amd64 LDFLAGS: -lSDL2_ttf_windows_amd64 -Wl,--no-undefined -lfreetype_windows_amd64 -lSDL2_windows_amd64 -lSDL2main_windows_amd64 -mwindows -Wl,--no-undefined -lm -ldinput8 -ldxguid -ldxerr8 -luser32 -lgdi32 -lwinmm -limm32 -lole32 -loleaut32 -lshell32 -lversion -luuid -static-libgcc
+//#cgo darwin,amd64 LDFLAGS: -lSDL2_ttf_darwin_amd64 -lm -liconv -lfreetype_darwin_amd64 -lSDL2_darwin_amd64 -Wl,-framework,CoreAudio -Wl,-framework,AudioToolbox -Wl,-framework,ForceFeedback -lobjc -Wl,-framework,CoreVideo -Wl,-framework,Cocoa -Wl,-framework,Carbon -Wl,-framework,IOKit
+//#cgo android,arm LDFLAGS: -lSDL2_ttf_android_arm -Wl,--no-undefined -lfreetype_android_arm -lSDL2_android_arm -lm -ldl -llog -landroid -lGLESv2
+//#cgo linux,arm LDFLAGS: -lSDL2_ttf_linux_arm -Wl,--no-undefined -lfreetype_linux_arm -lSDL2_linux_arm -lm -ldl -liconv
+import "C"

vendor/github.com/veandco/go-sdl2/ttf/sdl_ttf_wrapper.h

@@ -0,0 +1,6 @@
+#if defined(__WIN32)
+	#include <SDL2/SDL_ttf.h>
+	#include <stdlib.h>
+#else
+	#include <SDL_ttf.h>
+#endif

vendor/modules.txt

@@ -0,0 +1,4 @@
+# github.com/veandco/go-sdl2 v0.3.0
+github.com/veandco/go-sdl2/img
+github.com/veandco/go-sdl2/sdl
+github.com/veandco/go-sdl2/ttf