app/internal/gl/impl: extract platform dependent opengl bindings

We'd like to support Gio using a different renderer binding than
the builtin. A first step is to define the Functions interface
in package gl, and extract the concrete implementations to a
separate package.

Updates #26

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

app/headless/headless.go

@@ -23,7 +23,7 @@ type Window struct {
 }
 
 type context interface {
-	Functions() *gl.Functions
+	Functions() gl.Functions
 	MakeCurrent() error
 	ReleaseCurrent()
 	Release()

app/headless/headless_darwin.go

@@ -3,6 +3,7 @@
 package headless
 
 import "gioui.org/app/internal/gl"
+import "gioui.org/app/internal/gl/impl"
 
 /*
 #cgo CFLAGS: -DGL_SILENCE_DEPRECATION -Werror -Wno-deprecated-declarations -fmodules -fobjc-arc -x objective-c
@@ -13,14 +14,14 @@ import "gioui.org/app/internal/gl"
 import "C"
 
 type nsContext struct {
-	c        *gl.Functions
+	c        gl.Functions
 	ctx      C.CFTypeRef
 	prepared bool
 }
 
 func newContext() (context, error) {
 	ctx := C.gio_headless_newContext()
-	return &nsContext{ctx: ctx, c: new(gl.Functions)}, nil
+	return &nsContext{ctx: ctx, c: new(impl.Functions)}, nil
 }
 
 func (c *nsContext) MakeCurrent() error {
@@ -36,7 +37,7 @@ func (c *nsContext) ReleaseCurrent() {
 	C.gio_headless_clearCurrentContext(c.ctx)
 }
 
-func (c *nsContext) Functions() *gl.Functions {
+func (c *nsContext) Functions() gl.Functions {
 	return c.c
 }
 

app/headless/headless_js.go

@@ -7,11 +7,12 @@ import (
 	"syscall/js"
 
 	"gioui.org/app/internal/gl"
+	"gioui.org/app/internal/gl/impl"
 )
 
 type jsContext struct {
 	ctx js.Value
-	f   *gl.Functions
+	f   gl.Functions
 }
 
 func newContext() (*jsContext, error) {
@@ -26,7 +27,7 @@ func newContext() (*jsContext, error) {
 	if ctx.IsNull() {
 		return nil, errors.New("headless: webgl is not supported")
 	}
-	f := &gl.Functions{Ctx: ctx}
+	f := &impl.Functions{Ctx: ctx}
 	if err := f.Init(version); err != nil {
 		return nil, err
 	}
@@ -37,7 +38,7 @@ func newContext() (*jsContext, error) {
 	return c, nil
 }
 
-func (c *jsContext) Functions() *gl.Functions {
+func (c *jsContext) Functions() gl.Functions {
 	return c.f
 }
 

app/internal/egl/egl.go

@@ -11,10 +11,11 @@ import (
 	"strings"
 
 	"gioui.org/app/internal/gl"
+	"gioui.org/app/internal/gl/impl"
 )
 
 type Context struct {
-	c             *gl.Functions
+	c             gl.Functions
 	disp          _EGLDisplay
 	eglCtx        *eglContext
 	eglSurf       _EGLSurface
@@ -109,12 +110,12 @@ func NewContext(disp NativeDisplayType) (*Context, error) {
 	c := &Context{
 		disp:   eglDisp,
 		eglCtx: eglCtx,
-		c:      new(gl.Functions),
+		c:      new(impl.Functions),
 	}
 	return c, nil
 }
 
-func (c *Context) Functions() *gl.Functions {
+func (c *Context) Functions() gl.Functions {
 	return c.c
 }
 

app/internal/egl/egl_windows.go

@@ -11,6 +11,7 @@ import (
 	syscall "golang.org/x/sys/windows"
 
 	"gioui.org/app/internal/gl"
+	"gioui.org/app/internal/gl/impl"
 )
 
 type (
@@ -56,7 +57,7 @@ func loadDLLs() error {
 	if err := loadDLL(libEGL, "libEGL.dll"); err != nil {
 		return err
 	}
-	if err := loadDLL(gl.LibGLESv2, "libGLESv2.dll"); err != nil {
+	if err := loadDLL(impl.LibGLESv2, "libGLESv2.dll"); err != nil {
 		return err
 	}
 	// d3dcompiler_47.dll is needed internally for shader compilation to function.

app/internal/gl/gl.go

@@ -81,8 +81,7 @@ const (
 	GPU_DISJOINT_EXT = 0x8FBB
 )
 
-// Enforce Functions interface.
+type Functions interface {
-var _ interface {
 	ActiveTexture(texture Enum)
 	AttachShader(p Program, s Shader)
 	BeginQuery(target Enum, query Query)
@@ -140,6 +139,7 @@ var _ interface {
 	InvalidateFramebuffer(target, attachment Enum)
 	LinkProgram(p Program)
 	PixelStorei(pname Enum, param int32)
+	ReadPixels(x, y, width, height int, format, ty Enum, data []byte)
 	RenderbufferStorage(target, internalformat Enum, width, height int)
 	Scissor(x, y, width, height int32)
 	ShaderSource(s Shader, src string)
@@ -154,4 +154,4 @@ var _ interface {
 	UseProgram(p Program)
 	VertexAttribPointer(dst Attrib, size int, ty Enum, normalized bool, stride, offset int)
 	Viewport(x, y, width, height int)
-} = (*Functions)(nil)
+}

app/internal/gl/impl/gl.go

@@ -2,12 +2,14 @@
 
 // +build darwin linux freebsd openbsd
 
-package gl
+package impl
 
 import (
 	"runtime"
 	"strings"
 	"unsafe"
+
+	"gioui.org/app/internal/gl"
 )
 
 /*
@@ -59,7 +61,7 @@ __attribute__ ((visibility ("hidden"))) void gio_glDrawElements(GLenum mode, GLs
 }
 
 __attribute__ ((visibility ("hidden"))) void gio_glInvalidateFramebuffer(GLenum target, GLenum attachment) {
-	// Framebuffer invalidation is just a hint and can safely be ignored.
+	// gl.Framebuffer invalidation is just a hint and can safely be ignored.
 	if (_glInvalidateFramebuffer != NULL) {
 		_glInvalidateFramebuffer(target, 1, &attachment);
 	}
@@ -134,54 +136,54 @@ __attribute__((constructor)) static void gio_loadGLFunctions() {
 import "C"
 
 type Functions struct {
-	// Query caches.
+	// gl.Query caches.
 	uints [100]C.GLuint
 	ints  [100]C.GLint
 }
 
-func (f *Functions) ActiveTexture(texture Enum) {
+func (f *Functions) ActiveTexture(texture gl.Enum) {
 	C.glActiveTexture(C.GLenum(texture))
 }
 
-func (f *Functions) AttachShader(p Program, s Shader) {
+func (f *Functions) AttachShader(p gl.Program, s gl.Shader) {
 	C.glAttachShader(C.GLuint(p.V), C.GLuint(s.V))
 }
 
-func (f *Functions) BeginQuery(target Enum, query Query) {
+func (f *Functions) BeginQuery(target gl.Enum, query gl.Query) {
 	C.gio_glBeginQuery(C.GLenum(target), C.GLenum(query.V))
 }
 
-func (f *Functions) BindAttribLocation(p Program, a Attrib, name string) {
+func (f *Functions) BindAttribLocation(p gl.Program, a gl.Attrib, name string) {
 	cname := C.CString(name)
 	defer C.free(unsafe.Pointer(cname))
 	C.glBindAttribLocation(C.GLuint(p.V), C.GLuint(a), cname)
 }
 
-func (f *Functions) BindBuffer(target Enum, b Buffer) {
+func (f *Functions) BindBuffer(target gl.Enum, b gl.Buffer) {
 	C.glBindBuffer(C.GLenum(target), C.GLuint(b.V))
 }
 
-func (f *Functions) BindFramebuffer(target Enum, fb Framebuffer) {
+func (f *Functions) BindFramebuffer(target gl.Enum, fb gl.Framebuffer) {
 	C.glBindFramebuffer(C.GLenum(target), C.GLuint(fb.V))
 }
 
-func (f *Functions) BindRenderbuffer(target Enum, fb Renderbuffer) {
+func (f *Functions) BindRenderbuffer(target gl.Enum, fb gl.Renderbuffer) {
 	C.glBindRenderbuffer(C.GLenum(target), C.GLuint(fb.V))
 }
 
-func (f *Functions) BindTexture(target Enum, t Texture) {
+func (f *Functions) BindTexture(target gl.Enum, t gl.Texture) {
 	C.glBindTexture(C.GLenum(target), C.GLuint(t.V))
 }
 
-func (f *Functions) BlendEquation(mode Enum) {
+func (f *Functions) BlendEquation(mode gl.Enum) {
 	C.glBlendEquation(C.GLenum(mode))
 }
 
-func (f *Functions) BlendFunc(sfactor, dfactor Enum) {
+func (f *Functions) BlendFunc(sfactor, dfactor gl.Enum) {
 	C.glBlendFunc(C.GLenum(sfactor), C.GLenum(dfactor))
 }
 
-func (f *Functions) BufferData(target Enum, src []byte, usage Enum) {
+func (f *Functions) BufferData(target gl.Enum, src []byte, usage gl.Enum) {
 	var p unsafe.Pointer
 	if len(src) > 0 {
 		p = unsafe.Pointer(&src[0])
@@ -189,11 +191,11 @@ func (f *Functions) BufferData(target Enum, src []byte, usage Enum) {
 	C.glBufferData(C.GLenum(target), C.GLsizeiptr(len(src)), p, C.GLenum(usage))
 }
 
-func (f *Functions) CheckFramebufferStatus(target Enum) Enum {
+func (f *Functions) CheckFramebufferStatus(target gl.Enum) gl.Enum {
-	return Enum(C.glCheckFramebufferStatus(C.GLenum(target)))
+	return gl.Enum(C.glCheckFramebufferStatus(C.GLenum(target)))
 }
 
-func (f *Functions) Clear(mask Enum) {
+func (f *Functions) Clear(mask gl.Enum) {
 	C.glClear(C.GLbitfield(mask))
 }
 
@@ -205,77 +207,77 @@ func (f *Functions) ClearDepthf(d float32) {
 	C.glClearDepthf(C.GLfloat(d))
 }
 
-func (f *Functions) CompileShader(s Shader) {
+func (f *Functions) CompileShader(s gl.Shader) {
 	C.glCompileShader(C.GLuint(s.V))
 }
 
-func (f *Functions) CreateBuffer() Buffer {
+func (f *Functions) CreateBuffer() gl.Buffer {
 	C.glGenBuffers(1, &f.uints[0])
-	return Buffer{uint(f.uints[0])}
+	return gl.Buffer{uint(f.uints[0])}
 }
 
-func (f *Functions) CreateFramebuffer() Framebuffer {
+func (f *Functions) CreateFramebuffer() gl.Framebuffer {
 	C.glGenFramebuffers(1, &f.uints[0])
-	return Framebuffer{uint(f.uints[0])}
+	return gl.Framebuffer{uint(f.uints[0])}
 }
 
-func (f *Functions) CreateProgram() Program {
+func (f *Functions) CreateProgram() gl.Program {
-	return Program{uint(C.glCreateProgram())}
+	return gl.Program{uint(C.glCreateProgram())}
 }
 
-func (f *Functions) CreateQuery() Query {
+func (f *Functions) CreateQuery() gl.Query {
 	C.gio_glGenQueries(1, &f.uints[0])
-	return Query{uint(f.uints[0])}
+	return gl.Query{uint(f.uints[0])}
 }
 
-func (f *Functions) CreateRenderbuffer() Renderbuffer {
+func (f *Functions) CreateRenderbuffer() gl.Renderbuffer {
 	C.glGenRenderbuffers(1, &f.uints[0])
-	return Renderbuffer{uint(f.uints[0])}
+	return gl.Renderbuffer{uint(f.uints[0])}
 }
 
-func (f *Functions) CreateShader(ty Enum) Shader {
+func (f *Functions) CreateShader(ty gl.Enum) gl.Shader {
-	return Shader{uint(C.glCreateShader(C.GLenum(ty)))}
+	return gl.Shader{uint(C.glCreateShader(C.GLenum(ty)))}
 }
 
-func (f *Functions) CreateTexture() Texture {
+func (f *Functions) CreateTexture() gl.Texture {
 	C.glGenTextures(1, &f.uints[0])
-	return Texture{uint(f.uints[0])}
+	return gl.Texture{uint(f.uints[0])}
 }
 
-func (f *Functions) DeleteBuffer(v Buffer) {
+func (f *Functions) DeleteBuffer(v gl.Buffer) {
 	f.uints[0] = C.GLuint(v.V)
 	C.glDeleteBuffers(1, &f.uints[0])
 }
 
-func (f *Functions) DeleteFramebuffer(v Framebuffer) {
+func (f *Functions) DeleteFramebuffer(v gl.Framebuffer) {
 	f.uints[0] = C.GLuint(v.V)
 	C.glDeleteFramebuffers(1, &f.uints[0])
 }
 
-func (f *Functions) DeleteProgram(p Program) {
+func (f *Functions) DeleteProgram(p gl.Program) {
 	C.glDeleteProgram(C.GLuint(p.V))
 }
 
-func (f *Functions) DeleteQuery(query Query) {
+func (f *Functions) DeleteQuery(query gl.Query) {
 	f.uints[0] = C.GLuint(query.V)
 	C.gio_glDeleteQueries(1, &f.uints[0])
 }
 
-func (f *Functions) DeleteRenderbuffer(v Renderbuffer) {
+func (f *Functions) DeleteRenderbuffer(v gl.Renderbuffer) {
 	f.uints[0] = C.GLuint(v.V)
 	C.glDeleteRenderbuffers(1, &f.uints[0])
 }
 
-func (f *Functions) DeleteShader(s Shader) {
+func (f *Functions) DeleteShader(s gl.Shader) {
 	C.glDeleteShader(C.GLuint(s.V))
 }
 
-func (f *Functions) DeleteTexture(v Texture) {
+func (f *Functions) DeleteTexture(v gl.Texture) {
 	f.uints[0] = C.GLuint(v.V)
 	C.glDeleteTextures(1, &f.uints[0])
 }
 
-func (f *Functions) DepthFunc(v Enum) {
+func (f *Functions) DepthFunc(v gl.Enum) {
 	C.glDepthFunc(C.GLenum(v))
 }
 
@@ -287,31 +289,31 @@ func (f *Functions) DepthMask(mask bool) {
 	C.glDepthMask(m)
 }
 
-func (f *Functions) DisableVertexAttribArray(a Attrib) {
+func (f *Functions) DisableVertexAttribArray(a gl.Attrib) {
 	C.glDisableVertexAttribArray(C.GLuint(a))
 }
 
-func (f *Functions) Disable(cap Enum) {
+func (f *Functions) Disable(cap gl.Enum) {
 	C.glDisable(C.GLenum(cap))
 }
 
-func (f *Functions) DrawArrays(mode Enum, first int, count int) {
+func (f *Functions) DrawArrays(mode gl.Enum, first int, count int) {
 	C.glDrawArrays(C.GLenum(mode), C.GLint(first), C.GLsizei(count))
 }
 
-func (f *Functions) DrawElements(mode Enum, count int, ty Enum, offset int) {
+func (f *Functions) DrawElements(mode gl.Enum, count int, ty gl.Enum, offset int) {
 	C.gio_glDrawElements(C.GLenum(mode), C.GLsizei(count), C.GLenum(ty), C.uintptr_t(offset))
 }
 
-func (f *Functions) Enable(cap Enum) {
+func (f *Functions) Enable(cap gl.Enum) {
 	C.glEnable(C.GLenum(cap))
 }
 
-func (f *Functions) EndQuery(target Enum) {
+func (f *Functions) EndQuery(target gl.Enum) {
 	C.gio_glEndQuery(C.GLenum(target))
 }
 
-func (f *Functions) EnableVertexAttribArray(a Attrib) {
+func (f *Functions) EnableVertexAttribArray(a gl.Attrib) {
 	C.glEnableVertexAttribArray(C.GLuint(a))
 }
 
@@ -319,67 +321,67 @@ func (f *Functions) Finish() {
 	C.glFinish()
 }
 
-func (f *Functions) FramebufferRenderbuffer(target, attachment, renderbuffertarget Enum, renderbuffer Renderbuffer) {
+func (f *Functions) FramebufferRenderbuffer(target, attachment, renderbuffertarget gl.Enum, renderbuffer gl.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) {
+func (f *Functions) FramebufferTexture2D(target, attachment, texTarget gl.Enum, t gl.Texture, level int) {
 	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 {
+func (c *Functions) GetBinding(pname gl.Enum) gl.Object {
-	return Object{uint(c.GetInteger(pname))}
+	return gl.Object{uint(c.GetInteger(pname))}
 }
 
-func (f *Functions) GetError() Enum {
+func (f *Functions) GetError() gl.Enum {
-	return Enum(C.glGetError())
+	return gl.Enum(C.glGetError())
 }
 
-func (f *Functions) GetRenderbufferParameteri(target, pname Enum) int {
+func (f *Functions) GetRenderbufferParameteri(target, pname gl.Enum) int {
 	C.glGetRenderbufferParameteriv(C.GLenum(target), C.GLenum(pname), &f.ints[0])
 	return int(f.ints[0])
 }
 
-func (f *Functions) GetFramebufferAttachmentParameteri(target, attachment, pname Enum) int {
+func (f *Functions) GetFramebufferAttachmentParameteri(target, attachment, pname gl.Enum) int {
 	C.glGetFramebufferAttachmentParameteriv(C.GLenum(target), C.GLenum(attachment), C.GLenum(pname), &f.ints[0])
 	return int(f.ints[0])
 }
 
-func (f *Functions) GetInteger(pname Enum) int {
+func (f *Functions) GetInteger(pname gl.Enum) int {
 	C.glGetIntegerv(C.GLenum(pname), &f.ints[0])
 	return int(f.ints[0])
 }
 
-func (f *Functions) GetProgrami(p Program, pname Enum) int {
+func (f *Functions) GetProgrami(p gl.Program, pname gl.Enum) int {
 	C.glGetProgramiv(C.GLuint(p.V), C.GLenum(pname), &f.ints[0])
 	return int(f.ints[0])
 }
 
-func (f *Functions) GetProgramInfoLog(p Program) string {
+func (f *Functions) GetProgramInfoLog(p gl.Program) string {
-	n := f.GetProgrami(p, INFO_LOG_LENGTH)
+	n := f.GetProgrami(p, gl.INFO_LOG_LENGTH)
 	buf := make([]byte, n)
 	C.glGetProgramInfoLog(C.GLuint(p.V), C.GLsizei(len(buf)), nil, (*C.GLchar)(unsafe.Pointer(&buf[0])))
 	return string(buf)
 }
 
-func (f *Functions) GetQueryObjectuiv(query Query, pname Enum) uint {
+func (f *Functions) GetQueryObjectuiv(query gl.Query, pname gl.Enum) uint {
 	C.gio_glGetQueryObjectuiv(C.GLuint(query.V), C.GLenum(pname), &f.uints[0])
 	return uint(f.uints[0])
 }
 
-func (f *Functions) GetShaderi(s Shader, pname Enum) int {
+func (f *Functions) GetShaderi(s gl.Shader, pname gl.Enum) int {
 	C.glGetShaderiv(C.GLuint(s.V), C.GLenum(pname), &f.ints[0])
 	return int(f.ints[0])
 }
 
-func (f *Functions) GetShaderInfoLog(s Shader) string {
+func (f *Functions) GetShaderInfoLog(s gl.Shader) string {
-	n := f.GetShaderi(s, INFO_LOG_LENGTH)
+	n := f.GetShaderi(s, gl.INFO_LOG_LENGTH)
 	buf := make([]byte, n)
 	C.glGetShaderInfoLog(C.GLuint(s.V), C.GLsizei(len(buf)), nil, (*C.GLchar)(unsafe.Pointer(&buf[0])))
 	return string(buf)
 }
 
-func (f *Functions) GetStringi(pname Enum, index int) string {
+func (f *Functions) GetStringi(pname gl.Enum, index int) string {
 	str := C.gio_glGetStringi(C.GLenum(pname), C.GLuint(index))
 	if str == nil {
 		return ""
@@ -387,15 +389,15 @@ func (f *Functions) GetStringi(pname Enum, index int) string {
 	return C.GoString((*C.char)(unsafe.Pointer(str)))
 }
 
-func (f *Functions) GetString(pname Enum) string {
+func (f *Functions) GetString(pname gl.Enum) string {
 	switch {
-	case runtime.GOOS == "darwin" && pname == EXTENSIONS:
+	case runtime.GOOS == "darwin" && pname == gl.EXTENSIONS:
 		// macOS OpenGL 3 core profile doesn't support glGetString(GL_EXTENSIONS).
 		// Use glGetStringi(GL_EXTENSIONS, <index>).
 		var exts []string
-		nexts := f.GetInteger(NUM_EXTENSIONS)
+		nexts := f.GetInteger(gl.NUM_EXTENSIONS)
 		for i := 0; i < nexts; i++ {
-			ext := f.GetStringi(EXTENSIONS, i)
+			ext := f.GetStringi(gl.EXTENSIONS, i)
 			exts = append(exts, ext)
 		}
 		return strings.Join(exts, " ")
@@ -405,21 +407,21 @@ func (f *Functions) GetString(pname Enum) string {
 	}
 }
 
-func (f *Functions) GetUniformLocation(p Program, name string) Uniform {
+func (f *Functions) GetUniformLocation(p gl.Program, name string) gl.Uniform {
 	cname := C.CString(name)
 	defer C.free(unsafe.Pointer(cname))
-	return Uniform{int(C.glGetUniformLocation(C.GLuint(p.V), cname))}
+	return gl.Uniform{int(C.glGetUniformLocation(C.GLuint(p.V), cname))}
 }
 
-func (f *Functions) InvalidateFramebuffer(target, attachment Enum) {
+func (f *Functions) InvalidateFramebuffer(target, attachment gl.Enum) {
 	C.gio_glInvalidateFramebuffer(C.GLenum(target), C.GLenum(attachment))
 }
 
-func (f *Functions) LinkProgram(p Program) {
+func (f *Functions) LinkProgram(p gl.Program) {
 	C.glLinkProgram(C.GLuint(p.V))
 }
 
-func (f *Functions) PixelStorei(pname Enum, param int32) {
+func (f *Functions) PixelStorei(pname gl.Enum, param int32) {
 	C.glPixelStorei(C.GLenum(pname), C.GLint(param))
 }
 
@@ -427,7 +429,7 @@ func (f *Functions) Scissor(x, y, width, height int32) {
 	C.glScissor(C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height))
 }
 
-func (f *Functions) ReadPixels(x, y, width, height int, format, ty Enum, data []byte) {
+func (f *Functions) ReadPixels(x, y, width, height int, format, ty gl.Enum, data []byte) {
 	var p unsafe.Pointer
 	if len(data) > 0 {
 		p = unsafe.Pointer(&data[0])
@@ -435,18 +437,18 @@ func (f *Functions) ReadPixels(x, y, width, height int, format, ty Enum, data []
 	C.glReadPixels(C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(ty), p)
 }
 
-func (f *Functions) RenderbufferStorage(target, internalformat Enum, width, height int) {
+func (f *Functions) RenderbufferStorage(target, internalformat gl.Enum, width, height int) {
 	C.glRenderbufferStorage(C.GLenum(target), C.GLenum(internalformat), C.GLsizei(width), C.GLsizei(height))
 }
 
-func (f *Functions) ShaderSource(s Shader, src string) {
+func (f *Functions) ShaderSource(s gl.Shader, src string) {
 	csrc := C.CString(src)
 	defer C.free(unsafe.Pointer(csrc))
 	strlen := C.GLint(len(src))
 	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) {
+func (f *Functions) TexImage2D(target gl.Enum, level int, internalFormat int, width int, height int, format gl.Enum, ty gl.Enum, data []byte) {
 	var p unsafe.Pointer
 	if len(data) > 0 {
 		p = unsafe.Pointer(&data[0])
@@ -454,7 +456,7 @@ func (f *Functions) TexImage2D(target Enum, level int, internalFormat int, width
 	C.glTexImage2D(C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), 0, C.GLenum(format), C.GLenum(ty), p)
 }
 
-func (f *Functions) TexSubImage2D(target Enum, level int, x int, y int, width int, height int, format Enum, ty Enum, data []byte) {
+func (f *Functions) TexSubImage2D(target gl.Enum, level int, x int, y int, width int, height int, format gl.Enum, ty gl.Enum, data []byte) {
 	var p unsafe.Pointer
 	if len(data) > 0 {
 		p = unsafe.Pointer(&data[0])
@@ -462,35 +464,35 @@ func (f *Functions) TexSubImage2D(target Enum, level int, x int, y int, width in
 	C.glTexSubImage2D(C.GLenum(target), C.GLint(level), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(ty), p)
 }
 
-func (f *Functions) TexParameteri(target, pname Enum, param int) {
+func (f *Functions) TexParameteri(target, pname gl.Enum, param int) {
 	C.glTexParameteri(C.GLenum(target), C.GLenum(pname), C.GLint(param))
 }
 
-func (f *Functions) Uniform1f(dst Uniform, v float32) {
+func (f *Functions) Uniform1f(dst gl.Uniform, v float32) {
 	C.glUniform1f(C.GLint(dst.V), C.GLfloat(v))
 }
 
-func (f *Functions) Uniform1i(dst Uniform, v int) {
+func (f *Functions) Uniform1i(dst gl.Uniform, v int) {
 	C.glUniform1i(C.GLint(dst.V), C.GLint(v))
 }
 
-func (f *Functions) Uniform2f(dst Uniform, v0 float32, v1 float32) {
+func (f *Functions) Uniform2f(dst gl.Uniform, v0 float32, v1 float32) {
 	C.glUniform2f(C.GLint(dst.V), C.GLfloat(v0), C.GLfloat(v1))
 }
 
-func (f *Functions) Uniform3f(dst Uniform, v0 float32, v1 float32, v2 float32) {
+func (f *Functions) Uniform3f(dst gl.Uniform, v0 float32, v1 float32, v2 float32) {
 	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) {
+func (f *Functions) Uniform4f(dst gl.Uniform, v0 float32, v1 float32, v2 float32, v3 float32) {
 	C.glUniform4f(C.GLint(dst.V), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3))
 }
 
-func (f *Functions) UseProgram(p Program) {
+func (f *Functions) UseProgram(p gl.Program) {
 	C.glUseProgram(C.GLuint(p.V))
 }
 
-func (f *Functions) VertexAttribPointer(dst Attrib, size int, ty Enum, normalized bool, stride int, offset int) {
+func (f *Functions) VertexAttribPointer(dst gl.Attrib, size int, ty gl.Enum, normalized bool, stride int, offset int) {
 	var n C.GLboolean = C.GL_FALSE
 	if normalized {
 		n = C.GL_TRUE

app/internal/gl/impl/gl_js.go

@@ -1,11 +1,13 @@
 // SPDX-License-Identifier: Unlicense OR MIT
 
-package gl
+package impl
 
 import (
 	"errors"
 	"strings"
 	"syscall/js"
+
+	"gioui.org/app/internal/gl"
 )
 
 type Functions struct {
@@ -41,47 +43,47 @@ func (f *Functions) getExtension(name string) js.Value {
 	return f.Ctx.Call("getExtension", name)
 }
 
-func (f *Functions) ActiveTexture(t Enum) {
+func (f *Functions) ActiveTexture(t gl.Enum) {
 	f.Ctx.Call("activeTexture", int(t))
 }
-func (f *Functions) AttachShader(p Program, s Shader) {
+func (f *Functions) AttachShader(p gl.Program, s gl.Shader) {
 	f.Ctx.Call("attachShader", js.Value(p), js.Value(s))
 }
-func (f *Functions) BeginQuery(target Enum, query Query) {
+func (f *Functions) BeginQuery(target gl.Enum, query gl.Query) {
 	if !f.EXT_disjoint_timer_query_webgl2.IsNull() {
 		f.Ctx.Call("beginQuery", int(target), js.Value(query))
 	} else {
 		f.EXT_disjoint_timer_query.Call("beginQueryEXT", int(target), js.Value(query))
 	}
 }
-func (f *Functions) BindAttribLocation(p Program, a Attrib, name string) {
+func (f *Functions) BindAttribLocation(p gl.Program, a gl.Attrib, name string) {
 	f.Ctx.Call("bindAttribLocation", js.Value(p), int(a), name)
 }
-func (f *Functions) BindBuffer(target Enum, b Buffer) {
+func (f *Functions) BindBuffer(target gl.Enum, b gl.Buffer) {
 	f.Ctx.Call("bindBuffer", int(target), js.Value(b))
 }
-func (f *Functions) BindFramebuffer(target Enum, fb Framebuffer) {
+func (f *Functions) BindFramebuffer(target gl.Enum, fb gl.Framebuffer) {
 	f.Ctx.Call("bindFramebuffer", int(target), js.Value(fb))
 }
-func (f *Functions) BindRenderbuffer(target Enum, rb Renderbuffer) {
+func (f *Functions) BindRenderbuffer(target gl.Enum, rb gl.Renderbuffer) {
 	f.Ctx.Call("bindRenderbuffer", int(target), js.Value(rb))
 }
-func (f *Functions) BindTexture(target Enum, t Texture) {
+func (f *Functions) BindTexture(target gl.Enum, t gl.Texture) {
 	f.Ctx.Call("bindTexture", int(target), js.Value(t))
 }
-func (f *Functions) BlendEquation(mode Enum) {
+func (f *Functions) BlendEquation(mode gl.Enum) {
 	f.Ctx.Call("blendEquation", int(mode))
 }
-func (f *Functions) BlendFunc(sfactor, dfactor Enum) {
+func (f *Functions) BlendFunc(sfactor, dfactor gl.Enum) {
 	f.Ctx.Call("blendFunc", int(sfactor), int(dfactor))
 }
-func (f *Functions) BufferData(target Enum, src []byte, usage Enum) {
+func (f *Functions) BufferData(target gl.Enum, src []byte, usage gl.Enum) {
 	f.Ctx.Call("bufferData", int(target), f.byteArrayOf(src), int(usage))
 }
-func (f *Functions) CheckFramebufferStatus(target Enum) Enum {
+func (f *Functions) CheckFramebufferStatus(target gl.Enum) gl.Enum {
-	return Enum(f.Ctx.Call("checkFramebufferStatus", int(target)).Int())
+	return gl.Enum(f.Ctx.Call("checkFramebufferStatus", int(target)).Int())
 }
-func (f *Functions) Clear(mask Enum) {
+func (f *Functions) Clear(mask gl.Enum) {
 	f.Ctx.Call("clear", int(mask))
 }
 func (f *Functions) ClearColor(red, green, blue, alpha float32) {
@@ -90,80 +92,80 @@ func (f *Functions) ClearColor(red, green, blue, alpha float32) {
 func (f *Functions) ClearDepthf(d float32) {
 	f.Ctx.Call("clearDepth", d)
 }
-func (f *Functions) CompileShader(s Shader) {
+func (f *Functions) CompileShader(s gl.Shader) {
 	f.Ctx.Call("compileShader", js.Value(s))
 }
-func (f *Functions) CreateBuffer() Buffer {
+func (f *Functions) CreateBuffer() gl.Buffer {
-	return Buffer(f.Ctx.Call("createBuffer"))
+	return gl.Buffer(f.Ctx.Call("createBuffer"))
 }
-func (f *Functions) CreateFramebuffer() Framebuffer {
+func (f *Functions) CreateFramebuffer() gl.Framebuffer {
-	return Framebuffer(f.Ctx.Call("createFramebuffer"))
+	return gl.Framebuffer(f.Ctx.Call("createFramebuffer"))
 }
-func (f *Functions) CreateProgram() Program {
+func (f *Functions) CreateProgram() gl.Program {
-	return Program(f.Ctx.Call("createProgram"))
+	return gl.Program(f.Ctx.Call("createProgram"))
 }
-func (f *Functions) CreateQuery() Query {
+func (f *Functions) CreateQuery() gl.Query {
-	return Query(f.Ctx.Call("createQuery"))
+	return gl.Query(f.Ctx.Call("createQuery"))
 }
-func (f *Functions) CreateRenderbuffer() Renderbuffer {
+func (f *Functions) CreateRenderbuffer() gl.Renderbuffer {
-	return Renderbuffer(f.Ctx.Call("createRenderbuffer"))
+	return gl.Renderbuffer(f.Ctx.Call("createRenderbuffer"))
 }
-func (f *Functions) CreateShader(ty Enum) Shader {
+func (f *Functions) CreateShader(ty gl.Enum) gl.Shader {
-	return Shader(f.Ctx.Call("createShader", int(ty)))
+	return gl.Shader(f.Ctx.Call("createShader", int(ty)))
 }
-func (f *Functions) CreateTexture() Texture {
+func (f *Functions) CreateTexture() gl.Texture {
-	return Texture(f.Ctx.Call("createTexture"))
+	return gl.Texture(f.Ctx.Call("createTexture"))
 }
-func (f *Functions) DeleteBuffer(v Buffer) {
+func (f *Functions) DeleteBuffer(v gl.Buffer) {
 	f.Ctx.Call("deleteBuffer", js.Value(v))
 }
-func (f *Functions) DeleteFramebuffer(v Framebuffer) {
+func (f *Functions) DeleteFramebuffer(v gl.Framebuffer) {
 	f.Ctx.Call("deleteFramebuffer", js.Value(v))
 }
-func (f *Functions) DeleteProgram(p Program) {
+func (f *Functions) DeleteProgram(p gl.Program) {
 	f.Ctx.Call("deleteProgram", js.Value(p))
 }
-func (f *Functions) DeleteQuery(query Query) {
+func (f *Functions) DeleteQuery(query gl.Query) {
 	if !f.EXT_disjoint_timer_query_webgl2.IsNull() {
 		f.Ctx.Call("deleteQuery", js.Value(query))
 	} else {
 		f.EXT_disjoint_timer_query.Call("deleteQueryEXT", js.Value(query))
 	}
 }
-func (f *Functions) DeleteShader(s Shader) {
+func (f *Functions) DeleteShader(s gl.Shader) {
 	f.Ctx.Call("deleteShader", js.Value(s))
 }
-func (f *Functions) DeleteRenderbuffer(v Renderbuffer) {
+func (f *Functions) DeleteRenderbuffer(v gl.Renderbuffer) {
 	f.Ctx.Call("deleteRenderbuffer", js.Value(v))
 }
-func (f *Functions) DeleteTexture(v Texture) {
+func (f *Functions) DeleteTexture(v gl.Texture) {
 	f.Ctx.Call("deleteTexture", js.Value(v))
 }
-func (f *Functions) DepthFunc(fn Enum) {
+func (f *Functions) DepthFunc(fn gl.Enum) {
 	f.Ctx.Call("depthFunc", int(fn))
 }
 func (f *Functions) DepthMask(mask bool) {
 	f.Ctx.Call("depthMask", mask)
 }
-func (f *Functions) DisableVertexAttribArray(a Attrib) {
+func (f *Functions) DisableVertexAttribArray(a gl.Attrib) {
 	f.Ctx.Call("disableVertexAttribArray", int(a))
 }
-func (f *Functions) Disable(cap Enum) {
+func (f *Functions) Disable(cap gl.Enum) {
 	f.Ctx.Call("disable", int(cap))
 }
-func (f *Functions) DrawArrays(mode Enum, first, count int) {
+func (f *Functions) DrawArrays(mode gl.Enum, first, count int) {
 	f.Ctx.Call("drawArrays", int(mode), first, count)
 }
-func (f *Functions) DrawElements(mode Enum, count int, ty Enum, offset int) {
+func (f *Functions) DrawElements(mode gl.Enum, count int, ty gl.Enum, offset int) {
 	f.Ctx.Call("drawElements", int(mode), count, int(ty), offset)
 }
-func (f *Functions) Enable(cap Enum) {
+func (f *Functions) Enable(cap gl.Enum) {
 	f.Ctx.Call("enable", int(cap))
 }
-func (f *Functions) EnableVertexAttribArray(a Attrib) {
+func (f *Functions) EnableVertexAttribArray(a gl.Attrib) {
 	f.Ctx.Call("enableVertexAttribArray", int(a))
 }
-func (f *Functions) EndQuery(target Enum) {
+func (f *Functions) EndQuery(target gl.Enum) {
 	if !f.EXT_disjoint_timer_query_webgl2.IsNull() {
 		f.Ctx.Call("endQuery", int(target))
 	} else {
@@ -173,49 +175,49 @@ func (f *Functions) EndQuery(target Enum) {
 func (f *Functions) Finish() {
 	f.Ctx.Call("finish")
 }
-func (f *Functions) FramebufferRenderbuffer(target, attachment, renderbuffertarget Enum, renderbuffer Renderbuffer) {
+func (f *Functions) FramebufferRenderbuffer(target, attachment, renderbuffertarget gl.Enum, renderbuffer gl.Renderbuffer) {
 	f.Ctx.Call("framebufferRenderbuffer", int(target), int(attachment), int(renderbuffertarget), js.Value(renderbuffer))
 }
-func (f *Functions) FramebufferTexture2D(target, attachment, texTarget Enum, t Texture, level int) {
+func (f *Functions) FramebufferTexture2D(target, attachment, texTarget gl.Enum, t gl.Texture, level int) {
 	f.Ctx.Call("framebufferTexture2D", int(target), int(attachment), int(texTarget), js.Value(t), level)
 }
-func (f *Functions) GetError() Enum {
+func (f *Functions) GetError() gl.Enum {
-	return Enum(f.Ctx.Call("getError").Int())
+	return gl.Enum(f.Ctx.Call("getError").Int())
 }
-func (f *Functions) GetRenderbufferParameteri(target, pname Enum) int {
+func (f *Functions) GetRenderbufferParameteri(target, pname gl.Enum) int {
 	return paramVal(f.Ctx.Call("getRenderbufferParameteri", int(pname)))
 }
-func (f *Functions) GetFramebufferAttachmentParameteri(target, attachment, pname Enum) int {
+func (f *Functions) GetFramebufferAttachmentParameteri(target, attachment, pname gl.Enum) int {
 	return paramVal(f.Ctx.Call("getFramebufferAttachmentParameter", int(target), int(attachment), int(pname)))
 }
-func (f *Functions) GetBinding(pname Enum) Object {
+func (f *Functions) GetBinding(pname gl.Enum) gl.Object {
-	return Object(f.Ctx.Call("getParameter", int(pname)))
+	return gl.Object(f.Ctx.Call("getParameter", int(pname)))
 }
-func (f *Functions) GetInteger(pname Enum) int {
+func (f *Functions) GetInteger(pname gl.Enum) int {
 	return paramVal(f.Ctx.Call("getParameter", int(pname)))
 }
-func (f *Functions) GetProgrami(p Program, pname Enum) int {
+func (f *Functions) GetProgrami(p gl.Program, pname gl.Enum) int {
 	return paramVal(f.Ctx.Call("getProgramParameter", js.Value(p), int(pname)))
 }
-func (f *Functions) GetProgramInfoLog(p Program) string {
+func (f *Functions) GetProgramInfoLog(p gl.Program) string {
 	return f.Ctx.Call("getProgramInfoLog", js.Value(p)).String()
 }
-func (f *Functions) GetQueryObjectuiv(query Query, pname Enum) uint {
+func (f *Functions) GetQueryObjectuiv(query gl.Query, pname gl.Enum) uint {
 	if !f.EXT_disjoint_timer_query_webgl2.IsNull() {
 		return uint(paramVal(f.Ctx.Call("getQueryParameter", js.Value(query), int(pname))))
 	} else {
 		return uint(paramVal(f.EXT_disjoint_timer_query.Call("getQueryObjectEXT", js.Value(query), int(pname))))
 	}
 }
-func (f *Functions) GetShaderi(s Shader, pname Enum) int {
+func (f *Functions) GetShaderi(s gl.Shader, pname gl.Enum) int {
 	return paramVal(f.Ctx.Call("getShaderParameter", js.Value(s), int(pname)))
 }
-func (f *Functions) GetShaderInfoLog(s Shader) string {
+func (f *Functions) GetShaderInfoLog(s gl.Shader) string {
 	return f.Ctx.Call("getShaderInfoLog", js.Value(s)).String()
 }
-func (f *Functions) GetString(pname Enum) string {
+func (f *Functions) GetString(pname gl.Enum) string {
 	switch pname {
-	case EXTENSIONS:
+	case gl.EXTENSIONS:
 		extsjs := f.Ctx.Call("getSupportedExtensions")
 		var exts []string
 		for i := 0; i < extsjs.Length(); i++ {
@@ -226,10 +228,10 @@ func (f *Functions) GetString(pname Enum) string {
 		return f.Ctx.Call("getParameter", int(pname)).String()
 	}
 }
-func (f *Functions) GetUniformLocation(p Program, name string) Uniform {
+func (f *Functions) GetUniformLocation(p gl.Program, name string) gl.Uniform {
-	return Uniform(f.Ctx.Call("getUniformLocation", js.Value(p), name))
+	return gl.Uniform(f.Ctx.Call("getUniformLocation", js.Value(p), name))
 }
-func (f *Functions) InvalidateFramebuffer(target, attachment Enum) {
+func (f *Functions) InvalidateFramebuffer(target, attachment gl.Enum) {
 	fn := f.Ctx.Get("invalidateFramebuffer")
 	if !fn.IsUndefined() {
 		if f.int32Buf.IsUndefined() {
@@ -239,16 +241,16 @@ func (f *Functions) InvalidateFramebuffer(target, attachment Enum) {
 		f.Ctx.Call("invalidateFramebuffer", int(target), f.int32Buf)
 	}
 }
-func (f *Functions) LinkProgram(p Program) {
+func (f *Functions) LinkProgram(p gl.Program) {
 	f.Ctx.Call("linkProgram", js.Value(p))
 }
-func (f *Functions) PixelStorei(pname Enum, param int32) {
+func (f *Functions) PixelStorei(pname gl.Enum, param int32) {
 	f.Ctx.Call("pixelStorei", int(pname), param)
 }
-func (f *Functions) RenderbufferStorage(target, internalformat Enum, width, height int) {
+func (f *Functions) RenderbufferStorage(target, internalformat gl.Enum, width, height int) {
 	f.Ctx.Call("renderbufferStorage", int(target), int(internalformat), width, height)
 }
-func (f *Functions) ReadPixels(x, y, width, height int, format, ty Enum, data []byte) {
+func (f *Functions) ReadPixels(x, y, width, height int, format, ty gl.Enum, data []byte) {
 	f.resizeByteBuffer(len(data))
 	f.Ctx.Call("readPixels", x, y, width, height, int(format), int(ty), f.byteBuf)
 	js.CopyBytesToGo(data, f.byteBuf)
@@ -256,37 +258,37 @@ func (f *Functions) ReadPixels(x, y, width, height int, format, ty Enum, data []
 func (f *Functions) Scissor(x, y, width, height int32) {
 	f.Ctx.Call("scissor", x, y, width, height)
 }
-func (f *Functions) ShaderSource(s Shader, src string) {
+func (f *Functions) ShaderSource(s gl.Shader, src string) {
 	f.Ctx.Call("shaderSource", js.Value(s), src)
 }
-func (f *Functions) TexImage2D(target Enum, level int, internalFormat int, width, height int, format, ty Enum, data []byte) {
+func (f *Functions) TexImage2D(target gl.Enum, level int, internalFormat int, width, height int, format, ty gl.Enum, data []byte) {
 	f.Ctx.Call("texImage2D", int(target), int(level), int(internalFormat), int(width), int(height), 0, int(format), int(ty), f.byteArrayOf(data))
 }
-func (f *Functions) TexSubImage2D(target Enum, level int, x, y, width, height int, format, ty Enum, data []byte) {
+func (f *Functions) TexSubImage2D(target gl.Enum, level int, x, y, width, height int, format, ty gl.Enum, data []byte) {
 	f.Ctx.Call("texSubImage2D", int(target), level, x, y, width, height, int(format), int(ty), f.byteArrayOf(data))
 }
-func (f *Functions) TexParameteri(target, pname Enum, param int) {
+func (f *Functions) TexParameteri(target, pname gl.Enum, param int) {
 	f.Ctx.Call("texParameteri", int(target), int(pname), int(param))
 }
-func (f *Functions) Uniform1f(dst Uniform, v float32) {
+func (f *Functions) Uniform1f(dst gl.Uniform, v float32) {
 	f.Ctx.Call("uniform1f", js.Value(dst), v)
 }
-func (f *Functions) Uniform1i(dst Uniform, v int) {
+func (f *Functions) Uniform1i(dst gl.Uniform, v int) {
 	f.Ctx.Call("uniform1i", js.Value(dst), v)
 }
-func (f *Functions) Uniform2f(dst Uniform, v0, v1 float32) {
+func (f *Functions) Uniform2f(dst gl.Uniform, v0, v1 float32) {
 	f.Ctx.Call("uniform2f", js.Value(dst), v0, v1)
 }
-func (f *Functions) Uniform3f(dst Uniform, v0, v1, v2 float32) {
+func (f *Functions) Uniform3f(dst gl.Uniform, v0, v1, v2 float32) {
 	f.Ctx.Call("uniform3f", js.Value(dst), v0, v1, v2)
 }
-func (f *Functions) Uniform4f(dst Uniform, v0, v1, v2, v3 float32) {
+func (f *Functions) Uniform4f(dst gl.Uniform, v0, v1, v2, v3 float32) {
 	f.Ctx.Call("uniform4f", js.Value(dst), v0, v1, v2, v3)
 }
-func (f *Functions) UseProgram(p Program) {
+func (f *Functions) UseProgram(p gl.Program) {
 	f.Ctx.Call("useProgram", js.Value(p))
 }
-func (f *Functions) VertexAttribPointer(dst Attrib, size int, ty Enum, normalized bool, stride, offset int) {
+func (f *Functions) VertexAttribPointer(dst gl.Attrib, size int, ty gl.Enum, normalized bool, stride, offset int) {
 	f.Ctx.Call("vertexAttribPointer", int(dst), size, int(ty), normalized, stride, offset)
 }
 func (f *Functions) Viewport(x, y, width, height int) {

app/internal/gl/impl/gl_windows.go

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Unlicense OR MIT
 
-package gl
+package impl
 
 import (
 	"math"
@@ -9,6 +9,8 @@ import (
 	"unsafe"
 
 	"golang.org/x/sys/windows"
+
+	"gioui.org/app/internal/gl"
 )
 
 var (
@@ -87,44 +89,44 @@ var (
 )
 
 type Functions struct {
-	// Query caches.
+	// gl.Query caches.
 	int32s [100]int32
 }
 
-func (c *Functions) ActiveTexture(t Enum) {
+func (c *Functions) ActiveTexture(t gl.Enum) {
 	syscall.Syscall(_glActiveTexture.Addr(), 1, uintptr(t), 0, 0)
 }
-func (c *Functions) AttachShader(p Program, s Shader) {
+func (c *Functions) AttachShader(p gl.Program, s gl.Shader) {
 	syscall.Syscall(_glAttachShader.Addr(), 2, uintptr(p.V), uintptr(s.V), 0)
 }
-func (f *Functions) BeginQuery(target Enum, query Query) {
+func (f *Functions) BeginQuery(target gl.Enum, query gl.Query) {
 	syscall.Syscall(_glBeginQuery.Addr(), 2, uintptr(target), uintptr(query.V), 0)
 }
-func (c *Functions) BindAttribLocation(p Program, a Attrib, name string) {
+func (c *Functions) BindAttribLocation(p gl.Program, a gl.Attrib, name string) {
 	cname := cString(name)
 	c0 := &cname[0]
 	syscall.Syscall(_glBindAttribLocation.Addr(), 3, uintptr(p.V), uintptr(a), uintptr(unsafe.Pointer(c0)))
 	issue34474KeepAlive(c)
 }
-func (c *Functions) BindBuffer(target Enum, b Buffer) {
+func (c *Functions) BindBuffer(target gl.Enum, b gl.Buffer) {
 	syscall.Syscall(_glBindBuffer.Addr(), 2, uintptr(target), uintptr(b.V), 0)
 }
-func (c *Functions) BindFramebuffer(target Enum, fb Framebuffer) {
+func (c *Functions) BindFramebuffer(target gl.Enum, fb gl.Framebuffer) {
 	syscall.Syscall(_glBindFramebuffer.Addr(), 2, uintptr(target), uintptr(fb.V), 0)
 }
-func (c *Functions) BindRenderbuffer(target Enum, rb Renderbuffer) {
+func (c *Functions) BindRenderbuffer(target gl.Enum, rb gl.Renderbuffer) {
 	syscall.Syscall(_glBindRenderbuffer.Addr(), 2, uintptr(target), uintptr(rb.V), 0)
 }
-func (c *Functions) BindTexture(target Enum, t Texture) {
+func (c *Functions) BindTexture(target gl.Enum, t gl.Texture) {
 	syscall.Syscall(_glBindTexture.Addr(), 2, uintptr(target), uintptr(t.V), 0)
 }
-func (c *Functions) BlendEquation(mode Enum) {
+func (c *Functions) BlendEquation(mode gl.Enum) {
 	syscall.Syscall(_glBlendEquation.Addr(), 1, uintptr(mode), 0, 0)
 }
-func (c *Functions) BlendFunc(sfactor, dfactor Enum) {
+func (c *Functions) BlendFunc(sfactor, dfactor gl.Enum) {
 	syscall.Syscall(_glBlendFunc.Addr(), 2, uintptr(sfactor), uintptr(dfactor), 0)
 }
-func (c *Functions) BufferData(target Enum, src []byte, usage Enum) {
+func (c *Functions) BufferData(target gl.Enum, src []byte, usage gl.Enum) {
 	if n := len(src); n == 0 {
 		syscall.Syscall6(_glBufferData.Addr(), 4, uintptr(target), 0, 0, uintptr(usage), 0, 0)
 	} else {
@@ -133,11 +135,11 @@ func (c *Functions) BufferData(target Enum, src []byte, usage Enum) {
 		issue34474KeepAlive(s0)
 	}
 }
-func (c *Functions) CheckFramebufferStatus(target Enum) Enum {
+func (c *Functions) CheckFramebufferStatus(target gl.Enum) gl.Enum {
 	s, _, _ := syscall.Syscall(_glCheckFramebufferStatus.Addr(), 1, uintptr(target), 0, 0)
-	return Enum(s)
+	return gl.Enum(s)
 }
-func (c *Functions) Clear(mask Enum) {
+func (c *Functions) Clear(mask gl.Enum) {
 	syscall.Syscall(_glClear.Addr(), 1, uintptr(mask), 0, 0)
 }
 func (c *Functions) ClearColor(red, green, blue, alpha float32) {
@@ -146,64 +148,64 @@ func (c *Functions) ClearColor(red, green, blue, alpha float32) {
 func (c *Functions) ClearDepthf(d float32) {
 	syscall.Syscall(_glClearDepthf.Addr(), 1, uintptr(math.Float32bits(d)), 0, 0)
 }
-func (c *Functions) CompileShader(s Shader) {
+func (c *Functions) CompileShader(s gl.Shader) {
 	syscall.Syscall(_glCompileShader.Addr(), 1, uintptr(s.V), 0, 0)
 }
-func (c *Functions) CreateBuffer() Buffer {
+func (c *Functions) CreateBuffer() gl.Buffer {
 	var buf uintptr
 	syscall.Syscall(_glGenBuffers.Addr(), 2, 1, uintptr(unsafe.Pointer(&buf)), 0)
-	return Buffer{uint(buf)}
+	return gl.Buffer{uint(buf)}
 }
-func (c *Functions) CreateFramebuffer() Framebuffer {
+func (c *Functions) CreateFramebuffer() gl.Framebuffer {
 	var fb uintptr
 	syscall.Syscall(_glGenFramebuffers.Addr(), 2, 1, uintptr(unsafe.Pointer(&fb)), 0)
-	return Framebuffer{uint(fb)}
+	return gl.Framebuffer{uint(fb)}
 }
-func (c *Functions) CreateProgram() Program {
+func (c *Functions) CreateProgram() gl.Program {
 	p, _, _ := syscall.Syscall(_glCreateProgram.Addr(), 0, 0, 0, 0)
-	return Program{uint(p)}
+	return gl.Program{uint(p)}
 }
-func (f *Functions) CreateQuery() Query {
+func (f *Functions) CreateQuery() gl.Query {
 	var q uintptr
 	syscall.Syscall(_glGenQueries.Addr(), 2, 1, uintptr(unsafe.Pointer(&q)), 0)
-	return Query{uint(q)}
+	return gl.Query{uint(q)}
 }
-func (c *Functions) CreateRenderbuffer() Renderbuffer {
+func (c *Functions) CreateRenderbuffer() gl.Renderbuffer {
 	var rb uintptr
 	syscall.Syscall(_glGenRenderbuffers.Addr(), 2, 1, uintptr(unsafe.Pointer(&rb)), 0)
-	return Renderbuffer{uint(rb)}
+	return gl.Renderbuffer{uint(rb)}
 }
-func (c *Functions) CreateShader(ty Enum) Shader {
+func (c *Functions) CreateShader(ty gl.Enum) gl.Shader {
 	s, _, _ := syscall.Syscall(_glCreateShader.Addr(), 1, uintptr(ty), 0, 0)
-	return Shader{uint(s)}
+	return gl.Shader{uint(s)}
 }
-func (c *Functions) CreateTexture() Texture {
+func (c *Functions) CreateTexture() gl.Texture {
 	var t uintptr
 	syscall.Syscall(_glGenTextures.Addr(), 2, 1, uintptr(unsafe.Pointer(&t)), 0)
-	return Texture{uint(t)}
+	return gl.Texture{uint(t)}
 }
-func (c *Functions) DeleteBuffer(v Buffer) {
+func (c *Functions) DeleteBuffer(v gl.Buffer) {
 	syscall.Syscall(_glDeleteBuffers.Addr(), 2, 1, uintptr(unsafe.Pointer(&v)), 0)
 }
-func (c *Functions) DeleteFramebuffer(v Framebuffer) {
+func (c *Functions) DeleteFramebuffer(v gl.Framebuffer) {
 	syscall.Syscall(_glDeleteFramebuffers.Addr(), 2, 1, uintptr(unsafe.Pointer(&v.V)), 0)
 }
-func (c *Functions) DeleteProgram(p Program) {
+func (c *Functions) DeleteProgram(p gl.Program) {
 	syscall.Syscall(_glDeleteProgram.Addr(), 1, uintptr(p.V), 0, 0)
 }
-func (f *Functions) DeleteQuery(query Query) {
+func (f *Functions) DeleteQuery(query gl.Query) {
 	syscall.Syscall(_glDeleteQueries.Addr(), 2, 1, uintptr(unsafe.Pointer(&query.V)), 0)
 }
-func (c *Functions) DeleteShader(s Shader) {
+func (c *Functions) DeleteShader(s gl.Shader) {
 	syscall.Syscall(_glDeleteShader.Addr(), 1, uintptr(s.V), 0, 0)
 }
-func (c *Functions) DeleteRenderbuffer(v Renderbuffer) {
+func (c *Functions) DeleteRenderbuffer(v gl.Renderbuffer) {
 	syscall.Syscall(_glDeleteRenderbuffers.Addr(), 2, 1, uintptr(unsafe.Pointer(&v.V)), 0)
 }
-func (c *Functions) DeleteTexture(v Texture) {
+func (c *Functions) DeleteTexture(v gl.Texture) {
 	syscall.Syscall(_glDeleteTextures.Addr(), 2, 1, uintptr(unsafe.Pointer(&v.V)), 0)
 }
-func (c *Functions) DepthFunc(f Enum) {
+func (c *Functions) DepthFunc(f gl.Enum) {
 	syscall.Syscall(_glDepthFunc.Addr(), 1, uintptr(f), 0, 0)
 }
 func (c *Functions) DepthMask(mask bool) {
@@ -213,91 +215,91 @@ func (c *Functions) DepthMask(mask bool) {
 	}
 	syscall.Syscall(_glDepthMask.Addr(), 1, m, 0, 0)
 }
-func (c *Functions) DisableVertexAttribArray(a Attrib) {
+func (c *Functions) DisableVertexAttribArray(a gl.Attrib) {
 	syscall.Syscall(_glDisableVertexAttribArray.Addr(), 1, uintptr(a), 0, 0)
 }
-func (c *Functions) Disable(cap Enum) {
+func (c *Functions) Disable(cap gl.Enum) {
 	syscall.Syscall(_glDisable.Addr(), 1, uintptr(cap), 0, 0)
 }
-func (c *Functions) DrawArrays(mode Enum, first, count int) {
+func (c *Functions) DrawArrays(mode gl.Enum, first, count int) {
 	syscall.Syscall(_glDrawArrays.Addr(), 3, uintptr(mode), uintptr(first), uintptr(count))
 }
-func (c *Functions) DrawElements(mode Enum, count int, ty Enum, offset int) {
+func (c *Functions) DrawElements(mode gl.Enum, count int, ty gl.Enum, offset int) {
 	syscall.Syscall6(_glDrawElements.Addr(), 4, uintptr(mode), uintptr(count), uintptr(ty), uintptr(offset), 0, 0)
 }
-func (c *Functions) Enable(cap Enum) {
+func (c *Functions) Enable(cap gl.Enum) {
 	syscall.Syscall(_glEnable.Addr(), 1, uintptr(cap), 0, 0)
 }
-func (c *Functions) EnableVertexAttribArray(a Attrib) {
+func (c *Functions) EnableVertexAttribArray(a gl.Attrib) {
 	syscall.Syscall(_glEnableVertexAttribArray.Addr(), 1, uintptr(a), 0, 0)
 }
-func (f *Functions) EndQuery(target Enum) {
+func (f *Functions) EndQuery(target gl.Enum) {
 	syscall.Syscall(_glEndQuery.Addr(), 1, uintptr(target), 0, 0)
 }
 func (c *Functions) Finish() {
 	syscall.Syscall(_glFinish.Addr(), 0, 0, 0, 0)
 }
-func (c *Functions) FramebufferRenderbuffer(target, attachment, renderbuffertarget Enum, renderbuffer Renderbuffer) {
+func (c *Functions) FramebufferRenderbuffer(target, attachment, renderbuffertarget gl.Enum, renderbuffer gl.Renderbuffer) {
 	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) {
+func (c *Functions) FramebufferTexture2D(target, attachment, texTarget gl.Enum, t gl.Texture, level int) {
 	syscall.Syscall6(_glFramebufferTexture2D.Addr(), 5, uintptr(target), uintptr(attachment), uintptr(texTarget), uintptr(t.V), uintptr(level), 0)
 }
-func (c *Functions) GetBinding(pname Enum) Object {
+func (c *Functions) GetBinding(pname gl.Enum) gl.Object {
-	return Object{uint(c.GetInteger(pname))}
+	return gl.Object{uint(c.GetInteger(pname))}
 }
-func (c *Functions) GetError() Enum {
+func (c *Functions) GetError() gl.Enum {
 	e, _, _ := syscall.Syscall(_glGetError.Addr(), 0, 0, 0, 0)
-	return Enum(e)
+	return gl.Enum(e)
 }
-func (c *Functions) GetRenderbufferParameteri(target, pname Enum) int {
+func (c *Functions) GetRenderbufferParameteri(target, pname gl.Enum) int {
 	p, _, _ := syscall.Syscall(_glGetRenderbufferParameteri.Addr(), 2, uintptr(target), uintptr(pname), 0)
 	return int(p)
 }
-func (c *Functions) GetFramebufferAttachmentParameteri(target, attachment, pname Enum) int {
+func (c *Functions) GetFramebufferAttachmentParameteri(target, attachment, pname gl.Enum) int {
 	p, _, _ := syscall.Syscall(_glGetFramebufferAttachmentParameteri.Addr(), 3, uintptr(target), uintptr(attachment), uintptr(pname))
 	return int(p)
 }
-func (c *Functions) GetInteger(pname Enum) int {
+func (c *Functions) GetInteger(pname gl.Enum) int {
 	syscall.Syscall(_glGetIntegerv.Addr(), 2, uintptr(pname), uintptr(unsafe.Pointer(&c.int32s[0])), 0)
 	return int(c.int32s[0])
 }
-func (c *Functions) GetProgrami(p Program, pname Enum) int {
+func (c *Functions) GetProgrami(p gl.Program, pname gl.Enum) int {
 	syscall.Syscall(_glGetProgramiv.Addr(), 3, uintptr(p.V), uintptr(pname), uintptr(unsafe.Pointer(&c.int32s[0])))
 	return int(c.int32s[0])
 }
-func (c *Functions) GetProgramInfoLog(p Program) string {
+func (c *Functions) GetProgramInfoLog(p gl.Program) string {
-	n := c.GetProgrami(p, INFO_LOG_LENGTH)
+	n := c.GetProgrami(p, gl.INFO_LOG_LENGTH)
 	buf := make([]byte, n)
 	syscall.Syscall6(_glGetProgramInfoLog.Addr(), 4, uintptr(p.V), uintptr(len(buf)), 0, uintptr(unsafe.Pointer(&buf[0])), 0, 0)
 	return string(buf)
 }
-func (c *Functions) GetQueryObjectuiv(query Query, pname Enum) uint {
+func (c *Functions) GetQueryObjectuiv(query gl.Query, pname gl.Enum) uint {
 	syscall.Syscall(_glGetQueryObjectuiv.Addr(), 3, uintptr(query.V), uintptr(pname), uintptr(unsafe.Pointer(&c.int32s[0])))
 	return uint(c.int32s[0])
 }
-func (c *Functions) GetShaderi(s Shader, pname Enum) int {
+func (c *Functions) GetShaderi(s gl.Shader, pname gl.Enum) int {
 	syscall.Syscall(_glGetShaderiv.Addr(), 3, uintptr(s.V), uintptr(pname), uintptr(unsafe.Pointer(&c.int32s[0])))
 	return int(c.int32s[0])
 }
-func (c *Functions) GetShaderInfoLog(s Shader) string {
+func (c *Functions) GetShaderInfoLog(s gl.Shader) string {
-	n := c.GetShaderi(s, INFO_LOG_LENGTH)
+	n := c.GetShaderi(s, gl.INFO_LOG_LENGTH)
 	buf := make([]byte, n)
 	syscall.Syscall6(_glGetShaderInfoLog.Addr(), 4, uintptr(s.V), uintptr(len(buf)), 0, uintptr(unsafe.Pointer(&buf[0])), 0, 0)
 	return string(buf)
 }
-func (c *Functions) GetString(pname Enum) string {
+func (c *Functions) GetString(pname gl.Enum) string {
 	s, _, _ := syscall.Syscall(_glGetString.Addr(), 1, uintptr(pname), 0, 0)
-	return GoString(SliceOf(s))
+	return gl.GoString(gl.SliceOf(s))
 }
-func (c *Functions) GetUniformLocation(p Program, name string) Uniform {
+func (c *Functions) GetUniformLocation(p gl.Program, name string) gl.Uniform {
 	cname := cString(name)
 	c0 := &cname[0]
 	u, _, _ := syscall.Syscall(_glGetUniformLocation.Addr(), 2, uintptr(p.V), uintptr(unsafe.Pointer(c0)), 0)
 	issue34474KeepAlive(c)
-	return Uniform{int(u)}
+	return gl.Uniform{int(u)}
 }
-func (c *Functions) InvalidateFramebuffer(target, attachment Enum) {
+func (c *Functions) InvalidateFramebuffer(target, attachment gl.Enum) {
 	addr := _glInvalidateFramebuffer.Addr()
 	if addr == 0 {
 		// InvalidateFramebuffer is just a hint. Skip it if not supported.
@@ -305,30 +307,30 @@ func (c *Functions) InvalidateFramebuffer(target, attachment Enum) {
 	}
 	syscall.Syscall(addr, 3, uintptr(target), 1, uintptr(unsafe.Pointer(&attachment)))
 }
-func (c *Functions) LinkProgram(p Program) {
+func (c *Functions) LinkProgram(p gl.Program) {
 	syscall.Syscall(_glLinkProgram.Addr(), 1, uintptr(p.V), 0, 0)
 }
-func (c *Functions) PixelStorei(pname Enum, param int32) {
+func (c *Functions) PixelStorei(pname gl.Enum, param int32) {
 	syscall.Syscall(_glPixelStorei.Addr(), 2, uintptr(pname), uintptr(param), 0)
 }
-func (f *Functions) ReadPixels(x, y, width, height int, format, ty Enum, data []byte) {
+func (f *Functions) ReadPixels(x, y, width, height int, format, ty gl.Enum, data []byte) {
 	d0 := &data[0]
 	syscall.Syscall9(_glReadPixels.Addr(), 7, uintptr(x), uintptr(y), uintptr(width), uintptr(height), uintptr(format), uintptr(ty), uintptr(unsafe.Pointer(d0)), 0, 0)
 	issue34474KeepAlive(d0)
 }
-func (c *Functions) RenderbufferStorage(target, internalformat Enum, width, height int) {
+func (c *Functions) RenderbufferStorage(target, internalformat gl.Enum, width, height int) {
 	syscall.Syscall6(_glRenderbufferStorage.Addr(), 4, uintptr(target), uintptr(internalformat), uintptr(width), uintptr(height), 0, 0)
 }
 func (c *Functions) Scissor(x, y, width, height int32) {
 	syscall.Syscall6(_glScissor.Addr(), 4, uintptr(x), uintptr(y), uintptr(width), uintptr(height), 0, 0)
 }
-func (c *Functions) ShaderSource(s Shader, src string) {
+func (c *Functions) ShaderSource(s gl.Shader, src string) {
 	var n uintptr = uintptr(len(src))
 	psrc := &src
 	syscall.Syscall6(_glShaderSource.Addr(), 4, uintptr(s.V), 1, uintptr(unsafe.Pointer(psrc)), uintptr(unsafe.Pointer(&n)), 0, 0)
 	issue34474KeepAlive(psrc)
 }
-func (c *Functions) TexImage2D(target Enum, level int, internalFormat int, width, height int, format, ty Enum, data []byte) {
+func (c *Functions) TexImage2D(target gl.Enum, level int, internalFormat int, width, height int, format, ty gl.Enum, data []byte) {
 	if len(data) == 0 {
 		syscall.Syscall9(_glTexImage2D.Addr(), 9, uintptr(target), uintptr(level), uintptr(internalFormat), uintptr(width), uintptr(height), 0, uintptr(format), uintptr(ty), 0)
 	} else {
@@ -337,33 +339,33 @@ func (c *Functions) TexImage2D(target Enum, level int, internalFormat int, width
 		issue34474KeepAlive(d0)
 	}
 }
-func (c *Functions) TexSubImage2D(target Enum, level int, x, y, width, height int, format, ty Enum, data []byte) {
+func (c *Functions) TexSubImage2D(target gl.Enum, level int, x, y, width, height int, format, ty gl.Enum, data []byte) {
 	d0 := &data[0]
 	syscall.Syscall9(_glTexSubImage2D.Addr(), 9, uintptr(target), uintptr(level), uintptr(x), uintptr(y), uintptr(width), uintptr(height), uintptr(format), uintptr(ty), uintptr(unsafe.Pointer(d0)))
 	issue34474KeepAlive(d0)
 }
-func (c *Functions) TexParameteri(target, pname Enum, param int) {
+func (c *Functions) TexParameteri(target, pname gl.Enum, param int) {
 	syscall.Syscall(_glTexParameteri.Addr(), 3, uintptr(target), uintptr(pname), uintptr(param))
 }
-func (c *Functions) Uniform1f(dst Uniform, v float32) {
+func (c *Functions) Uniform1f(dst gl.Uniform, v float32) {
 	syscall.Syscall(_glUniform1f.Addr(), 2, uintptr(dst.V), uintptr(math.Float32bits(v)), 0)
 }
-func (c *Functions) Uniform1i(dst Uniform, v int) {
+func (c *Functions) Uniform1i(dst gl.Uniform, v int) {
 	syscall.Syscall(_glUniform1i.Addr(), 2, uintptr(dst.V), uintptr(v), 0)
 }
-func (c *Functions) Uniform2f(dst Uniform, v0, v1 float32) {
+func (c *Functions) Uniform2f(dst gl.Uniform, v0, v1 float32) {
 	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) {
+func (c *Functions) Uniform3f(dst gl.Uniform, v0, v1, v2 float32) {
 	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) {
+func (c *Functions) Uniform4f(dst gl.Uniform, v0, v1, v2, v3 float32) {
 	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) {
+func (c *Functions) UseProgram(p gl.Program) {
 	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) {
+func (c *Functions) VertexAttribPointer(dst gl.Attrib, size int, ty gl.Enum, normalized bool, stride, offset int) {
 	var norm uintptr
 	if normalized {
 		norm = 1

app/internal/gl/srgb.go

@@ -12,7 +12,7 @@ import (
 // for gamma-correct rendering on platforms without
 // sRGB enabled native framebuffers.
 type SRGBFBO struct {
-	c             *Functions
+	c             Functions
 	width, height int
 	frameBuffer   Framebuffer
 	depthBuffer   Renderbuffer
@@ -23,7 +23,7 @@ type SRGBFBO struct {
 	es3           bool
 }
 
-func NewSRGBFBO(f *Functions) (*SRGBFBO, error) {
+func NewSRGBFBO(f Functions) (*SRGBFBO, error) {
 	var es3 bool
 	glVer := f.GetString(VERSION)
 	ver, err := ParseGLVersion(glVer)

app/internal/gl/util.go

@@ -10,7 +10,7 @@ import (
 	"unsafe"
 )
 
-func CreateProgram(ctx *Functions, vsSrc, fsSrc string, attribs []string) (Program, error) {
+func CreateProgram(ctx Functions, vsSrc, fsSrc string, attribs []string) (Program, error) {
 	vs, err := createShader(ctx, VERTEX_SHADER, vsSrc)
 	if err != nil {
 		return Program{}, err
@@ -39,7 +39,7 @@ func CreateProgram(ctx *Functions, vsSrc, fsSrc string, attribs []string) (Progr
 	return prog, nil
 }
 
-func GetUniformLocation(ctx *Functions, prog Program, name string) Uniform {
+func GetUniformLocation(ctx Functions, prog Program, name string) Uniform {
 	loc := ctx.GetUniformLocation(prog, name)
 	if !loc.Valid() {
 		panic(fmt.Errorf("uniform %s not found", name))
@@ -47,7 +47,7 @@ func GetUniformLocation(ctx *Functions, prog Program, name string) Uniform {
 	return loc
 }
 
-func createShader(ctx *Functions, typ Enum, src string) (Shader, error) {
+func createShader(ctx Functions, typ Enum, src string) (Shader, error) {
 	sh := ctx.CreateShader(typ)
 	if !sh.Valid() {
 		return Shader{}, errors.New("glCreateShader failed")

app/internal/gpu/context.go

@@ -11,7 +11,7 @@ import (
 
 type context struct {
 	caps caps
-	*gl.Functions
+	gl.Functions
 }
 
 type caps struct {
@@ -32,7 +32,7 @@ type textureTriple struct {
 	typ            gl.Enum
 }
 
-func newContext(glctx *gl.Functions) (*context, error) {
+func newContext(glctx gl.Functions) (*context, error) {
 	ctx := &context{
 		Functions: glctx,
 	}

app/internal/gpu/gpu.go

@@ -222,7 +222,7 @@ var (
 	attribUV    gl.Attrib = 1
 )
 
-func New(ctx *gl.Functions) (*GPU, error) {
+func New(ctx gl.Functions) (*GPU, error) {
 	g := &GPU{
 		pathCache: newOpCache(),
 		cache:     newResourceCache(),
@@ -233,7 +233,7 @@ func New(ctx *gl.Functions) (*GPU, error) {
 	return g, nil
 }
 
-func (g *GPU) init(glctx *gl.Functions) error {
+func (g *GPU) init(glctx gl.Functions) error {
 	ctx, err := newContext(glctx)
 	if err != nil {
 		return err

app/internal/window/gl_ios.go

@@ -17,11 +17,12 @@ import (
 	"fmt"
 
 	"gioui.org/app/internal/gl"
+	"gioui.org/app/internal/gl/impl"
 )
 
 type context struct {
 	owner                    *window
-	c                        *gl.Functions
+	c                        gl.Functions
 	ctx                      C.CFTypeRef
 	layer                    C.CFTypeRef
 	init                     bool
@@ -44,12 +45,12 @@ func newContext(w *window) (*context, error) {
 		ctx:   ctx,
 		owner: w,
 		layer: C.CFTypeRef(w.contextLayer()),
-		c:     new(gl.Functions),
+		c:     new(impl.Functions),
 	}
 	return c, nil
 }
 
-func (c *context) Functions() *gl.Functions {
+func (c *context) Functions() gl.Functions {
 	return c.c
 }
 

app/internal/window/gl_js.go

@@ -7,12 +7,13 @@ import (
 	"syscall/js"
 
 	"gioui.org/app/internal/gl"
+	"gioui.org/app/internal/gl/impl"
 )
 
 type context struct {
 	ctx     js.Value
 	cnv     js.Value
-	f       *gl.Functions
+	f       gl.Functions
 	srgbFBO *gl.SRGBFBO
 }
 
@@ -32,7 +33,7 @@ func newContext(w *window) (*context, error) {
 	if ctx.IsNull() {
 		return nil, errors.New("app: webgl is not supported")
 	}
-	f := &gl.Functions{Ctx: ctx}
+	f := &impl.Functions{Ctx: ctx}
 	if err := f.Init(version); err != nil {
 		return nil, err
 	}
@@ -44,7 +45,7 @@ func newContext(w *window) (*context, error) {
 	return c, nil
 }
 
-func (c *context) Functions() *gl.Functions {
+func (c *context) Functions() gl.Functions {
 	return c.f
 }
 

app/internal/window/gl_macos.go

@@ -6,6 +6,7 @@ package window
 
 import (
 	"gioui.org/app/internal/gl"
+	"gioui.org/app/internal/gl/impl"
 )
 
 /*
@@ -18,7 +19,7 @@ import (
 import "C"
 
 type context struct {
-	c    *gl.Functions
+	c    gl.Functions
 	ctx  C.CFTypeRef
 	view C.CFTypeRef
 }
@@ -34,13 +35,13 @@ func newContext(w *window) (*context, error) {
 	ctx := C.gio_contextForView(view)
 	c := &context{
 		ctx:  ctx,
-		c:    new(gl.Functions),
+		c:    new(impl.Functions),
 		view: view,
 	}
 	return c, nil
 }
 
-func (c *context) Functions() *gl.Functions {
+func (c *context) Functions() gl.Functions {
 	return c.c
 }
 

app/internal/window/window.go

@@ -32,7 +32,7 @@ type Callbacks interface {
 }
 
 type Context interface {
-	Functions() *gl.Functions
+	Functions() gl.Functions
 	Present() error
 	MakeCurrent() error
 	Release()