From dab796808acab7948946ae45891686e5f3b4ad95 Mon Sep 17 00:00:00 2001 From: Elias Naur Date: Mon, 27 Jun 2022 11:08:19 +0200 Subject: [PATCH] internal/gl: avoid excessive Cgo pointer checks As suggested by Egon Elbre, passing a large struct of function pointers forces Cgo checks on all of the pointer on every Cgo call. This change instead passes only the relevant function pointer. Signed-off-by: Elias Naur --- internal/gl/gl_unix.go | 1068 ++++++++++++++++++++++------------------ 1 file changed, 579 insertions(+), 489 deletions(-) diff --git a/internal/gl/gl_unix.go b/internal/gl/gl_unix.go index f223ced5..a746ee92 100644 --- a/internal/gl/gl_unix.go +++ b/internal/gl/gl_unix.go @@ -34,486 +34,483 @@ typedef unsigned char GLboolean; typedef int GLsizei; typedef uint8_t GLubyte; -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 (*glBlendFuncSeparate)(GLenum srcRGB, GLenum dstRGB, GLenum srcA, GLenum dstA); - 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); - void (*glCopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); - 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 (*glFlush)(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 (*glGetFloatv)(GLenum pname, GLfloat *data); - void (*glGetIntegerv)(GLenum pname, GLint *data); - void (*glGetIntegeri_v)(GLenum pname, GLuint idx, 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 (*glGetVertexAttribiv)(GLuint index, GLenum pname, GLint *params); - void (*glGetVertexAttribPointerv)(GLuint index, GLenum pname, void **params); - GLboolean (*glIsEnabled)(GLenum cap); - 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); +typedef void (*_glActiveTexture)(GLenum texture); +typedef void (*_glAttachShader)(GLuint program, GLuint shader); +typedef void (*_glBindAttribLocation)(GLuint program, GLuint index, const GLchar *name); +typedef void (*_glBindBuffer)(GLenum target, GLuint buffer); +typedef void (*_glBindFramebuffer)(GLenum target, GLuint framebuffer); +typedef void (*_glBindRenderbuffer)(GLenum target, GLuint renderbuffer); +typedef void (*_glBindTexture)(GLenum target, GLuint texture); +typedef void (*_glBlendEquation)(GLenum mode); +typedef void (*_glBlendFuncSeparate)(GLenum srcRGB, GLenum dstRGB, GLenum srcA, GLenum dstA); +typedef void (*_glBufferData)(GLenum target, GLsizeiptr size, const void *data, GLenum usage); +typedef void (*_glBufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, const void *data); +typedef GLenum (*_glCheckFramebufferStatus)(GLenum target); +typedef void (*_glClear)(GLbitfield mask); +typedef void (*_glClearColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +typedef void (*_glClearDepthf)(GLfloat d); +typedef void (*_glCompileShader)(GLuint shader); +typedef void (*_glCopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +typedef GLuint (*_glCreateProgram)(void); +typedef GLuint (*_glCreateShader)(GLenum type); +typedef void (*_glDeleteBuffers)(GLsizei n, const GLuint *buffers); +typedef void (*_glDeleteFramebuffers)(GLsizei n, const GLuint *framebuffers); +typedef void (*_glDeleteProgram)(GLuint program); +typedef void (*_glDeleteRenderbuffers)(GLsizei n, const GLuint *renderbuffers); +typedef void (*_glDeleteShader)(GLuint shader); +typedef void (*_glDeleteTextures)(GLsizei n, const GLuint *textures); +typedef void (*_glDepthFunc)(GLenum func); +typedef void (*_glDepthMask)(GLboolean flag); +typedef void (*_glDisable)(GLenum cap); +typedef void (*_glDisableVertexAttribArray)(GLuint index); +typedef void (*_glDrawArrays)(GLenum mode, GLint first, GLsizei count); +typedef void (*_glDrawElements)(GLenum mode, GLsizei count, GLenum type, const void *indices); +typedef void (*_glEnable)(GLenum cap); +typedef void (*_glEnableVertexAttribArray)(GLuint index); +typedef void (*_glFinish)(void); +typedef void (*_glFlush)(void); +typedef void (*_glFramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +typedef void (*_glFramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +typedef void (*_glGenBuffers)(GLsizei n, GLuint *buffers); +typedef void (*_glGenFramebuffers)(GLsizei n, GLuint *framebuffers); +typedef void (*_glGenRenderbuffers)(GLsizei n, GLuint *renderbuffers); +typedef void (*_glGenTextures)(GLsizei n, GLuint *textures); +typedef GLenum (*_glGetError)(void); +typedef void (*_glGetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint *params); +typedef void (*_glGetFloatv)(GLenum pname, GLfloat *data); +typedef void (*_glGetIntegerv)(GLenum pname, GLint *data); +typedef void (*_glGetIntegeri_v)(GLenum pname, GLuint idx, GLint *data); +typedef void (*_glGetProgramiv)(GLuint program, GLenum pname, GLint *params); +typedef void (*_glGetProgramInfoLog)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +typedef void (*_glGetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint *params); +typedef void (*_glGetShaderiv)(GLuint shader, GLenum pname, GLint *params); +typedef void (*_glGetShaderInfoLog)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +typedef const GLubyte *(*_glGetString)(GLenum name); +typedef GLint (*_glGetUniformLocation)(GLuint program, const GLchar *name); +typedef void (*_glGetVertexAttribiv)(GLuint index, GLenum pname, GLint *params); +typedef void (*_glGetVertexAttribPointerv)(GLuint index, GLenum pname, void **params); +typedef GLboolean (*_glIsEnabled)(GLenum cap); +typedef void (*_glLinkProgram)(GLuint program); +typedef void (*_glPixelStorei)(GLenum pname, GLint param); +typedef void (*_glReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels); +typedef void (*_glRenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (*_glScissor)(GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (*_glShaderSource)(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length); +typedef void (*_glTexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels); +typedef void (*_glTexParameteri)(GLenum target, GLenum pname, GLint param); +typedef void (*_glTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); +typedef void (*_glUniform1f)(GLint location, GLfloat v0); +typedef void (*_glUniform1i)(GLint location, GLint v0); +typedef void (*_glUniform2f)(GLint location, GLfloat v0, GLfloat v1); +typedef void (*_glUniform3f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +typedef void (*_glUniform4f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +typedef void (*_glUseProgram)(GLuint program); +typedef void (*_glVertexAttribPointer)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer); +typedef void (*_glViewport)(GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (*_glBindVertexArray)(GLuint array); +typedef void (*_glBindBufferBase)(GLenum target, GLuint index, GLuint buffer); +typedef GLuint (*_glGetUniformBlockIndex)(GLuint program, const GLchar *uniformBlockName); +typedef void (*_glUniformBlockBinding)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); +typedef void (*_glInvalidateFramebuffer)(GLenum target, GLsizei numAttachments, const GLenum *attachments); +typedef void (*_glBeginQuery)(GLenum target, GLuint id); +typedef void (*_glDeleteQueries)(GLsizei n, const GLuint *ids); +typedef void (*_glDeleteVertexArrays)(GLsizei n, const GLuint *ids); +typedef void (*_glEndQuery)(GLenum target); +typedef void (*_glGenQueries)(GLsizei n, GLuint *ids); +typedef void (*_glGenVertexArrays)(GLsizei n, GLuint *ids); +typedef void (*_glGetProgramBinary)(GLuint program, GLsizei bufsize, GLsizei *length, GLenum *binaryFormat, void *binary); +typedef void (*_glGetQueryObjectuiv)(GLuint id, GLenum pname, GLuint *params); +typedef const GLubyte* (*_glGetStringi)(GLenum name, GLuint index); +typedef void (*_glDispatchCompute)(GLuint x, GLuint y, GLuint z); +typedef void (*_glMemoryBarrier)(GLbitfield barriers); +typedef void* (*_glMapBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); +typedef GLboolean (*_glUnmapBuffer)(GLenum target); +typedef void (*_glBindImageTexture)(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format); +typedef void (*_glTexStorage2D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (*_glBlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); - void (*glBindVertexArray)(GLuint array); - 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); - void (*glBeginQuery)(GLenum target, GLuint id); - void (*glDeleteQueries)(GLsizei n, const GLuint *ids); - void (*glDeleteVertexArrays)(GLsizei n, const GLuint *ids); - void (*glEndQuery)(GLenum target); - void (*glGenQueries)(GLsizei n, GLuint *ids); - void (*glGenVertexArrays)(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); +static void glActiveTexture(_glActiveTexture f, GLenum texture) { + f(texture); } -static void glAttachShader(glFunctions *f, GLuint program, GLuint shader) { - f->glAttachShader(program, shader); +static void glAttachShader(_glAttachShader f, GLuint program, GLuint shader) { + f(program, shader); } -static void glBindAttribLocation(glFunctions *f, GLuint program, GLuint index, const GLchar *name) { - f->glBindAttribLocation(program, index, name); +static void glBindAttribLocation(_glBindAttribLocation f, GLuint program, GLuint index, const GLchar *name) { + f(program, index, name); } -static void glBindBuffer(glFunctions *f, GLenum target, GLuint buffer) { - f->glBindBuffer(target, buffer); +static void glBindBuffer(_glBindBuffer f, GLenum target, GLuint buffer) { + f(target, buffer); } -static void glBindFramebuffer(glFunctions *f, GLenum target, GLuint framebuffer) { - f->glBindFramebuffer(target, framebuffer); +static void glBindFramebuffer(_glBindFramebuffer f, GLenum target, GLuint framebuffer) { + f(target, framebuffer); } -static void glBindRenderbuffer(glFunctions *f, GLenum target, GLuint renderbuffer) { - f->glBindRenderbuffer(target, renderbuffer); +static void glBindRenderbuffer(_glBindRenderbuffer f, GLenum target, GLuint renderbuffer) { + f(target, renderbuffer); } -static void glBindTexture(glFunctions *f, GLenum target, GLuint texture) { - f->glBindTexture(target, texture); +static void glBindTexture(_glBindTexture f, GLenum target, GLuint texture) { + f(target, texture); } -static void glBindVertexArray(glFunctions *f, GLuint array) { - f->glBindVertexArray(array); +static void glBindVertexArray(_glBindVertexArray f, GLuint array) { + f(array); } -static void glBlendEquation(glFunctions *f, GLenum mode) { - f->glBlendEquation(mode); +static void glBlendEquation(_glBlendEquation f, GLenum mode) { + f(mode); } -static void glBlendFuncSeparate(glFunctions *f, GLenum srcRGB, GLenum dstRGB, GLenum srcA, GLenum dstA) { - f->glBlendFuncSeparate(srcRGB, dstRGB, srcA, dstA); +static void glBlendFuncSeparate(_glBlendFuncSeparate f, GLenum srcRGB, GLenum dstRGB, GLenum srcA, GLenum dstA) { + f(srcRGB, dstRGB, srcA, dstA); } -static void glBufferData(glFunctions *f, GLenum target, GLsizeiptr size, const void *data, GLenum usage) { - f->glBufferData(target, size, data, usage); +static void glBufferData(_glBufferData f, GLenum target, GLsizeiptr size, const void *data, GLenum usage) { + f(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 void glBufferSubData(_glBufferSubData f, GLenum target, GLintptr offset, GLsizeiptr size, const void *data) { + f(target, offset, size, data); } -static GLenum glCheckFramebufferStatus(glFunctions *f, GLenum target) { - return f->glCheckFramebufferStatus(target); +static GLenum glCheckFramebufferStatus(_glCheckFramebufferStatus f, GLenum target) { + return f(target); } -static void glClear(glFunctions *f, GLbitfield mask) { - f->glClear(mask); +static void glClear(_glClear f, GLbitfield mask) { + f(mask); } -static void glClearColor(glFunctions *f, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { - f->glClearColor(red, green, blue, alpha); +static void glClearColor(_glClearColor f, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { + f(red, green, blue, alpha); } -static void glClearDepthf(glFunctions *f, GLfloat d) { - f->glClearDepthf(d); +static void glClearDepthf(_glClearDepthf f, GLfloat d) { + f(d); } -static void glCompileShader(glFunctions *f, GLuint shader) { - f->glCompileShader(shader); +static void glCompileShader(_glCompileShader f, GLuint shader) { + f(shader); } -static void glCopyTexSubImage2D(glFunctions *f, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { - f->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +static void glCopyTexSubImage2D(_glCopyTexSubImage2D f, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { + f(target, level, xoffset, yoffset, x, y, width, height); } -static GLuint glCreateProgram(glFunctions *f) { - return f->glCreateProgram(); +static GLuint glCreateProgram(_glCreateProgram f) { + return f(); } -static GLuint glCreateShader(glFunctions *f, GLenum type) { - return f->glCreateShader(type); +static GLuint glCreateShader(_glCreateShader f, GLenum type) { + return f(type); } -static void glDeleteBuffers(glFunctions *f, GLsizei n, const GLuint *buffers) { - f->glDeleteBuffers(n, buffers); +static void glDeleteBuffers(_glDeleteBuffers f, GLsizei n, const GLuint *buffers) { + f(n, buffers); } -static void glDeleteFramebuffers(glFunctions *f, GLsizei n, const GLuint *framebuffers) { - f->glDeleteFramebuffers(n, framebuffers); +static void glDeleteFramebuffers(_glDeleteFramebuffers f, GLsizei n, const GLuint *framebuffers) { + f(n, framebuffers); } -static void glDeleteProgram(glFunctions *f, GLuint program) { - f->glDeleteProgram(program); +static void glDeleteProgram(_glDeleteProgram f, GLuint program) { + f(program); } -static void glDeleteRenderbuffers(glFunctions *f, GLsizei n, const GLuint *renderbuffers) { - f->glDeleteRenderbuffers(n, renderbuffers); +static void glDeleteRenderbuffers(_glDeleteRenderbuffers f, GLsizei n, const GLuint *renderbuffers) { + f(n, renderbuffers); } -static void glDeleteShader(glFunctions *f, GLuint shader) { - f->glDeleteShader(shader); +static void glDeleteShader(_glDeleteShader f, GLuint shader) { + f(shader); } -static void glDeleteTextures(glFunctions *f, GLsizei n, const GLuint *textures) { - f->glDeleteTextures(n, textures); +static void glDeleteTextures(_glDeleteTextures f, GLsizei n, const GLuint *textures) { + f(n, textures); } -static void glDepthFunc(glFunctions *f, GLenum func) { - f->glDepthFunc(func); +static void glDepthFunc(_glDepthFunc f, GLenum func) { + f(func); } -static void glDepthMask(glFunctions *f, GLboolean flag) { - f->glDepthMask(flag); +static void glDepthMask(_glDepthMask f, GLboolean flag) { + f(flag); } -static void glDisable(glFunctions *f, GLenum cap) { - f->glDisable(cap); +static void glDisable(_glDisable f, GLenum cap) { + f(cap); } -static void glDisableVertexAttribArray(glFunctions *f, GLuint index) { - f->glDisableVertexAttribArray(index); +static void glDisableVertexAttribArray(_glDisableVertexAttribArray f, GLuint index) { + f(index); } -static void glDrawArrays(glFunctions *f, GLenum mode, GLint first, GLsizei count) { - f->glDrawArrays(mode, first, count); +static void glDrawArrays(_glDrawArrays f, GLenum mode, GLint first, GLsizei count) { + f(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 glDrawElements(_glDrawElements f, GLenum mode, GLsizei count, GLenum type, const uintptr_t offset) { + f(mode, count, type, (const void *)offset); } -static void glEnable(glFunctions *f, GLenum cap) { - f->glEnable(cap); +static void glEnable(_glEnable f, GLenum cap) { + f(cap); } -static void glEnableVertexAttribArray(glFunctions *f, GLuint index) { - f->glEnableVertexAttribArray(index); +static void glEnableVertexAttribArray(_glEnableVertexAttribArray f, GLuint index) { + f(index); } -static void glFinish(glFunctions *f) { - f->glFinish(); +static void glFinish(_glFinish f) { + f(); } -static void glFlush(glFunctions *f) { - f->glFlush(); +static void glFlush(_glFlush f) { + f(); } -static void glFramebufferRenderbuffer(glFunctions *f, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) { - f->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); +static void glFramebufferRenderbuffer(_glFramebufferRenderbuffer f, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) { + f(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 glFramebufferTexture2D(_glFramebufferTexture2D f, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { + f(target, attachment, textarget, texture, level); } -static void glGenBuffers(glFunctions *f, GLsizei n, GLuint *buffers) { - f->glGenBuffers(n, buffers); +static void glGenBuffers(_glGenBuffers f, GLsizei n, GLuint *buffers) { + f(n, buffers); } -static void glGenFramebuffers(glFunctions *f, GLsizei n, GLuint *framebuffers) { - f->glGenFramebuffers(n, framebuffers); +static void glGenFramebuffers(_glGenFramebuffers f, GLsizei n, GLuint *framebuffers) { + f(n, framebuffers); } -static void glGenRenderbuffers(glFunctions *f, GLsizei n, GLuint *renderbuffers) { - f->glGenRenderbuffers(n, renderbuffers); +static void glGenRenderbuffers(_glGenRenderbuffers f, GLsizei n, GLuint *renderbuffers) { + f(n, renderbuffers); } -static void glGenTextures(glFunctions *f, GLsizei n, GLuint *textures) { - f->glGenTextures(n, textures); +static void glGenTextures(_glGenTextures f, GLsizei n, GLuint *textures) { + f(n, textures); } -static GLenum glGetError(glFunctions *f) { - return f->glGetError(); +static GLenum glGetError(_glGetError f) { + return f(); } -static void glGetFramebufferAttachmentParameteriv(glFunctions *f, GLenum target, GLenum attachment, GLenum pname, GLint *params) { - f->glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); +static void glGetFramebufferAttachmentParameteriv(_glGetFramebufferAttachmentParameteriv f, GLenum target, GLenum attachment, GLenum pname, GLint *params) { + f(target, attachment, pname, params); } -static void glGetIntegerv(glFunctions *f, GLenum pname, GLint *data) { - f->glGetIntegerv(pname, data); +static void glGetIntegerv(_glGetIntegerv f, GLenum pname, GLint *data) { + f(pname, data); } -static void glGetFloatv(glFunctions *f, GLenum pname, GLfloat *data) { - f->glGetFloatv(pname, data); +static void glGetFloatv(_glGetFloatv f, GLenum pname, GLfloat *data) { + f(pname, data); } -static void glGetIntegeri_v(glFunctions *f, GLenum pname, GLuint idx, GLint *data) { - f->glGetIntegeri_v(pname, idx, data); +static void glGetIntegeri_v(_glGetIntegeri_v f, GLenum pname, GLuint idx, GLint *data) { + f(pname, idx, data); } -static void glGetProgramiv(glFunctions *f, GLuint program, GLenum pname, GLint *params) { - f->glGetProgramiv(program, pname, params); +static void glGetProgramiv(_glGetProgramiv f, GLuint program, GLenum pname, GLint *params) { + f(program, pname, params); } -static void glGetProgramInfoLog(glFunctions *f, GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog) { - f->glGetProgramInfoLog(program, bufSize, length, infoLog); +static void glGetProgramInfoLog(_glGetProgramInfoLog f, GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog) { + f(program, bufSize, length, infoLog); } -static void glGetRenderbufferParameteriv(glFunctions *f, GLenum target, GLenum pname, GLint *params) { - f->glGetRenderbufferParameteriv(target, pname, params); +static void glGetRenderbufferParameteriv(_glGetRenderbufferParameteriv f, GLenum target, GLenum pname, GLint *params) { + f(target, pname, params); } -static void glGetShaderiv(glFunctions *f, GLuint shader, GLenum pname, GLint *params) { - f->glGetShaderiv(shader, pname, params); +static void glGetShaderiv(_glGetShaderiv f, GLuint shader, GLenum pname, GLint *params) { + f(shader, pname, params); } -static void glGetShaderInfoLog(glFunctions *f, GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog) { - f->glGetShaderInfoLog(shader, bufSize, length, infoLog); +static void glGetShaderInfoLog(_glGetShaderInfoLog f, GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog) { + f(shader, bufSize, length, infoLog); } -static const GLubyte *glGetString(glFunctions *f, GLenum name) { - return f->glGetString(name); +static const GLubyte *glGetString(_glGetString f, GLenum name) { + return f(name); } -static GLint glGetUniformLocation(glFunctions *f, GLuint program, const GLchar *name) { - return f->glGetUniformLocation(program, name); +static GLint glGetUniformLocation(_glGetUniformLocation f, GLuint program, const GLchar *name) { + return f(program, name); } -static void glGetVertexAttribiv(glFunctions *f, GLuint index, GLenum pname, GLint *data) { - f->glGetVertexAttribiv(index, pname, data); +static void glGetVertexAttribiv(_glGetVertexAttribiv f, GLuint index, GLenum pname, GLint *data) { + f(index, pname, data); } // Return uintptr_t to avoid Cgo pointer check. -static uintptr_t glGetVertexAttribPointerv(glFunctions *f, GLuint index, GLenum pname) { +static uintptr_t glGetVertexAttribPointerv(_glGetVertexAttribPointerv f, GLuint index, GLenum pname) { void *ptrs; - f->glGetVertexAttribPointerv(index, pname, &ptrs); + f(index, pname, &ptrs); return (uintptr_t)ptrs; } -static GLboolean glIsEnabled(glFunctions *f, GLenum cap) { - return f->glIsEnabled(cap); +static GLboolean glIsEnabled(_glIsEnabled f, GLenum cap) { + return f(cap); } -static void glLinkProgram(glFunctions *f, GLuint program) { - f->glLinkProgram(program); +static void glLinkProgram(_glLinkProgram f, GLuint program) { + f(program); } -static void glPixelStorei(glFunctions *f, GLenum pname, GLint param) { - f->glPixelStorei(pname, param); +static void glPixelStorei(_glPixelStorei f, GLenum pname, GLint param) { + f(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 glReadPixels(_glReadPixels f, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels) { + f(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 glRenderbufferStorage(_glRenderbufferStorage f, GLenum target, GLenum internalformat, GLsizei width, GLsizei height) { + f(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 glScissor(_glScissor f, GLint x, GLint y, GLsizei width, GLsizei height) { + f(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 glShaderSource(_glShaderSource f, GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length) { + f(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 glTexImage2D(_glTexImage2D f, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels) { + f(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 glTexParameteri(_glTexParameteri f, GLenum target, GLenum pname, GLint param) { + f(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 glTexSubImage2D(_glTexSubImage2D f, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) { + f(target, level, xoffset, yoffset, width, height, format, type, pixels); } -static void glUniform1f(glFunctions *f, GLint location, GLfloat v0) { - f->glUniform1f(location, v0); +static void glUniform1f(_glUniform1f f, GLint location, GLfloat v0) { + f(location, v0); } -static void glUniform1i(glFunctions *f, GLint location, GLint v0) { - f->glUniform1i(location, v0); +static void glUniform1i(_glUniform1i f, GLint location, GLint v0) { + f(location, v0); } -static void glUniform2f(glFunctions *f, GLint location, GLfloat v0, GLfloat v1) { - f->glUniform2f(location, v0, v1); +static void glUniform2f(_glUniform2f f, GLint location, GLfloat v0, GLfloat v1) { + f(location, v0, v1); } -static void glUniform3f(glFunctions *f, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) { - f->glUniform3f(location, v0, v1, v2); +static void glUniform3f(_glUniform3f f, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) { + f(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 glUniform4f(_glUniform4f f, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) { + f(location, v0, v1, v2, v3); } -static void glUseProgram(glFunctions *f, GLuint program) { - f->glUseProgram(program); +static void glUseProgram(_glUseProgram f, GLuint program) { + f(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 glVertexAttribPointer(_glVertexAttribPointer f, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, uintptr_t offset) { + f(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 glViewport(_glViewport f, GLint x, GLint y, GLsizei width, GLsizei height) { + f(x, y, width, height); } -static void glBindBufferBase(glFunctions *f, GLenum target, GLuint index, GLuint buffer) { - f->glBindBufferBase(target, index, buffer); +static void glBindBufferBase(_glBindBufferBase f, GLenum target, GLuint index, GLuint buffer) { + f(target, index, buffer); } -static void glUniformBlockBinding(glFunctions *f, GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) { - f->glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding); +static void glUniformBlockBinding(_glUniformBlockBinding f, GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) { + f(program, uniformBlockIndex, uniformBlockBinding); } -static GLuint glGetUniformBlockIndex(glFunctions *f, GLuint program, const GLchar *uniformBlockName) { - return f->glGetUniformBlockIndex(program, uniformBlockName); +static GLuint glGetUniformBlockIndex(_glGetUniformBlockIndex f, GLuint program, const GLchar *uniformBlockName) { + return f(program, uniformBlockName); } -static void glInvalidateFramebuffer(glFunctions *f, GLenum target, GLenum attachment) { +static void glInvalidateFramebuffer(_glInvalidateFramebuffer f, GLenum target, GLenum attachment) { // Framebuffer invalidation is just a hint and can safely be ignored. - if (f->glInvalidateFramebuffer != NULL) { - f->glInvalidateFramebuffer(target, 1, &attachment); + if (f != NULL) { + f(target, 1, &attachment); } } -static void glBeginQuery(glFunctions *f, GLenum target, GLenum attachment) { - f->glBeginQuery(target, attachment); +static void glBeginQuery(_glBeginQuery f, GLenum target, GLenum attachment) { + f(target, attachment); } -static void glDeleteQueries(glFunctions *f, GLsizei n, const GLuint *ids) { - f->glDeleteQueries(n, ids); +static void glDeleteQueries(_glDeleteQueries f, GLsizei n, const GLuint *ids) { + f(n, ids); } -static void glDeleteVertexArrays(glFunctions *f, GLsizei n, const GLuint *ids) { - f->glDeleteVertexArrays(n, ids); +static void glDeleteVertexArrays(_glDeleteVertexArrays f, GLsizei n, const GLuint *ids) { + f(n, ids); } -static void glEndQuery(glFunctions *f, GLenum target) { - f->glEndQuery(target); +static void glEndQuery(_glEndQuery f, GLenum target) { + f(target); } -static const GLubyte* glGetStringi(glFunctions *f, GLenum name, GLuint index) { - return f->glGetStringi(name, index); +static const GLubyte* glGetStringi(_glGetStringi f, GLenum name, GLuint index) { + return f(name, index); } -static void glGenQueries(glFunctions *f, GLsizei n, GLuint *ids) { - f->glGenQueries(n, ids); +static void glGenQueries(_glGenQueries f, GLsizei n, GLuint *ids) { + f(n, ids); } -static void glGenVertexArrays(glFunctions *f, GLsizei n, GLuint *ids) { - f->glGenVertexArrays(n, ids); +static void glGenVertexArrays(_glGenVertexArrays f, GLsizei n, GLuint *ids) { + f(n, ids); } -static void glGetProgramBinary(glFunctions *f, GLuint program, GLsizei bufsize, GLsizei *length, GLenum *binaryFormat, void *binary) { - f->glGetProgramBinary(program, bufsize, length, binaryFormat, binary); +static void glGetProgramBinary(_glGetProgramBinary f, GLuint program, GLsizei bufsize, GLsizei *length, GLenum *binaryFormat, void *binary) { + f(program, bufsize, length, binaryFormat, binary); } -static void glGetQueryObjectuiv(glFunctions *f, GLuint id, GLenum pname, GLuint *params) { - f->glGetQueryObjectuiv(id, pname, params); +static void glGetQueryObjectuiv(_glGetQueryObjectuiv f, GLuint id, GLenum pname, GLuint *params) { + f(id, pname, params); } -static void glMemoryBarrier(glFunctions *f, GLbitfield barriers) { - f->glMemoryBarrier(barriers); +static void glMemoryBarrier(_glMemoryBarrier f, GLbitfield barriers) { + f(barriers); } -static void glDispatchCompute(glFunctions *f, GLuint x, GLuint y, GLuint z) { - f->glDispatchCompute(x, y, z); +static void glDispatchCompute(_glDispatchCompute f, GLuint x, GLuint y, GLuint z) { + f(x, y, z); } -static void *glMapBufferRange(glFunctions *f, GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) { - return f->glMapBufferRange(target, offset, length, access); +static void *glMapBufferRange(_glMapBufferRange f, GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) { + return f(target, offset, length, access); } -static GLboolean glUnmapBuffer(glFunctions *f, GLenum target) { - return f->glUnmapBuffer(target); +static GLboolean glUnmapBuffer(_glUnmapBuffer f, GLenum target) { + return f(target); } -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 glBindImageTexture(_glBindImageTexture f, GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format) { + f(unit, texture, level, layered, layer, access, format); } -static void glTexStorage2D(glFunctions *f, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height) { - f->glTexStorage2D(target, levels, internalFormat, width, height); +static void glTexStorage2D(_glTexStorage2D f, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height) { + f(target, levels, internalFormat, width, height); } -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); +static void glBlitFramebuffer(_glBlitFramebuffer f, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) { + f(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); } */ import "C" @@ -526,7 +523,100 @@ type Functions struct { ints [100]C.GLint floats [100]C.GLfloat - f C.glFunctions + glActiveTexture C._glActiveTexture + glAttachShader C._glAttachShader + glBindAttribLocation C._glBindAttribLocation + glBindBuffer C._glBindBuffer + glBindFramebuffer C._glBindFramebuffer + glBindRenderbuffer C._glBindRenderbuffer + glBindTexture C._glBindTexture + glBlendEquation C._glBlendEquation + glBlendFuncSeparate C._glBlendFuncSeparate + glBufferData C._glBufferData + glBufferSubData C._glBufferSubData + glCheckFramebufferStatus C._glCheckFramebufferStatus + glClear C._glClear + glClearColor C._glClearColor + glClearDepthf C._glClearDepthf + glCompileShader C._glCompileShader + glCopyTexSubImage2D C._glCopyTexSubImage2D + glCreateProgram C._glCreateProgram + glCreateShader C._glCreateShader + glDeleteBuffers C._glDeleteBuffers + glDeleteFramebuffers C._glDeleteFramebuffers + glDeleteProgram C._glDeleteProgram + glDeleteRenderbuffers C._glDeleteRenderbuffers + glDeleteShader C._glDeleteShader + glDeleteTextures C._glDeleteTextures + glDepthFunc C._glDepthFunc + glDepthMask C._glDepthMask + glDisable C._glDisable + glDisableVertexAttribArray C._glDisableVertexAttribArray + glDrawArrays C._glDrawArrays + glDrawElements C._glDrawElements + glEnable C._glEnable + glEnableVertexAttribArray C._glEnableVertexAttribArray + glFinish C._glFinish + glFlush C._glFlush + glFramebufferRenderbuffer C._glFramebufferRenderbuffer + glFramebufferTexture2D C._glFramebufferTexture2D + glGenBuffers C._glGenBuffers + glGenFramebuffers C._glGenFramebuffers + glGenRenderbuffers C._glGenRenderbuffers + glGenTextures C._glGenTextures + glGetError C._glGetError + glGetFramebufferAttachmentParameteriv C._glGetFramebufferAttachmentParameteriv + glGetFloatv C._glGetFloatv + glGetIntegerv C._glGetIntegerv + glGetIntegeri_v C._glGetIntegeri_v + glGetProgramiv C._glGetProgramiv + glGetProgramInfoLog C._glGetProgramInfoLog + glGetRenderbufferParameteriv C._glGetRenderbufferParameteriv + glGetShaderiv C._glGetShaderiv + glGetShaderInfoLog C._glGetShaderInfoLog + glGetString C._glGetString + glGetUniformLocation C._glGetUniformLocation + glGetVertexAttribiv C._glGetVertexAttribiv + glGetVertexAttribPointerv C._glGetVertexAttribPointerv + glIsEnabled C._glIsEnabled + glLinkProgram C._glLinkProgram + glPixelStorei C._glPixelStorei + glReadPixels C._glReadPixels + glRenderbufferStorage C._glRenderbufferStorage + glScissor C._glScissor + glShaderSource C._glShaderSource + glTexImage2D C._glTexImage2D + glTexParameteri C._glTexParameteri + glTexSubImage2D C._glTexSubImage2D + glUniform1f C._glUniform1f + glUniform1i C._glUniform1i + glUniform2f C._glUniform2f + glUniform3f C._glUniform3f + glUniform4f C._glUniform4f + glUseProgram C._glUseProgram + glVertexAttribPointer C._glVertexAttribPointer + glViewport C._glViewport + glBindVertexArray C._glBindVertexArray + glBindBufferBase C._glBindBufferBase + glGetUniformBlockIndex C._glGetUniformBlockIndex + glUniformBlockBinding C._glUniformBlockBinding + glInvalidateFramebuffer C._glInvalidateFramebuffer + glBeginQuery C._glBeginQuery + glDeleteQueries C._glDeleteQueries + glDeleteVertexArrays C._glDeleteVertexArrays + glEndQuery C._glEndQuery + glGenQueries C._glGenQueries + glGenVertexArrays C._glGenVertexArrays + glGetProgramBinary C._glGetProgramBinary + glGetQueryObjectuiv C._glGetQueryObjectuiv + glGetStringi C._glGetStringi + glDispatchCompute C._glDispatchCompute + glMemoryBarrier C._glMemoryBarrier + glMapBufferRange C._glMapBufferRange + glUnmapBuffer C._glUnmapBuffer + glBindImageTexture C._glBindImageTexture + glTexStorage2D C._glTexStorage2D + glBlitFramebuffer C._glBlitFramebuffer } func NewFunctions(ctx Context, forceES bool) (*Functions, error) { @@ -595,159 +685,159 @@ func (f *Functions) load(forceES bool) error { 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.glBlendFuncSeparate = must("glBlendFuncSeparate") - 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.glCopyTexSubImage2D = must("glCopyTexSubImage2D") - 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.glFlush = must("glFlush") - 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.glGetFloatv = must("glGetFloatv") - 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.glGetVertexAttribiv = must("glGetVertexAttribiv") - f.f.glGetVertexAttribPointerv = must("glGetVertexAttribPointerv") - f.f.glIsEnabled = must("glIsEnabled") - 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") + f.glActiveTexture = must("glActiveTexture") + f.glAttachShader = must("glAttachShader") + f.glBindAttribLocation = must("glBindAttribLocation") + f.glBindBuffer = must("glBindBuffer") + f.glBindFramebuffer = must("glBindFramebuffer") + f.glBindRenderbuffer = must("glBindRenderbuffer") + f.glBindTexture = must("glBindTexture") + f.glBlendEquation = must("glBlendEquation") + f.glBlendFuncSeparate = must("glBlendFuncSeparate") + f.glBufferData = must("glBufferData") + f.glBufferSubData = must("glBufferSubData") + f.glCheckFramebufferStatus = must("glCheckFramebufferStatus") + f.glClear = must("glClear") + f.glClearColor = must("glClearColor") + f.glClearDepthf = must("glClearDepthf") + f.glCompileShader = must("glCompileShader") + f.glCopyTexSubImage2D = must("glCopyTexSubImage2D") + f.glCreateProgram = must("glCreateProgram") + f.glCreateShader = must("glCreateShader") + f.glDeleteBuffers = must("glDeleteBuffers") + f.glDeleteFramebuffers = must("glDeleteFramebuffers") + f.glDeleteProgram = must("glDeleteProgram") + f.glDeleteRenderbuffers = must("glDeleteRenderbuffers") + f.glDeleteShader = must("glDeleteShader") + f.glDeleteTextures = must("glDeleteTextures") + f.glDepthFunc = must("glDepthFunc") + f.glDepthMask = must("glDepthMask") + f.glDisable = must("glDisable") + f.glDisableVertexAttribArray = must("glDisableVertexAttribArray") + f.glDrawArrays = must("glDrawArrays") + f.glDrawElements = must("glDrawElements") + f.glEnable = must("glEnable") + f.glEnableVertexAttribArray = must("glEnableVertexAttribArray") + f.glFinish = must("glFinish") + f.glFlush = must("glFlush") + f.glFramebufferRenderbuffer = must("glFramebufferRenderbuffer") + f.glFramebufferTexture2D = must("glFramebufferTexture2D") + f.glGenBuffers = must("glGenBuffers") + f.glGenFramebuffers = must("glGenFramebuffers") + f.glGenRenderbuffers = must("glGenRenderbuffers") + f.glGenTextures = must("glGenTextures") + f.glGetError = must("glGetError") + f.glGetFramebufferAttachmentParameteriv = must("glGetFramebufferAttachmentParameteriv") + f.glGetIntegerv = must("glGetIntegerv") + f.glGetFloatv = must("glGetFloatv") + f.glGetProgramiv = must("glGetProgramiv") + f.glGetProgramInfoLog = must("glGetProgramInfoLog") + f.glGetRenderbufferParameteriv = must("glGetRenderbufferParameteriv") + f.glGetShaderiv = must("glGetShaderiv") + f.glGetShaderInfoLog = must("glGetShaderInfoLog") + f.glGetString = must("glGetString") + f.glGetUniformLocation = must("glGetUniformLocation") + f.glGetVertexAttribiv = must("glGetVertexAttribiv") + f.glGetVertexAttribPointerv = must("glGetVertexAttribPointerv") + f.glIsEnabled = must("glIsEnabled") + f.glLinkProgram = must("glLinkProgram") + f.glPixelStorei = must("glPixelStorei") + f.glReadPixels = must("glReadPixels") + f.glRenderbufferStorage = must("glRenderbufferStorage") + f.glScissor = must("glScissor") + f.glShaderSource = must("glShaderSource") + f.glTexImage2D = must("glTexImage2D") + f.glTexParameteri = must("glTexParameteri") + f.glTexSubImage2D = must("glTexSubImage2D") + f.glUniform1f = must("glUniform1f") + f.glUniform1i = must("glUniform1i") + f.glUniform2f = must("glUniform2f") + f.glUniform3f = must("glUniform3f") + f.glUniform4f = must("glUniform4f") + f.glUseProgram = must("glUseProgram") + f.glVertexAttribPointer = must("glVertexAttribPointer") + f.glViewport = must("glViewport") // Extensions and GL ES 3 functions. - f.f.glBindBufferBase = load("glBindBufferBase") - f.f.glBindVertexArray = load("glBindVertexArray") - f.f.glGetIntegeri_v = load("glGetIntegeri_v") - f.f.glGetUniformBlockIndex = load("glGetUniformBlockIndex") - f.f.glUniformBlockBinding = load("glUniformBlockBinding") - f.f.glInvalidateFramebuffer = load("glInvalidateFramebuffer") - f.f.glGetStringi = load("glGetStringi") + f.glBindBufferBase = load("glBindBufferBase") + f.glBindVertexArray = load("glBindVertexArray") + f.glGetIntegeri_v = load("glGetIntegeri_v") + f.glGetUniformBlockIndex = load("glGetUniformBlockIndex") + f.glUniformBlockBinding = load("glUniformBlockBinding") + f.glInvalidateFramebuffer = load("glInvalidateFramebuffer") + f.glGetStringi = load("glGetStringi") // Fall back to EXT_invalidate_framebuffer if available. - if f.f.glInvalidateFramebuffer == nil { - f.f.glInvalidateFramebuffer = load("glDiscardFramebufferEXT") + if f.glInvalidateFramebuffer == nil { + f.glInvalidateFramebuffer = load("glDiscardFramebufferEXT") } - f.f.glBeginQuery = load("glBeginQuery") - if f.f.glBeginQuery == nil { - f.f.glBeginQuery = load("glBeginQueryEXT") + f.glBeginQuery = load("glBeginQuery") + if f.glBeginQuery == nil { + f.glBeginQuery = load("glBeginQueryEXT") } - f.f.glDeleteQueries = load("glDeleteQueries") - if f.f.glDeleteQueries == nil { - f.f.glDeleteQueries = load("glDeleteQueriesEXT") + f.glDeleteQueries = load("glDeleteQueries") + if f.glDeleteQueries == nil { + f.glDeleteQueries = load("glDeleteQueriesEXT") } - f.f.glEndQuery = load("glEndQuery") - if f.f.glEndQuery == nil { - f.f.glEndQuery = load("glEndQueryEXT") + f.glEndQuery = load("glEndQuery") + if f.glEndQuery == nil { + f.glEndQuery = load("glEndQueryEXT") } - f.f.glGenQueries = load("glGenQueries") - if f.f.glGenQueries == nil { - f.f.glGenQueries = load("glGenQueriesEXT") + f.glGenQueries = load("glGenQueries") + if f.glGenQueries == nil { + f.glGenQueries = load("glGenQueriesEXT") } - f.f.glGetQueryObjectuiv = load("glGetQueryObjectuiv") - if f.f.glGetQueryObjectuiv == nil { - f.f.glGetQueryObjectuiv = load("glGetQueryObjectuivEXT") + f.glGetQueryObjectuiv = load("glGetQueryObjectuiv") + if f.glGetQueryObjectuiv == nil { + f.glGetQueryObjectuiv = load("glGetQueryObjectuivEXT") } - f.f.glDeleteVertexArrays = load("glDeleteVertexArrays") - f.f.glGenVertexArrays = load("glGenVertexArrays") - 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") + f.glDeleteVertexArrays = load("glDeleteVertexArrays") + f.glGenVertexArrays = load("glGenVertexArrays") + f.glMemoryBarrier = load("glMemoryBarrier") + f.glDispatchCompute = load("glDispatchCompute") + f.glMapBufferRange = load("glMapBufferRange") + f.glUnmapBuffer = load("glUnmapBuffer") + f.glBindImageTexture = load("glBindImageTexture") + f.glTexStorage2D = load("glTexStorage2D") + f.glBlitFramebuffer = load("glBlitFramebuffer") + f.glGetProgramBinary = load("glGetProgramBinary") return loadErr } func (f *Functions) ActiveTexture(texture Enum) { - C.glActiveTexture(&f.f, C.GLenum(texture)) + C.glActiveTexture(f.glActiveTexture, C.GLenum(texture)) } func (f *Functions) AttachShader(p Program, s Shader) { - C.glAttachShader(&f.f, C.GLuint(p.V), C.GLuint(s.V)) + C.glAttachShader(f.glAttachShader, C.GLuint(p.V), C.GLuint(s.V)) } func (f *Functions) BeginQuery(target Enum, query Query) { - C.glBeginQuery(&f.f, C.GLenum(target), C.GLenum(query.V)) + C.glBeginQuery(f.glBeginQuery, C.GLenum(target), C.GLenum(query.V)) } func (f *Functions) BindAttribLocation(p Program, a Attrib, name string) { cname := C.CString(name) defer C.free(unsafe.Pointer(cname)) - C.glBindAttribLocation(&f.f, C.GLuint(p.V), C.GLuint(a), cname) + C.glBindAttribLocation(f.glBindAttribLocation, C.GLuint(p.V), C.GLuint(a), cname) } func (f *Functions) BindBufferBase(target Enum, index int, b Buffer) { - C.glBindBufferBase(&f.f, C.GLenum(target), C.GLuint(index), C.GLuint(b.V)) + C.glBindBufferBase(f.glBindBufferBase, C.GLenum(target), C.GLuint(index), C.GLuint(b.V)) } func (f *Functions) BindBuffer(target Enum, b Buffer) { - C.glBindBuffer(&f.f, C.GLenum(target), C.GLuint(b.V)) + C.glBindBuffer(f.glBindBuffer, C.GLenum(target), C.GLuint(b.V)) } func (f *Functions) BindFramebuffer(target Enum, fb Framebuffer) { - C.glBindFramebuffer(&f.f, C.GLenum(target), C.GLuint(fb.V)) + C.glBindFramebuffer(f.glBindFramebuffer, C.GLenum(target), C.GLuint(fb.V)) } func (f *Functions) BindRenderbuffer(target Enum, fb Renderbuffer) { - C.glBindRenderbuffer(&f.f, C.GLenum(target), C.GLuint(fb.V)) + C.glBindRenderbuffer(f.glBindRenderbuffer, C.GLenum(target), C.GLuint(fb.V)) } func (f *Functions) BindImageTexture(unit int, t Texture, level int, layered bool, layer int, access, format Enum) { @@ -755,27 +845,27 @@ func (f *Functions) BindImageTexture(unit int, t Texture, level int, layered boo if layered { l = TRUE } - C.glBindImageTexture(&f.f, C.GLuint(unit), C.GLuint(t.V), C.GLint(level), l, C.GLint(layer), C.GLenum(access), C.GLenum(format)) + C.glBindImageTexture(f.glBindImageTexture, 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(&f.f, C.GLenum(target), C.GLuint(t.V)) + C.glBindTexture(f.glBindTexture, C.GLenum(target), C.GLuint(t.V)) } func (f *Functions) BindVertexArray(a VertexArray) { - C.glBindVertexArray(&f.f, C.GLuint(a.V)) + C.glBindVertexArray(f.glBindVertexArray, C.GLuint(a.V)) } func (f *Functions) BlendEquation(mode Enum) { - C.glBlendEquation(&f.f, C.GLenum(mode)) + C.glBlendEquation(f.glBlendEquation, C.GLenum(mode)) } func (f *Functions) BlendFuncSeparate(srcRGB, dstRGB, srcA, dstA Enum) { - C.glBlendFuncSeparate(&f.f, C.GLenum(srcRGB), C.GLenum(dstRGB), C.GLenum(srcA), C.GLenum(dstA)) + C.glBlendFuncSeparate(f.glBlendFuncSeparate, C.GLenum(srcRGB), C.GLenum(dstRGB), C.GLenum(srcA), C.GLenum(dstA)) } func (f *Functions) BlitFramebuffer(sx0, sy0, sx1, sy1, dx0, dy0, dx1, dy1 int, mask Enum, filter Enum) { - C.glBlitFramebuffer(&f.f, + C.glBlitFramebuffer(f.glBlitFramebuffer, 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), @@ -787,7 +877,7 @@ func (f *Functions) BufferData(target Enum, size int, usage Enum, data []byte) { if len(data) > 0 { p = unsafe.Pointer(&data[0]) } - C.glBufferData(&f.f, C.GLenum(target), C.GLsizeiptr(size), p, C.GLenum(usage)) + C.glBufferData(f.glBufferData, C.GLenum(target), C.GLsizeiptr(size), p, C.GLenum(usage)) } func (f *Functions) BufferSubData(target Enum, offset int, src []byte) { @@ -795,111 +885,111 @@ func (f *Functions) BufferSubData(target Enum, offset int, src []byte) { if len(src) > 0 { p = unsafe.Pointer(&src[0]) } - C.glBufferSubData(&f.f, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(len(src)), p) + C.glBufferSubData(f.glBufferSubData, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(len(src)), p) } func (f *Functions) CheckFramebufferStatus(target Enum) Enum { - return Enum(C.glCheckFramebufferStatus(&f.f, C.GLenum(target))) + return Enum(C.glCheckFramebufferStatus(f.glCheckFramebufferStatus, C.GLenum(target))) } func (f *Functions) Clear(mask Enum) { - C.glClear(&f.f, C.GLbitfield(mask)) + C.glClear(f.glClear, C.GLbitfield(mask)) } func (f *Functions) ClearColor(red float32, green float32, blue float32, alpha float32) { - C.glClearColor(&f.f, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) + C.glClearColor(f.glClearColor, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) } func (f *Functions) ClearDepthf(d float32) { - C.glClearDepthf(&f.f, C.GLfloat(d)) + C.glClearDepthf(f.glClearDepthf, C.GLfloat(d)) } func (f *Functions) CompileShader(s Shader) { - C.glCompileShader(&f.f, C.GLuint(s.V)) + C.glCompileShader(f.glCompileShader, C.GLuint(s.V)) } func (f *Functions) CopyTexSubImage2D(target Enum, level, xoffset, yoffset, x, y, width, height int) { - C.glCopyTexSubImage2D(&f.f, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) + C.glCopyTexSubImage2D(f.glCopyTexSubImage2D, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) } func (f *Functions) CreateBuffer() Buffer { - C.glGenBuffers(&f.f, 1, &f.uints[0]) + C.glGenBuffers(f.glGenBuffers, 1, &f.uints[0]) return Buffer{uint(f.uints[0])} } func (f *Functions) CreateFramebuffer() Framebuffer { - C.glGenFramebuffers(&f.f, 1, &f.uints[0]) + C.glGenFramebuffers(f.glGenFramebuffers, 1, &f.uints[0]) return Framebuffer{uint(f.uints[0])} } func (f *Functions) CreateProgram() Program { - return Program{uint(C.glCreateProgram(&f.f))} + return Program{uint(C.glCreateProgram(f.glCreateProgram))} } func (f *Functions) CreateQuery() Query { - C.glGenQueries(&f.f, 1, &f.uints[0]) + C.glGenQueries(f.glGenQueries, 1, &f.uints[0]) return Query{uint(f.uints[0])} } func (f *Functions) CreateRenderbuffer() Renderbuffer { - C.glGenRenderbuffers(&f.f, 1, &f.uints[0]) + C.glGenRenderbuffers(f.glGenRenderbuffers, 1, &f.uints[0]) return Renderbuffer{uint(f.uints[0])} } func (f *Functions) CreateShader(ty Enum) Shader { - return Shader{uint(C.glCreateShader(&f.f, C.GLenum(ty)))} + return Shader{uint(C.glCreateShader(f.glCreateShader, C.GLenum(ty)))} } func (f *Functions) CreateTexture() Texture { - C.glGenTextures(&f.f, 1, &f.uints[0]) + C.glGenTextures(f.glGenTextures, 1, &f.uints[0]) return Texture{uint(f.uints[0])} } func (f *Functions) CreateVertexArray() VertexArray { - C.glGenVertexArrays(&f.f, 1, &f.uints[0]) + C.glGenVertexArrays(f.glGenVertexArrays, 1, &f.uints[0]) return VertexArray{uint(f.uints[0])} } func (f *Functions) DeleteBuffer(v Buffer) { f.uints[0] = C.GLuint(v.V) - C.glDeleteBuffers(&f.f, 1, &f.uints[0]) + C.glDeleteBuffers(f.glDeleteBuffers, 1, &f.uints[0]) } func (f *Functions) DeleteFramebuffer(v Framebuffer) { f.uints[0] = C.GLuint(v.V) - C.glDeleteFramebuffers(&f.f, 1, &f.uints[0]) + C.glDeleteFramebuffers(f.glDeleteFramebuffers, 1, &f.uints[0]) } func (f *Functions) DeleteProgram(p Program) { - C.glDeleteProgram(&f.f, C.GLuint(p.V)) + C.glDeleteProgram(f.glDeleteProgram, C.GLuint(p.V)) } func (f *Functions) DeleteQuery(query Query) { f.uints[0] = C.GLuint(query.V) - C.glDeleteQueries(&f.f, 1, &f.uints[0]) + C.glDeleteQueries(f.glDeleteQueries, 1, &f.uints[0]) } func (f *Functions) DeleteVertexArray(array VertexArray) { f.uints[0] = C.GLuint(array.V) - C.glDeleteVertexArrays(&f.f, 1, &f.uints[0]) + C.glDeleteVertexArrays(f.glDeleteVertexArrays, 1, &f.uints[0]) } func (f *Functions) DeleteRenderbuffer(v Renderbuffer) { f.uints[0] = C.GLuint(v.V) - C.glDeleteRenderbuffers(&f.f, 1, &f.uints[0]) + C.glDeleteRenderbuffers(f.glDeleteRenderbuffers, 1, &f.uints[0]) } func (f *Functions) DeleteShader(s Shader) { - C.glDeleteShader(&f.f, C.GLuint(s.V)) + C.glDeleteShader(f.glDeleteShader, C.GLuint(s.V)) } func (f *Functions) DeleteTexture(v Texture) { f.uints[0] = C.GLuint(v.V) - C.glDeleteTextures(&f.f, 1, &f.uints[0]) + C.glDeleteTextures(f.glDeleteTextures, 1, &f.uints[0]) } func (f *Functions) DepthFunc(v Enum) { - C.glDepthFunc(&f.f, C.GLenum(v)) + C.glDepthFunc(f.glDepthFunc, C.GLenum(v)) } func (f *Functions) DepthMask(mask bool) { @@ -907,55 +997,55 @@ func (f *Functions) DepthMask(mask bool) { if mask { m = C.GLboolean(TRUE) } - C.glDepthMask(&f.f, m) + C.glDepthMask(f.glDepthMask, m) } func (f *Functions) DisableVertexAttribArray(a Attrib) { - C.glDisableVertexAttribArray(&f.f, C.GLuint(a)) + C.glDisableVertexAttribArray(f.glDisableVertexAttribArray, C.GLuint(a)) } func (f *Functions) Disable(cap Enum) { - C.glDisable(&f.f, C.GLenum(cap)) + C.glDisable(f.glDisable, C.GLenum(cap)) } func (f *Functions) DrawArrays(mode Enum, first int, count int) { - C.glDrawArrays(&f.f, C.GLenum(mode), C.GLint(first), C.GLsizei(count)) + C.glDrawArrays(f.glDrawArrays, C.GLenum(mode), C.GLint(first), C.GLsizei(count)) } func (f *Functions) DrawElements(mode Enum, count int, ty Enum, offset int) { - C.glDrawElements(&f.f, C.GLenum(mode), C.GLsizei(count), C.GLenum(ty), C.uintptr_t(offset)) + C.glDrawElements(f.glDrawElements, C.GLenum(mode), C.GLsizei(count), C.GLenum(ty), C.uintptr_t(offset)) } func (f *Functions) DispatchCompute(x, y, z int) { - C.glDispatchCompute(&f.f, C.GLuint(x), C.GLuint(y), C.GLuint(z)) + C.glDispatchCompute(f.glDispatchCompute, C.GLuint(x), C.GLuint(y), C.GLuint(z)) } func (f *Functions) Enable(cap Enum) { - C.glEnable(&f.f, C.GLenum(cap)) + C.glEnable(f.glEnable, C.GLenum(cap)) } func (f *Functions) EndQuery(target Enum) { - C.glEndQuery(&f.f, C.GLenum(target)) + C.glEndQuery(f.glEndQuery, C.GLenum(target)) } func (f *Functions) EnableVertexAttribArray(a Attrib) { - C.glEnableVertexAttribArray(&f.f, C.GLuint(a)) + C.glEnableVertexAttribArray(f.glEnableVertexAttribArray, C.GLuint(a)) } func (f *Functions) Finish() { - C.glFinish(&f.f) + C.glFinish(f.glFinish) } func (f *Functions) Flush() { - C.glFlush(&f.f) + C.glFlush(f.glFinish) } func (f *Functions) FramebufferRenderbuffer(target, attachment, renderbuffertarget Enum, renderbuffer Renderbuffer) { - C.glFramebufferRenderbuffer(&f.f, C.GLenum(target), C.GLenum(attachment), C.GLenum(renderbuffertarget), C.GLuint(renderbuffer.V)) + C.glFramebufferRenderbuffer(f.glFramebufferRenderbuffer, C.GLenum(target), C.GLenum(attachment), C.GLenum(renderbuffertarget), C.GLuint(renderbuffer.V)) } func (f *Functions) FramebufferTexture2D(target, attachment, texTarget Enum, t Texture, level int) { - C.glFramebufferTexture2D(&f.f, C.GLenum(target), C.GLenum(attachment), C.GLenum(texTarget), C.GLuint(t.V), C.GLint(level)) + C.glFramebufferTexture2D(f.glFramebufferTexture2D, C.GLenum(target), C.GLenum(attachment), C.GLenum(texTarget), C.GLuint(t.V), C.GLint(level)) } func (c *Functions) GetBinding(pname Enum) Object { @@ -967,21 +1057,21 @@ func (c *Functions) GetBindingi(pname Enum, idx int) Object { } func (f *Functions) GetError() Enum { - return Enum(C.glGetError(&f.f)) + return Enum(C.glGetError(f.glGetError)) } func (f *Functions) GetRenderbufferParameteri(target, pname Enum) int { - C.glGetRenderbufferParameteriv(&f.f, C.GLenum(target), C.GLenum(pname), &f.ints[0]) + C.glGetRenderbufferParameteriv(f.glGetRenderbufferParameteriv, 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(&f.f, C.GLenum(target), C.GLenum(attachment), C.GLenum(pname), &f.ints[0]) + C.glGetFramebufferAttachmentParameteriv(f.glGetFramebufferAttachmentParameteriv, C.GLenum(target), C.GLenum(attachment), C.GLenum(pname), &f.ints[0]) return int(f.ints[0]) } func (f *Functions) GetFloat4(pname Enum) [4]float32 { - C.glGetFloatv(&f.f, C.GLenum(pname), &f.floats[0]) + C.glGetFloatv(f.glGetFloatv, C.GLenum(pname), &f.floats[0]) var r [4]float32 for i := range r { r[i] = float32(f.floats[i]) @@ -990,12 +1080,12 @@ func (f *Functions) GetFloat4(pname Enum) [4]float32 { } func (f *Functions) GetFloat(pname Enum) float32 { - C.glGetFloatv(&f.f, C.GLenum(pname), &f.floats[0]) + C.glGetFloatv(f.glGetFloatv, C.GLenum(pname), &f.floats[0]) return float32(f.floats[0]) } func (f *Functions) GetInteger4(pname Enum) [4]int { - C.glGetIntegerv(&f.f, C.GLenum(pname), &f.ints[0]) + C.glGetIntegerv(f.glGetIntegerv, C.GLenum(pname), &f.ints[0]) var r [4]int for i := range r { r[i] = int(f.ints[i]) @@ -1004,17 +1094,17 @@ func (f *Functions) GetInteger4(pname Enum) [4]int { } func (f *Functions) GetInteger(pname Enum) int { - C.glGetIntegerv(&f.f, C.GLenum(pname), &f.ints[0]) + C.glGetIntegerv(f.glGetIntegerv, C.GLenum(pname), &f.ints[0]) return int(f.ints[0]) } func (f *Functions) GetIntegeri(pname Enum, idx int) int { - C.glGetIntegeri_v(&f.f, C.GLenum(pname), C.GLuint(idx), &f.ints[0]) + C.glGetIntegeri_v(f.glGetIntegeri_v, C.GLenum(pname), C.GLuint(idx), &f.ints[0]) return int(f.ints[0]) } func (f *Functions) GetProgrami(p Program, pname Enum) int { - C.glGetProgramiv(&f.f, C.GLuint(p.V), C.GLenum(pname), &f.ints[0]) + C.glGetProgramiv(f.glGetProgramiv, C.GLuint(p.V), C.GLenum(pname), &f.ints[0]) return int(f.ints[0]) } @@ -1025,36 +1115,36 @@ func (f *Functions) GetProgramBinary(p Program) []byte { } buf := make([]byte, sz) var format C.GLenum - C.glGetProgramBinary(&f.f, C.GLuint(p.V), C.GLsizei(sz), nil, &format, unsafe.Pointer(&buf[0])) + C.glGetProgramBinary(f.glGetProgramBinary, 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(&f.f, C.GLuint(p.V), C.GLsizei(len(buf)), nil, (*C.GLchar)(unsafe.Pointer(&buf[0]))) + C.glGetProgramInfoLog(f.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 { - C.glGetQueryObjectuiv(&f.f, C.GLuint(query.V), C.GLenum(pname), &f.uints[0]) + C.glGetQueryObjectuiv(f.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 { - C.glGetShaderiv(&f.f, C.GLuint(s.V), C.GLenum(pname), &f.ints[0]) + C.glGetShaderiv(f.glGetShaderiv, 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(&f.f, C.GLuint(s.V), C.GLsizei(len(buf)), nil, (*C.GLchar)(unsafe.Pointer(&buf[0]))) + C.glGetShaderInfoLog(f.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 { - str := C.glGetStringi(&f.f, C.GLenum(pname), C.GLuint(index)) + str := C.glGetStringi(f.glGetStringi, C.GLenum(pname), C.GLuint(index)) if str == nil { return "" } @@ -1074,7 +1164,7 @@ func (f *Functions) GetString(pname Enum) string { } return strings.Join(exts, " ") default: - str := C.glGetString(&f.f, C.GLenum(pname)) + str := C.glGetString(f.glGetString, C.GLenum(pname)) return C.GoString((*C.char)(unsafe.Pointer(str))) } } @@ -1082,17 +1172,17 @@ 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.glGetUniformBlockIndex(&f.f, C.GLuint(p.V), cname)) + return uint(C.glGetUniformBlockIndex(f.glGetUniformBlockIndex, 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(&f.f, C.GLuint(p.V), cname))} + return Uniform{int(C.glGetUniformLocation(f.glGetUniformLocation, C.GLuint(p.V), cname))} } func (f *Functions) GetVertexAttrib(index int, pname Enum) int { - C.glGetVertexAttribiv(&f.f, C.GLuint(index), C.GLenum(pname), &f.ints[0]) + C.glGetVertexAttribiv(f.glGetVertexAttribiv, C.GLuint(index), C.GLenum(pname), &f.ints[0]) return int(f.ints[0]) } @@ -1101,32 +1191,32 @@ func (f *Functions) GetVertexAttribBinding(index int, pname Enum) Object { } func (f *Functions) GetVertexAttribPointer(index int, pname Enum) uintptr { - ptr := C.glGetVertexAttribPointerv(&f.f, C.GLuint(index), C.GLenum(pname)) + ptr := C.glGetVertexAttribPointerv(f.glGetVertexAttribPointerv, C.GLuint(index), C.GLenum(pname)) return uintptr(ptr) } func (f *Functions) InvalidateFramebuffer(target, attachment Enum) { - C.glInvalidateFramebuffer(&f.f, C.GLenum(target), C.GLenum(attachment)) + C.glInvalidateFramebuffer(f.glInvalidateFramebuffer, C.GLenum(target), C.GLenum(attachment)) } func (f *Functions) IsEnabled(cap Enum) bool { - return C.glIsEnabled(&f.f, C.GLenum(cap)) == TRUE + return C.glIsEnabled(f.glIsEnabled, C.GLenum(cap)) == TRUE } func (f *Functions) LinkProgram(p Program) { - C.glLinkProgram(&f.f, C.GLuint(p.V)) + C.glLinkProgram(f.glLinkProgram, C.GLuint(p.V)) } func (f *Functions) PixelStorei(pname Enum, param int) { - C.glPixelStorei(&f.f, C.GLenum(pname), C.GLint(param)) + C.glPixelStorei(f.glPixelStorei, C.GLenum(pname), C.GLint(param)) } func (f *Functions) MemoryBarrier(barriers Enum) { - C.glMemoryBarrier(&f.f, C.GLbitfield(barriers)) + C.glMemoryBarrier(f.glMemoryBarrier, C.GLbitfield(barriers)) } func (f *Functions) MapBufferRange(target Enum, offset, length int, access Enum) []byte { - p := C.glMapBufferRange(&f.f, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(length), C.GLbitfield(access)) + p := C.glMapBufferRange(f.glMapBufferRange, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(length), C.GLbitfield(access)) if p == nil { return nil } @@ -1134,7 +1224,7 @@ func (f *Functions) MapBufferRange(target Enum, offset, length int, access Enum) } func (f *Functions) Scissor(x, y, width, height int32) { - C.glScissor(&f.f, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) + C.glScissor(f.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) { @@ -1142,26 +1232,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(&f.f, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(ty), p) + C.glReadPixels(f.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) { - C.glRenderbufferStorage(&f.f, C.GLenum(target), C.GLenum(internalformat), C.GLsizei(width), C.GLsizei(height)) + C.glRenderbufferStorage(f.glRenderbufferStorage, 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(&f.f, C.GLuint(s.V), 1, &csrc, &strlen) + C.glShaderSource(f.glShaderSource, 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(&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) + C.glTexImage2D(f.glTexImage2D, 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.glTexStorage2D(&f.f, C.GLenum(target), C.GLsizei(levels), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) + C.glTexStorage2D(f.glTexStorage2D, 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) { @@ -1169,43 +1259,43 @@ 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(&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) + C.glTexSubImage2D(f.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) { - C.glTexParameteri(&f.f, C.GLenum(target), C.GLenum(pname), C.GLint(param)) + C.glTexParameteri(f.glTexParameteri, C.GLenum(target), C.GLenum(pname), C.GLint(param)) } func (f *Functions) UniformBlockBinding(p Program, uniformBlockIndex uint, uniformBlockBinding uint) { - C.glUniformBlockBinding(&f.f, C.GLuint(p.V), C.GLuint(uniformBlockIndex), C.GLuint(uniformBlockBinding)) + C.glUniformBlockBinding(f.glUniformBlockBinding, C.GLuint(p.V), C.GLuint(uniformBlockIndex), C.GLuint(uniformBlockBinding)) } func (f *Functions) Uniform1f(dst Uniform, v float32) { - C.glUniform1f(&f.f, C.GLint(dst.V), C.GLfloat(v)) + C.glUniform1f(f.glUniform1f, C.GLint(dst.V), C.GLfloat(v)) } func (f *Functions) Uniform1i(dst Uniform, v int) { - C.glUniform1i(&f.f, C.GLint(dst.V), C.GLint(v)) + C.glUniform1i(f.glUniform1i, C.GLint(dst.V), C.GLint(v)) } func (f *Functions) Uniform2f(dst Uniform, v0 float32, v1 float32) { - C.glUniform2f(&f.f, C.GLint(dst.V), C.GLfloat(v0), C.GLfloat(v1)) + C.glUniform2f(f.glUniform2f, C.GLint(dst.V), C.GLfloat(v0), C.GLfloat(v1)) } func (f *Functions) Uniform3f(dst Uniform, v0 float32, v1 float32, v2 float32) { - C.glUniform3f(&f.f, C.GLint(dst.V), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) + C.glUniform3f(f.glUniform3f, C.GLint(dst.V), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) } func (f *Functions) Uniform4f(dst Uniform, v0 float32, v1 float32, v2 float32, v3 float32) { - C.glUniform4f(&f.f, C.GLint(dst.V), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) + C.glUniform4f(f.glUniform4f, C.GLint(dst.V), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) } func (f *Functions) UseProgram(p Program) { - C.glUseProgram(&f.f, C.GLuint(p.V)) + C.glUseProgram(f.glUseProgram, C.GLuint(p.V)) } func (f *Functions) UnmapBuffer(target Enum) bool { - r := C.glUnmapBuffer(&f.f, C.GLenum(target)) + r := C.glUnmapBuffer(f.glUnmapBuffer, C.GLenum(target)) return r == TRUE } @@ -1214,9 +1304,9 @@ func (f *Functions) VertexAttribPointer(dst Attrib, size int, ty Enum, normalize if normalized { n = TRUE } - C.glVertexAttribPointer(&f.f, C.GLuint(dst), C.GLint(size), C.GLenum(ty), n, C.GLsizei(stride), C.uintptr_t(offset)) + C.glVertexAttribPointer(f.glVertexAttribPointer, 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(&f.f, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) + C.glViewport(f.glViewport, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) }