Use dep to vendor things

vendor/github.com/go-gl/gl/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Eric Woroshow
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/go-gl/gl/v3.3-core/gl/conversions.go

@@ -0,0 +1,109 @@
+// Glow automatically generated OpenGL binding: http://github.com/go-gl/glow
+
+package gl
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"unsafe"
+)
+
+// #include <stdlib.h>
+import "C"
+
+// Ptr takes a slice or pointer (to a singular scalar value or the first
+// element of an array or slice) and returns its GL-compatible address.
+//
+// For example:
+//
+// 	var data []uint8
+// 	...
+// 	gl.TexImage2D(gl.TEXTURE_2D, ..., gl.UNSIGNED_BYTE, gl.Ptr(&data[0]))
+func Ptr(data interface{}) unsafe.Pointer {
+	if data == nil {
+		return unsafe.Pointer(nil)
+	}
+	var addr unsafe.Pointer
+	v := reflect.ValueOf(data)
+	switch v.Type().Kind() {
+	case reflect.Ptr:
+		e := v.Elem()
+		switch e.Kind() {
+		case
+			reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+			reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
+			reflect.Float32, reflect.Float64:
+			addr = unsafe.Pointer(e.UnsafeAddr())
+		default:
+			panic(fmt.Errorf("unsupported pointer to type %s; must be a slice or pointer to a singular scalar value or the first element of an array or slice", e.Kind()))
+		}
+	case reflect.Uintptr:
+		addr = unsafe.Pointer(v.Pointer())
+	case reflect.Slice:
+		addr = unsafe.Pointer(v.Index(0).UnsafeAddr())
+	default:
+		panic(fmt.Errorf("unsupported type %s; must be a slice or pointer to a singular scalar value or the first element of an array or slice", v.Type()))
+	}
+	return addr
+}
+
+// PtrOffset takes a pointer offset and returns a GL-compatible pointer.
+// Useful for functions such as glVertexAttribPointer that take pointer
+// parameters indicating an offset rather than an absolute memory address.
+func PtrOffset(offset int) unsafe.Pointer {
+	return unsafe.Pointer(uintptr(offset))
+}
+
+// Str takes a null-terminated Go string and returns its GL-compatible address.
+// This function reaches into Go string storage in an unsafe way so the caller
+// must ensure the string is not garbage collected.
+func Str(str string) *uint8 {
+	if !strings.HasSuffix(str, "\x00") {
+		panic("str argument missing null terminator: " + str)
+	}
+	header := (*reflect.StringHeader)(unsafe.Pointer(&str))
+	return (*uint8)(unsafe.Pointer(header.Data))
+}
+
+// GoStr takes a null-terminated string returned by OpenGL and constructs a
+// corresponding Go string.
+func GoStr(cstr *uint8) string {
+	return C.GoString((*C.char)(unsafe.Pointer(cstr)))
+}
+
+// Strs takes a list of Go strings (with or without null-termination) and
+// returns their C counterpart.
+//
+// The returned free function must be called once you are done using the strings
+// in order to free the memory.
+//
+// If no strings are provided as a parameter this function will panic.
+func Strs(strs ...string) (cstrs **uint8, free func()) {
+	if len(strs) == 0 {
+		panic("Strs: expected at least 1 string")
+	}
+
+	// Allocate a contiguous array large enough to hold all the strings' contents.
+	n := 0
+	for i := range strs {
+		n += len(strs[i])
+	}
+	data := C.malloc(C.size_t(n))
+
+	// Copy all the strings into data.
+	dataSlice := *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader{
+		Data: uintptr(data),
+		Len:  n,
+		Cap:  n,
+	}))
+	css := make([]*uint8, len(strs)) // Populated with pointers to each string.
+	offset := 0
+	for i := range strs {
+		copy(dataSlice[offset:offset+len(strs[i])], strs[i][:]) // Copy strs[i] into proper data location.
+		css[i] = (*uint8)(unsafe.Pointer(&dataSlice[offset]))   // Set a pointer to it.
+		offset += len(strs[i])
+	}
+
+	return (**uint8)(&css[0]), func() { C.free(data) }
+}

vendor/github.com/go-gl/gl/v3.3-core/gl/debug.go

@@ -0,0 +1,31 @@
+// Glow automatically generated OpenGL binding: http://github.com/go-gl/glow
+
+package gl
+
+import "C"
+import "unsafe"
+
+type DebugProc func(
+	source uint32,
+	gltype uint32,
+	id uint32,
+	severity uint32,
+	length int32,
+	message string,
+	userParam unsafe.Pointer)
+
+var userDebugCallback DebugProc
+
+//export glowDebugCallback_glcore33
+func glowDebugCallback_glcore33(
+	source uint32,
+	gltype uint32,
+	id uint32,
+	severity uint32,
+	length int32,
+	message *uint8,
+	userParam unsafe.Pointer) {
+	if userDebugCallback != nil {
+		userDebugCallback(source, gltype, id, severity, length, GoStr(message), userParam)
+	}
+}

vendor/github.com/go-gl/gl/v3.3-core/gl/procaddr.go

@@ -0,0 +1,65 @@
+// This file implements GlowGetProcAddress for every supported platform. The
+// correct version is chosen automatically based on build tags:
+// windows: WGL
+// darwin: CGL
+// linux freebsd: GLX
+// Use of EGL instead of the platform's default (listed above) is made possible
+// via the "egl" build tag.
+// It is also possible to install your own function outside this package for
+// retrieving OpenGL function pointers, to do this see InitWithProcAddrFunc.
+package gl
+
+/*
+#cgo windows CFLAGS: -DTAG_WINDOWS
+#cgo windows LDFLAGS: -lopengl32
+#cgo darwin CFLAGS: -DTAG_DARWIN
+#cgo darwin LDFLAGS: -framework OpenGL
+#cgo linux freebsd CFLAGS: -DTAG_POSIX
+#cgo linux freebsd LDFLAGS: -lGL
+#cgo egl CFLAGS: -DTAG_EGL
+#cgo egl LDFLAGS: -lEGL
+// Check the EGL tag first as it takes priority over the platform's default
+// configuration of WGL/GLX/CGL.
+#if defined(TAG_EGL)
+	#include <stdlib.h>
+	#include <EGL/egl.h>
+	void* GlowGetProcAddress_glcore33(const char* name) {
+		return eglGetProcAddress(name);
+	}
+#elif defined(TAG_WINDOWS)
+	#define WIN32_LEAN_AND_MEAN 1
+	#include <windows.h>
+	#include <stdlib.h>
+	static HMODULE ogl32dll = NULL;
+	void* GlowGetProcAddress_glcore33(const char* name) {
+		void* pf = wglGetProcAddress((LPCSTR) name);
+		if (pf) {
+			return pf;
+		}
+		if (ogl32dll == NULL) {
+			ogl32dll = LoadLibraryA("opengl32.dll");
+		}
+		return GetProcAddress(ogl32dll, (LPCSTR) name);
+	}
+#elif defined(TAG_DARWIN)
+	#include <stdlib.h>
+	#include <dlfcn.h>
+	void* GlowGetProcAddress_glcore33(const char* name) {
+		return dlsym(RTLD_DEFAULT, name);
+	}
+#elif defined(TAG_POSIX)
+	#include <stdlib.h>
+	#include <GL/glx.h>
+	void* GlowGetProcAddress_glcore33(const char* name) {
+		return glXGetProcAddress(name);
+	}
+#endif
+*/
+import "C"
+import "unsafe"
+
+func getProcAddress(namea string) unsafe.Pointer {
+	cname := C.CString(namea)
+	defer C.free(unsafe.Pointer(cname))
+	return C.GlowGetProcAddress_glcore33(cname)
+}