From b622412ac69e83f4b4ab92c2b0084464135415ab Mon Sep 17 00:00:00 2001 From: Elias Naur Date: Fri, 14 May 2021 21:07:04 +0200 Subject: [PATCH] gpu: support forced OpenGL ES mode, for ANGLE on macOS macOS is the only platform where desktop OpenGL is used. To support foreign ANGLE contexts add a setting to override Gio's selection of OpenGL implementation. The bulk of this change is making all function pointers per-context instead of global, and loading the OpenGL library dynamically. As a side effect we're closer to Gio tolerating a platform without any OpenGL implementation. For example, Apple has deprecated OpenGL and OpenGL ES on its platforms and may remove them in the future. Note that as a side-effect of this change, Gio needs Go 1.16 or newer to run on iOS. Signed-off-by: Elias Naur --- app/internal/wm/gl_ios.go | 2 +- gpu/internal/driver/api.go | 5 +- gpu/internal/opengl/opengl.go | 2 +- internal/gl/gl_js.go | 2 +- internal/gl/gl_unix.go | 880 +++++++++++++++++++++++++--------- internal/gl/gl_windows.go | 2 +- 6 files changed, 672 insertions(+), 221 deletions(-) diff --git a/app/internal/wm/gl_ios.go b/app/internal/wm/gl_ios.go index 811bd8af..186c7072 100644 --- a/app/internal/wm/gl_ios.go +++ b/app/internal/wm/gl_ios.go @@ -47,7 +47,7 @@ func newContext(w *window) (*context, error) { return nil, fmt.Errorf("failed to create EAGLContext") } api := contextAPI() - f, err := gl.NewFunctions(api.Context) + f, err := gl.NewFunctions(api.Context, api.ES) if err != nil { return nil, err } diff --git a/gpu/internal/driver/api.go b/gpu/internal/driver/api.go index f0b41cf6..c15fb897 100644 --- a/gpu/internal/driver/api.go +++ b/gpu/internal/driver/api.go @@ -9,13 +9,16 @@ import ( "gioui.org/internal/gl" ) -// See gpu/api.go for documentation for the API types +// See gpu/api.go for documentation for the API types. type API interface { implementsAPI() } type OpenGL struct { + // ES forces the use of ANGLE OpenGL ES libraries on macOS. It is + // ignored on all other platforms. + ES bool // Context contains the WebGL context for WebAssembly platforms. It is // empty for all other platforms; an OpenGL context is assumed current when // calling NewDevice. diff --git a/gpu/internal/opengl/opengl.go b/gpu/internal/opengl/opengl.go index 8e0a4f39..85a98252 100644 --- a/gpu/internal/opengl/opengl.go +++ b/gpu/internal/opengl/opengl.go @@ -131,7 +131,7 @@ func init() { } func newOpenGLDevice(api driver.OpenGL) (driver.Device, error) { - f, err := gl.NewFunctions(api.Context) + f, err := gl.NewFunctions(api.Context, api.ES) if err != nil { return nil, err } diff --git a/internal/gl/gl_js.go b/internal/gl/gl_js.go index 13890a7a..efe3cb86 100644 --- a/internal/gl/gl_js.go +++ b/internal/gl/gl_js.go @@ -23,7 +23,7 @@ type Functions struct { type Context js.Value -func NewFunctions(ctx Context) (*Functions, error) { +func NewFunctions(ctx Context, forceES bool) (*Functions, error) { f := &Functions{ Ctx: js.Value(ctx), uint8Array: js.Global().Get("Uint8Array"), diff --git a/internal/gl/gl_unix.go b/internal/gl/gl_unix.go index f7e7a66c..525cdd71 100644 --- a/internal/gl/gl_unix.go +++ b/internal/gl/gl_unix.go @@ -5,6 +5,7 @@ package gl import ( + "fmt" "runtime" "strings" "unsafe" @@ -12,177 +13,454 @@ import ( /* #cgo CFLAGS: -Werror -#cgo linux,!android pkg-config: glesv2 #cgo linux freebsd LDFLAGS: -ldl -#cgo freebsd openbsd android LDFLAGS: -lGLESv2 -#cgo freebsd CFLAGS: -I/usr/local/include -#cgo freebsd LDFLAGS: -L/usr/local/lib -#cgo openbsd CFLAGS: -I/usr/X11R6/include -#cgo openbsd LDFLAGS: -L/usr/X11R6/lib -#cgo darwin,!ios CFLAGS: -DGL_SILENCE_DEPRECATION -#cgo darwin,!ios LDFLAGS: -framework OpenGL -#cgo darwin,ios CFLAGS: -DGLES_SILENCE_DEPRECATION -#cgo darwin,ios LDFLAGS: -framework OpenGLES +#include #include +#include #define __USE_GNU #include -#ifdef __APPLE__ - #include "TargetConditionals.h" - #if TARGET_OS_IPHONE - #include - #else - #include - #endif -#else -#include -#include -#endif +typedef unsigned int GLenum; +typedef unsigned int GLuint; +typedef char GLchar; +typedef float GLfloat; +typedef ssize_t GLsizeiptr; +typedef intptr_t GLintptr; +typedef unsigned int GLbitfield; +typedef int GLint; +typedef unsigned char GLboolean; +typedef int GLsizei; +typedef uint8_t GLubyte; -static void (*_glBindBufferBase)(GLenum target, GLuint index, GLuint buffer); -static GLuint (*_glGetUniformBlockIndex)(GLuint program, const GLchar *uniformBlockName); -static void (*_glUniformBlockBinding)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); -static void (*_glInvalidateFramebuffer)(GLenum target, GLsizei numAttachments, const GLenum *attachments); +typedef struct { + void (*glActiveTexture)(GLenum texture); + void (*glAttachShader)(GLuint program, GLuint shader); + void (*glBindAttribLocation)(GLuint program, GLuint index, const GLchar *name); + void (*glBindBuffer)(GLenum target, GLuint buffer); + void (*glBindFramebuffer)(GLenum target, GLuint framebuffer); + void (*glBindRenderbuffer)(GLenum target, GLuint renderbuffer); + void (*glBindTexture)(GLenum target, GLuint texture); + void (*glBlendEquation)(GLenum mode); + void (*glBlendFunc)(GLenum sfactor, GLenum dfactor); + void (*glBufferData)(GLenum target, GLsizeiptr size, const void *data, GLenum usage); + void (*glBufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, const void *data); + GLenum (*glCheckFramebufferStatus)(GLenum target); + void (*glClear)(GLbitfield mask); + void (*glClearColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); + void (*glClearDepthf)(GLfloat d); + void (*glCompileShader)(GLuint shader); + GLuint (*glCreateProgram)(void); + GLuint (*glCreateShader)(GLenum type); + void (*glDeleteBuffers)(GLsizei n, const GLuint *buffers); + void (*glDeleteFramebuffers)(GLsizei n, const GLuint *framebuffers); + void (*glDeleteProgram)(GLuint program); + void (*glDeleteRenderbuffers)(GLsizei n, const GLuint *renderbuffers); + void (*glDeleteShader)(GLuint shader); + void (*glDeleteTextures)(GLsizei n, const GLuint *textures); + void (*glDepthFunc)(GLenum func); + void (*glDepthMask)(GLboolean flag); + void (*glDisable)(GLenum cap); + void (*glDisableVertexAttribArray)(GLuint index); + void (*glDrawArrays)(GLenum mode, GLint first, GLsizei count); + void (*glDrawElements)(GLenum mode, GLsizei count, GLenum type, const void *indices); + void (*glEnable)(GLenum cap); + void (*glEnableVertexAttribArray)(GLuint index); + void (*glFinish)(void); + void (*glFramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); + void (*glFramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); + void (*glGenBuffers)(GLsizei n, GLuint *buffers); + void (*glGenFramebuffers)(GLsizei n, GLuint *framebuffers); + void (*glGenRenderbuffers)(GLsizei n, GLuint *renderbuffers); + void (*glGenTextures)(GLsizei n, GLuint *textures); + GLenum (*glGetError)(void); + void (*glGetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint *params); + void (*glGetIntegerv)(GLenum pname, GLint *data); + void (*glGetProgramiv)(GLuint program, GLenum pname, GLint *params); + void (*glGetProgramInfoLog)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); + void (*glGetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint *params); + void (*glGetShaderiv)(GLuint shader, GLenum pname, GLint *params); + void (*glGetShaderInfoLog)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); + const GLubyte *(*glGetString)(GLenum name); + GLint (*glGetUniformLocation)(GLuint program, const GLchar *name); + void (*glLinkProgram)(GLuint program); + void (*glPixelStorei)(GLenum pname, GLint param); + void (*glReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels); + void (*glRenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); + void (*glScissor)(GLint x, GLint y, GLsizei width, GLsizei height); + void (*glShaderSource)(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length); + void (*glTexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels); + void (*glTexParameteri)(GLenum target, GLenum pname, GLint param); + void (*glTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); + void (*glUniform1f)(GLint location, GLfloat v0); + void (*glUniform1i)(GLint location, GLint v0); + void (*glUniform2f)(GLint location, GLfloat v0, GLfloat v1); + void (*glUniform3f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); + void (*glUniform4f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); + void (*glUseProgram)(GLuint program); + void (*glVertexAttribPointer)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer); + void (*glViewport)(GLint x, GLint y, GLsizei width, GLsizei height); -static void (*_glBeginQuery)(GLenum target, GLuint id); -static void (*_glDeleteQueries)(GLsizei n, const GLuint *ids); -static void (*_glEndQuery)(GLenum target); -static void (*_glGenQueries)(GLsizei n, GLuint *ids); -static void (*_glGetProgramBinary)(GLuint program, GLsizei bufsize, GLsizei *length, GLenum *binaryFormat, void *binary); -static void (*_glGetQueryObjectuiv)(GLuint id, GLenum pname, GLuint *params); -static const GLubyte* (*_glGetStringi)(GLenum name, GLuint index); -static void (*_glMemoryBarrier)(GLbitfield barriers); -static void (*_glDispatchCompute)(GLuint x, GLuint y, GLuint z); -static void* (*_glMapBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); -static GLboolean (*_glUnmapBuffer)(GLenum target); -static void (*_glBindImageTexture)(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format); -static void (*_glTexStorage2D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height); -static void (*_glBlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); + void (*glBindBufferBase)(GLenum target, GLuint index, GLuint buffer); + GLuint (*glGetUniformBlockIndex)(GLuint program, const GLchar *uniformBlockName); + void (*glUniformBlockBinding)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); + void (*glInvalidateFramebuffer)(GLenum target, GLsizei numAttachments, const GLenum *attachments); -// The pointer-free version of glVertexAttribPointer, to avoid the Cgo pointer checks. -static void gio_glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, uintptr_t offset) { - glVertexAttribPointer(index, size, type, normalized, stride, (const GLvoid *)offset); + void (*glBeginQuery)(GLenum target, GLuint id); + void (*glDeleteQueries)(GLsizei n, const GLuint *ids); + void (*glEndQuery)(GLenum target); + void (*glGenQueries)(GLsizei n, GLuint *ids); + void (*glGetProgramBinary)(GLuint program, GLsizei bufsize, GLsizei *length, GLenum *binaryFormat, void *binary); + void (*glGetQueryObjectuiv)(GLuint id, GLenum pname, GLuint *params); + const GLubyte* (*glGetStringi)(GLenum name, GLuint index); + void (*glDispatchCompute)(GLuint x, GLuint y, GLuint z); + void (*glMemoryBarrier)(GLbitfield barriers); + void* (*glMapBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); + GLboolean (*glUnmapBuffer)(GLenum target); + void (*glBindImageTexture)(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format); + void (*glTexStorage2D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height); + void (*glBlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +} glFunctions; + +static void glActiveTexture(glFunctions *f, GLenum texture) { + f->glActiveTexture(texture); } -// The pointer-free version of glDrawElements, to avoid the Cgo pointer checks. -static void gio_glDrawElements(GLenum mode, GLsizei count, GLenum type, const uintptr_t offset) { - glDrawElements(mode, count, type, (const GLvoid *)offset); +static void glAttachShader(glFunctions *f, GLuint program, GLuint shader) { + f->glAttachShader(program, shader); } -static void gio_glBindBufferBase(GLenum target, GLuint index, GLuint buffer) { - _glBindBufferBase(target, index, buffer); +static void glBindAttribLocation(glFunctions *f, GLuint program, GLuint index, const GLchar *name) { + f->glBindAttribLocation(program, index, name); } -static void gio_glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) { - _glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding); +static void glBindBuffer(glFunctions *f, GLenum target, GLuint buffer) { + f->glBindBuffer(target, buffer); } -static GLuint gio_glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName) { - return _glGetUniformBlockIndex(program, uniformBlockName); +static void glBindFramebuffer(glFunctions *f, GLenum target, GLuint framebuffer) { + f->glBindFramebuffer(target, framebuffer); } -static void gio_glInvalidateFramebuffer(GLenum target, GLenum attachment) { +static void glBindRenderbuffer(glFunctions *f, GLenum target, GLuint renderbuffer) { + f->glBindRenderbuffer(target, renderbuffer); +} + +static void glBindTexture(glFunctions *f, GLenum target, GLuint texture) { + f->glBindTexture(target, texture); +} + +static void glBlendEquation(glFunctions *f, GLenum mode) { + f->glBlendEquation(mode); +} + +static void glBlendFunc(glFunctions *f, GLenum sfactor, GLenum dfactor) { + f->glBlendFunc(sfactor, dfactor); +} + +static void glBufferData(glFunctions *f, GLenum target, GLsizeiptr size, const void *data, GLenum usage) { + f->glBufferData(target, size, data, usage); +} + +static void glBufferSubData(glFunctions *f, GLenum target, GLintptr offset, GLsizeiptr size, const void *data) { + f->glBufferSubData(target, offset, size, data); +} + +static GLenum glCheckFramebufferStatus(glFunctions *f, GLenum target) { + return f->glCheckFramebufferStatus(target); +} + +static void glClear(glFunctions *f, GLbitfield mask) { + f->glClear(mask); +} + +static void glClearColor(glFunctions *f, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { + f->glClearColor(red, green, blue, alpha); +} + +static void glClearDepthf(glFunctions *f, GLfloat d) { + f->glClearDepthf(d); +} + +static void glCompileShader(glFunctions *f, GLuint shader) { + f->glCompileShader(shader); +} + +static GLuint glCreateProgram(glFunctions *f) { + return f->glCreateProgram(); +} + +static GLuint glCreateShader(glFunctions *f, GLenum type) { + return f->glCreateShader(type); +} + +static void glDeleteBuffers(glFunctions *f, GLsizei n, const GLuint *buffers) { + f->glDeleteBuffers(n, buffers); +} + +static void glDeleteFramebuffers(glFunctions *f, GLsizei n, const GLuint *framebuffers) { + f->glDeleteFramebuffers(n, framebuffers); +} + +static void glDeleteProgram(glFunctions *f, GLuint program) { + f->glDeleteProgram(program); +} + +static void glDeleteRenderbuffers(glFunctions *f, GLsizei n, const GLuint *renderbuffers) { + f->glDeleteRenderbuffers(n, renderbuffers); +} + +static void glDeleteShader(glFunctions *f, GLuint shader) { + f->glDeleteShader(shader); +} + +static void glDeleteTextures(glFunctions *f, GLsizei n, const GLuint *textures) { + f->glDeleteTextures(n, textures); +} + +static void glDepthFunc(glFunctions *f, GLenum func) { + f->glDepthFunc(func); +} + +static void glDepthMask(glFunctions *f, GLboolean flag) { + f->glDepthMask(flag); +} + +static void glDisable(glFunctions *f, GLenum cap) { + f->glDisable(cap); +} + +static void glDisableVertexAttribArray(glFunctions *f, GLuint index) { + f->glDisableVertexAttribArray(index); +} + +static void glDrawArrays(glFunctions *f, GLenum mode, GLint first, GLsizei count) { + f->glDrawArrays(mode, first, count); +} + +// offset is defined as an uintptr_t to omit Cgo pointer checks. +static void glDrawElements(glFunctions *f, GLenum mode, GLsizei count, GLenum type, const uintptr_t offset) { + f->glDrawElements(mode, count, type, (const void *)offset); +} + +static void glEnable(glFunctions *f, GLenum cap) { + f->glEnable(cap); +} + +static void glEnableVertexAttribArray(glFunctions *f, GLuint index) { + f->glEnableVertexAttribArray(index); +} + +static void glFinish(glFunctions *f) { + f->glFinish(); +} + +static void glFramebufferRenderbuffer(glFunctions *f, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) { + f->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); +} + +static void glFramebufferTexture2D(glFunctions *f, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { + f->glFramebufferTexture2D(target, attachment, textarget, texture, level); +} + +static void glGenBuffers(glFunctions *f, GLsizei n, GLuint *buffers) { + f->glGenBuffers(n, buffers); +} + +static void glGenFramebuffers(glFunctions *f, GLsizei n, GLuint *framebuffers) { + f->glGenFramebuffers(n, framebuffers); +} + +static void glGenRenderbuffers(glFunctions *f, GLsizei n, GLuint *renderbuffers) { + f->glGenRenderbuffers(n, renderbuffers); +} + +static void glGenTextures(glFunctions *f, GLsizei n, GLuint *textures) { + f->glGenTextures(n, textures); +} + +static GLenum glGetError(glFunctions *f) { + return f->glGetError(); +} + +static void glGetFramebufferAttachmentParameteriv(glFunctions *f, GLenum target, GLenum attachment, GLenum pname, GLint *params) { + f->glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); +} + +static void glGetIntegerv(glFunctions *f, GLenum pname, GLint *data) { + f->glGetIntegerv(pname, data); +} + +static void glGetProgramiv(glFunctions *f, GLuint program, GLenum pname, GLint *params) { + f->glGetProgramiv(program, pname, params); +} + +static void glGetProgramInfoLog(glFunctions *f, GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog) { + f->glGetProgramInfoLog(program, bufSize, length, infoLog); +} + +static void glGetRenderbufferParameteriv(glFunctions *f, GLenum target, GLenum pname, GLint *params) { + f->glGetRenderbufferParameteriv(target, pname, params); +} + +static void glGetShaderiv(glFunctions *f, GLuint shader, GLenum pname, GLint *params) { + f->glGetShaderiv(shader, pname, params); +} + +static void glGetShaderInfoLog(glFunctions *f, GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog) { + f->glGetShaderInfoLog(shader, bufSize, length, infoLog); +} + +static const GLubyte *glGetString(glFunctions *f, GLenum name) { + return f->glGetString(name); +} + +static GLint glGetUniformLocation(glFunctions *f, GLuint program, const GLchar *name) { + return f->glGetUniformLocation(program, name); +} + +static void glLinkProgram(glFunctions *f, GLuint program) { + f->glLinkProgram(program); +} + +static void glPixelStorei(glFunctions *f, GLenum pname, GLint param) { + f->glPixelStorei(pname, param); +} + +static void glReadPixels(glFunctions *f, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels) { + f->glReadPixels(x, y, width, height, format, type, pixels); +} + +static void glRenderbufferStorage(glFunctions *f, GLenum target, GLenum internalformat, GLsizei width, GLsizei height) { + f->glRenderbufferStorage(target, internalformat, width, height); +} + +static void glScissor(glFunctions *f, GLint x, GLint y, GLsizei width, GLsizei height) { + f->glScissor(x, y, width, height); +} + +static void glShaderSource(glFunctions *f, GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length) { + f->glShaderSource(shader, count, string, length); +} + +static void glTexImage2D(glFunctions *f, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels) { + f->glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels); +} + +static void glTexParameteri(glFunctions *f, GLenum target, GLenum pname, GLint param) { + f->glTexParameteri(target, pname, param); +} + +static void glTexSubImage2D(glFunctions *f, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) { + f->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); +} + +static void glUniform1f(glFunctions *f, GLint location, GLfloat v0) { + f->glUniform1f(location, v0); +} + +static void glUniform1i(glFunctions *f, GLint location, GLint v0) { + f->glUniform1i(location, v0); +} + +static void glUniform2f(glFunctions *f, GLint location, GLfloat v0, GLfloat v1) { + f->glUniform2f(location, v0, v1); +} + +static void glUniform3f(glFunctions *f, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) { + f->glUniform3f(location, v0, v1, v2); +} + +static void glUniform4f(glFunctions *f, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) { + f->glUniform4f(location, v0, v1, v2, v3); +} + +static void glUseProgram(glFunctions *f, GLuint program) { + f->glUseProgram(program); +} + +// offset is defined as an uintptr_t to omit Cgo pointer checks. +static void glVertexAttribPointer(glFunctions *f, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, uintptr_t offset) { + f->glVertexAttribPointer(index, size, type, normalized, stride, (const void *)offset); +} + +static void glViewport(glFunctions *f, GLint x, GLint y, GLsizei width, GLsizei height) { + f->glViewport(x, y, width, height); +} + +static void glBindBufferBase(glFunctions *f, GLenum target, GLuint index, GLuint buffer) { + f->glBindBufferBase(target, index, buffer); +} + +static void glUniformBlockBinding(glFunctions *f, GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) { + f->glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding); +} + +static GLuint glGetUniformBlockIndex(glFunctions *f, GLuint program, const GLchar *uniformBlockName) { + return f->glGetUniformBlockIndex(program, uniformBlockName); +} + +static void glInvalidateFramebuffer(glFunctions *f, GLenum target, GLenum attachment) { // Framebuffer invalidation is just a hint and can safely be ignored. - if (_glInvalidateFramebuffer != NULL) { - _glInvalidateFramebuffer(target, 1, &attachment); + if (f->glInvalidateFramebuffer != NULL) { + f->glInvalidateFramebuffer(target, 1, &attachment); } } -static void gio_glBeginQuery(GLenum target, GLenum attachment) { - _glBeginQuery(target, attachment); +static void glBeginQuery(glFunctions *f, GLenum target, GLenum attachment) { + f->glBeginQuery(target, attachment); } -static void gio_glDeleteQueries(GLsizei n, const GLuint *ids) { - _glDeleteQueries(n, ids); +static void glDeleteQueries(glFunctions *f, GLsizei n, const GLuint *ids) { + f->glDeleteQueries(n, ids); } -static void gio_glEndQuery(GLenum target) { - _glEndQuery(target); +static void glEndQuery(glFunctions *f, GLenum target) { + f->glEndQuery(target); } -static const GLubyte* gio_glGetStringi(GLenum name, GLuint index) { - return _glGetStringi(name, index); +static const GLubyte* glGetStringi(glFunctions *f, GLenum name, GLuint index) { + return f->glGetStringi(name, index); } -static void gio_glGenQueries(GLsizei n, GLuint *ids) { - _glGenQueries(n, ids); +static void glGenQueries(glFunctions *f, GLsizei n, GLuint *ids) { + f->glGenQueries(n, ids); } -static void gio_glGetProgramBinary(GLuint program, GLsizei bufsize, GLsizei *length, GLenum *binaryFormat, void *binary) { - _glGetProgramBinary(program, bufsize, length, binaryFormat, binary); +static void glGetProgramBinary(glFunctions *f, GLuint program, GLsizei bufsize, GLsizei *length, GLenum *binaryFormat, void *binary) { + f->glGetProgramBinary(program, bufsize, length, binaryFormat, binary); } -static void gio_glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params) { - _glGetQueryObjectuiv(id, pname, params); +static void glGetQueryObjectuiv(glFunctions *f, GLuint id, GLenum pname, GLuint *params) { + f->glGetQueryObjectuiv(id, pname, params); } -static void gio_glMemoryBarrier(GLbitfield barriers) { - _glMemoryBarrier(barriers); +static void glMemoryBarrier(glFunctions *f, GLbitfield barriers) { + f->glMemoryBarrier(barriers); } -static void gio_glDispatchCompute(GLuint x, GLuint y, GLuint z) { - _glDispatchCompute(x, y, z); +static void glDispatchCompute(glFunctions *f, GLuint x, GLuint y, GLuint z) { + f->glDispatchCompute(x, y, z); } -static void *gio_glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) { - return _glMapBufferRange(target, offset, length, access); +static void *glMapBufferRange(glFunctions *f, GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) { + return f->glMapBufferRange(target, offset, length, access); } -static GLboolean gio_glUnmapBuffer(GLenum target) { - return _glUnmapBuffer(target); +static GLboolean glUnmapBuffer(glFunctions *f, GLenum target) { + return f->glUnmapBuffer(target); } -static void gio_glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format) { - _glBindImageTexture(unit, texture, level, layered, layer, access, format); +static void glBindImageTexture(glFunctions *f, GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format) { + f->glBindImageTexture(unit, texture, level, layered, layer, access, format); } -static void gio_glTexStorage2D(GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height) { - _glTexStorage2D(target, levels, internalFormat, width, height); +static void glTexStorage2D(glFunctions *f, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height) { + f->glTexStorage2D(target, levels, internalFormat, width, height); } -static void gio_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) { - _glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); -} - -__attribute__((constructor)) static void gio_loadGLFunctions() { - // Load libGLESv3 if available. - dlopen("libGLESv3.so", RTLD_NOW | RTLD_GLOBAL); - - _glBindBufferBase = dlsym(RTLD_DEFAULT, "glBindBufferBase"); - _glGetUniformBlockIndex = dlsym(RTLD_DEFAULT, "glGetUniformBlockIndex"); - _glUniformBlockBinding = dlsym(RTLD_DEFAULT, "glUniformBlockBinding"); - _glInvalidateFramebuffer = dlsym(RTLD_DEFAULT, "glInvalidateFramebuffer"); - _glGetStringi = dlsym(RTLD_DEFAULT, "glGetStringi"); - // Fall back to EXT_invalidate_framebuffer if available. - if (_glInvalidateFramebuffer == NULL) { - _glInvalidateFramebuffer = dlsym(RTLD_DEFAULT, "glDiscardFramebufferEXT"); - } - - _glBeginQuery = dlsym(RTLD_DEFAULT, "glBeginQuery"); - if (_glBeginQuery == NULL) - _glBeginQuery = dlsym(RTLD_DEFAULT, "glBeginQueryEXT"); - _glDeleteQueries = dlsym(RTLD_DEFAULT, "glDeleteQueries"); - if (_glDeleteQueries == NULL) - _glDeleteQueries = dlsym(RTLD_DEFAULT, "glDeleteQueriesEXT"); - _glEndQuery = dlsym(RTLD_DEFAULT, "glEndQuery"); - if (_glEndQuery == NULL) - _glEndQuery = dlsym(RTLD_DEFAULT, "glEndQueryEXT"); - _glGenQueries = dlsym(RTLD_DEFAULT, "glGenQueries"); - if (_glGenQueries == NULL) - _glGenQueries = dlsym(RTLD_DEFAULT, "glGenQueriesEXT"); - _glGetQueryObjectuiv = dlsym(RTLD_DEFAULT, "glGetQueryObjectuiv"); - if (_glGetQueryObjectuiv == NULL) - _glGetQueryObjectuiv = dlsym(RTLD_DEFAULT, "glGetQueryObjectuivEXT"); - - _glMemoryBarrier = dlsym(RTLD_DEFAULT, "glMemoryBarrier"); - _glDispatchCompute = dlsym(RTLD_DEFAULT, "glDispatchCompute"); - _glMapBufferRange = dlsym(RTLD_DEFAULT, "glMapBufferRange"); - _glUnmapBuffer = dlsym(RTLD_DEFAULT, "glUnmapBuffer"); - _glBindImageTexture = dlsym(RTLD_DEFAULT, "glBindImageTexture"); - _glTexStorage2D = dlsym(RTLD_DEFAULT, "glTexStorage2D"); - _glBlitFramebuffer = dlsym(RTLD_DEFAULT, "glBlitFramebuffer"); - _glGetProgramBinary = dlsym(RTLD_DEFAULT, "glGetProgramBinary"); +static void glBlitFramebuffer(glFunctions *f, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) { + f->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); } */ import "C" @@ -193,71 +471,241 @@ type Functions struct { // Query caches. uints [100]C.GLuint ints [100]C.GLint + + f C.glFunctions } -func NewFunctions(ctx Context) (*Functions, error) { +func NewFunctions(ctx Context, forceES bool) (*Functions, error) { if ctx != nil { panic("non-nil context") } - return new(Functions), nil + f := new(Functions) + err := f.load(forceES) + if err != nil { + return nil, err + } + return f, nil +} + +func dlsym(handle unsafe.Pointer, s string) unsafe.Pointer { + cs := C.CString(s) + defer C.free(unsafe.Pointer(cs)) + return C.dlsym(handle, cs) +} + +func dlopen(lib string) unsafe.Pointer { + clib := C.CString(lib) + defer C.free(unsafe.Pointer(clib)) + return C.dlopen(clib, C.RTLD_NOW) +} + +func (f *Functions) load(forceES bool) error { + var ( + loadErr error + libNames []string + handles []unsafe.Pointer + ) + switch { + case runtime.GOOS == "darwin" && !forceES: + libNames = []string{"/System/Library/Frameworks/OpenGL.framework/OpenGL"} + case runtime.GOOS == "darwin" && forceES: + libNames = []string{"libGLESv2.dylib"} + case runtime.GOOS == "ios": + libNames = []string{"/System/Library/Frameworks/OpenGLES.framework/OpenGLES"} + default: + libNames = []string{"libGLESv2.so", "libGLESv3.so"} + } + for _, lib := range libNames { + if h := dlopen(lib); h != nil { + handles = append(handles, h) + } + } + if len(handles) == 0 { + return fmt.Errorf("gl: no OpenGL implementation could be loaded (tried %q)", libNames) + } + load := func(s string) *[0]byte { + for _, h := range handles { + if f := dlsym(h, s); f != nil { + return (*[0]byte)(f) + } + } + return nil + } + must := func(s string) *[0]byte { + ptr := load(s) + if ptr == nil { + loadErr = fmt.Errorf("gl: failed to load symbol %q", s) + } + return ptr + } + // GL ES 2.0 functions. + f.f.glActiveTexture = must("glActiveTexture") + f.f.glAttachShader = must("glAttachShader") + f.f.glBindAttribLocation = must("glBindAttribLocation") + f.f.glBindBuffer = must("glBindBuffer") + f.f.glBindFramebuffer = must("glBindFramebuffer") + f.f.glBindRenderbuffer = must("glBindRenderbuffer") + f.f.glBindTexture = must("glBindTexture") + f.f.glBlendEquation = must("glBlendEquation") + f.f.glBlendFunc = must("glBlendFunc") + f.f.glBufferData = must("glBufferData") + f.f.glBufferSubData = must("glBufferSubData") + f.f.glCheckFramebufferStatus = must("glCheckFramebufferStatus") + f.f.glClear = must("glClear") + f.f.glClearColor = must("glClearColor") + f.f.glClearDepthf = must("glClearDepthf") + f.f.glCompileShader = must("glCompileShader") + f.f.glCreateProgram = must("glCreateProgram") + f.f.glCreateShader = must("glCreateShader") + f.f.glDeleteBuffers = must("glDeleteBuffers") + f.f.glDeleteFramebuffers = must("glDeleteFramebuffers") + f.f.glDeleteProgram = must("glDeleteProgram") + f.f.glDeleteRenderbuffers = must("glDeleteRenderbuffers") + f.f.glDeleteShader = must("glDeleteShader") + f.f.glDeleteTextures = must("glDeleteTextures") + f.f.glDepthFunc = must("glDepthFunc") + f.f.glDepthMask = must("glDepthMask") + f.f.glDisable = must("glDisable") + f.f.glDisableVertexAttribArray = must("glDisableVertexAttribArray") + f.f.glDrawArrays = must("glDrawArrays") + f.f.glDrawElements = must("glDrawElements") + f.f.glEnable = must("glEnable") + f.f.glEnableVertexAttribArray = must("glEnableVertexAttribArray") + f.f.glFinish = must("glFinish") + f.f.glFramebufferRenderbuffer = must("glFramebufferRenderbuffer") + f.f.glFramebufferTexture2D = must("glFramebufferTexture2D") + f.f.glGenBuffers = must("glGenBuffers") + f.f.glGenFramebuffers = must("glGenFramebuffers") + f.f.glGenRenderbuffers = must("glGenRenderbuffers") + f.f.glGenTextures = must("glGenTextures") + f.f.glGetError = must("glGetError") + f.f.glGetFramebufferAttachmentParameteriv = must("glGetFramebufferAttachmentParameteriv") + f.f.glGetIntegerv = must("glGetIntegerv") + f.f.glGetProgramiv = must("glGetProgramiv") + f.f.glGetProgramInfoLog = must("glGetProgramInfoLog") + f.f.glGetRenderbufferParameteriv = must("glGetRenderbufferParameteriv") + f.f.glGetShaderiv = must("glGetShaderiv") + f.f.glGetShaderInfoLog = must("glGetShaderInfoLog") + f.f.glGetString = must("glGetString") + f.f.glGetUniformLocation = must("glGetUniformLocation") + f.f.glLinkProgram = must("glLinkProgram") + f.f.glPixelStorei = must("glPixelStorei") + f.f.glReadPixels = must("glReadPixels") + f.f.glRenderbufferStorage = must("glRenderbufferStorage") + f.f.glScissor = must("glScissor") + f.f.glShaderSource = must("glShaderSource") + f.f.glTexImage2D = must("glTexImage2D") + f.f.glTexParameteri = must("glTexParameteri") + f.f.glTexSubImage2D = must("glTexSubImage2D") + f.f.glUniform1f = must("glUniform1f") + f.f.glUniform1i = must("glUniform1i") + f.f.glUniform2f = must("glUniform2f") + f.f.glUniform3f = must("glUniform3f") + f.f.glUniform4f = must("glUniform4f") + f.f.glUseProgram = must("glUseProgram") + f.f.glVertexAttribPointer = must("glVertexAttribPointer") + f.f.glViewport = must("glViewport") + + // Extensions and GL ES 3 functions. + f.f.glBindBufferBase = load("glBindBufferBase") + f.f.glGetUniformBlockIndex = load("glGetUniformBlockIndex") + f.f.glUniformBlockBinding = load("glUniformBlockBinding") + f.f.glInvalidateFramebuffer = load("glInvalidateFramebuffer") + f.f.glGetStringi = load("glGetStringi") + // Fall back to EXT_invalidate_framebuffer if available. + if f.f.glInvalidateFramebuffer == nil { + f.f.glInvalidateFramebuffer = load("glDiscardFramebufferEXT") + } + + f.f.glBeginQuery = load("glBeginQuery") + if f.f.glBeginQuery == nil { + f.f.glBeginQuery = load("glBeginQueryEXT") + } + f.f.glDeleteQueries = load("glDeleteQueries") + if f.f.glDeleteQueries == nil { + f.f.glDeleteQueries = load("glDeleteQueriesEXT") + } + f.f.glEndQuery = load("glEndQuery") + if f.f.glEndQuery == nil { + f.f.glEndQuery = load("glEndQueryEXT") + } + f.f.glGenQueries = load("glGenQueries") + if f.f.glGenQueries == nil { + f.f.glGenQueries = load("glGenQueriesEXT") + } + f.f.glGetQueryObjectuiv = load("glGetQueryObjectuiv") + if f.f.glGetQueryObjectuiv == nil { + f.f.glGetQueryObjectuiv = load("glGetQueryObjectuivEXT") + } + + f.f.glMemoryBarrier = load("glMemoryBarrier") + f.f.glDispatchCompute = load("glDispatchCompute") + f.f.glMapBufferRange = load("glMapBufferRange") + f.f.glUnmapBuffer = load("glUnmapBuffer") + f.f.glBindImageTexture = load("glBindImageTexture") + f.f.glTexStorage2D = load("glTexStorage2D") + f.f.glBlitFramebuffer = load("glBlitFramebuffer") + f.f.glGetProgramBinary = load("glGetProgramBinary") + + return loadErr } func (f *Functions) ActiveTexture(texture Enum) { - C.glActiveTexture(C.GLenum(texture)) + C.glActiveTexture(&f.f, C.GLenum(texture)) } func (f *Functions) AttachShader(p Program, s Shader) { - C.glAttachShader(C.GLuint(p.V), C.GLuint(s.V)) + C.glAttachShader(&f.f, 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.V)) + C.glBeginQuery(&f.f, 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.V), C.GLuint(a), cname) + C.glBindAttribLocation(&f.f, C.GLuint(p.V), C.GLuint(a), cname) } func (f *Functions) BindBufferBase(target Enum, index int, b Buffer) { - C.gio_glBindBufferBase(C.GLenum(target), C.GLuint(index), C.GLuint(b.V)) + C.glBindBufferBase(&f.f, C.GLenum(target), C.GLuint(index), C.GLuint(b.V)) } func (f *Functions) BindBuffer(target Enum, b Buffer) { - C.glBindBuffer(C.GLenum(target), C.GLuint(b.V)) + C.glBindBuffer(&f.f, C.GLenum(target), C.GLuint(b.V)) } func (f *Functions) BindFramebuffer(target Enum, fb Framebuffer) { - C.glBindFramebuffer(C.GLenum(target), C.GLuint(fb.V)) + C.glBindFramebuffer(&f.f, C.GLenum(target), C.GLuint(fb.V)) } func (f *Functions) BindRenderbuffer(target Enum, fb Renderbuffer) { - C.glBindRenderbuffer(C.GLenum(target), C.GLuint(fb.V)) + C.glBindRenderbuffer(&f.f, C.GLenum(target), C.GLuint(fb.V)) } func (f *Functions) BindImageTexture(unit int, t Texture, level int, layered bool, layer int, access, format Enum) { - l := C.GLboolean(C.GL_FALSE) + l := C.GLboolean(FALSE) if layered { - l = C.GL_TRUE + l = TRUE } - C.gio_glBindImageTexture(C.GLuint(unit), C.GLuint(t.V), C.GLint(level), l, C.GLint(layer), C.GLenum(access), C.GLenum(format)) + C.glBindImageTexture(&f.f, C.GLuint(unit), C.GLuint(t.V), C.GLint(level), l, C.GLint(layer), C.GLenum(access), C.GLenum(format)) } func (f *Functions) BindTexture(target Enum, t Texture) { - C.glBindTexture(C.GLenum(target), C.GLuint(t.V)) + C.glBindTexture(&f.f, C.GLenum(target), C.GLuint(t.V)) } func (f *Functions) BlendEquation(mode Enum) { - C.glBlendEquation(C.GLenum(mode)) + C.glBlendEquation(&f.f, C.GLenum(mode)) } func (f *Functions) BlendFunc(sfactor, dfactor Enum) { - C.glBlendFunc(C.GLenum(sfactor), C.GLenum(dfactor)) + C.glBlendFunc(&f.f, C.GLenum(sfactor), C.GLenum(dfactor)) } func (f *Functions) BlitFramebuffer(sx0, sy0, sx1, sy1, dx0, dy0, dx1, dy1 int, mask Enum, filter Enum) { - C.gio_glBlitFramebuffer( + C.glBlitFramebuffer(&f.f, C.GLint(sx0), C.GLint(sy0), C.GLint(sx1), C.GLint(sy1), C.GLint(dx0), C.GLint(dy0), C.GLint(dx1), C.GLint(dy1), C.GLenum(mask), C.GLenum(filter), @@ -265,7 +713,7 @@ func (f *Functions) BlitFramebuffer(sx0, sy0, sx1, sy1, dx0, dy0, dx1, dy1 int, } func (f *Functions) BufferData(target Enum, size int, usage Enum) { - C.glBufferData(C.GLenum(target), C.GLsizeiptr(size), nil, C.GLenum(usage)) + C.glBufferData(&f.f, C.GLenum(target), C.GLsizeiptr(size), nil, C.GLenum(usage)) } func (f *Functions) BufferSubData(target Enum, offset int, src []byte) { @@ -273,149 +721,149 @@ func (f *Functions) BufferSubData(target Enum, offset int, src []byte) { if len(src) > 0 { p = unsafe.Pointer(&src[0]) } - C.glBufferSubData(C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(len(src)), p) + C.glBufferSubData(&f.f, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(len(src)), p) } func (f *Functions) CheckFramebufferStatus(target Enum) Enum { - return Enum(C.glCheckFramebufferStatus(C.GLenum(target))) + return Enum(C.glCheckFramebufferStatus(&f.f, C.GLenum(target))) } func (f *Functions) Clear(mask Enum) { - C.glClear(C.GLbitfield(mask)) + C.glClear(&f.f, C.GLbitfield(mask)) } func (f *Functions) ClearColor(red float32, green float32, blue float32, alpha float32) { - C.glClearColor(C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) + C.glClearColor(&f.f, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) } func (f *Functions) ClearDepthf(d float32) { - C.glClearDepthf(C.GLfloat(d)) + C.glClearDepthf(&f.f, C.GLfloat(d)) } func (f *Functions) CompileShader(s Shader) { - C.glCompileShader(C.GLuint(s.V)) + C.glCompileShader(&f.f, C.GLuint(s.V)) } func (f *Functions) CreateBuffer() Buffer { - C.glGenBuffers(1, &f.uints[0]) + C.glGenBuffers(&f.f, 1, &f.uints[0]) return Buffer{uint(f.uints[0])} } func (f *Functions) CreateFramebuffer() Framebuffer { - C.glGenFramebuffers(1, &f.uints[0]) + C.glGenFramebuffers(&f.f, 1, &f.uints[0]) return Framebuffer{uint(f.uints[0])} } func (f *Functions) CreateProgram() Program { - return Program{uint(C.glCreateProgram())} + return Program{uint(C.glCreateProgram(&f.f))} } func (f *Functions) CreateQuery() Query { - C.gio_glGenQueries(1, &f.uints[0]) + C.glGenQueries(&f.f, 1, &f.uints[0]) return Query{uint(f.uints[0])} } func (f *Functions) CreateRenderbuffer() Renderbuffer { - C.glGenRenderbuffers(1, &f.uints[0]) + C.glGenRenderbuffers(&f.f, 1, &f.uints[0]) return Renderbuffer{uint(f.uints[0])} } func (f *Functions) CreateShader(ty Enum) Shader { - return Shader{uint(C.glCreateShader(C.GLenum(ty)))} + return Shader{uint(C.glCreateShader(&f.f, C.GLenum(ty)))} } func (f *Functions) CreateTexture() Texture { - C.glGenTextures(1, &f.uints[0]) + C.glGenTextures(&f.f, 1, &f.uints[0]) return Texture{uint(f.uints[0])} } func (f *Functions) DeleteBuffer(v Buffer) { f.uints[0] = C.GLuint(v.V) - C.glDeleteBuffers(1, &f.uints[0]) + C.glDeleteBuffers(&f.f, 1, &f.uints[0]) } func (f *Functions) DeleteFramebuffer(v Framebuffer) { f.uints[0] = C.GLuint(v.V) - C.glDeleteFramebuffers(1, &f.uints[0]) + C.glDeleteFramebuffers(&f.f, 1, &f.uints[0]) } func (f *Functions) DeleteProgram(p Program) { - C.glDeleteProgram(C.GLuint(p.V)) + C.glDeleteProgram(&f.f, C.GLuint(p.V)) } func (f *Functions) DeleteQuery(query Query) { f.uints[0] = C.GLuint(query.V) - C.gio_glDeleteQueries(1, &f.uints[0]) + C.glDeleteQueries(&f.f, 1, &f.uints[0]) } func (f *Functions) DeleteRenderbuffer(v Renderbuffer) { f.uints[0] = C.GLuint(v.V) - C.glDeleteRenderbuffers(1, &f.uints[0]) + C.glDeleteRenderbuffers(&f.f, 1, &f.uints[0]) } func (f *Functions) DeleteShader(s Shader) { - C.glDeleteShader(C.GLuint(s.V)) + C.glDeleteShader(&f.f, C.GLuint(s.V)) } func (f *Functions) DeleteTexture(v Texture) { f.uints[0] = C.GLuint(v.V) - C.glDeleteTextures(1, &f.uints[0]) + C.glDeleteTextures(&f.f, 1, &f.uints[0]) } func (f *Functions) DepthFunc(v Enum) { - C.glDepthFunc(C.GLenum(v)) + C.glDepthFunc(&f.f, C.GLenum(v)) } func (f *Functions) DepthMask(mask bool) { - m := C.GLboolean(C.GL_FALSE) + m := C.GLboolean(FALSE) if mask { - m = C.GLboolean(C.GL_TRUE) + m = C.GLboolean(TRUE) } - C.glDepthMask(m) + C.glDepthMask(&f.f, m) } func (f *Functions) DisableVertexAttribArray(a Attrib) { - C.glDisableVertexAttribArray(C.GLuint(a)) + C.glDisableVertexAttribArray(&f.f, C.GLuint(a)) } func (f *Functions) Disable(cap Enum) { - C.glDisable(C.GLenum(cap)) + C.glDisable(&f.f, C.GLenum(cap)) } func (f *Functions) DrawArrays(mode Enum, first int, count int) { - C.glDrawArrays(C.GLenum(mode), C.GLint(first), C.GLsizei(count)) + C.glDrawArrays(&f.f, C.GLenum(mode), C.GLint(first), C.GLsizei(count)) } func (f *Functions) DrawElements(mode Enum, count int, ty Enum, offset int) { - C.gio_glDrawElements(C.GLenum(mode), C.GLsizei(count), C.GLenum(ty), C.uintptr_t(offset)) + C.glDrawElements(&f.f, C.GLenum(mode), C.GLsizei(count), C.GLenum(ty), C.uintptr_t(offset)) } func (f *Functions) DispatchCompute(x, y, z int) { - C.gio_glDispatchCompute(C.GLuint(x), C.GLuint(y), C.GLuint(z)) + C.glDispatchCompute(&f.f, C.GLuint(x), C.GLuint(y), C.GLuint(z)) } func (f *Functions) Enable(cap Enum) { - C.glEnable(C.GLenum(cap)) + C.glEnable(&f.f, C.GLenum(cap)) } func (f *Functions) EndQuery(target Enum) { - C.gio_glEndQuery(C.GLenum(target)) + C.glEndQuery(&f.f, C.GLenum(target)) } func (f *Functions) EnableVertexAttribArray(a Attrib) { - C.glEnableVertexAttribArray(C.GLuint(a)) + C.glEnableVertexAttribArray(&f.f, C.GLuint(a)) } func (f *Functions) Finish() { - C.glFinish() + C.glFinish(&f.f) } func (f *Functions) FramebufferRenderbuffer(target, attachment, renderbuffertarget Enum, renderbuffer Renderbuffer) { - C.glFramebufferRenderbuffer(C.GLenum(target), C.GLenum(attachment), C.GLenum(renderbuffertarget), C.GLuint(renderbuffer.V)) + C.glFramebufferRenderbuffer(&f.f, 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.V), C.GLint(level)) + C.glFramebufferTexture2D(&f.f, C.GLenum(target), C.GLenum(attachment), C.GLenum(texTarget), C.GLuint(t.V), C.GLint(level)) } func (c *Functions) GetBinding(pname Enum) Object { @@ -423,21 +871,21 @@ func (c *Functions) GetBinding(pname Enum) Object { } func (f *Functions) GetError() Enum { - return Enum(C.glGetError()) + return Enum(C.glGetError(&f.f)) } func (f *Functions) GetRenderbufferParameteri(target, pname Enum) int { - C.glGetRenderbufferParameteriv(C.GLenum(target), C.GLenum(pname), &f.ints[0]) + C.glGetRenderbufferParameteriv(&f.f, C.GLenum(target), C.GLenum(pname), &f.ints[0]) return int(f.ints[0]) } func (f *Functions) GetFramebufferAttachmentParameteri(target, attachment, pname Enum) int { - C.glGetFramebufferAttachmentParameteriv(C.GLenum(target), C.GLenum(attachment), C.GLenum(pname), &f.ints[0]) + C.glGetFramebufferAttachmentParameteriv(&f.f, C.GLenum(target), C.GLenum(attachment), C.GLenum(pname), &f.ints[0]) return int(f.ints[0]) } func (f *Functions) GetInteger4(pname Enum) [4]int { - C.glGetIntegerv(C.GLenum(pname), &f.ints[0]) + C.glGetIntegerv(&f.f, C.GLenum(pname), &f.ints[0]) var r [4]int for i := range r { r[i] = int(f.ints[i]) @@ -446,12 +894,12 @@ func (f *Functions) GetInteger4(pname Enum) [4]int { } func (f *Functions) GetInteger(pname Enum) int { - C.glGetIntegerv(C.GLenum(pname), &f.ints[0]) + C.glGetIntegerv(&f.f, C.GLenum(pname), &f.ints[0]) return int(f.ints[0]) } func (f *Functions) GetProgrami(p Program, pname Enum) int { - C.glGetProgramiv(C.GLuint(p.V), C.GLenum(pname), &f.ints[0]) + C.glGetProgramiv(&f.f, C.GLuint(p.V), C.GLenum(pname), &f.ints[0]) return int(f.ints[0]) } @@ -462,36 +910,36 @@ func (f *Functions) GetProgramBinary(p Program) []byte { } buf := make([]byte, sz) var format C.GLenum - C.gio_glGetProgramBinary(C.GLuint(p.V), C.GLsizei(sz), nil, &format, unsafe.Pointer(&buf[0])) + C.glGetProgramBinary(&f.f, C.GLuint(p.V), C.GLsizei(sz), nil, &format, unsafe.Pointer(&buf[0])) return buf } func (f *Functions) GetProgramInfoLog(p Program) string { n := f.GetProgrami(p, INFO_LOG_LENGTH) buf := make([]byte, n) - C.glGetProgramInfoLog(C.GLuint(p.V), C.GLsizei(len(buf)), nil, (*C.GLchar)(unsafe.Pointer(&buf[0]))) + C.glGetProgramInfoLog(&f.f, 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 { - C.gio_glGetQueryObjectuiv(C.GLuint(query.V), C.GLenum(pname), &f.uints[0]) + C.glGetQueryObjectuiv(&f.f, C.GLuint(query.V), C.GLenum(pname), &f.uints[0]) return uint(f.uints[0]) } func (f *Functions) GetShaderi(s Shader, pname Enum) int { - C.glGetShaderiv(C.GLuint(s.V), C.GLenum(pname), &f.ints[0]) + C.glGetShaderiv(&f.f, C.GLuint(s.V), C.GLenum(pname), &f.ints[0]) return int(f.ints[0]) } func (f *Functions) GetShaderInfoLog(s Shader) string { n := f.GetShaderi(s, INFO_LOG_LENGTH) buf := make([]byte, n) - C.glGetShaderInfoLog(C.GLuint(s.V), C.GLsizei(len(buf)), nil, (*C.GLchar)(unsafe.Pointer(&buf[0]))) + C.glGetShaderInfoLog(&f.f, 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 { - str := C.gio_glGetStringi(C.GLenum(pname), C.GLuint(index)) + str := C.glGetStringi(&f.f, C.GLenum(pname), C.GLuint(index)) if str == nil { return "" } @@ -511,7 +959,7 @@ func (f *Functions) GetString(pname Enum) string { } return strings.Join(exts, " ") default: - str := C.glGetString(C.GLenum(pname)) + str := C.glGetString(&f.f, C.GLenum(pname)) return C.GoString((*C.char)(unsafe.Pointer(str))) } } @@ -519,33 +967,33 @@ func (f *Functions) GetString(pname Enum) string { func (f *Functions) GetUniformBlockIndex(p Program, name string) uint { cname := C.CString(name) defer C.free(unsafe.Pointer(cname)) - return uint(C.gio_glGetUniformBlockIndex(C.GLuint(p.V), cname)) + return uint(C.glGetUniformBlockIndex(&f.f, C.GLuint(p.V), cname)) } func (f *Functions) GetUniformLocation(p Program, name string) Uniform { cname := C.CString(name) defer C.free(unsafe.Pointer(cname)) - return Uniform{int(C.glGetUniformLocation(C.GLuint(p.V), cname))} + return Uniform{int(C.glGetUniformLocation(&f.f, C.GLuint(p.V), cname))} } func (f *Functions) InvalidateFramebuffer(target, attachment Enum) { - C.gio_glInvalidateFramebuffer(C.GLenum(target), C.GLenum(attachment)) + C.glInvalidateFramebuffer(&f.f, C.GLenum(target), C.GLenum(attachment)) } func (f *Functions) LinkProgram(p Program) { - C.glLinkProgram(C.GLuint(p.V)) + C.glLinkProgram(&f.f, C.GLuint(p.V)) } func (f *Functions) PixelStorei(pname Enum, param int32) { - C.glPixelStorei(C.GLenum(pname), C.GLint(param)) + C.glPixelStorei(&f.f, C.GLenum(pname), C.GLint(param)) } func (f *Functions) MemoryBarrier(barriers Enum) { - C.gio_glMemoryBarrier(C.GLbitfield(barriers)) + C.glMemoryBarrier(&f.f, C.GLbitfield(barriers)) } func (f *Functions) MapBufferRange(target Enum, offset, length int, access Enum) []byte { - p := C.gio_glMapBufferRange(C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(length), C.GLbitfield(access)) + p := C.glMapBufferRange(&f.f, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(length), C.GLbitfield(access)) if p == nil { return nil } @@ -553,7 +1001,7 @@ func (f *Functions) MapBufferRange(target Enum, offset, length int, access Enum) } func (f *Functions) Scissor(x, y, width, height int32) { - C.glScissor(C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) + C.glScissor(&f.f, 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) { @@ -561,26 +1009,26 @@ func (f *Functions) ReadPixels(x, y, width, height int, format, ty Enum, data [] if len(data) > 0 { p = unsafe.Pointer(&data[0]) } - C.glReadPixels(C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(ty), p) + C.glReadPixels(&f.f, 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) { - C.glRenderbufferStorage(C.GLenum(target), C.GLenum(internalformat), C.GLsizei(width), C.GLsizei(height)) + C.glRenderbufferStorage(&f.f, C.GLenum(target), C.GLenum(internalformat), C.GLsizei(width), C.GLsizei(height)) } 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.V), 1, &csrc, &strlen) + C.glShaderSource(&f.f, C.GLuint(s.V), 1, &csrc, &strlen) } func (f *Functions) TexImage2D(target Enum, level int, internalFormat Enum, width int, height int, format Enum, ty Enum) { - C.glTexImage2D(C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), 0, C.GLenum(format), C.GLenum(ty), nil) + C.glTexImage2D(&f.f, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), 0, C.GLenum(format), C.GLenum(ty), nil) } func (f *Functions) TexStorage2D(target Enum, levels int, internalFormat Enum, width, height int) { - C.gio_glTexStorage2D(C.GLenum(target), C.GLsizei(levels), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) + C.glTexStorage2D(&f.f, C.GLenum(target), C.GLsizei(levels), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) } func (f *Functions) TexSubImage2D(target Enum, level int, x int, y int, width int, height int, format Enum, ty Enum, data []byte) { @@ -588,54 +1036,54 @@ func (f *Functions) TexSubImage2D(target Enum, level int, x int, y int, width in if len(data) > 0 { p = unsafe.Pointer(&data[0]) } - 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) + C.glTexSubImage2D(&f.f, 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) { - C.glTexParameteri(C.GLenum(target), C.GLenum(pname), C.GLint(param)) + C.glTexParameteri(&f.f, C.GLenum(target), C.GLenum(pname), C.GLint(param)) } func (f *Functions) UniformBlockBinding(p Program, uniformBlockIndex uint, uniformBlockBinding uint) { - C.gio_glUniformBlockBinding(C.GLuint(p.V), C.GLuint(uniformBlockIndex), C.GLuint(uniformBlockBinding)) + C.glUniformBlockBinding(&f.f, C.GLuint(p.V), C.GLuint(uniformBlockIndex), C.GLuint(uniformBlockBinding)) } func (f *Functions) Uniform1f(dst Uniform, v float32) { - C.glUniform1f(C.GLint(dst.V), C.GLfloat(v)) + C.glUniform1f(&f.f, C.GLint(dst.V), C.GLfloat(v)) } func (f *Functions) Uniform1i(dst Uniform, v int) { - C.glUniform1i(C.GLint(dst.V), C.GLint(v)) + C.glUniform1i(&f.f, C.GLint(dst.V), C.GLint(v)) } func (f *Functions) Uniform2f(dst Uniform, v0 float32, v1 float32) { - C.glUniform2f(C.GLint(dst.V), C.GLfloat(v0), C.GLfloat(v1)) + C.glUniform2f(&f.f, 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.V), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) + C.glUniform3f(&f.f, 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.V), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) + C.glUniform4f(&f.f, 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.V)) + C.glUseProgram(&f.f, C.GLuint(p.V)) } func (f *Functions) UnmapBuffer(target Enum) bool { - r := C.gio_glUnmapBuffer(C.GLenum(target)) - return r == C.GL_TRUE + r := C.glUnmapBuffer(&f.f, C.GLenum(target)) + return r == TRUE } func (f *Functions) VertexAttribPointer(dst Attrib, size int, ty Enum, normalized bool, stride int, offset int) { - var n C.GLboolean = C.GL_FALSE + var n C.GLboolean = FALSE if normalized { - n = C.GL_TRUE + n = TRUE } - C.gio_glVertexAttribPointer(C.GLuint(dst), C.GLint(size), C.GLenum(ty), n, C.GLsizei(stride), C.uintptr_t(offset)) + C.glVertexAttribPointer(&f.f, C.GLuint(dst), C.GLint(size), C.GLenum(ty), n, C.GLsizei(stride), C.uintptr_t(offset)) } func (f *Functions) Viewport(x int, y int, width int, height int) { - C.glViewport(C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) + C.glViewport(&f.f, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) } diff --git a/internal/gl/gl_windows.go b/internal/gl/gl_windows.go index 68004696..0239b75a 100644 --- a/internal/gl/gl_windows.go +++ b/internal/gl/gl_windows.go @@ -98,7 +98,7 @@ type Functions struct { type Context interface{} -func NewFunctions(ctx Context) (*Functions, error) { +func NewFunctions(ctx Context, forceES bool) (*Functions, error) { if ctx != nil { panic("non-nil context") }