gl_unix.go

// SPDX-License-Identifier: Unlicense OR MIT

//go:build darwin || linux || freebsd || openbsd
// +build darwin linux freebsd openbsd

package gl

import (
	"fmt"
	"runtime"
	"strings"
	"unsafe"
)

/*
#cgo CFLAGS: -Werror
#cgo linux freebsd LDFLAGS: -ldl

#include <stdint.h>
#include <stdlib.h>
#include <sys/types.h>
#define __USE_GNU
#include <dlfcn.h>

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;

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 (*_glGenerateMipmap)(GLenum target);
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);

static void glActiveTexture(_glActiveTexture f, GLenum texture) {
	f(texture);
}

static void glAttachShader(_glAttachShader f, GLuint program, GLuint shader) {
	f(program, shader);
}

static void glBindAttribLocation(_glBindAttribLocation f, GLuint program, GLuint index, const GLchar *name) {
	f(program, index, name);
}

static void glBindBuffer(_glBindBuffer f, GLenum target, GLuint buffer) {
	f(target, buffer);
}

static void glBindFramebuffer(_glBindFramebuffer f, GLenum target, GLuint framebuffer) {
	f(target, framebuffer);
}

static void glBindRenderbuffer(_glBindRenderbuffer f, GLenum target, GLuint renderbuffer) {
	f(target, renderbuffer);
}

static void glBindTexture(_glBindTexture f, GLenum target, GLuint texture) {
	f(target, texture);
}

static void glBindVertexArray(_glBindVertexArray f, GLuint array) {
	f(array);
}

static void glBlendEquation(_glBlendEquation f, GLenum mode) {
	f(mode);
}

static void glBlendFuncSeparate(_glBlendFuncSeparate f, GLenum srcRGB, GLenum dstRGB, GLenum srcA, GLenum dstA) {
	f(srcRGB, dstRGB, srcA, dstA);
}

static void glBufferData(_glBufferData f, GLenum target, GLsizeiptr size, const void *data, GLenum usage) {
	f(target, size, data, usage);
}

static void glBufferSubData(_glBufferSubData f, GLenum target, GLintptr offset, GLsizeiptr size, const void *data) {
	f(target, offset, size, data);
}

static GLenum glCheckFramebufferStatus(_glCheckFramebufferStatus f, GLenum target) {
	return f(target);
}

static void glClear(_glClear f, GLbitfield mask) {
	f(mask);
}

static void glClearColor(_glClearColor f, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
	f(red, green, blue, alpha);
}

static void glClearDepthf(_glClearDepthf f, GLfloat d) {
	f(d);
}

static void glCompileShader(_glCompileShader f, GLuint shader) {
	f(shader);
}

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(_glCreateProgram f) {
	return f();
}

static GLuint glCreateShader(_glCreateShader f, GLenum type) {
	return f(type);
}

static void glDeleteBuffers(_glDeleteBuffers f, GLsizei n, const GLuint *buffers) {
	f(n, buffers);
}

static void glDeleteFramebuffers(_glDeleteFramebuffers f, GLsizei n, const GLuint *framebuffers) {
	f(n, framebuffers);
}

static void glDeleteProgram(_glDeleteProgram f, GLuint program) {
	f(program);
}

static void glDeleteRenderbuffers(_glDeleteRenderbuffers f, GLsizei n, const GLuint *renderbuffers) {
	f(n, renderbuffers);
}

static void glDeleteShader(_glDeleteShader f, GLuint shader) {
	f(shader);
}

static void glDeleteTextures(_glDeleteTextures f, GLsizei n, const GLuint *textures) {
	f(n, textures);
}

static void glDepthFunc(_glDepthFunc f, GLenum func) {
	f(func);
}

static void glDepthMask(_glDepthMask f, GLboolean flag) {
	f(flag);
}

static void glDisable(_glDisable f, GLenum cap) {
	f(cap);
}

static void glDisableVertexAttribArray(_glDisableVertexAttribArray f, GLuint index) {
	f(index);
}

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(_glDrawElements f, GLenum mode, GLsizei count, GLenum type, const uintptr_t offset) {
	f(mode, count, type, (const void *)offset);
}

static void glEnable(_glEnable f, GLenum cap) {
	f(cap);
}

static void glEnableVertexAttribArray(_glEnableVertexAttribArray f, GLuint index) {
	f(index);
}

static void glFinish(_glFinish f) {
	f();
}

static void glFlush(_glFlush f) {
	f();
}

static void glFramebufferRenderbuffer(_glFramebufferRenderbuffer f, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {
	f(target, attachment, renderbuffertarget, renderbuffer);
}

static void glFramebufferTexture2D(_glFramebufferTexture2D f, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {
	f(target, attachment, textarget, texture, level);
}

static void glGenBuffers(_glGenBuffers f, GLsizei n, GLuint *buffers) {
	f(n, buffers);
}

static void glGenerateMipmap(_glGenerateMipmap f, GLenum target) {
	f(target);
}

static void glGenFramebuffers(_glGenFramebuffers f, GLsizei n, GLuint *framebuffers) {
	f(n, framebuffers);
}

static void glGenRenderbuffers(_glGenRenderbuffers f, GLsizei n, GLuint *renderbuffers) {
	f(n, renderbuffers);
}

static void glGenTextures(_glGenTextures f, GLsizei n, GLuint *textures) {
	f(n, textures);
}

static GLenum glGetError(_glGetError f) {
	return f();
}

static void glGetFramebufferAttachmentParameteriv(_glGetFramebufferAttachmentParameteriv f, GLenum target, GLenum attachment, GLenum pname, GLint *params) {
	f(target, attachment, pname, params);
}

static void glGetIntegerv(_glGetIntegerv f, GLenum pname, GLint *data) {
	f(pname, data);
}

static void glGetFloatv(_glGetFloatv f, GLenum pname, GLfloat *data) {
	f(pname, data);
}

static void glGetIntegeri_v(_glGetIntegeri_v f, GLenum pname, GLuint idx, GLint *data) {
	f(pname, idx, data);
}

static void glGetProgramiv(_glGetProgramiv f, GLuint program, GLenum pname, GLint *params) {
	f(program, pname, params);
}

static void glGetProgramInfoLog(_glGetProgramInfoLog f, GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog) {
	f(program, bufSize, length, infoLog);
}

static void glGetRenderbufferParameteriv(_glGetRenderbufferParameteriv f, GLenum target, GLenum pname, GLint *params) {
	f(target, pname, params);
}

static void glGetShaderiv(_glGetShaderiv f, GLuint shader, GLenum pname, GLint *params) {
	f(shader, pname, params);
}

static void glGetShaderInfoLog(_glGetShaderInfoLog f, GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog) {
	f(shader, bufSize, length, infoLog);
}

static const GLubyte *glGetString(_glGetString f, GLenum name) {
	return f(name);
}

static GLint glGetUniformLocation(_glGetUniformLocation f, GLuint program, const GLchar *name) {
	return f(program, name);
}

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(_glGetVertexAttribPointerv f, GLuint index, GLenum pname) {
	void *ptrs;
	f(index, pname, &ptrs);
	return (uintptr_t)ptrs;
}

static GLboolean glIsEnabled(_glIsEnabled f, GLenum cap) {
	return f(cap);
}

static void glLinkProgram(_glLinkProgram f, GLuint program) {
	f(program);
}

static void glPixelStorei(_glPixelStorei f, GLenum pname, GLint param) {
	f(pname, param);
}

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(_glRenderbufferStorage f, GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {
	f(target, internalformat, width, height);
}

static void glScissor(_glScissor f, GLint x, GLint y, GLsizei width, GLsizei height) {
	f(x, y, width, height);
}

static void glShaderSource(_glShaderSource f, GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length) {
	f(shader, count, string, length);
}

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(_glTexParameteri f, GLenum target, GLenum pname, GLint param) {
	f(target, pname, param);
}

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(_glUniform1f f, GLint location, GLfloat v0) {
	f(location, v0);
}

static void glUniform1i(_glUniform1i f, GLint location, GLint v0) {
	f(location, v0);
}

static void glUniform2f(_glUniform2f f, GLint location, GLfloat v0, GLfloat v1) {
	f(location, v0, v1);
}

static void glUniform3f(_glUniform3f f, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {
	f(location, v0, v1, v2);
}

static void glUniform4f(_glUniform4f f, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {
	f(location, v0, v1, v2, v3);
}

static void glUseProgram(_glUseProgram f, GLuint program) {
	f(program);
}

// offset is defined as an uintptr_t to omit Cgo pointer checks.
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(_glViewport f, GLint x, GLint y, GLsizei width, GLsizei height) {
	f(x, y, width, height);
}

static void glBindBufferBase(_glBindBufferBase f, GLenum target, GLuint index, GLuint buffer) {
	f(target, index, buffer);
}

static void glUniformBlockBinding(_glUniformBlockBinding f, GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) {
	f(program, uniformBlockIndex, uniformBlockBinding);
}

static GLuint glGetUniformBlockIndex(_glGetUniformBlockIndex f, GLuint program, const GLchar *uniformBlockName) {
	return f(program, uniformBlockName);
}

static void glInvalidateFramebuffer(_glInvalidateFramebuffer f, GLenum target, GLenum attachment) {
	// Framebuffer invalidation is just a hint and can safely be ignored.
	if (f != NULL) {
		f(target, 1, &attachment);
	}
}

static void glBeginQuery(_glBeginQuery f, GLenum target, GLenum attachment) {
	f(target, attachment);
}

static void glDeleteQueries(_glDeleteQueries f, GLsizei n, const GLuint *ids) {
	f(n, ids);
}

static void glDeleteVertexArrays(_glDeleteVertexArrays f, GLsizei n, const GLuint *ids) {
	f(n, ids);
}

static void glEndQuery(_glEndQuery f, GLenum target) {
	f(target);
}

static const GLubyte* glGetStringi(_glGetStringi f, GLenum name, GLuint index) {
	return f(name, index);
}

static void glGenQueries(_glGenQueries f, GLsizei n, GLuint *ids) {
	f(n, ids);
}

static void glGenVertexArrays(_glGenVertexArrays f, GLsizei n, GLuint *ids) {
	f(n, ids);
}

static void glGetProgramBinary(_glGetProgramBinary f, GLuint program, GLsizei bufsize, GLsizei *length, GLenum *binaryFormat, void *binary) {
	f(program, bufsize, length, binaryFormat, binary);
}

static void glGetQueryObjectuiv(_glGetQueryObjectuiv f, GLuint id, GLenum pname, GLuint *params) {
	f(id, pname, params);
}

static void glMemoryBarrier(_glMemoryBarrier f, GLbitfield barriers) {
	f(barriers);
}

static void glDispatchCompute(_glDispatchCompute f, GLuint x, GLuint y, GLuint z) {
	f(x, y, z);
}

static void *glMapBufferRange(_glMapBufferRange f, GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) {
	return f(target, offset, length, access);
}

static GLboolean glUnmapBuffer(_glUnmapBuffer f, GLenum target) {
	return f(target);
}

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(_glTexStorage2D f, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height) {
	f(target, levels, internalFormat, width, height);
}

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"

type Context interface{}

type Functions struct {
	// Query caches.
	uints  [100]C.GLuint
	ints   [100]C.GLint
	floats [100]C.GLfloat

	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
	glGenerateMipmap                      C._glGenerateMipmap
	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) {
	if ctx != nil {
		panic("non-nil context")
	}
	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|C.RTLD_LOCAL)
}

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"}
	case runtime.GOOS == "android":
		libNames = []string{"libGLESv2.so", "libGLESv3.so"}
	default:
		libNames = []string{"libGLESv2.so.2", "libGLESv2.so.3.0"}
	}
	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.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.glGenerateMipmap = must("glGenerateMipmap")
	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.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.glInvalidateFramebuffer == nil {
		f.glInvalidateFramebuffer = load("glDiscardFramebufferEXT")
	}

	f.glBeginQuery = load("glBeginQuery")
	if f.glBeginQuery == nil {
		f.glBeginQuery = load("glBeginQueryEXT")
	}
	f.glDeleteQueries = load("glDeleteQueries")
	if f.glDeleteQueries == nil {
		f.glDeleteQueries = load("glDeleteQueriesEXT")
	}
	f.glEndQuery = load("glEndQuery")
	if f.glEndQuery == nil {
		f.glEndQuery = load("glEndQueryEXT")
	}
	f.glGenQueries = load("glGenQueries")
	if f.glGenQueries == nil {
		f.glGenQueries = load("glGenQueriesEXT")
	}
	f.glGetQueryObjectuiv = load("glGetQueryObjectuiv")
	if f.glGetQueryObjectuiv == nil {
		f.glGetQueryObjectuiv = load("glGetQueryObjectuivEXT")
	}

	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.glActiveTexture, C.GLenum(texture))
}

func (f *Functions) AttachShader(p Program, s Shader) {
	C.glAttachShader(f.glAttachShader, C.GLuint(p.V), C.GLuint(s.V))
}

func (f *Functions) BeginQuery(target Enum, query Query) {
	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.glBindAttribLocation, C.GLuint(p.V), C.GLuint(a), cname)
}

func (f *Functions) BindBufferBase(target Enum, index int, b Buffer) {
	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.glBindBuffer, C.GLenum(target), C.GLuint(b.V))
}

func (f *Functions) BindFramebuffer(target Enum, fb Framebuffer) {
	C.glBindFramebuffer(f.glBindFramebuffer, C.GLenum(target), C.GLuint(fb.V))
}

func (f *Functions) BindRenderbuffer(target Enum, fb Renderbuffer) {
	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) {
	l := C.GLboolean(FALSE)
	if layered {
		l = TRUE
	}
	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.glBindTexture, C.GLenum(target), C.GLuint(t.V))
}

func (f *Functions) BindVertexArray(a VertexArray) {
	C.glBindVertexArray(f.glBindVertexArray, C.GLuint(a.V))
}

func (f *Functions) BlendEquation(mode Enum) {
	C.glBlendEquation(f.glBlendEquation, C.GLenum(mode))
}

func (f *Functions) BlendFuncSeparate(srcRGB, dstRGB, srcA, dstA Enum) {
	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.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),
	)
}

func (f *Functions) BufferData(target Enum, size int, usage Enum, data []byte) {
	var p unsafe.Pointer
	if len(data) > 0 {
		p = unsafe.Pointer(&data[0])
	}
	C.glBufferData(f.glBufferData, C.GLenum(target), C.GLsizeiptr(size), p, C.GLenum(usage))
}

func (f *Functions) BufferSubData(target Enum, offset int, src []byte) {
	var p unsafe.Pointer
	if len(src) > 0 {
		p = unsafe.Pointer(&src[0])
	}
	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.glCheckFramebufferStatus, C.GLenum(target)))
}

func (f *Functions) Clear(mask Enum) {
	C.glClear(f.glClear, C.GLbitfield(mask))
}

func (f *Functions) ClearColor(red float32, green float32, blue float32, alpha float32) {
	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.glClearDepthf, C.GLfloat(d))
}

func (f *Functions) CompileShader(s Shader) {
	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.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.glGenBuffers, 1, &f.uints[0])
	return Buffer{uint(f.uints[0])}
}

func (f *Functions) CreateFramebuffer() Framebuffer {
	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.glCreateProgram))}
}

func (f *Functions) CreateQuery() Query {
	C.glGenQueries(f.glGenQueries, 1, &f.uints[0])
	return Query{uint(f.uints[0])}
}

func (f *Functions) CreateRenderbuffer() Renderbuffer {
	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.glCreateShader, C.GLenum(ty)))}
}

func (f *Functions) CreateTexture() Texture {
	C.glGenTextures(f.glGenTextures, 1, &f.uints[0])
	return Texture{uint(f.uints[0])}
}

func (f *Functions) CreateVertexArray() VertexArray {
	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.glDeleteBuffers, 1, &f.uints[0])
}

func (f *Functions) DeleteFramebuffer(v Framebuffer) {
	f.uints[0] = C.GLuint(v.V)
	C.glDeleteFramebuffers(f.glDeleteFramebuffers, 1, &f.uints[0])
}

func (f *Functions) DeleteProgram(p Program) {
	C.glDeleteProgram(f.glDeleteProgram, C.GLuint(p.V))
}

func (f *Functions) DeleteQuery(query Query) {
	f.uints[0] = C.GLuint(query.V)
	C.glDeleteQueries(f.glDeleteQueries, 1, &f.uints[0])
}

func (f *Functions) DeleteVertexArray(array VertexArray) {
	f.uints[0] = C.GLuint(array.V)
	C.glDeleteVertexArrays(f.glDeleteVertexArrays, 1, &f.uints[0])
}

func (f *Functions) DeleteRenderbuffer(v Renderbuffer) {
	f.uints[0] = C.GLuint(v.V)
	C.glDeleteRenderbuffers(f.glDeleteRenderbuffers, 1, &f.uints[0])
}

func (f *Functions) DeleteShader(s Shader) {
	C.glDeleteShader(f.glDeleteShader, C.GLuint(s.V))
}

func (f *Functions) DeleteTexture(v Texture) {
	f.uints[0] = C.GLuint(v.V)
	C.glDeleteTextures(f.glDeleteTextures, 1, &f.uints[0])
}

func (f *Functions) DepthFunc(v Enum) {
	C.glDepthFunc(f.glDepthFunc, C.GLenum(v))
}

func (f *Functions) DepthMask(mask bool) {
	m := C.GLboolean(FALSE)
	if mask {
		m = C.GLboolean(TRUE)
	}
	C.glDepthMask(f.glDepthMask, m)
}

func (f *Functions) DisableVertexAttribArray(a Attrib) {
	C.glDisableVertexAttribArray(f.glDisableVertexAttribArray, C.GLuint(a))
}

func (f *Functions) Disable(cap Enum) {
	C.glDisable(f.glDisable, C.GLenum(cap))
}

func (f *Functions) DrawArrays(mode Enum, first int, count int) {
	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.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.glDispatchCompute, C.GLuint(x), C.GLuint(y), C.GLuint(z))
}

func (f *Functions) Enable(cap Enum) {
	C.glEnable(f.glEnable, C.GLenum(cap))
}

func (f *Functions) EndQuery(target Enum) {
	C.glEndQuery(f.glEndQuery, C.GLenum(target))
}

func (f *Functions) EnableVertexAttribArray(a Attrib) {
	C.glEnableVertexAttribArray(f.glEnableVertexAttribArray, C.GLuint(a))
}

func (f *Functions) Finish() {
	C.glFinish(f.glFinish)
}

func (f *Functions) Flush() {
	C.glFlush(f.glFinish)
}

func (f *Functions) FramebufferRenderbuffer(target, attachment, renderbuffertarget Enum, renderbuffer Renderbuffer) {
	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.glFramebufferTexture2D, C.GLenum(target), C.GLenum(attachment), C.GLenum(texTarget), C.GLuint(t.V), C.GLint(level))
}

func (f *Functions) GenerateMipmap(target Enum) {
	C.glGenerateMipmap(f.glGenerateMipmap, C.GLenum(target))
}

func (c *Functions) GetBinding(pname Enum) Object {
	return Object{uint(c.GetInteger(pname))}
}

func (c *Functions) GetBindingi(pname Enum, idx int) Object {
	return Object{uint(c.GetIntegeri(pname, idx))}
}

func (f *Functions) GetError() Enum {
	return Enum(C.glGetError(f.glGetError))
}

func (f *Functions) GetRenderbufferParameteri(target, pname Enum) int {
	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.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.glGetFloatv, C.GLenum(pname), &f.floats[0])
	var r [4]float32
	for i := range r {
		r[i] = float32(f.floats[i])
	}
	return r
}

func (f *Functions) GetFloat(pname Enum) float32 {
	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.glGetIntegerv, C.GLenum(pname), &f.ints[0])
	var r [4]int
	for i := range r {
		r[i] = int(f.ints[i])
	}
	return r
}

func (f *Functions) GetInteger(pname Enum) int {
	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.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.glGetProgramiv, C.GLuint(p.V), C.GLenum(pname), &f.ints[0])
	return int(f.ints[0])
}

func (f *Functions) GetProgramBinary(p Program) []byte {
	sz := f.GetProgrami(p, PROGRAM_BINARY_LENGTH)
	if sz == 0 {
		return nil
	}
	buf := make([]byte, sz)
	var format C.GLenum
	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.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.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.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.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.glGetStringi, C.GLenum(pname), C.GLuint(index))
	if str == nil {
		return ""
	}
	return C.GoString((*C.char)(unsafe.Pointer(str)))
}

func (f *Functions) GetString(pname Enum) string {
	switch {
	case runtime.GOOS == "darwin" && pname == EXTENSIONS:
		// macOS OpenGL 3 core profile doesn't support glGetString(GL_EXTENSIONS).
		// Use glGetStringi(GL_EXTENSIONS, <index>).
		var exts []string
		nexts := f.GetInteger(NUM_EXTENSIONS)
		for i := 0; i < nexts; i++ {
			ext := f.getStringi(EXTENSIONS, i)
			exts = append(exts, ext)
		}
		return strings.Join(exts, " ")
	default:
		str := C.glGetString(f.glGetString, C.GLenum(pname))
		return C.GoString((*C.char)(unsafe.Pointer(str)))
	}
}

func (f *Functions) GetUniformBlockIndex(p Program, name string) uint {
	cname := C.CString(name)
	defer C.free(unsafe.Pointer(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.glGetUniformLocation, C.GLuint(p.V), cname))}
}

func (f *Functions) GetVertexAttrib(index int, pname Enum) int {
	C.glGetVertexAttribiv(f.glGetVertexAttribiv, C.GLuint(index), C.GLenum(pname), &f.ints[0])
	return int(f.ints[0])
}

func (f *Functions) GetVertexAttribBinding(index int, pname Enum) Object {
	return Object{uint(f.GetVertexAttrib(index, pname))}
}

func (f *Functions) GetVertexAttribPointer(index int, pname Enum) uintptr {
	ptr := C.glGetVertexAttribPointerv(f.glGetVertexAttribPointerv, C.GLuint(index), C.GLenum(pname))
	return uintptr(ptr)
}

func (f *Functions) InvalidateFramebuffer(target, attachment Enum) {
	C.glInvalidateFramebuffer(f.glInvalidateFramebuffer, C.GLenum(target), C.GLenum(attachment))
}

func (f *Functions) IsEnabled(cap Enum) bool {
	return C.glIsEnabled(f.glIsEnabled, C.GLenum(cap)) == TRUE
}

func (f *Functions) LinkProgram(p Program) {
	C.glLinkProgram(f.glLinkProgram, C.GLuint(p.V))
}

func (f *Functions) PixelStorei(pname Enum, param int) {
	C.glPixelStorei(f.glPixelStorei, C.GLenum(pname), C.GLint(param))
}

func (f *Functions) MemoryBarrier(barriers Enum) {
	C.glMemoryBarrier(f.glMemoryBarrier, C.GLbitfield(barriers))
}

func (f *Functions) MapBufferRange(target Enum, offset, length int, access Enum) []byte {
	p := C.glMapBufferRange(f.glMapBufferRange, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(length), C.GLbitfield(access))
	if p == nil {
		return nil
	}
	return (*[1 << 30]byte)(p)[:length:length]
}

func (f *Functions) Scissor(x, y, width, height int32) {
	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) {
	var p unsafe.Pointer
	if len(data) > 0 {
		p = unsafe.Pointer(&data[0])
	}
	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.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.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.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.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) {
	var p unsafe.Pointer
	if len(data) > 0 {
		p = unsafe.Pointer(&data[0])
	}
	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.glTexParameteri, C.GLenum(target), C.GLenum(pname), C.GLint(param))
}

func (f *Functions) UniformBlockBinding(p Program, uniformBlockIndex uint, uniformBlockBinding uint) {
	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.glUniform1f, C.GLint(dst.V), C.GLfloat(v))
}

func (f *Functions) Uniform1i(dst Uniform, v int) {
	C.glUniform1i(f.glUniform1i, C.GLint(dst.V), C.GLint(v))
}

func (f *Functions) Uniform2f(dst Uniform, v0 float32, v1 float32) {
	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.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.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.glUseProgram, C.GLuint(p.V))
}

func (f *Functions) UnmapBuffer(target Enum) bool {
	r := C.glUnmapBuffer(f.glUnmapBuffer, 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 = FALSE
	if normalized {
		n = TRUE
	}
	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.glViewport, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height))
}