ui/app: make opengl objects structs

WebGL use opaque values for object handles, not integers. To ensure
portability, wrap handle types with a struct.

Signed-off-by: Elias Naur <mail@eliasnaur.com>

ui/app/egl.go

@@ -33,6 +33,13 @@ type eglContext struct {
 	srgb     bool
 }
 
+var (
+	nilEGLSurface          _EGLSurface
+	nilEGLContext          _EGLContext
+	nilEGLConfig           _EGLConfig
+	nilEGLNativeWindowType _EGLNativeWindowType
+)
+
 const (
 	_EGL_ALPHA_SIZE             = 0x3021
 	_EGL_BLUE_SIZE              = 0x3022

ui/app/egl_linux.go

@@ -20,13 +20,6 @@ type (
 	_EGLSurface = C.EGLSurface
 )
 
-var (
-	nilEGLSurface          _EGLSurface
-	nilEGLContext          _EGLContext
-	nilEGLConfig           _EGLConfig
-	nilEGLNativeWindowType _EGLNativeWindowType
-)
-
 func eglChooseConfig(disp _EGLDisplay, attribs []_EGLint) (_EGLConfig, bool) {
 	var cfg C.EGLConfig
 	var ncfg C.EGLint

ui/app/egl_windows.go

@@ -41,13 +41,6 @@ var (
 	_eglQueryString         = libEGL.NewProc("eglQueryString")
 )
 
-const (
-	nilEGLSurface          _EGLSurface          = 0
-	nilEGLContext          _EGLContext          = 0
-	nilEGLConfig           _EGLConfig           = 0
-	nilEGLNativeWindowType _EGLNativeWindowType = 0
-)
-
 func init() {
 	mustLoadDLL(libEGL, "libEGL.dll")
 	mustLoadDLL(gl.LibGLESv2, "libGLESv2.dll")

ui/app/internal/gl/functions.go

@@ -120,33 +120,33 @@ func (f *Functions) ActiveTexture(texture Enum) {
 }
 
 func (f *Functions) AttachShader(p Program, s Shader) {
-	C.glAttachShader(C.GLuint(p), C.GLuint(s))
+	C.glAttachShader(C.GLuint(p.V), C.GLuint(s.V))
 }
 
 func (f *Functions) BeginQuery(target Enum, query Query) {
-	C.gio_glBeginQuery(C.GLenum(target), C.GLenum(query))
+	C.gio_glBeginQuery(C.GLenum(target), C.GLenum(query.V))
 }
 
 func (f *Functions) BindAttribLocation(p Program, a Attrib, name string) {
 	cname := C.CString(name)
 	defer C.free(unsafe.Pointer(cname))
-	C.glBindAttribLocation(C.GLuint(p), C.GLuint(a), cname)
+	C.glBindAttribLocation(C.GLuint(p.V), C.GLuint(a), cname)
 }
 
 func (f *Functions) BindBuffer(target Enum, b Buffer) {
-	C.glBindBuffer(C.GLenum(target), C.GLuint(b))
+	C.glBindBuffer(C.GLenum(target), C.GLuint(b.V))
 }
 
 func (f *Functions) BindFramebuffer(target Enum, fb Framebuffer) {
-	C.glBindFramebuffer(C.GLenum(target), C.GLuint(fb))
+	C.glBindFramebuffer(C.GLenum(target), C.GLuint(fb.V))
 }
 
 func (f *Functions) BindRenderbuffer(target Enum, fb Renderbuffer) {
-	C.glBindRenderbuffer(C.GLenum(target), C.GLuint(fb))
+	C.glBindRenderbuffer(C.GLenum(target), C.GLuint(fb.V))
 }
 
 func (f *Functions) BindTexture(target Enum, t Texture) {
-	C.glBindTexture(C.GLenum(target), C.GLuint(t))
+	C.glBindTexture(C.GLenum(target), C.GLuint(t.V))
 }
 
 func (f *Functions) BlendEquation(mode Enum) {
@@ -182,77 +182,77 @@ func (f *Functions) ClearDepthf(d float32) {
 }
 
 func (f *Functions) CompileShader(s Shader) {
-	C.glCompileShader(C.GLuint(s))
+	C.glCompileShader(C.GLuint(s.V))
 }
 
 func (f *Functions) CreateBuffer() Buffer {
 	var handle C.GLuint
 	C.glGenBuffers(1, &handle)
-	return Buffer(handle)
+	return Buffer{uint(handle)}
 }
 
 func (f *Functions) CreateFramebuffer() Framebuffer {
 	var handle C.GLuint
 	C.glGenFramebuffers(1, &handle)
-	return Framebuffer(handle)
+	return Framebuffer{uint(handle)}
 }
 
 func (f *Functions) CreateProgram() Program {
-	return Program(C.glCreateProgram())
+	return Program{uint(C.glCreateProgram())}
 }
 
 func (f *Functions) CreateQuery() Query {
 	var handle C.GLuint
 	C.gio_glGenQueries(1, &handle)
-	return Query(handle)
+	return Query{uint(handle)}
 }
 
 func (f *Functions) CreateRenderbuffer() Renderbuffer {
 	var handle C.GLuint
 	C.glGenRenderbuffers(1, &handle)
-	return Renderbuffer(handle)
+	return Renderbuffer{uint(handle)}
 }
 
 func (f *Functions) CreateShader(ty Enum) Shader {
-	return Shader(C.glCreateShader(C.GLenum(ty)))
+	return Shader{uint(C.glCreateShader(C.GLenum(ty)))}
 }
 
 func (f *Functions) CreateTexture() Texture {
 	var handle C.GLuint
 	C.glGenTextures(1, &handle)
-	return Texture(handle)
+	return Texture{uint(handle)}
 }
 
 func (f *Functions) DeleteBuffer(v Buffer) {
-	handle := C.GLuint(v)
+	handle := C.GLuint(v.V)
 	C.glDeleteBuffers(1, &handle)
 }
 
 func (f *Functions) DeleteFramebuffer(v Framebuffer) {
-	handle := C.GLuint(v)
+	handle := C.GLuint(v.V)
 	C.glDeleteFramebuffers(1, &handle)
 }
 
 func (f *Functions) DeleteProgram(p Program) {
-	C.glDeleteProgram(C.GLuint(p))
+	C.glDeleteProgram(C.GLuint(p.V))
 }
 
 func (f *Functions) DeleteQuery(query Query) {
-	handle := C.GLuint(query)
+	handle := C.GLuint(query.V)
 	C.gio_glDeleteQueries(1, &handle)
 }
 
 func (f *Functions) DeleteRenderbuffer(v Renderbuffer) {
-	handle := C.GLuint(v)
+	handle := C.GLuint(v.V)
 	C.glDeleteRenderbuffers(1, &handle)
 }
 
 func (f *Functions) DeleteShader(s Shader) {
-	C.glDeleteShader(C.GLuint(s))
+	C.glDeleteShader(C.GLuint(s.V))
 }
 
 func (f *Functions) DeleteTexture(v Texture) {
-	handle := C.GLuint(v)
+	handle := C.GLuint(v.V)
 	C.glDeleteTextures(1, &handle)
 }
 
@@ -301,11 +301,15 @@ func (f *Functions) Finish() {
 }
 
 func (f *Functions) FramebufferRenderbuffer(target, attachment, renderbuffertarget Enum, renderbuffer Renderbuffer) {
-	C.glFramebufferRenderbuffer(C.GLenum(target), C.GLenum(attachment), C.GLenum(renderbuffertarget), C.GLuint(renderbuffer))
+	C.glFramebufferRenderbuffer(C.GLenum(target), C.GLenum(attachment), C.GLenum(renderbuffertarget), C.GLuint(renderbuffer.V))
 }
 
 func (f *Functions) FramebufferTexture2D(target, attachment, texTarget Enum, t Texture, level int) {
-	C.glFramebufferTexture2D(C.GLenum(target), C.GLenum(attachment), C.GLenum(texTarget), C.GLuint(t), C.GLint(level))
+	C.glFramebufferTexture2D(C.GLenum(target), C.GLenum(attachment), C.GLenum(texTarget), C.GLuint(t.V), C.GLint(level))
+}
+
+func (c *Functions) GetBinding(pname Enum) Object {
+	return Object{uint(c.GetInteger(pname))}
 }
 
 func (f *Functions) GetError() Enum {
@@ -336,45 +340,45 @@ func (f *Functions) GetInteger(pname Enum) int {
 func (f *Functions) GetProgrami(p Program, pname Enum) int {
 	// Hope this is enough room.
 	var buf [100]C.GLint
-	C.glGetProgramiv(C.GLuint(p), C.GLenum(pname), &buf[0])
+	C.glGetProgramiv(C.GLuint(p.V), C.GLenum(pname), &buf[0])
 	return int(buf[0])
 }
 
 func (f *Functions) GetProgramInfoLog(p Program) string {
 	var plen C.GLsizei
-	C.glGetProgramInfoLog(C.GLuint(p), 0, &plen, nil)
+	C.glGetProgramInfoLog(C.GLuint(p.V), 0, &plen, nil)
 	if plen == 0 {
 		return ""
 	}
 	// Make room for the string and the null terminator.
 	buf := make([]byte, plen+1)
-	C.glGetProgramInfoLog(C.GLuint(p), C.GLsizei(len(buf)), &plen, (*C.GLchar)(unsafe.Pointer(&buf[0])))
+	C.glGetProgramInfoLog(C.GLuint(p.V), C.GLsizei(len(buf)), &plen, (*C.GLchar)(unsafe.Pointer(&buf[0])))
 	return string(buf[:len(buf)-1])
 }
 
 func (f *Functions) GetQueryObjectuiv(query Query, pname Enum) uint {
 	// Hope this is enough room.
 	var buf [100]C.GLuint
-	C.gio_glGetQueryObjectuiv(C.GLuint(query), C.GLenum(pname), &buf[0])
+	C.gio_glGetQueryObjectuiv(C.GLuint(query.V), C.GLenum(pname), &buf[0])
 	return uint(buf[0])
 }
 
 func (f *Functions) GetShaderi(s Shader, pname Enum) int {
 	// Hope this is enough room.
 	var buf [100]C.GLint
-	C.glGetShaderiv(C.GLuint(s), C.GLenum(pname), &buf[0])
+	C.glGetShaderiv(C.GLuint(s.V), C.GLenum(pname), &buf[0])
 	return int(buf[0])
 }
 
 func (f *Functions) GetShaderInfoLog(s Shader) string {
 	var plen C.GLsizei
-	C.glGetShaderInfoLog(C.GLuint(s), 0, &plen, nil)
+	C.glGetShaderInfoLog(C.GLuint(s.V), 0, &plen, nil)
 	if plen == 0 {
 		return ""
 	}
 	// Make room for the string and the null terminator.
 	buf := make([]byte, plen+1)
-	C.glGetShaderInfoLog(C.GLuint(s), C.GLsizei(len(buf)), &plen, (*C.GLchar)(unsafe.Pointer(&buf[0])))
+	C.glGetShaderInfoLog(C.GLuint(s.V), C.GLsizei(len(buf)), &plen, (*C.GLchar)(unsafe.Pointer(&buf[0])))
 	return string(buf[:len(buf)-1])
 }
 
@@ -386,7 +390,7 @@ func (f *Functions) GetString(pname Enum) string {
 func (f *Functions) GetUniformLocation(p Program, name string) Uniform {
 	cname := C.CString(name)
 	defer C.free(unsafe.Pointer(cname))
-	return Uniform(C.glGetUniformLocation(C.GLuint(p), cname))
+	return Uniform{int(C.glGetUniformLocation(C.GLuint(p.V), cname))}
 }
 
 func (f *Functions) InvalidateFramebuffer(target, attachment Enum) {
@@ -394,7 +398,7 @@ func (f *Functions) InvalidateFramebuffer(target, attachment Enum) {
 }
 
 func (f *Functions) LinkProgram(p Program) {
-	C.glLinkProgram(C.GLuint(p))
+	C.glLinkProgram(C.GLuint(p.V))
 }
 
 func (f *Functions) PixelStorei(pname Enum, param int32) {
@@ -413,7 +417,7 @@ func (f *Functions) ShaderSource(s Shader, src string) {
 	csrc := C.CString(src)
 	defer C.free(unsafe.Pointer(csrc))
 	strlen := C.GLint(len(src))
-	C.glShaderSource(C.GLuint(s), 1, &csrc, &strlen)
+	C.glShaderSource(C.GLuint(s.V), 1, &csrc, &strlen)
 }
 
 func (f *Functions) TexImage2D(target Enum, level int, internalFormat int, width int, height int, format Enum, ty Enum, data []byte) {
@@ -437,27 +441,27 @@ func (f *Functions) TexParameteri(target, pname Enum, param int) {
 }
 
 func (f *Functions) Uniform1f(dst Uniform, v float32) {
-	C.glUniform1f(C.GLint(dst), C.GLfloat(v))
+	C.glUniform1f(C.GLint(dst.V), C.GLfloat(v))
 }
 
 func (f *Functions) Uniform1i(dst Uniform, v int) {
-	C.glUniform1i(C.GLint(dst), C.GLint(v))
+	C.glUniform1i(C.GLint(dst.V), C.GLint(v))
 }
 
 func (f *Functions) Uniform2f(dst Uniform, v0 float32, v1 float32) {
-	C.glUniform2f(C.GLint(dst), C.GLfloat(v0), C.GLfloat(v1))
+	C.glUniform2f(C.GLint(dst.V), C.GLfloat(v0), C.GLfloat(v1))
 }
 
 func (f *Functions) Uniform3f(dst Uniform, v0 float32, v1 float32, v2 float32) {
-	C.glUniform3f(C.GLint(dst), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2))
+	C.glUniform3f(C.GLint(dst.V), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2))
 }
 
 func (f *Functions) Uniform4f(dst Uniform, v0 float32, v1 float32, v2 float32, v3 float32) {
-	C.glUniform4f(C.GLint(dst), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3))
+	C.glUniform4f(C.GLint(dst.V), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3))
 }
 
 func (f *Functions) UseProgram(p Program) {
-	C.glUseProgram(C.GLuint(p))
+	C.glUseProgram(C.GLuint(p.V))
 }
 
 func (f *Functions) VertexAttribPointer(dst Attrib, size int, ty Enum, normalized bool, stride int, offset int) {

ui/app/internal/gl/gl.go

@@ -3,16 +3,8 @@
 package gl
 
 type (
-	Attrib       uint
-	Buffer       uint
-	Enum         uint
-	Framebuffer  uint
-	Program      uint
-	Renderbuffer uint
-	Shader       uint
-	Texture      uint
-	Uniform      int
-	Query        uint
+	Attrib uint
+	Enum   uint
 )
 
 type Context interface {
@@ -135,6 +127,7 @@ var _ interface {
 	Finish()
 	FramebufferRenderbuffer(target, attachment, renderbuffertarget Enum, renderbuffer Renderbuffer)
 	FramebufferTexture2D(target, attachment, texTarget Enum, t Texture, level int)
+	GetBinding(pname Enum) Object
 	GetError() Enum
 	GetRenderbufferParameteri(target, pname Enum) int
 	GetFramebufferAttachmentParameteri(target, attachment, pname Enum) int

ui/app/internal/gl/gl_windows.go

@@ -91,26 +91,26 @@ func (c *Functions) ActiveTexture(t Enum) {
 	syscall.Syscall(_glActiveTexture.Addr(), 1, uintptr(t), 0, 0)
 }
 func (c *Functions) AttachShader(p Program, s Shader) {
-	syscall.Syscall(_glAttachShader.Addr(), 2, uintptr(p), uintptr(s), 0)
+	syscall.Syscall(_glAttachShader.Addr(), 2, uintptr(p.V), uintptr(s.V), 0)
 }
 func (f *Functions) BeginQuery(target Enum, query Query) {
-	syscall.Syscall(_glBeginQuery.Addr(), 2, uintptr(target), uintptr(query), 0)
+	syscall.Syscall(_glBeginQuery.Addr(), 2, uintptr(target), uintptr(query.V), 0)
 }
 func (c *Functions) BindAttribLocation(p Program, a Attrib, name string) {
 	cname := cString(name)
-	syscall.Syscall(_glBindAttribLocation.Addr(), 3, uintptr(p), uintptr(a), uintptr(unsafe.Pointer(&cname[0])))
+	syscall.Syscall(_glBindAttribLocation.Addr(), 3, uintptr(p.V), uintptr(a), uintptr(unsafe.Pointer(&cname[0])))
 }
 func (c *Functions) BindBuffer(target Enum, b Buffer) {
-	syscall.Syscall(_glBindBuffer.Addr(), 2, uintptr(target), uintptr(b), 0)
+	syscall.Syscall(_glBindBuffer.Addr(), 2, uintptr(target), uintptr(b.V), 0)
 }
 func (c *Functions) BindFramebuffer(target Enum, fb Framebuffer) {
-	syscall.Syscall(_glBindFramebuffer.Addr(), 2, uintptr(target), uintptr(fb), 0)
+	syscall.Syscall(_glBindFramebuffer.Addr(), 2, uintptr(target), uintptr(fb.V), 0)
 }
 func (c *Functions) BindRenderbuffer(target Enum, rb Renderbuffer) {
-	syscall.Syscall(_glBindRenderbuffer.Addr(), 2, uintptr(target), uintptr(rb), 0)
+	syscall.Syscall(_glBindRenderbuffer.Addr(), 2, uintptr(target), uintptr(rb.V), 0)
 }
 func (c *Functions) BindTexture(target Enum, t Texture) {
-	syscall.Syscall(_glBindTexture.Addr(), 2, uintptr(target), uintptr(t), 0)
+	syscall.Syscall(_glBindTexture.Addr(), 2, uintptr(target), uintptr(t.V), 0)
 }
 func (c *Functions) BlendEquation(mode Enum) {
 	syscall.Syscall(_glBlendEquation.Addr(), 1, uintptr(mode), 0, 0)
@@ -139,61 +139,61 @@ func (c *Functions) ClearDepthf(d float32) {
 	syscall.Syscall(_glClearDepthf.Addr(), 1, uintptr(math.Float32bits(d)), 0, 0)
 }
 func (c *Functions) CompileShader(s Shader) {
-	syscall.Syscall(_glCompileShader.Addr(), 1, uintptr(s), 0, 0)
+	syscall.Syscall(_glCompileShader.Addr(), 1, uintptr(s.V), 0, 0)
 }
 func (c *Functions) CreateBuffer() Buffer {
 	var buf uintptr
 	syscall.Syscall(_glGenBuffers.Addr(), 2, 1, uintptr(unsafe.Pointer(&buf)), 0)
-	return Buffer(buf)
+	return Buffer{uint(buf)}
 }
 func (c *Functions) CreateFramebuffer() Framebuffer {
 	var fb uintptr
 	syscall.Syscall(_glGenFramebuffers.Addr(), 2, 1, uintptr(unsafe.Pointer(&fb)), 0)
-	return Framebuffer(fb)
+	return Framebuffer{uint(fb)}
 }
 func (c *Functions) CreateProgram() Program {
 	p, _, _ := syscall.Syscall(_glCreateProgram.Addr(), 0, 0, 0, 0)
-	return Program(p)
+	return Program{uint(p)}
 }
 func (f *Functions) CreateQuery() Query {
 	var q uintptr
 	syscall.Syscall(_glGenQueries.Addr(), 2, 1, uintptr(unsafe.Pointer(&q)), 0)
-	return Query(q)
+	return Query{uint(q)}
 }
 func (c *Functions) CreateRenderbuffer() Renderbuffer {
 	var rb uintptr
 	syscall.Syscall(_glGenRenderbuffers.Addr(), 2, 1, uintptr(unsafe.Pointer(&rb)), 0)
-	return Renderbuffer(rb)
+	return Renderbuffer{uint(rb)}
 }
 func (c *Functions) CreateShader(ty Enum) Shader {
 	s, _, _ := syscall.Syscall(_glCreateShader.Addr(), 1, uintptr(ty), 0, 0)
-	return Shader(s)
+	return Shader{uint(s)}
 }
 func (c *Functions) CreateTexture() Texture {
 	var t uintptr
 	syscall.Syscall(_glGenTextures.Addr(), 2, 1, uintptr(unsafe.Pointer(&t)), 0)
-	return Texture(t)
+	return Texture{uint(t)}
 }
 func (c *Functions) DeleteBuffer(v Buffer) {
 	syscall.Syscall(_glDeleteBuffers.Addr(), 2, 1, uintptr(unsafe.Pointer(&v)), 0)
 }
 func (c *Functions) DeleteFramebuffer(v Framebuffer) {
-	syscall.Syscall(_glDeleteFramebuffers.Addr(), 2, 1, uintptr(unsafe.Pointer(&v)), 0)
+	syscall.Syscall(_glDeleteFramebuffers.Addr(), 2, 1, uintptr(unsafe.Pointer(&v.V)), 0)
 }
 func (c *Functions) DeleteProgram(p Program) {
-	syscall.Syscall(_glDeleteProgram.Addr(), 1, uintptr(p), 0, 0)
+	syscall.Syscall(_glDeleteProgram.Addr(), 1, uintptr(p.V), 0, 0)
 }
 func (f *Functions) DeleteQuery(query Query) {
-	syscall.Syscall(_glDeleteQueries.Addr(), 2, 1, uintptr(unsafe.Pointer(&query)), 0)
+	syscall.Syscall(_glDeleteQueries.Addr(), 2, 1, uintptr(unsafe.Pointer(&query.V)), 0)
 }
 func (c *Functions) DeleteShader(s Shader) {
-	syscall.Syscall(_glDeleteShader.Addr(), 1, uintptr(s), 0, 0)
+	syscall.Syscall(_glDeleteShader.Addr(), 1, uintptr(s.V), 0, 0)
 }
 func (c *Functions) DeleteRenderbuffer(v Renderbuffer) {
-	syscall.Syscall(_glDeleteRenderbuffers.Addr(), 2, 1, uintptr(unsafe.Pointer(&v)), 0)
+	syscall.Syscall(_glDeleteRenderbuffers.Addr(), 2, 1, uintptr(unsafe.Pointer(&v.V)), 0)
 }
 func (c *Functions) DeleteTexture(v Texture) {
-	syscall.Syscall(_glDeleteTextures.Addr(), 2, 1, uintptr(unsafe.Pointer(&v)), 0)
+	syscall.Syscall(_glDeleteTextures.Addr(), 2, 1, uintptr(unsafe.Pointer(&v.V)), 0)
 }
 func (c *Functions) DepthFunc(f Enum) {
 	syscall.Syscall(_glDepthFunc.Addr(), 1, uintptr(f), 0, 0)
@@ -230,10 +230,13 @@ func (c *Functions) Finish() {
 	syscall.Syscall(_glFinish.Addr(), 0, 0, 0, 0)
 }
 func (c *Functions) FramebufferRenderbuffer(target, attachment, renderbuffertarget Enum, renderbuffer Renderbuffer) {
-	syscall.Syscall6(_glFramebufferRenderbuffer.Addr(), 4, uintptr(target), uintptr(attachment), uintptr(renderbuffertarget), uintptr(renderbuffer), 0, 0)
+	syscall.Syscall6(_glFramebufferRenderbuffer.Addr(), 4, uintptr(target), uintptr(attachment), uintptr(renderbuffertarget), uintptr(renderbuffer.V), 0, 0)
 }
 func (c *Functions) FramebufferTexture2D(target, attachment, texTarget Enum, t Texture, level int) {
-	syscall.Syscall6(_glFramebufferTexture2D.Addr(), 5, uintptr(target), uintptr(attachment), uintptr(texTarget), uintptr(t), uintptr(level), 0)
+	syscall.Syscall6(_glFramebufferTexture2D.Addr(), 5, uintptr(target), uintptr(attachment), uintptr(texTarget), uintptr(t.V), uintptr(level), 0)
+}
+func (c *Functions) GetBinding(pname Enum) Object {
+	return Object{uint(c.GetInteger(pname))}
 }
 func (c *Functions) GetError() Enum {
 	e, _, _ := syscall.Syscall(_glGetError.Addr(), 0, 0, 0, 0)
@@ -256,41 +259,41 @@ func (c *Functions) GetInteger(pname Enum) int {
 func (c *Functions) GetProgrami(p Program, pname Enum) int {
 	// Hopefully enough space.
 	var params [100]int32
-	syscall.Syscall(_glGetProgramiv.Addr(), 3, uintptr(p), uintptr(pname), uintptr(unsafe.Pointer(&params[0])))
+	syscall.Syscall(_glGetProgramiv.Addr(), 3, uintptr(p.V), uintptr(pname), uintptr(unsafe.Pointer(&params[0])))
 	return int(params[0])
 }
 func (c *Functions) GetProgramInfoLog(p Program) string {
 	var n uintptr
-	syscall.Syscall6(_glGetProgramInfoLog.Addr(), 4, uintptr(p), 0, uintptr(unsafe.Pointer(&n)), 0, 0, 0)
+	syscall.Syscall6(_glGetProgramInfoLog.Addr(), 4, uintptr(p.V), 0, uintptr(unsafe.Pointer(&n)), 0, 0, 0)
 	if n == 0 {
 		return ""
 	}
 	// Make space for the null terminator.
 	buf := make([]byte, n+1)
-	syscall.Syscall6(_glGetProgramInfoLog.Addr(), 4, uintptr(p), uintptr(len(buf)), uintptr(unsafe.Pointer(&n)), uintptr(unsafe.Pointer(&buf[0])), 0, 0)
+	syscall.Syscall6(_glGetProgramInfoLog.Addr(), 4, uintptr(p.V), uintptr(len(buf)), uintptr(unsafe.Pointer(&n)), uintptr(unsafe.Pointer(&buf[0])), 0, 0)
 	return string(buf[:len(buf)-1])
 }
 func (f *Functions) GetQueryObjectuiv(query Query, pname Enum) uint {
 	// Hope this is enough room.
 	var buf [100]int32
-	syscall.Syscall(_glGetQueryObjectuiv.Addr(), 3, uintptr(query), uintptr(pname), uintptr(unsafe.Pointer(&buf[0])))
+	syscall.Syscall(_glGetQueryObjectuiv.Addr(), 3, uintptr(query.V), uintptr(pname), uintptr(unsafe.Pointer(&buf[0])))
 	return uint(buf[0])
 }
 func (c *Functions) GetShaderi(s Shader, pname Enum) int {
 	// Hopefully enough room.
 	var params [100]int32
-	syscall.Syscall(_glGetShaderiv.Addr(), 3, uintptr(s), uintptr(pname), uintptr(unsafe.Pointer(&params[0])))
+	syscall.Syscall(_glGetShaderiv.Addr(), 3, uintptr(s.V), uintptr(pname), uintptr(unsafe.Pointer(&params[0])))
 	return int(params[0])
 }
 func (c *Functions) GetShaderInfoLog(s Shader) string {
 	var n uintptr
-	syscall.Syscall6(_glGetShaderInfoLog.Addr(), 4, uintptr(s), 0, uintptr(unsafe.Pointer(&n)), 0, 0, 0)
+	syscall.Syscall6(_glGetShaderInfoLog.Addr(), 4, uintptr(s.V), 0, uintptr(unsafe.Pointer(&n)), 0, 0, 0)
 	if n == 0 {
 		return ""
 	}
 	// Make space for the null terminator.
 	buf := make([]byte, n+1)
-	syscall.Syscall6(_glGetShaderInfoLog.Addr(), 4, uintptr(s), uintptr(len(buf)), uintptr(unsafe.Pointer(&n)), uintptr(unsafe.Pointer(&buf[0])), 0, 0)
+	syscall.Syscall6(_glGetShaderInfoLog.Addr(), 4, uintptr(s.V), uintptr(len(buf)), uintptr(unsafe.Pointer(&n)), uintptr(unsafe.Pointer(&buf[0])), 0, 0)
 	return string(buf[:len(buf)-1])
 }
 func (c *Functions) GetString(pname Enum) string {
@@ -299,8 +302,8 @@ func (c *Functions) GetString(pname Enum) string {
 }
 func (c *Functions) GetUniformLocation(p Program, name string) Uniform {
 	cname := cString(name)
-	u, _, _ := syscall.Syscall(_glGetUniformLocation.Addr(), 2, uintptr(p), uintptr(unsafe.Pointer(&cname[0])), 0)
-	return Uniform(u)
+	u, _, _ := syscall.Syscall(_glGetUniformLocation.Addr(), 2, uintptr(p.V), uintptr(unsafe.Pointer(&cname[0])), 0)
+	return Uniform{int(u)}
 }
 func (c *Functions) InvalidateFramebuffer(target, attachment Enum) {
 	addr := _glInvalidateFramebuffer.Addr()
@@ -311,7 +314,7 @@ func (c *Functions) InvalidateFramebuffer(target, attachment Enum) {
 	syscall.Syscall(addr, 3, uintptr(target), 1, uintptr(unsafe.Pointer(&attachment)))
 }
 func (c *Functions) LinkProgram(p Program) {
-	syscall.Syscall(_glLinkProgram.Addr(), 1, uintptr(p), 0, 0)
+	syscall.Syscall(_glLinkProgram.Addr(), 1, uintptr(p.V), 0, 0)
 }
 func (c *Functions) PixelStorei(pname Enum, param int32) {
 	syscall.Syscall(_glPixelStorei.Addr(), 2, uintptr(pname), uintptr(param), 0)
@@ -324,7 +327,7 @@ func (c *Functions) Scissor(x, y, width, height int32) {
 }
 func (c *Functions) ShaderSource(s Shader, src string) {
 	var n uintptr = uintptr(len(src))
-	syscall.Syscall6(_glShaderSource.Addr(), 4, uintptr(s), 1, uintptr(unsafe.Pointer(&src)), uintptr(unsafe.Pointer(&n)), 0, 0)
+	syscall.Syscall6(_glShaderSource.Addr(), 4, uintptr(s.V), 1, uintptr(unsafe.Pointer(&src)), uintptr(unsafe.Pointer(&n)), 0, 0)
 }
 func (c *Functions) TexImage2D(target Enum, level int, internalFormat int, width, height int, format, ty Enum, data []byte) {
 	if len(data) == 0 {
@@ -340,22 +343,22 @@ func (c *Functions) TexParameteri(target, pname Enum, param int) {
 	syscall.Syscall(_glTexParameteri.Addr(), 3, uintptr(target), uintptr(pname), uintptr(param))
 }
 func (c *Functions) Uniform1f(dst Uniform, v float32) {
-	syscall.Syscall(_glUniform1f.Addr(), 2, uintptr(dst), uintptr(math.Float32bits(v)), 0)
+	syscall.Syscall(_glUniform1f.Addr(), 2, uintptr(dst.V), uintptr(math.Float32bits(v)), 0)
 }
 func (c *Functions) Uniform1i(dst Uniform, v int) {
-	syscall.Syscall(_glUniform1i.Addr(), 2, uintptr(dst), uintptr(v), 0)
+	syscall.Syscall(_glUniform1i.Addr(), 2, uintptr(dst.V), uintptr(v), 0)
 }
 func (c *Functions) Uniform2f(dst Uniform, v0, v1 float32) {
-	syscall.Syscall(_glUniform2f.Addr(), 3, uintptr(dst), uintptr(math.Float32bits(v0)), uintptr(math.Float32bits(v1)))
+	syscall.Syscall(_glUniform2f.Addr(), 3, uintptr(dst.V), uintptr(math.Float32bits(v0)), uintptr(math.Float32bits(v1)))
 }
 func (c *Functions) Uniform3f(dst Uniform, v0, v1, v2 float32) {
-	syscall.Syscall6(_glUniform3f.Addr(), 4, uintptr(dst), uintptr(math.Float32bits(v0)), uintptr(math.Float32bits(v1)), uintptr(math.Float32bits(v2)), 0, 0)
+	syscall.Syscall6(_glUniform3f.Addr(), 4, uintptr(dst.V), uintptr(math.Float32bits(v0)), uintptr(math.Float32bits(v1)), uintptr(math.Float32bits(v2)), 0, 0)
 }
 func (c *Functions) Uniform4f(dst Uniform, v0, v1, v2, v3 float32) {
-	syscall.Syscall6(_glUniform4f.Addr(), 5, uintptr(dst), uintptr(math.Float32bits(v0)), uintptr(math.Float32bits(v1)), uintptr(math.Float32bits(v2)), uintptr(math.Float32bits(v3)), 0)
+	syscall.Syscall6(_glUniform4f.Addr(), 5, uintptr(dst.V), uintptr(math.Float32bits(v0)), uintptr(math.Float32bits(v1)), uintptr(math.Float32bits(v2)), uintptr(math.Float32bits(v3)), 0)
 }
 func (c *Functions) UseProgram(p Program) {
-	syscall.Syscall(_glUseProgram.Addr(), 1, uintptr(p), 0, 0)
+	syscall.Syscall(_glUseProgram.Addr(), 1, uintptr(p.V), 0, 0)
 }
 func (c *Functions) VertexAttribPointer(dst Attrib, size int, ty Enum, normalized bool, stride, offset int) {
 	var norm uintptr

ui/app/internal/gl/srgb.go

@@ -69,7 +69,7 @@ func NewSRGBFBO(f *Functions) (*SRGBFBO, error) {
 }
 
 func (s *SRGBFBO) Blit() {
-	s.c.BindFramebuffer(FRAMEBUFFER, 0)
+	s.c.BindFramebuffer(FRAMEBUFFER, Framebuffer{})
 	s.c.ClearColor(1, 0, 1, 1)
 	s.c.Clear(COLOR_BUFFER_BIT)
 	s.c.UseProgram(s.prog)
@@ -80,7 +80,7 @@ func (s *SRGBFBO) Blit() {
 	s.c.EnableVertexAttribArray(0)
 	s.c.EnableVertexAttribArray(1)
 	s.c.DrawArrays(TRIANGLE_STRIP, 0, 4)
-	s.c.BindTexture(TEXTURE_2D, 0)
+	s.c.BindTexture(TEXTURE_2D, Texture{})
 	s.c.DisableVertexAttribArray(0)
 	s.c.DisableVertexAttribArray(1)
 	s.c.BindFramebuffer(FRAMEBUFFER, s.frameBuffer)
@@ -106,7 +106,7 @@ func (s *SRGBFBO) Refresh(w, h int) error {
 	} else /* EXT_sRGB */ {
 		s.c.TexImage2D(TEXTURE_2D, 0, SRGB_ALPHA_EXT, w, h, SRGB_ALPHA_EXT, UNSIGNED_BYTE, nil)
 	}
-	currentRB := Renderbuffer(s.c.GetInteger(RENDERBUFFER_BINDING))
+	currentRB := Renderbuffer(s.c.GetBinding(RENDERBUFFER_BINDING))
 	s.c.BindRenderbuffer(RENDERBUFFER, s.depthBuffer)
 	s.c.RenderbufferStorage(RENDERBUFFER, DEPTH_COMPONENT16, w, h)
 	s.c.BindRenderbuffer(RENDERBUFFER, currentRB)

ui/app/internal/gl/types.go

@@ -0,0 +1,19 @@
+// +build !js
+
+package gl
+
+type (
+	Buffer       struct{ V uint }
+	Framebuffer  struct{ V uint }
+	Program      struct{ V uint }
+	Renderbuffer struct{ V uint }
+	Shader       struct{ V uint }
+	Texture      struct{ V uint }
+	Query        struct{ V uint }
+	Uniform      struct{ V int }
+	Object       struct{ V uint }
+)
+
+func (u Uniform) Valid() bool {
+	return u.V != -1
+}

ui/app/internal/gl/util.go

@@ -13,17 +13,17 @@ import (
 func CreateProgram(ctx *Functions, vsSrc, fsSrc string, attribs []string) (Program, error) {
 	vs, err := createShader(ctx, VERTEX_SHADER, vsSrc)
 	if err != nil {
-		return 0, err
+		return Program{}, err
 	}
 	defer ctx.DeleteShader(vs)
 	fs, err := createShader(ctx, FRAGMENT_SHADER, fsSrc)
 	if err != nil {
-		return 0, err
+		return Program{}, err
 	}
 	defer ctx.DeleteShader(fs)
 	prog := ctx.CreateProgram()
-	if prog == 0 {
-		return 0, errors.New("glCreateProgram failed")
+	if prog == (Program{}) {
+		return Program{}, errors.New("glCreateProgram failed")
 	}
 	ctx.AttachShader(prog, vs)
 	ctx.AttachShader(prog, fs)
@@ -34,14 +34,14 @@ func CreateProgram(ctx *Functions, vsSrc, fsSrc string, attribs []string) (Progr
 	if ctx.GetProgrami(prog, LINK_STATUS) == 0 {
 		log := ctx.GetProgramInfoLog(prog)
 		ctx.DeleteProgram(prog)
-		return 0, fmt.Errorf("program link failed: %s", strings.TrimSpace(log))
+		return Program{}, fmt.Errorf("program link failed: %s", strings.TrimSpace(log))
 	}
 	return prog, nil
 }
 
 func GetUniformLocation(ctx *Functions, prog Program, name string) Uniform {
 	loc := ctx.GetUniformLocation(prog, name)
-	if loc == -1 {
+	if !loc.Valid() {
 		panic(fmt.Errorf("uniform %s not found", name))
 	}
 	return loc
@@ -49,15 +49,15 @@ func GetUniformLocation(ctx *Functions, prog Program, name string) Uniform {
 
 func createShader(ctx *Functions, typ Enum, src string) (Shader, error) {
 	sh := ctx.CreateShader(typ)
-	if sh == 0 {
-		return 0, errors.New("glCreateShader failed")
+	if sh == (Shader{}) {
+		return Shader{}, errors.New("glCreateShader failed")
 	}
 	ctx.ShaderSource(sh, src)
 	ctx.CompileShader(sh)
 	if ctx.GetShaderi(sh, COMPILE_STATUS) == 0 {
 		log := ctx.GetShaderInfoLog(sh)
 		ctx.DeleteShader(sh)
-		return 0, fmt.Errorf("shader compilation failed: %s", strings.TrimSpace(log))
+		return Shader{}, fmt.Errorf("shader compilation failed: %s", strings.TrimSpace(log))
 	}
 	return sh, nil
 }

ui/app/internal/gpu/gpu.go

@@ -326,7 +326,7 @@ func (g *GPU) setErr(err error) {
 }
 
 func (r *renderer) texHandle(t *texture) gl.Texture {
-	if t.id != 0 {
+	if t.id != (gl.Texture{}) {
 		return t.id
 	}
 	t.id = createTexture(r.ctx)
@@ -336,7 +336,7 @@ func (r *renderer) texHandle(t *texture) gl.Texture {
 }
 
 func (t *texture) release(ctx *gl.Functions) {
-	if t.id != 0 {
+	if t.id != (gl.Texture{}) {
 		ctx.DeleteTexture(t.id)
 	}
 }

ui/app/internal/gpu/path.go

@@ -117,7 +117,7 @@ func newCoverer(ctx *gl.Functions) *coverer {
 }
 
 func newStenciler(ctx *gl.Functions) *stenciler {
-	defFBO := gl.Framebuffer(ctx.GetInteger(gl.FRAMEBUFFER_BINDING))
+	defFBO := gl.Framebuffer(ctx.GetBinding(gl.FRAMEBUFFER_BINDING))
 	prog, err := gl.CreateProgram(ctx, stencilVSrc, stencilFSrc, pathAttribs)
 	if err != nil {
 		panic(err)
@@ -248,7 +248,7 @@ func (p *pather) stencilPath(bounds image.Rectangle, offset f32.Point, uv image.
 
 func (s *stenciler) beginIntersect(sizes []image.Point) {
 	s.ctx.ActiveTexture(gl.TEXTURE1)
-	s.ctx.BindTexture(gl.TEXTURE_2D, 0)
+	s.ctx.BindTexture(gl.TEXTURE_2D, gl.Texture{})
 	s.ctx.ActiveTexture(gl.TEXTURE0)
 	s.ctx.BlendFunc(gl.DST_COLOR, gl.ZERO)
 	// 8 bit coverage is enough, but OpenGL ES only supports single channel
@@ -275,7 +275,7 @@ func (s *stenciler) cover(idx int) stencilFBO {
 
 func (s *stenciler) begin(sizes []image.Point) {
 	s.ctx.ActiveTexture(gl.TEXTURE1)
-	s.ctx.BindTexture(gl.TEXTURE_2D, 0)
+	s.ctx.BindTexture(gl.TEXTURE_2D, gl.Texture{})
 	s.ctx.ActiveTexture(gl.TEXTURE0)
 	s.ctx.BlendFunc(gl.ONE, gl.ONE)
 	s.fbos.resize(s.ctx, sizes, gl.R16F, gl.RED, gl.HALF_FLOAT)