import ctypes

from .gl2 import _get_gl_func, _lib

# void = glActiveTexture(GLenum texture)
def glActiveTexture(texture): ...

# void = glAttachShader(GLuint program, GLuint shader)
def glAttachShader(program, shader): ...

# void = glBindAttribLocation(GLuint program, GLuint index, GLchar* name)
def glBindAttribLocation(program, index, name): ...

# void = glBindBuffer(GLenum target, GLuint buffer)
def glBindBuffer(target, buffer): ...

# void = glBindFramebuffer(GLenum target, GLuint framebuffer)
def glBindFramebuffer(target, framebuffer): ...

# void = glBindRenderbuffer(GLenum target, GLuint renderbuffer)
def glBindRenderbuffer(target, renderbuffer): ...

# void = glBindTexture(GLenum target, GLuint texture)
def glBindTexture(target, texture): ...

# void = glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
def glBlendColor(red, green, blue, alpha): ...

# void = glBlendEquation(GLenum mode)
def glBlendEquation(mode): ...

# void = glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
def glBlendEquationSeparate(modeRGB, modeAlpha): ...

# void = glBlendFunc(GLenum sfactor, GLenum dfactor)
def glBlendFunc(sfactor, dfactor): ...

# void = glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
def glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha): ...

# void = glBufferData(GLenum target, GLsizeiptr size, GLvoid* data, GLenum usage)
def glBufferData(target, data, usage): ...

# void = glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data)
def glBufferSubData(target, offset, data): ...

# GLenum = glCheckFramebufferStatus(GLenum target)
def glCheckFramebufferStatus(target): ...

# void = glClear(GLbitfield mask)
def glClear(mask): ...

# void = glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
def glClearColor(red, green, blue, alpha): ...

# void = glClearDepthf(GLclampf depth)
def glClearDepth(depth): ...

# void = glClearStencil(GLint s)
def glClearStencil(s): ...

# void = glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
def glColorMask(red, green, blue, alpha): ...

# void = glCompileShader(GLuint shader)
def glCompileShader(shader): ...

# void = glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, GLvoid* data)
def glCompressedTexImage2D(target, level, internalformat, width, height, border, data): ...

# void = glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, GLvoid* data)
def glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, data): ...

# void = glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
def glCopyTexImage2D(target, level, internalformat, x, y, width, height, border): ...

# void = glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
def glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height): ...

# GLuint = glCreateProgram()
def glCreateProgram(): ...

# GLuint = glCreateShader(GLenum type)
def glCreateShader(type): ...

# void = glCullFace(GLenum mode)
def glCullFace(mode): ...

# void = glDeleteBuffers(GLsizei n, GLuint* buffers)
def glDeleteBuffer(buffer): ...

# void = glDeleteFramebuffers(GLsizei n, GLuint* framebuffers)
def glDeleteFramebuffer(framebuffer): ...

# void = glDeleteProgram(GLuint program)
def glDeleteProgram(program): ...

# void = glDeleteRenderbuffers(GLsizei n, GLuint* renderbuffers)
def glDeleteRenderbuffer(renderbuffer): ...

# void = glDeleteShader(GLuint shader)
def glDeleteShader(shader): ...

# void = glDeleteTextures(GLsizei n, GLuint* textures)
def glDeleteTexture(texture): ...

# void = glDepthFunc(GLenum func)
def glDepthFunc(func): ...

# void = glDepthMask(GLboolean flag)
def glDepthMask(flag): ...

# void = glDepthRangef(GLclampf zNear, GLclampf zFar)
def glDepthRange(zNear, zFar): ...

# void = glDetachShader(GLuint program, GLuint shader)
def glDetachShader(program, shader): ...

# void = glDisable(GLenum cap)
def glDisable(cap): ...

# void = glDisableVertexAttribArray(GLuint index)
def glDisableVertexAttribArray(index): ...

# void = glDrawArrays(GLenum mode, GLint first, GLsizei count)
def glDrawArrays(mode, first, count): ...

# void = glDrawElements(GLenum mode, GLsizei count, GLenum type, GLvoid* indices)
def glDrawElements(mode, count, type, offset): ...

# void = glEnable(GLenum cap)
def glEnable(cap): ...

# void = glEnableVertexAttribArray(GLuint index)
def glEnableVertexAttribArray(index): ...

# void = glFinish()
def glFinish(): ...

# void = glFlush()
def glFlush(): ...

# void = glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
def glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer): ...

# void = glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
def glFramebufferTexture2D(target, attachment, textarget, texture, level): ...

# void = glFrontFace(GLenum mode)
def glFrontFace(mode): ...

# void = glGenBuffers(GLsizei n, GLuint* buffers)
def glCreateBuffer(): ...

# void = glGenFramebuffers(GLsizei n, GLuint* framebuffers)
def glCreateFramebuffer(): ...

# void = glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
def glCreateRenderbuffer(): ...

# void = glGenTextures(GLsizei n, GLuint* textures)
def glCreateTexture(): ...

# void = glGenerateMipmap(GLenum target)
def glGenerateMipmap(target): ...

# void = glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name)
def glGetActiveAttrib(program, index): ...

# void = glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name)
def glGetActiveUniform(program, index): ...

# void = glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
def glGetAttachedShaders(program): ...

# GLint = glGetAttribLocation(GLuint program, GLchar* name)
def glGetAttribLocation(program, name): ...

# void = glGetBooleanv(GLenum pname, GLboolean* params)
def _glGetBooleanv(pname): ...

# void = glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
def glGetBufferParameter(target, pname): ...

# GLenum = glGetError()
def glGetError(): ...

# void = glGetFloatv(GLenum pname, GLfloat* params)
def _glGetFloatv(pname): ...

# void = glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
def glGetFramebufferAttachmentParameter(target, attachment, pname): ...

# void = glGetIntegerv(GLenum pname, GLint* params)
def _glGetIntegerv(pname): ...

# void = glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog)
def glGetProgramInfoLog(program): ...

# void = glGetProgramiv(GLuint program, GLenum pname, GLint* params)
def glGetProgramParameter(program, pname): ...

# void = glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
def glGetRenderbufferParameter(target, pname): ...

# void = glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog)
def glGetShaderInfoLog(shader): ...

# void = glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
def glGetShaderPrecisionFormat(shadertype, precisiontype): ...

# void = glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source)
def glGetShaderSource(shader): ...

# void = glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
def glGetShaderParameter(shader, pname): ...

# GLubyte* = glGetString(GLenum name)
def glGetParameter(pname): ...

# void = glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
def glGetTexParameter(target, pname): ...

# void = glGetUniformfv(GLuint program, GLint location, GLfloat* params)
def glGetUniform(program, location): ...

# GLint = glGetUniformLocation(GLuint program, GLchar* name)
def glGetUniformLocation(program, name): ...

# void = glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
def glGetVertexAttrib(index, pname): ...

# void = glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** pointer)
def glGetVertexAttribOffset(index, pname): ...

# void = glHint(GLenum target, GLenum mode)
def glHint(target, mode): ...

# GLboolean = glIsBuffer(GLuint buffer)
def glIsBuffer(buffer): ...

# GLboolean = glIsEnabled(GLenum cap)
def glIsEnabled(cap): ...

# GLboolean = glIsFramebuffer(GLuint framebuffer)
def glIsFramebuffer(framebuffer): ...

# GLboolean = glIsProgram(GLuint program)
def glIsProgram(program): ...

# GLboolean = glIsRenderbuffer(GLuint renderbuffer)
def glIsRenderbuffer(renderbuffer): ...

# GLboolean = glIsShader(GLuint shader)
def glIsShader(shader): ...

# GLboolean = glIsTexture(GLuint texture)
def glIsTexture(texture): ...

# void = glLineWidth(GLfloat width)
def glLineWidth(width): ...

# void = glLinkProgram(GLuint program)
def glLinkProgram(program): ...

# void = glPixelStorei(GLenum pname, GLint param)
def glPixelStorei(pname, param): ...

# void = glPolygonOffset(GLfloat factor, GLfloat units)
def glPolygonOffset(factor, units): ...

# void = glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)
def glReadPixels(x, y, width, height, format, type): ...

# void = glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
def glRenderbufferStorage(target, internalformat, width, height): ...

# void = glSampleCoverage(GLclampf value, GLboolean invert)
def glSampleCoverage(value, invert): ...

# void = glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
def glScissor(x, y, width, height): ...

# void = glShaderSource(GLuint shader, GLsizei count, GLchar** string, GLint* length)
def glShaderSource(shader, source): ...

# void = glStencilFunc(GLenum func, GLint ref, GLuint mask)
def glStencilFunc(func, ref, mask): ...

# void = glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
def glStencilFuncSeparate(face, func, ref, mask): ...

# void = glStencilMask(GLuint mask)
def glStencilMask(mask): ...

# void = glStencilMaskSeparate(GLenum face, GLuint mask)
def glStencilMaskSeparate(face, mask): ...

# void = glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
def glStencilOp(fail, zfail, zpass): ...

# void = glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
def glStencilOpSeparate(face, fail, zfail, zpass): ...

# void = glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLvoid* pixels)
def glTexImage2D(target, level, internalformat, format, type, pixels): ...
def glTexParameterf(target, pname, param): ...
def glTexParameteri(target, pname, param): ...

# void = glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)
def glTexSubImage2D(target, level, xoffset, yoffset, format, type, pixels): ...
def glUniform1f(location, v1): ...
def glUniform2f(location, v1, v2): ...
def glUniform3f(location, v1, v2, v3): ...
def glUniform4f(location, v1, v2, v3, v4): ...
def glUniform1i(location, v1): ...
def glUniform2i(location, v1, v2): ...
def glUniform3i(location, v1, v2, v3): ...
def glUniform4i(location, v1, v2, v3, v4): ...
def glUniform1fv(location, count, values): ...
def glUniform2fv(location, count, values): ...
def glUniform3fv(location, count, values): ...
def glUniform4fv(location, count, values): ...
def glUniform1iv(location, count, values): ...
def glUniform2iv(location, count, values): ...
def glUniform3iv(location, count, values): ...
def glUniform4iv(location, count, values): ...
def glUniformMatrix2fv(location, count, transpose, values): ...
def glUniformMatrix3fv(location, count, transpose, values): ...
def glUniformMatrix4fv(location, count, transpose, values): ...

# void = glUseProgram(GLuint program)
def glUseProgram(program): ...

# void = glValidateProgram(GLuint program)
def glValidateProgram(program): ...
def glVertexAttrib1f(index, v1): ...
def glVertexAttrib2f(index, v1, v2): ...
def glVertexAttrib3f(index, v1, v2, v3): ...
def glVertexAttrib4f(index, v1, v2, v3, v4): ...

# void = glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLvoid* ptr)
def glVertexAttribPointer(indx, size, type, normalized, stride, offset): ...

# void = glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
def glViewport(x, y, width, height): ...
