module glad.gl.funcs;


private import glad.gl.types;
bool GL_VERSION_1_0;
bool GL_VERSION_1_1;
bool GL_VERSION_1_2;
bool GL_VERSION_1_3;
bool GL_VERSION_1_4;
bool GL_VERSION_1_5;
bool GL_VERSION_2_0;
bool GL_VERSION_2_1;
bool GL_VERSION_3_0;
bool GL_VERSION_3_1;
bool GL_VERSION_3_2;
bool GL_VERSION_3_3;
bool GL_VERSION_4_0;
bool GL_VERSION_4_1;
bool GL_VERSION_4_2;
bool GL_VERSION_4_3;
bool GL_VERSION_4_4;
nothrow extern(System) {
alias fp_glCullFace = void function(GLenum);
alias fp_glFrontFace = void function(GLenum);
alias fp_glHint = void function(GLenum, GLenum);
alias fp_glLineWidth = void function(GLfloat);
alias fp_glPointSize = void function(GLfloat);
alias fp_glPolygonMode = void function(GLenum, GLenum);
alias fp_glScissor = void function(GLint, GLint, GLsizei, GLsizei);
alias fp_glTexParameterf = void function(GLenum, GLenum, GLfloat);
alias fp_glTexParameterfv = void function(GLenum, GLenum, const(GLfloat)*);
alias fp_glTexParameteri = void function(GLenum, GLenum, GLint);
alias fp_glTexParameteriv = void function(GLenum, GLenum, const(GLint)*);
alias fp_glTexImage1D = void function(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const(GLvoid)*);
alias fp_glTexImage2D = void function(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const(GLvoid)*);
alias fp_glDrawBuffer = void function(GLenum);
alias fp_glClear = void function(GLbitfield);
alias fp_glClearColor = void function(GLfloat, GLfloat, GLfloat, GLfloat);
alias fp_glClearStencil = void function(GLint);
alias fp_glClearDepth = void function(GLdouble);
alias fp_glStencilMask = void function(GLuint);
alias fp_glColorMask = void function(GLboolean, GLboolean, GLboolean, GLboolean);
alias fp_glDepthMask = void function(GLboolean);
alias fp_glDisable = void function(GLenum);
alias fp_glEnable = void function(GLenum);
alias fp_glFinish = void function();
alias fp_glFlush = void function();
alias fp_glBlendFunc = void function(GLenum, GLenum);
alias fp_glLogicOp = void function(GLenum);
alias fp_glStencilFunc = void function(GLenum, GLint, GLuint);
alias fp_glStencilOp = void function(GLenum, GLenum, GLenum);
alias fp_glDepthFunc = void function(GLenum);
alias fp_glPixelStoref = void function(GLenum, GLfloat);
alias fp_glPixelStorei = void function(GLenum, GLint);
alias fp_glReadBuffer = void function(GLenum);
alias fp_glReadPixels = void function(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid*);
alias fp_glGetBooleanv = void function(GLenum, GLboolean*);
alias fp_glGetDoublev = void function(GLenum, GLdouble*);
alias fp_glGetError = GLenum function();
alias fp_glGetFloatv = void function(GLenum, GLfloat*);
alias fp_glGetIntegerv = void function(GLenum, GLint*);
alias fp_glGetString = const(GLubyte)* function(GLenum);
alias fp_glGetTexImage = void function(GLenum, GLint, GLenum, GLenum, GLvoid*);
alias fp_glGetTexParameterfv = void function(GLenum, GLenum, GLfloat*);
alias fp_glGetTexParameteriv = void function(GLenum, GLenum, GLint*);
alias fp_glGetTexLevelParameterfv = void function(GLenum, GLint, GLenum, GLfloat*);
alias fp_glGetTexLevelParameteriv = void function(GLenum, GLint, GLenum, GLint*);
alias fp_glIsEnabled = GLboolean function(GLenum);
alias fp_glDepthRange = void function(GLdouble, GLdouble);
alias fp_glViewport = void function(GLint, GLint, GLsizei, GLsizei);
alias fp_glNewList = void function(GLuint, GLenum);
alias fp_glEndList = void function();
alias fp_glCallList = void function(GLuint);
alias fp_glCallLists = void function(GLsizei, GLenum, const(GLvoid)*);
alias fp_glDeleteLists = void function(GLuint, GLsizei);
alias fp_glGenLists = GLuint function(GLsizei);
alias fp_glListBase = void function(GLuint);
alias fp_glBegin = void function(GLenum);
alias fp_glBitmap = void function(GLsizei, GLsizei, GLfloat, GLfloat, GLfloat, GLfloat, const(GLubyte)*);
alias fp_glColor3b = void function(GLbyte, GLbyte, GLbyte);
alias fp_glColor3bv = void function(const(GLbyte)*);
alias fp_glColor3d = void function(GLdouble, GLdouble, GLdouble);
alias fp_glColor3dv = void function(const(GLdouble)*);
alias fp_glColor3f = void function(GLfloat, GLfloat, GLfloat);
alias fp_glColor3fv = void function(const(GLfloat)*);
alias fp_glColor3i = void function(GLint, GLint, GLint);
alias fp_glColor3iv = void function(const(GLint)*);
alias fp_glColor3s = void function(GLshort, GLshort, GLshort);
alias fp_glColor3sv = void function(const(GLshort)*);
alias fp_glColor3ub = void function(GLubyte, GLubyte, GLubyte);
alias fp_glColor3ubv = void function(const(GLubyte)*);
alias fp_glColor3ui = void function(GLuint, GLuint, GLuint);
alias fp_glColor3uiv = void function(const(GLuint)*);
alias fp_glColor3us = void function(GLushort, GLushort, GLushort);
alias fp_glColor3usv = void function(const(GLushort)*);
alias fp_glColor4b = void function(GLbyte, GLbyte, GLbyte, GLbyte);
alias fp_glColor4bv = void function(const(GLbyte)*);
alias fp_glColor4d = void function(GLdouble, GLdouble, GLdouble, GLdouble);
alias fp_glColor4dv = void function(const(GLdouble)*);
alias fp_glColor4f = void function(GLfloat, GLfloat, GLfloat, GLfloat);
alias fp_glColor4fv = void function(const(GLfloat)*);
alias fp_glColor4i = void function(GLint, GLint, GLint, GLint);
alias fp_glColor4iv = void function(const(GLint)*);
alias fp_glColor4s = void function(GLshort, GLshort, GLshort, GLshort);
alias fp_glColor4sv = void function(const(GLshort)*);
alias fp_glColor4ub = void function(GLubyte, GLubyte, GLubyte, GLubyte);
alias fp_glColor4ubv = void function(const(GLubyte)*);
alias fp_glColor4ui = void function(GLuint, GLuint, GLuint, GLuint);
alias fp_glColor4uiv = void function(const(GLuint)*);
alias fp_glColor4us = void function(GLushort, GLushort, GLushort, GLushort);
alias fp_glColor4usv = void function(const(GLushort)*);
alias fp_glEdgeFlag = void function(GLboolean);
alias fp_glEdgeFlagv = void function(const(GLboolean)*);
alias fp_glEnd = void function();
alias fp_glIndexd = void function(GLdouble);
alias fp_glIndexdv = void function(const(GLdouble)*);
alias fp_glIndexf = void function(GLfloat);
alias fp_glIndexfv = void function(const(GLfloat)*);
alias fp_glIndexi = void function(GLint);
alias fp_glIndexiv = void function(const(GLint)*);
alias fp_glIndexs = void function(GLshort);
alias fp_glIndexsv = void function(const(GLshort)*);
alias fp_glNormal3b = void function(GLbyte, GLbyte, GLbyte);
alias fp_glNormal3bv = void function(const(GLbyte)*);
alias fp_glNormal3d = void function(GLdouble, GLdouble, GLdouble);
alias fp_glNormal3dv = void function(const(GLdouble)*);
alias fp_glNormal3f = void function(GLfloat, GLfloat, GLfloat);
alias fp_glNormal3fv = void function(const(GLfloat)*);
alias fp_glNormal3i = void function(GLint, GLint, GLint);
alias fp_glNormal3iv = void function(const(GLint)*);
alias fp_glNormal3s = void function(GLshort, GLshort, GLshort);
alias fp_glNormal3sv = void function(const(GLshort)*);
alias fp_glRasterPos2d = void function(GLdouble, GLdouble);
alias fp_glRasterPos2dv = void function(const(GLdouble)*);
alias fp_glRasterPos2f = void function(GLfloat, GLfloat);
alias fp_glRasterPos2fv = void function(const(GLfloat)*);
alias fp_glRasterPos2i = void function(GLint, GLint);
alias fp_glRasterPos2iv = void function(const(GLint)*);
alias fp_glRasterPos2s = void function(GLshort, GLshort);
alias fp_glRasterPos2sv = void function(const(GLshort)*);
alias fp_glRasterPos3d = void function(GLdouble, GLdouble, GLdouble);
alias fp_glRasterPos3dv = void function(const(GLdouble)*);
alias fp_glRasterPos3f = void function(GLfloat, GLfloat, GLfloat);
alias fp_glRasterPos3fv = void function(const(GLfloat)*);
alias fp_glRasterPos3i = void function(GLint, GLint, GLint);
alias fp_glRasterPos3iv = void function(const(GLint)*);
alias fp_glRasterPos3s = void function(GLshort, GLshort, GLshort);
alias fp_glRasterPos3sv = void function(const(GLshort)*);
alias fp_glRasterPos4d = void function(GLdouble, GLdouble, GLdouble, GLdouble);
alias fp_glRasterPos4dv = void function(const(GLdouble)*);
alias fp_glRasterPos4f = void function(GLfloat, GLfloat, GLfloat, GLfloat);
alias fp_glRasterPos4fv = void function(const(GLfloat)*);
alias fp_glRasterPos4i = void function(GLint, GLint, GLint, GLint);
alias fp_glRasterPos4iv = void function(const(GLint)*);
alias fp_glRasterPos4s = void function(GLshort, GLshort, GLshort, GLshort);
alias fp_glRasterPos4sv = void function(const(GLshort)*);
alias fp_glRectd = void function(GLdouble, GLdouble, GLdouble, GLdouble);
alias fp_glRectdv = void function(const(GLdouble)*, const(GLdouble)*);
alias fp_glRectf = void function(GLfloat, GLfloat, GLfloat, GLfloat);
alias fp_glRectfv = void function(const(GLfloat)*, const(GLfloat)*);
alias fp_glRecti = void function(GLint, GLint, GLint, GLint);
alias fp_glRectiv = void function(const(GLint)*, const(GLint)*);
alias fp_glRects = void function(GLshort, GLshort, GLshort, GLshort);
alias fp_glRectsv = void function(const(GLshort)*, const(GLshort)*);
alias fp_glTexCoord1d = void function(GLdouble);
alias fp_glTexCoord1dv = void function(const(GLdouble)*);
alias fp_glTexCoord1f = void function(GLfloat);
alias fp_glTexCoord1fv = void function(const(GLfloat)*);
alias fp_glTexCoord1i = void function(GLint);
alias fp_glTexCoord1iv = void function(const(GLint)*);
alias fp_glTexCoord1s = void function(GLshort);
alias fp_glTexCoord1sv = void function(const(GLshort)*);
alias fp_glTexCoord2d = void function(GLdouble, GLdouble);
alias fp_glTexCoord2dv = void function(const(GLdouble)*);
alias fp_glTexCoord2f = void function(GLfloat, GLfloat);
alias fp_glTexCoord2fv = void function(const(GLfloat)*);
alias fp_glTexCoord2i = void function(GLint, GLint);
alias fp_glTexCoord2iv = void function(const(GLint)*);
alias fp_glTexCoord2s = void function(GLshort, GLshort);
alias fp_glTexCoord2sv = void function(const(GLshort)*);
alias fp_glTexCoord3d = void function(GLdouble, GLdouble, GLdouble);
alias fp_glTexCoord3dv = void function(const(GLdouble)*);
alias fp_glTexCoord3f = void function(GLfloat, GLfloat, GLfloat);
alias fp_glTexCoord3fv = void function(const(GLfloat)*);
alias fp_glTexCoord3i = void function(GLint, GLint, GLint);
alias fp_glTexCoord3iv = void function(const(GLint)*);
alias fp_glTexCoord3s = void function(GLshort, GLshort, GLshort);
alias fp_glTexCoord3sv = void function(const(GLshort)*);
alias fp_glTexCoord4d = void function(GLdouble, GLdouble, GLdouble, GLdouble);
alias fp_glTexCoord4dv = void function(const(GLdouble)*);
alias fp_glTexCoord4f = void function(GLfloat, GLfloat, GLfloat, GLfloat);
alias fp_glTexCoord4fv = void function(const(GLfloat)*);
alias fp_glTexCoord4i = void function(GLint, GLint, GLint, GLint);
alias fp_glTexCoord4iv = void function(const(GLint)*);
alias fp_glTexCoord4s = void function(GLshort, GLshort, GLshort, GLshort);
alias fp_glTexCoord4sv = void function(const(GLshort)*);
alias fp_glVertex2d = void function(GLdouble, GLdouble);
alias fp_glVertex2dv = void function(const(GLdouble)*);
alias fp_glVertex2f = void function(GLfloat, GLfloat);
alias fp_glVertex2fv = void function(const(GLfloat)*);
alias fp_glVertex2i = void function(GLint, GLint);
alias fp_glVertex2iv = void function(const(GLint)*);
alias fp_glVertex2s = void function(GLshort, GLshort);
alias fp_glVertex2sv = void function(const(GLshort)*);
alias fp_glVertex3d = void function(GLdouble, GLdouble, GLdouble);
alias fp_glVertex3dv = void function(const(GLdouble)*);
alias fp_glVertex3f = void function(GLfloat, GLfloat, GLfloat);
alias fp_glVertex3fv = void function(const(GLfloat)*);
alias fp_glVertex3i = void function(GLint, GLint, GLint);
alias fp_glVertex3iv = void function(const(GLint)*);
alias fp_glVertex3s = void function(GLshort, GLshort, GLshort);
alias fp_glVertex3sv = void function(const(GLshort)*);
alias fp_glVertex4d = void function(GLdouble, GLdouble, GLdouble, GLdouble);
alias fp_glVertex4dv = void function(const(GLdouble)*);
alias fp_glVertex4f = void function(GLfloat, GLfloat, GLfloat, GLfloat);
alias fp_glVertex4fv = void function(const(GLfloat)*);
alias fp_glVertex4i = void function(GLint, GLint, GLint, GLint);
alias fp_glVertex4iv = void function(const(GLint)*);
alias fp_glVertex4s = void function(GLshort, GLshort, GLshort, GLshort);
alias fp_glVertex4sv = void function(const(GLshort)*);
alias fp_glClipPlane = void function(GLenum, const(GLdouble)*);
alias fp_glColorMaterial = void function(GLenum, GLenum);
alias fp_glFogf = void function(GLenum, GLfloat);
alias fp_glFogfv = void function(GLenum, const(GLfloat)*);
alias fp_glFogi = void function(GLenum, GLint);
alias fp_glFogiv = void function(GLenum, const(GLint)*);
alias fp_glLightf = void function(GLenum, GLenum, GLfloat);
alias fp_glLightfv = void function(GLenum, GLenum, const(GLfloat)*);
alias fp_glLighti = void function(GLenum, GLenum, GLint);
alias fp_glLightiv = void function(GLenum, GLenum, const(GLint)*);
alias fp_glLightModelf = void function(GLenum, GLfloat);
alias fp_glLightModelfv = void function(GLenum, const(GLfloat)*);
alias fp_glLightModeli = void function(GLenum, GLint);
alias fp_glLightModeliv = void function(GLenum, const(GLint)*);
alias fp_glLineStipple = void function(GLint, GLushort);
alias fp_glMaterialf = void function(GLenum, GLenum, GLfloat);
alias fp_glMaterialfv = void function(GLenum, GLenum, const(GLfloat)*);
alias fp_glMateriali = void function(GLenum, GLenum, GLint);
alias fp_glMaterialiv = void function(GLenum, GLenum, const(GLint)*);
alias fp_glPolygonStipple = void function(const(GLubyte)*);
alias fp_glShadeModel = void function(GLenum);
alias fp_glTexEnvf = void function(GLenum, GLenum, GLfloat);
alias fp_glTexEnvfv = void function(GLenum, GLenum, const(GLfloat)*);
alias fp_glTexEnvi = void function(GLenum, GLenum, GLint);
alias fp_glTexEnviv = void function(GLenum, GLenum, const(GLint)*);
alias fp_glTexGend = void function(GLenum, GLenum, GLdouble);
alias fp_glTexGendv = void function(GLenum, GLenum, const(GLdouble)*);
alias fp_glTexGenf = void function(GLenum, GLenum, GLfloat);
alias fp_glTexGenfv = void function(GLenum, GLenum, const(GLfloat)*);
alias fp_glTexGeni = void function(GLenum, GLenum, GLint);
alias fp_glTexGeniv = void function(GLenum, GLenum, const(GLint)*);
alias fp_glFeedbackBuffer = void function(GLsizei, GLenum, GLfloat*);
alias fp_glSelectBuffer = void function(GLsizei, GLuint*);
alias fp_glRenderMode = GLint function(GLenum);
alias fp_glInitNames = void function();
alias fp_glLoadName = void function(GLuint);
alias fp_glPassThrough = void function(GLfloat);
alias fp_glPopName = void function();
alias fp_glPushName = void function(GLuint);
alias fp_glClearAccum = void function(GLfloat, GLfloat, GLfloat, GLfloat);
alias fp_glClearIndex = void function(GLfloat);
alias fp_glIndexMask = void function(GLuint);
alias fp_glAccum = void function(GLenum, GLfloat);
alias fp_glPopAttrib = void function();
alias fp_glPushAttrib = void function(GLbitfield);
alias fp_glMap1d = void function(GLenum, GLdouble, GLdouble, GLint, GLint, const(GLdouble)*);
alias fp_glMap1f = void function(GLenum, GLfloat, GLfloat, GLint, GLint, const(GLfloat)*);
alias fp_glMap2d = void function(GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, const(GLdouble)*);
alias fp_glMap2f = void function(GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, const(GLfloat)*);
alias fp_glMapGrid1d = void function(GLint, GLdouble, GLdouble);
alias fp_glMapGrid1f = void function(GLint, GLfloat, GLfloat);
alias fp_glMapGrid2d = void function(GLint, GLdouble, GLdouble, GLint, GLdouble, GLdouble);
alias fp_glMapGrid2f = void function(GLint, GLfloat, GLfloat, GLint, GLfloat, GLfloat);
alias fp_glEvalCoord1d = void function(GLdouble);
alias fp_glEvalCoord1dv = void function(const(GLdouble)*);
alias fp_glEvalCoord1f = void function(GLfloat);
alias fp_glEvalCoord1fv = void function(const(GLfloat)*);
alias fp_glEvalCoord2d = void function(GLdouble, GLdouble);
alias fp_glEvalCoord2dv = void function(const(GLdouble)*);
alias fp_glEvalCoord2f = void function(GLfloat, GLfloat);
alias fp_glEvalCoord2fv = void function(const(GLfloat)*);
alias fp_glEvalMesh1 = void function(GLenum, GLint, GLint);
alias fp_glEvalPoint1 = void function(GLint);
alias fp_glEvalMesh2 = void function(GLenum, GLint, GLint, GLint, GLint);
alias fp_glEvalPoint2 = void function(GLint, GLint);
alias fp_glAlphaFunc = void function(GLenum, GLfloat);
alias fp_glPixelZoom = void function(GLfloat, GLfloat);
alias fp_glPixelTransferf = void function(GLenum, GLfloat);
alias fp_glPixelTransferi = void function(GLenum, GLint);
alias fp_glPixelMapfv = void function(GLenum, GLsizei, const(GLfloat)*);
alias fp_glPixelMapuiv = void function(GLenum, GLsizei, const(GLuint)*);
alias fp_glPixelMapusv = void function(GLenum, GLsizei, const(GLushort)*);
alias fp_glCopyPixels = void function(GLint, GLint, GLsizei, GLsizei, GLenum);
alias fp_glDrawPixels = void function(GLsizei, GLsizei, GLenum, GLenum, const(GLvoid)*);
alias fp_glGetClipPlane = void function(GLenum, GLdouble*);
alias fp_glGetLightfv = void function(GLenum, GLenum, GLfloat*);
alias fp_glGetLightiv = void function(GLenum, GLenum, GLint*);
alias fp_glGetMapdv = void function(GLenum, GLenum, GLdouble*);
alias fp_glGetMapfv = void function(GLenum, GLenum, GLfloat*);
alias fp_glGetMapiv = void function(GLenum, GLenum, GLint*);
alias fp_glGetMaterialfv = void function(GLenum, GLenum, GLfloat*);
alias fp_glGetMaterialiv = void function(GLenum, GLenum, GLint*);
alias fp_glGetPixelMapfv = void function(GLenum, GLfloat*);
alias fp_glGetPixelMapuiv = void function(GLenum, GLuint*);
alias fp_glGetPixelMapusv = void function(GLenum, GLushort*);
alias fp_glGetPolygonStipple = void function(GLubyte*);
alias fp_glGetTexEnvfv = void function(GLenum, GLenum, GLfloat*);
alias fp_glGetTexEnviv = void function(GLenum, GLenum, GLint*);
alias fp_glGetTexGendv = void function(GLenum, GLenum, GLdouble*);
alias fp_glGetTexGenfv = void function(GLenum, GLenum, GLfloat*);
alias fp_glGetTexGeniv = void function(GLenum, GLenum, GLint*);
alias fp_glIsList = GLboolean function(GLuint);
alias fp_glFrustum = void function(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble);
alias fp_glLoadIdentity = void function();
alias fp_glLoadMatrixf = void function(const(GLfloat)*);
alias fp_glLoadMatrixd = void function(const(GLdouble)*);
alias fp_glMatrixMode = void function(GLenum);
alias fp_glMultMatrixf = void function(const(GLfloat)*);
alias fp_glMultMatrixd = void function(const(GLdouble)*);
alias fp_glOrtho = void function(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble);
alias fp_glPopMatrix = void function();
alias fp_glPushMatrix = void function();
alias fp_glRotated = void function(GLdouble, GLdouble, GLdouble, GLdouble);
alias fp_glRotatef = void function(GLfloat, GLfloat, GLfloat, GLfloat);
alias fp_glScaled = void function(GLdouble, GLdouble, GLdouble);
alias fp_glScalef = void function(GLfloat, GLfloat, GLfloat);
alias fp_glTranslated = void function(GLdouble, GLdouble, GLdouble);
alias fp_glTranslatef = void function(GLfloat, GLfloat, GLfloat);
alias fp_glDrawArrays = void function(GLenum, GLint, GLsizei);
alias fp_glDrawElements = void function(GLenum, GLsizei, GLenum, const(GLvoid)*);
alias fp_glGetPointerv = void function(GLenum, GLvoid**);
alias fp_glPolygonOffset = void function(GLfloat, GLfloat);
alias fp_glCopyTexImage1D = void function(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint);
alias fp_glCopyTexImage2D = void function(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint);
alias fp_glCopyTexSubImage1D = void function(GLenum, GLint, GLint, GLint, GLint, GLsizei);
alias fp_glCopyTexSubImage2D = void function(GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei);
alias fp_glTexSubImage1D = void function(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const(GLvoid)*);
alias fp_glTexSubImage2D = void function(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const(GLvoid)*);
alias fp_glBindTexture = void function(GLenum, GLuint);
alias fp_glDeleteTextures = void function(GLsizei, const(GLuint)*);
alias fp_glGenTextures = void function(GLsizei, GLuint*);
alias fp_glIsTexture = GLboolean function(GLuint);
alias fp_glArrayElement = void function(GLint);
alias fp_glColorPointer = void function(GLint, GLenum, GLsizei, const(GLvoid)*);
alias fp_glDisableClientState = void function(GLenum);
alias fp_glEdgeFlagPointer = void function(GLsizei, const(GLvoid)*);
alias fp_glEnableClientState = void function(GLenum);
alias fp_glIndexPointer = void function(GLenum, GLsizei, const(GLvoid)*);
alias fp_glInterleavedArrays = void function(GLenum, GLsizei, const(GLvoid)*);
alias fp_glNormalPointer = void function(GLenum, GLsizei, const(GLvoid)*);
alias fp_glTexCoordPointer = void function(GLint, GLenum, GLsizei, const(GLvoid)*);
alias fp_glVertexPointer = void function(GLint, GLenum, GLsizei, const(GLvoid)*);
alias fp_glAreTexturesResident = GLboolean function(GLsizei, const(GLuint)*, GLboolean*);
alias fp_glPrioritizeTextures = void function(GLsizei, const(GLuint)*, const(GLfloat)*);
alias fp_glIndexub = void function(GLubyte);
alias fp_glIndexubv = void function(const(GLubyte)*);
alias fp_glPopClientAttrib = void function();
alias fp_glPushClientAttrib = void function(GLbitfield);
alias fp_glBlendColor = void function(GLfloat, GLfloat, GLfloat, GLfloat);
alias fp_glBlendEquation = void function(GLenum);
alias fp_glDrawRangeElements = void function(GLenum, GLuint, GLuint, GLsizei, GLenum, const(GLvoid)*);
alias fp_glTexImage3D = void function(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const(GLvoid)*);
alias fp_glTexSubImage3D = void function(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const(GLvoid)*);
alias fp_glCopyTexSubImage3D = void function(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei);
alias fp_glActiveTexture = void function(GLenum);
alias fp_glSampleCoverage = void function(GLfloat, GLboolean);
alias fp_glCompressedTexImage3D = void function(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const(GLvoid)*);
alias fp_glCompressedTexImage2D = void function(GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const(GLvoid)*);
alias fp_glCompressedTexImage1D = void function(GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, const(GLvoid)*);
alias fp_glCompressedTexSubImage3D = void function(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const(GLvoid)*);
alias fp_glCompressedTexSubImage2D = void function(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const(GLvoid)*);
alias fp_glCompressedTexSubImage1D = void function(GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, const(GLvoid)*);
alias fp_glGetCompressedTexImage = void function(GLenum, GLint, GLvoid*);
alias fp_glClientActiveTexture = void function(GLenum);
alias fp_glMultiTexCoord1d = void function(GLenum, GLdouble);
alias fp_glMultiTexCoord1dv = void function(GLenum, const(GLdouble)*);
alias fp_glMultiTexCoord1f = void function(GLenum, GLfloat);
alias fp_glMultiTexCoord1fv = void function(GLenum, const(GLfloat)*);
alias fp_glMultiTexCoord1i = void function(GLenum, GLint);
alias fp_glMultiTexCoord1iv = void function(GLenum, const(GLint)*);
alias fp_glMultiTexCoord1s = void function(GLenum, GLshort);
alias fp_glMultiTexCoord1sv = void function(GLenum, const(GLshort)*);
alias fp_glMultiTexCoord2d = void function(GLenum, GLdouble, GLdouble);
alias fp_glMultiTexCoord2dv = void function(GLenum, const(GLdouble)*);
alias fp_glMultiTexCoord2f = void function(GLenum, GLfloat, GLfloat);
alias fp_glMultiTexCoord2fv = void function(GLenum, const(GLfloat)*);
alias fp_glMultiTexCoord2i = void function(GLenum, GLint, GLint);
alias fp_glMultiTexCoord2iv = void function(GLenum, const(GLint)*);
alias fp_glMultiTexCoord2s = void function(GLenum, GLshort, GLshort);
alias fp_glMultiTexCoord2sv = void function(GLenum, const(GLshort)*);
alias fp_glMultiTexCoord3d = void function(GLenum, GLdouble, GLdouble, GLdouble);
alias fp_glMultiTexCoord3dv = void function(GLenum, const(GLdouble)*);
alias fp_glMultiTexCoord3f = void function(GLenum, GLfloat, GLfloat, GLfloat);
alias fp_glMultiTexCoord3fv = void function(GLenum, const(GLfloat)*);
alias fp_glMultiTexCoord3i = void function(GLenum, GLint, GLint, GLint);
alias fp_glMultiTexCoord3iv = void function(GLenum, const(GLint)*);
alias fp_glMultiTexCoord3s = void function(GLenum, GLshort, GLshort, GLshort);
alias fp_glMultiTexCoord3sv = void function(GLenum, const(GLshort)*);
alias fp_glMultiTexCoord4d = void function(GLenum, GLdouble, GLdouble, GLdouble, GLdouble);
alias fp_glMultiTexCoord4dv = void function(GLenum, const(GLdouble)*);
alias fp_glMultiTexCoord4f = void function(GLenum, GLfloat, GLfloat, GLfloat, GLfloat);
alias fp_glMultiTexCoord4fv = void function(GLenum, const(GLfloat)*);
alias fp_glMultiTexCoord4i = void function(GLenum, GLint, GLint, GLint, GLint);
alias fp_glMultiTexCoord4iv = void function(GLenum, const(GLint)*);
alias fp_glMultiTexCoord4s = void function(GLenum, GLshort, GLshort, GLshort, GLshort);
alias fp_glMultiTexCoord4sv = void function(GLenum, const(GLshort)*);
alias fp_glLoadTransposeMatrixf = void function(const(GLfloat)*);
alias fp_glLoadTransposeMatrixd = void function(const(GLdouble)*);
alias fp_glMultTransposeMatrixf = void function(const(GLfloat)*);
alias fp_glMultTransposeMatrixd = void function(const(GLdouble)*);
alias fp_glBlendFuncSeparate = void function(GLenum, GLenum, GLenum, GLenum);
alias fp_glMultiDrawArrays = void function(GLenum, const(GLint)*, const(GLsizei)*, GLsizei);
alias fp_glMultiDrawElements = void function(GLenum, const(GLsizei)*, GLenum, const(GLvoid*)*, GLsizei);
alias fp_glPointParameterf = void function(GLenum, GLfloat);
alias fp_glPointParameterfv = void function(GLenum, const(GLfloat)*);
alias fp_glPointParameteri = void function(GLenum, GLint);
alias fp_glPointParameteriv = void function(GLenum, const(GLint)*);
alias fp_glFogCoordf = void function(GLfloat);
alias fp_glFogCoordfv = void function(const(GLfloat)*);
alias fp_glFogCoordd = void function(GLdouble);
alias fp_glFogCoorddv = void function(const(GLdouble)*);
alias fp_glFogCoordPointer = void function(GLenum, GLsizei, const(GLvoid)*);
alias fp_glSecondaryColor3b = void function(GLbyte, GLbyte, GLbyte);
alias fp_glSecondaryColor3bv = void function(const(GLbyte)*);
alias fp_glSecondaryColor3d = void function(GLdouble, GLdouble, GLdouble);
alias fp_glSecondaryColor3dv = void function(const(GLdouble)*);
alias fp_glSecondaryColor3f = void function(GLfloat, GLfloat, GLfloat);
alias fp_glSecondaryColor3fv = void function(const(GLfloat)*);
alias fp_glSecondaryColor3i = void function(GLint, GLint, GLint);
alias fp_glSecondaryColor3iv = void function(const(GLint)*);
alias fp_glSecondaryColor3s = void function(GLshort, GLshort, GLshort);
alias fp_glSecondaryColor3sv = void function(const(GLshort)*);
alias fp_glSecondaryColor3ub = void function(GLubyte, GLubyte, GLubyte);
alias fp_glSecondaryColor3ubv = void function(const(GLubyte)*);
alias fp_glSecondaryColor3ui = void function(GLuint, GLuint, GLuint);
alias fp_glSecondaryColor3uiv = void function(const(GLuint)*);
alias fp_glSecondaryColor3us = void function(GLushort, GLushort, GLushort);
alias fp_glSecondaryColor3usv = void function(const(GLushort)*);
alias fp_glSecondaryColorPointer = void function(GLint, GLenum, GLsizei, const(GLvoid)*);
alias fp_glWindowPos2d = void function(GLdouble, GLdouble);
alias fp_glWindowPos2dv = void function(const(GLdouble)*);
alias fp_glWindowPos2f = void function(GLfloat, GLfloat);
alias fp_glWindowPos2fv = void function(const(GLfloat)*);
alias fp_glWindowPos2i = void function(GLint, GLint);
alias fp_glWindowPos2iv = void function(const(GLint)*);
alias fp_glWindowPos2s = void function(GLshort, GLshort);
alias fp_glWindowPos2sv = void function(const(GLshort)*);
alias fp_glWindowPos3d = void function(GLdouble, GLdouble, GLdouble);
alias fp_glWindowPos3dv = void function(const(GLdouble)*);
alias fp_glWindowPos3f = void function(GLfloat, GLfloat, GLfloat);
alias fp_glWindowPos3fv = void function(const(GLfloat)*);
alias fp_glWindowPos3i = void function(GLint, GLint, GLint);
alias fp_glWindowPos3iv = void function(const(GLint)*);
alias fp_glWindowPos3s = void function(GLshort, GLshort, GLshort);
alias fp_glWindowPos3sv = void function(const(GLshort)*);
alias fp_glGenQueries = void function(GLsizei, GLuint*);
alias fp_glDeleteQueries = void function(GLsizei, const(GLuint)*);
alias fp_glIsQuery = GLboolean function(GLuint);
alias fp_glBeginQuery = void function(GLenum, GLuint);
alias fp_glEndQuery = void function(GLenum);
alias fp_glGetQueryiv = void function(GLenum, GLenum, GLint*);
alias fp_glGetQueryObjectiv = void function(GLuint, GLenum, GLint*);
alias fp_glGetQueryObjectuiv = void function(GLuint, GLenum, GLuint*);
alias fp_glBindBuffer = void function(GLenum, GLuint);
alias fp_glDeleteBuffers = void function(GLsizei, const(GLuint)*);
alias fp_glGenBuffers = void function(GLsizei, GLuint*);
alias fp_glIsBuffer = GLboolean function(GLuint);
alias fp_glBufferData = void function(GLenum, GLsizeiptr, const(GLvoid)*, GLenum);
alias fp_glBufferSubData = void function(GLenum, GLintptr, GLsizeiptr, const(GLvoid)*);
alias fp_glGetBufferSubData = void function(GLenum, GLintptr, GLsizeiptr, GLvoid*);
alias fp_glMapBuffer = void* function(GLenum, GLenum);
alias fp_glUnmapBuffer = GLboolean function(GLenum);
alias fp_glGetBufferParameteriv = void function(GLenum, GLenum, GLint*);
alias fp_glGetBufferPointerv = void function(GLenum, GLenum, GLvoid**);
alias fp_glBlendEquationSeparate = void function(GLenum, GLenum);
alias fp_glDrawBuffers = void function(GLsizei, const(GLenum)*);
alias fp_glStencilOpSeparate = void function(GLenum, GLenum, GLenum, GLenum);
alias fp_glStencilFuncSeparate = void function(GLenum, GLenum, GLint, GLuint);
alias fp_glStencilMaskSeparate = void function(GLenum, GLuint);
alias fp_glAttachShader = void function(GLuint, GLuint);
alias fp_glBindAttribLocation = void function(GLuint, GLuint, const(GLchar)*);
alias fp_glCompileShader = void function(GLuint);
alias fp_glCreateProgram = GLuint function();
alias fp_glCreateShader = GLuint function(GLenum);
alias fp_glDeleteProgram = void function(GLuint);
alias fp_glDeleteShader = void function(GLuint);
alias fp_glDetachShader = void function(GLuint, GLuint);
alias fp_glDisableVertexAttribArray = void function(GLuint);
alias fp_glEnableVertexAttribArray = void function(GLuint);
alias fp_glGetActiveAttrib = void function(GLuint, GLuint, GLsizei, GLsizei*, GLint*, GLenum*, GLchar*);
alias fp_glGetActiveUniform = void function(GLuint, GLuint, GLsizei, GLsizei*, GLint*, GLenum*, GLchar*);
alias fp_glGetAttachedShaders = void function(GLuint, GLsizei, GLsizei*, GLuint*);
alias fp_glGetAttribLocation = GLint function(GLuint, const(GLchar)*);
alias fp_glGetProgramiv = void function(GLuint, GLenum, GLint*);
alias fp_glGetProgramInfoLog = void function(GLuint, GLsizei, GLsizei*, GLchar*);
alias fp_glGetShaderiv = void function(GLuint, GLenum, GLint*);
alias fp_glGetShaderInfoLog = void function(GLuint, GLsizei, GLsizei*, GLchar*);
alias fp_glGetShaderSource = void function(GLuint, GLsizei, GLsizei*, GLchar*);
alias fp_glGetUniformLocation = GLint function(GLuint, const(GLchar)*);
alias fp_glGetUniformfv = void function(GLuint, GLint, GLfloat*);
alias fp_glGetUniformiv = void function(GLuint, GLint, GLint*);
alias fp_glGetVertexAttribdv = void function(GLuint, GLenum, GLdouble*);
alias fp_glGetVertexAttribfv = void function(GLuint, GLenum, GLfloat*);
alias fp_glGetVertexAttribiv = void function(GLuint, GLenum, GLint*);
alias fp_glGetVertexAttribPointerv = void function(GLuint, GLenum, GLvoid**);
alias fp_glIsProgram = GLboolean function(GLuint);
alias fp_glIsShader = GLboolean function(GLuint);
alias fp_glLinkProgram = void function(GLuint);
alias fp_glShaderSource = void function(GLuint, GLsizei, const(GLchar*)*, const(GLint)*);
alias fp_glUseProgram = void function(GLuint);
alias fp_glUniform1f = void function(GLint, GLfloat);
alias fp_glUniform2f = void function(GLint, GLfloat, GLfloat);
alias fp_glUniform3f = void function(GLint, GLfloat, GLfloat, GLfloat);
alias fp_glUniform4f = void function(GLint, GLfloat, GLfloat, GLfloat, GLfloat);
alias fp_glUniform1i = void function(GLint, GLint);
alias fp_glUniform2i = void function(GLint, GLint, GLint);
alias fp_glUniform3i = void function(GLint, GLint, GLint, GLint);
alias fp_glUniform4i = void function(GLint, GLint, GLint, GLint, GLint);
alias fp_glUniform1fv = void function(GLint, GLsizei, const(GLfloat)*);
alias fp_glUniform2fv = void function(GLint, GLsizei, const(GLfloat)*);
alias fp_glUniform3fv = void function(GLint, GLsizei, const(GLfloat)*);
alias fp_glUniform4fv = void function(GLint, GLsizei, const(GLfloat)*);
alias fp_glUniform1iv = void function(GLint, GLsizei, const(GLint)*);
alias fp_glUniform2iv = void function(GLint, GLsizei, const(GLint)*);
alias fp_glUniform3iv = void function(GLint, GLsizei, const(GLint)*);
alias fp_glUniform4iv = void function(GLint, GLsizei, const(GLint)*);
alias fp_glUniformMatrix2fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*);
alias fp_glUniformMatrix3fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*);
alias fp_glUniformMatrix4fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*);
alias fp_glValidateProgram = void function(GLuint);
alias fp_glVertexAttrib1d = void function(GLuint, GLdouble);
alias fp_glVertexAttrib1dv = void function(GLuint, const(GLdouble)*);
alias fp_glVertexAttrib1f = void function(GLuint, GLfloat);
alias fp_glVertexAttrib1fv = void function(GLuint, const(GLfloat)*);
alias fp_glVertexAttrib1s = void function(GLuint, GLshort);
alias fp_glVertexAttrib1sv = void function(GLuint, const(GLshort)*);
alias fp_glVertexAttrib2d = void function(GLuint, GLdouble, GLdouble);
alias fp_glVertexAttrib2dv = void function(GLuint, const(GLdouble)*);
alias fp_glVertexAttrib2f = void function(GLuint, GLfloat, GLfloat);
alias fp_glVertexAttrib2fv = void function(GLuint, const(GLfloat)*);
alias fp_glVertexAttrib2s = void function(GLuint, GLshort, GLshort);
alias fp_glVertexAttrib2sv = void function(GLuint, const(GLshort)*);
alias fp_glVertexAttrib3d = void function(GLuint, GLdouble, GLdouble, GLdouble);
alias fp_glVertexAttrib3dv = void function(GLuint, const(GLdouble)*);
alias fp_glVertexAttrib3f = void function(GLuint, GLfloat, GLfloat, GLfloat);
alias fp_glVertexAttrib3fv = void function(GLuint, const(GLfloat)*);
alias fp_glVertexAttrib3s = void function(GLuint, GLshort, GLshort, GLshort);
alias fp_glVertexAttrib3sv = void function(GLuint, const(GLshort)*);
alias fp_glVertexAttrib4Nbv = void function(GLuint, const(GLbyte)*);
alias fp_glVertexAttrib4Niv = void function(GLuint, const(GLint)*);
alias fp_glVertexAttrib4Nsv = void function(GLuint, const(GLshort)*);
alias fp_glVertexAttrib4Nub = void function(GLuint, GLubyte, GLubyte, GLubyte, GLubyte);
alias fp_glVertexAttrib4Nubv = void function(GLuint, const(GLubyte)*);
alias fp_glVertexAttrib4Nuiv = void function(GLuint, const(GLuint)*);
alias fp_glVertexAttrib4Nusv = void function(GLuint, const(GLushort)*);
alias fp_glVertexAttrib4bv = void function(GLuint, const(GLbyte)*);
alias fp_glVertexAttrib4d = void function(GLuint, GLdouble, GLdouble, GLdouble, GLdouble);
alias fp_glVertexAttrib4dv = void function(GLuint, const(GLdouble)*);
alias fp_glVertexAttrib4f = void function(GLuint, GLfloat, GLfloat, GLfloat, GLfloat);
alias fp_glVertexAttrib4fv = void function(GLuint, const(GLfloat)*);
alias fp_glVertexAttrib4iv = void function(GLuint, const(GLint)*);
alias fp_glVertexAttrib4s = void function(GLuint, GLshort, GLshort, GLshort, GLshort);
alias fp_glVertexAttrib4sv = void function(GLuint, const(GLshort)*);
alias fp_glVertexAttrib4ubv = void function(GLuint, const(GLubyte)*);
alias fp_glVertexAttrib4uiv = void function(GLuint, const(GLuint)*);
alias fp_glVertexAttrib4usv = void function(GLuint, const(GLushort)*);
alias fp_glVertexAttribPointer = void function(GLuint, GLint, GLenum, GLboolean, GLsizei, const(GLvoid)*);
alias fp_glUniformMatrix2x3fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*);
alias fp_glUniformMatrix3x2fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*);
alias fp_glUniformMatrix2x4fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*);
alias fp_glUniformMatrix4x2fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*);
alias fp_glUniformMatrix3x4fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*);
alias fp_glUniformMatrix4x3fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*);
alias fp_glColorMaski = void function(GLuint, GLboolean, GLboolean, GLboolean, GLboolean);
alias fp_glGetBooleani_v = void function(GLenum, GLuint, GLboolean*);
alias fp_glGetIntegeri_v = void function(GLenum, GLuint, GLint*);
alias fp_glEnablei = void function(GLenum, GLuint);
alias fp_glDisablei = void function(GLenum, GLuint);
alias fp_glIsEnabledi = GLboolean function(GLenum, GLuint);
alias fp_glBeginTransformFeedback = void function(GLenum);
alias fp_glEndTransformFeedback = void function();
alias fp_glBindBufferRange = void function(GLenum, GLuint, GLuint, GLintptr, GLsizeiptr);
alias fp_glBindBufferBase = void function(GLenum, GLuint, GLuint);
alias fp_glTransformFeedbackVaryings = void function(GLuint, GLsizei, const(GLchar*)*, GLenum);
alias fp_glGetTransformFeedbackVarying = void function(GLuint, GLuint, GLsizei, GLsizei*, GLsizei*, GLenum*, GLchar*);
alias fp_glClampColor = void function(GLenum, GLenum);
alias fp_glBeginConditionalRender = void function(GLuint, GLenum);
alias fp_glEndConditionalRender = void function();
alias fp_glVertexAttribIPointer = void function(GLuint, GLint, GLenum, GLsizei, const(GLvoid)*);
alias fp_glGetVertexAttribIiv = void function(GLuint, GLenum, GLint*);
alias fp_glGetVertexAttribIuiv = void function(GLuint, GLenum, GLuint*);
alias fp_glVertexAttribI1i = void function(GLuint, GLint);
alias fp_glVertexAttribI2i = void function(GLuint, GLint, GLint);
alias fp_glVertexAttribI3i = void function(GLuint, GLint, GLint, GLint);
alias fp_glVertexAttribI4i = void function(GLuint, GLint, GLint, GLint, GLint);
alias fp_glVertexAttribI1ui = void function(GLuint, GLuint);
alias fp_glVertexAttribI2ui = void function(GLuint, GLuint, GLuint);
alias fp_glVertexAttribI3ui = void function(GLuint, GLuint, GLuint, GLuint);
alias fp_glVertexAttribI4ui = void function(GLuint, GLuint, GLuint, GLuint, GLuint);
alias fp_glVertexAttribI1iv = void function(GLuint, const(GLint)*);
alias fp_glVertexAttribI2iv = void function(GLuint, const(GLint)*);
alias fp_glVertexAttribI3iv = void function(GLuint, const(GLint)*);
alias fp_glVertexAttribI4iv = void function(GLuint, const(GLint)*);
alias fp_glVertexAttribI1uiv = void function(GLuint, const(GLuint)*);
alias fp_glVertexAttribI2uiv = void function(GLuint, const(GLuint)*);
alias fp_glVertexAttribI3uiv = void function(GLuint, const(GLuint)*);
alias fp_glVertexAttribI4uiv = void function(GLuint, const(GLuint)*);
alias fp_glVertexAttribI4bv = void function(GLuint, const(GLbyte)*);
alias fp_glVertexAttribI4sv = void function(GLuint, const(GLshort)*);
alias fp_glVertexAttribI4ubv = void function(GLuint, const(GLubyte)*);
alias fp_glVertexAttribI4usv = void function(GLuint, const(GLushort)*);
alias fp_glGetUniformuiv = void function(GLuint, GLint, GLuint*);
alias fp_glBindFragDataLocation = void function(GLuint, GLuint, const(GLchar)*);
alias fp_glGetFragDataLocation = GLint function(GLuint, const(GLchar)*);
alias fp_glUniform1ui = void function(GLint, GLuint);
alias fp_glUniform2ui = void function(GLint, GLuint, GLuint);
alias fp_glUniform3ui = void function(GLint, GLuint, GLuint, GLuint);
alias fp_glUniform4ui = void function(GLint, GLuint, GLuint, GLuint, GLuint);
alias fp_glUniform1uiv = void function(GLint, GLsizei, const(GLuint)*);
alias fp_glUniform2uiv = void function(GLint, GLsizei, const(GLuint)*);
alias fp_glUniform3uiv = void function(GLint, GLsizei, const(GLuint)*);
alias fp_glUniform4uiv = void function(GLint, GLsizei, const(GLuint)*);
alias fp_glTexParameterIiv = void function(GLenum, GLenum, const(GLint)*);
alias fp_glTexParameterIuiv = void function(GLenum, GLenum, const(GLuint)*);
alias fp_glGetTexParameterIiv = void function(GLenum, GLenum, GLint*);
alias fp_glGetTexParameterIuiv = void function(GLenum, GLenum, GLuint*);
alias fp_glClearBufferiv = void function(GLenum, GLint, const(GLint)*);
alias fp_glClearBufferuiv = void function(GLenum, GLint, const(GLuint)*);
alias fp_glClearBufferfv = void function(GLenum, GLint, const(GLfloat)*);
alias fp_glClearBufferfi = void function(GLenum, GLint, GLfloat, GLint);
alias fp_glGetStringi = const(GLubyte)* function(GLenum, GLuint);
alias fp_glIsRenderbuffer = GLboolean function(GLuint);
alias fp_glBindRenderbuffer = void function(GLenum, GLuint);
alias fp_glDeleteRenderbuffers = void function(GLsizei, const(GLuint)*);
alias fp_glGenRenderbuffers = void function(GLsizei, GLuint*);
alias fp_glRenderbufferStorage = void function(GLenum, GLenum, GLsizei, GLsizei);
alias fp_glGetRenderbufferParameteriv = void function(GLenum, GLenum, GLint*);
alias fp_glIsFramebuffer = GLboolean function(GLuint);
alias fp_glBindFramebuffer = void function(GLenum, GLuint);
alias fp_glDeleteFramebuffers = void function(GLsizei, const(GLuint)*);
alias fp_glGenFramebuffers = void function(GLsizei, GLuint*);
alias fp_glCheckFramebufferStatus = GLenum function(GLenum);
alias fp_glFramebufferTexture1D = void function(GLenum, GLenum, GLenum, GLuint, GLint);
alias fp_glFramebufferTexture2D = void function(GLenum, GLenum, GLenum, GLuint, GLint);
alias fp_glFramebufferTexture3D = void function(GLenum, GLenum, GLenum, GLuint, GLint, GLint);
alias fp_glFramebufferRenderbuffer = void function(GLenum, GLenum, GLenum, GLuint);
alias fp_glGetFramebufferAttachmentParameteriv = void function(GLenum, GLenum, GLenum, GLint*);
alias fp_glGenerateMipmap = void function(GLenum);
alias fp_glBlitFramebuffer = void function(GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum);
alias fp_glRenderbufferStorageMultisample = void function(GLenum, GLsizei, GLenum, GLsizei, GLsizei);
alias fp_glFramebufferTextureLayer = void function(GLenum, GLenum, GLuint, GLint, GLint);
alias fp_glMapBufferRange = void* function(GLenum, GLintptr, GLsizeiptr, GLbitfield);
alias fp_glFlushMappedBufferRange = void function(GLenum, GLintptr, GLsizeiptr);
alias fp_glBindVertexArray = void function(GLuint);
alias fp_glDeleteVertexArrays = void function(GLsizei, const(GLuint)*);
alias fp_glGenVertexArrays = void function(GLsizei, GLuint*);
alias fp_glIsVertexArray = GLboolean function(GLuint);
alias fp_glDrawArraysInstanced = void function(GLenum, GLint, GLsizei, GLsizei);
alias fp_glDrawElementsInstanced = void function(GLenum, GLsizei, GLenum, const(GLvoid)*, GLsizei);
alias fp_glTexBuffer = void function(GLenum, GLenum, GLuint);
alias fp_glPrimitiveRestartIndex = void function(GLuint);
alias fp_glCopyBufferSubData = void function(GLenum, GLenum, GLintptr, GLintptr, GLsizeiptr);
alias fp_glGetUniformIndices = void function(GLuint, GLsizei, const(GLchar*)*, GLuint*);
alias fp_glGetActiveUniformsiv = void function(GLuint, GLsizei, const(GLuint)*, GLenum, GLint*);
alias fp_glGetActiveUniformName = void function(GLuint, GLuint, GLsizei, GLsizei*, GLchar*);
alias fp_glGetUniformBlockIndex = GLuint function(GLuint, const(GLchar)*);
alias fp_glGetActiveUniformBlockiv = void function(GLuint, GLuint, GLenum, GLint*);
alias fp_glGetActiveUniformBlockName = void function(GLuint, GLuint, GLsizei, GLsizei*, GLchar*);
alias fp_glUniformBlockBinding = void function(GLuint, GLuint, GLuint);
alias fp_glDrawElementsBaseVertex = void function(GLenum, GLsizei, GLenum, const(GLvoid)*, GLint);
alias fp_glDrawRangeElementsBaseVertex = void function(GLenum, GLuint, GLuint, GLsizei, GLenum, const(GLvoid)*, GLint);
alias fp_glDrawElementsInstancedBaseVertex = void function(GLenum, GLsizei, GLenum, const(GLvoid)*, GLsizei, GLint);
alias fp_glMultiDrawElementsBaseVertex = void function(GLenum, const(GLsizei)*, GLenum, const(GLvoid*)*, GLsizei, const(GLint)*);
alias fp_glProvokingVertex = void function(GLenum);
alias fp_glFenceSync = GLsync function(GLenum, GLbitfield);
alias fp_glIsSync = GLboolean function(GLsync);
alias fp_glDeleteSync = void function(GLsync);
alias fp_glClientWaitSync = GLenum function(GLsync, GLbitfield, GLuint64);
alias fp_glWaitSync = void function(GLsync, GLbitfield, GLuint64);
alias fp_glGetInteger64v = void function(GLenum, GLint64*);
alias fp_glGetSynciv = void function(GLsync, GLenum, GLsizei, GLsizei*, GLint*);
alias fp_glGetInteger64i_v = void function(GLenum, GLuint, GLint64*);
alias fp_glGetBufferParameteri64v = void function(GLenum, GLenum, GLint64*);
alias fp_glFramebufferTexture = void function(GLenum, GLenum, GLuint, GLint);
alias fp_glTexImage2DMultisample = void function(GLenum, GLsizei, GLint, GLsizei, GLsizei, GLboolean);
alias fp_glTexImage3DMultisample = void function(GLenum, GLsizei, GLint, GLsizei, GLsizei, GLsizei, GLboolean);
alias fp_glGetMultisamplefv = void function(GLenum, GLuint, GLfloat*);
alias fp_glSampleMaski = void function(GLuint, GLbitfield);
alias fp_glBindFragDataLocationIndexed = void function(GLuint, GLuint, GLuint, const(GLchar)*);
alias fp_glGetFragDataIndex = GLint function(GLuint, const(GLchar)*);
alias fp_glGenSamplers = void function(GLsizei, GLuint*);
alias fp_glDeleteSamplers = void function(GLsizei, const(GLuint)*);
alias fp_glIsSampler = GLboolean function(GLuint);
alias fp_glBindSampler = void function(GLuint, GLuint);
alias fp_glSamplerParameteri = void function(GLuint, GLenum, GLint);
alias fp_glSamplerParameteriv = void function(GLuint, GLenum, const(GLint)*);
alias fp_glSamplerParameterf = void function(GLuint, GLenum, GLfloat);
alias fp_glSamplerParameterfv = void function(GLuint, GLenum, const(GLfloat)*);
alias fp_glSamplerParameterIiv = void function(GLuint, GLenum, const(GLint)*);
alias fp_glSamplerParameterIuiv = void function(GLuint, GLenum, const(GLuint)*);
alias fp_glGetSamplerParameteriv = void function(GLuint, GLenum, GLint*);
alias fp_glGetSamplerParameterIiv = void function(GLuint, GLenum, GLint*);
alias fp_glGetSamplerParameterfv = void function(GLuint, GLenum, GLfloat*);
alias fp_glGetSamplerParameterIuiv = void function(GLuint, GLenum, GLuint*);
alias fp_glQueryCounter = void function(GLuint, GLenum);
alias fp_glGetQueryObjecti64v = void function(GLuint, GLenum, GLint64*);
alias fp_glGetQueryObjectui64v = void function(GLuint, GLenum, GLuint64*);
alias fp_glVertexAttribDivisor = void function(GLuint, GLuint);
alias fp_glVertexAttribP1ui = void function(GLuint, GLenum, GLboolean, GLuint);
alias fp_glVertexAttribP1uiv = void function(GLuint, GLenum, GLboolean, const(GLuint)*);
alias fp_glVertexAttribP2ui = void function(GLuint, GLenum, GLboolean, GLuint);
alias fp_glVertexAttribP2uiv = void function(GLuint, GLenum, GLboolean, const(GLuint)*);
alias fp_glVertexAttribP3ui = void function(GLuint, GLenum, GLboolean, GLuint);
alias fp_glVertexAttribP3uiv = void function(GLuint, GLenum, GLboolean, const(GLuint)*);
alias fp_glVertexAttribP4ui = void function(GLuint, GLenum, GLboolean, GLuint);
alias fp_glVertexAttribP4uiv = void function(GLuint, GLenum, GLboolean, const(GLuint)*);
alias fp_glVertexP2ui = void function(GLenum, GLuint);
alias fp_glVertexP2uiv = void function(GLenum, const(GLuint)*);
alias fp_glVertexP3ui = void function(GLenum, GLuint);
alias fp_glVertexP3uiv = void function(GLenum, const(GLuint)*);
alias fp_glVertexP4ui = void function(GLenum, GLuint);
alias fp_glVertexP4uiv = void function(GLenum, const(GLuint)*);
alias fp_glTexCoordP1ui = void function(GLenum, GLuint);
alias fp_glTexCoordP1uiv = void function(GLenum, const(GLuint)*);
alias fp_glTexCoordP2ui = void function(GLenum, GLuint);
alias fp_glTexCoordP2uiv = void function(GLenum, const(GLuint)*);
alias fp_glTexCoordP3ui = void function(GLenum, GLuint);
alias fp_glTexCoordP3uiv = void function(GLenum, const(GLuint)*);
alias fp_glTexCoordP4ui = void function(GLenum, GLuint);
alias fp_glTexCoordP4uiv = void function(GLenum, const(GLuint)*);
alias fp_glMultiTexCoordP1ui = void function(GLenum, GLenum, GLuint);
alias fp_glMultiTexCoordP1uiv = void function(GLenum, GLenum, const(GLuint)*);
alias fp_glMultiTexCoordP2ui = void function(GLenum, GLenum, GLuint);
alias fp_glMultiTexCoordP2uiv = void function(GLenum, GLenum, const(GLuint)*);
alias fp_glMultiTexCoordP3ui = void function(GLenum, GLenum, GLuint);
alias fp_glMultiTexCoordP3uiv = void function(GLenum, GLenum, const(GLuint)*);
alias fp_glMultiTexCoordP4ui = void function(GLenum, GLenum, GLuint);
alias fp_glMultiTexCoordP4uiv = void function(GLenum, GLenum, const(GLuint)*);
alias fp_glNormalP3ui = void function(GLenum, GLuint);
alias fp_glNormalP3uiv = void function(GLenum, const(GLuint)*);
alias fp_glColorP3ui = void function(GLenum, GLuint);
alias fp_glColorP3uiv = void function(GLenum, const(GLuint)*);
alias fp_glColorP4ui = void function(GLenum, GLuint);
alias fp_glColorP4uiv = void function(GLenum, const(GLuint)*);
alias fp_glSecondaryColorP3ui = void function(GLenum, GLuint);
alias fp_glSecondaryColorP3uiv = void function(GLenum, const(GLuint)*);
alias fp_glMinSampleShading = void function(GLfloat);
alias fp_glBlendEquationi = void function(GLuint, GLenum);
alias fp_glBlendEquationSeparatei = void function(GLuint, GLenum, GLenum);
alias fp_glBlendFunci = void function(GLuint, GLenum, GLenum);
alias fp_glBlendFuncSeparatei = void function(GLuint, GLenum, GLenum, GLenum, GLenum);
alias fp_glDrawArraysIndirect = void function(GLenum, const(GLvoid)*);
alias fp_glDrawElementsIndirect = void function(GLenum, GLenum, const(GLvoid)*);
alias fp_glUniform1d = void function(GLint, GLdouble);
alias fp_glUniform2d = void function(GLint, GLdouble, GLdouble);
alias fp_glUniform3d = void function(GLint, GLdouble, GLdouble, GLdouble);
alias fp_glUniform4d = void function(GLint, GLdouble, GLdouble, GLdouble, GLdouble);
alias fp_glUniform1dv = void function(GLint, GLsizei, const(GLdouble)*);
alias fp_glUniform2dv = void function(GLint, GLsizei, const(GLdouble)*);
alias fp_glUniform3dv = void function(GLint, GLsizei, const(GLdouble)*);
alias fp_glUniform4dv = void function(GLint, GLsizei, const(GLdouble)*);
alias fp_glUniformMatrix2dv = void function(GLint, GLsizei, GLboolean, const(GLdouble)*);
alias fp_glUniformMatrix3dv = void function(GLint, GLsizei, GLboolean, const(GLdouble)*);
alias fp_glUniformMatrix4dv = void function(GLint, GLsizei, GLboolean, const(GLdouble)*);
alias fp_glUniformMatrix2x3dv = void function(GLint, GLsizei, GLboolean, const(GLdouble)*);
alias fp_glUniformMatrix2x4dv = void function(GLint, GLsizei, GLboolean, const(GLdouble)*);
alias fp_glUniformMatrix3x2dv = void function(GLint, GLsizei, GLboolean, const(GLdouble)*);
alias fp_glUniformMatrix3x4dv = void function(GLint, GLsizei, GLboolean, const(GLdouble)*);
alias fp_glUniformMatrix4x2dv = void function(GLint, GLsizei, GLboolean, const(GLdouble)*);
alias fp_glUniformMatrix4x3dv = void function(GLint, GLsizei, GLboolean, const(GLdouble)*);
alias fp_glGetUniformdv = void function(GLuint, GLint, GLdouble*);
alias fp_glGetSubroutineUniformLocation = GLint function(GLuint, GLenum, const(GLchar)*);
alias fp_glGetSubroutineIndex = GLuint function(GLuint, GLenum, const(GLchar)*);
alias fp_glGetActiveSubroutineUniformiv = void function(GLuint, GLenum, GLuint, GLenum, GLint*);
alias fp_glGetActiveSubroutineUniformName = void function(GLuint, GLenum, GLuint, GLsizei, GLsizei*, GLchar*);
alias fp_glGetActiveSubroutineName = void function(GLuint, GLenum, GLuint, GLsizei, GLsizei*, GLchar*);
alias fp_glUniformSubroutinesuiv = void function(GLenum, GLsizei, const(GLuint)*);
alias fp_glGetUniformSubroutineuiv = void function(GLenum, GLint, GLuint*);
alias fp_glGetProgramStageiv = void function(GLuint, GLenum, GLenum, GLint*);
alias fp_glPatchParameteri = void function(GLenum, GLint);
alias fp_glPatchParameterfv = void function(GLenum, const(GLfloat)*);
alias fp_glBindTransformFeedback = void function(GLenum, GLuint);
alias fp_glDeleteTransformFeedbacks = void function(GLsizei, const(GLuint)*);
alias fp_glGenTransformFeedbacks = void function(GLsizei, GLuint*);
alias fp_glIsTransformFeedback = GLboolean function(GLuint);
alias fp_glPauseTransformFeedback = void function();
alias fp_glResumeTransformFeedback = void function();
alias fp_glDrawTransformFeedback = void function(GLenum, GLuint);
alias fp_glDrawTransformFeedbackStream = void function(GLenum, GLuint, GLuint);
alias fp_glBeginQueryIndexed = void function(GLenum, GLuint, GLuint);
alias fp_glEndQueryIndexed = void function(GLenum, GLuint);
alias fp_glGetQueryIndexediv = void function(GLenum, GLuint, GLenum, GLint*);
alias fp_glReleaseShaderCompiler = void function();
alias fp_glShaderBinary = void function(GLsizei, const(GLuint)*, GLenum, const(GLvoid)*, GLsizei);
alias fp_glGetShaderPrecisionFormat = void function(GLenum, GLenum, GLint*, GLint*);
alias fp_glDepthRangef = void function(GLfloat, GLfloat);
alias fp_glClearDepthf = void function(GLfloat);
alias fp_glGetProgramBinary = void function(GLuint, GLsizei, GLsizei*, GLenum*, GLvoid*);
alias fp_glProgramBinary = void function(GLuint, GLenum, const(GLvoid)*, GLsizei);
alias fp_glProgramParameteri = void function(GLuint, GLenum, GLint);
alias fp_glUseProgramStages = void function(GLuint, GLbitfield, GLuint);
alias fp_glActiveShaderProgram = void function(GLuint, GLuint);
alias fp_glCreateShaderProgramv = GLuint function(GLenum, GLsizei, const(GLchar*)*);
alias fp_glBindProgramPipeline = void function(GLuint);
alias fp_glDeleteProgramPipelines = void function(GLsizei, const(GLuint)*);
alias fp_glGenProgramPipelines = void function(GLsizei, GLuint*);
alias fp_glIsProgramPipeline = GLboolean function(GLuint);
alias fp_glGetProgramPipelineiv = void function(GLuint, GLenum, GLint*);
alias fp_glProgramUniform1i = void function(GLuint, GLint, GLint);
alias fp_glProgramUniform1iv = void function(GLuint, GLint, GLsizei, const(GLint)*);
alias fp_glProgramUniform1f = void function(GLuint, GLint, GLfloat);
alias fp_glProgramUniform1fv = void function(GLuint, GLint, GLsizei, const(GLfloat)*);
alias fp_glProgramUniform1d = void function(GLuint, GLint, GLdouble);
alias fp_glProgramUniform1dv = void function(GLuint, GLint, GLsizei, const(GLdouble)*);
alias fp_glProgramUniform1ui = void function(GLuint, GLint, GLuint);
alias fp_glProgramUniform1uiv = void function(GLuint, GLint, GLsizei, const(GLuint)*);
alias fp_glProgramUniform2i = void function(GLuint, GLint, GLint, GLint);
alias fp_glProgramUniform2iv = void function(GLuint, GLint, GLsizei, const(GLint)*);
alias fp_glProgramUniform2f = void function(GLuint, GLint, GLfloat, GLfloat);
alias fp_glProgramUniform2fv = void function(GLuint, GLint, GLsizei, const(GLfloat)*);
alias fp_glProgramUniform2d = void function(GLuint, GLint, GLdouble, GLdouble);
alias fp_glProgramUniform2dv = void function(GLuint, GLint, GLsizei, const(GLdouble)*);
alias fp_glProgramUniform2ui = void function(GLuint, GLint, GLuint, GLuint);
alias fp_glProgramUniform2uiv = void function(GLuint, GLint, GLsizei, const(GLuint)*);
alias fp_glProgramUniform3i = void function(GLuint, GLint, GLint, GLint, GLint);
alias fp_glProgramUniform3iv = void function(GLuint, GLint, GLsizei, const(GLint)*);
alias fp_glProgramUniform3f = void function(GLuint, GLint, GLfloat, GLfloat, GLfloat);
alias fp_glProgramUniform3fv = void function(GLuint, GLint, GLsizei, const(GLfloat)*);
alias fp_glProgramUniform3d = void function(GLuint, GLint, GLdouble, GLdouble, GLdouble);
alias fp_glProgramUniform3dv = void function(GLuint, GLint, GLsizei, const(GLdouble)*);
alias fp_glProgramUniform3ui = void function(GLuint, GLint, GLuint, GLuint, GLuint);
alias fp_glProgramUniform3uiv = void function(GLuint, GLint, GLsizei, const(GLuint)*);
alias fp_glProgramUniform4i = void function(GLuint, GLint, GLint, GLint, GLint, GLint);
alias fp_glProgramUniform4iv = void function(GLuint, GLint, GLsizei, const(GLint)*);
alias fp_glProgramUniform4f = void function(GLuint, GLint, GLfloat, GLfloat, GLfloat, GLfloat);
alias fp_glProgramUniform4fv = void function(GLuint, GLint, GLsizei, const(GLfloat)*);
alias fp_glProgramUniform4d = void function(GLuint, GLint, GLdouble, GLdouble, GLdouble, GLdouble);
alias fp_glProgramUniform4dv = void function(GLuint, GLint, GLsizei, const(GLdouble)*);
alias fp_glProgramUniform4ui = void function(GLuint, GLint, GLuint, GLuint, GLuint, GLuint);
alias fp_glProgramUniform4uiv = void function(GLuint, GLint, GLsizei, const(GLuint)*);
alias fp_glProgramUniformMatrix2fv = void function(GLuint, GLint, GLsizei, GLboolean, const(GLfloat)*);
alias fp_glProgramUniformMatrix3fv = void function(GLuint, GLint, GLsizei, GLboolean, const(GLfloat)*);
alias fp_glProgramUniformMatrix4fv = void function(GLuint, GLint, GLsizei, GLboolean, const(GLfloat)*);
alias fp_glProgramUniformMatrix2dv = void function(GLuint, GLint, GLsizei, GLboolean, const(GLdouble)*);
alias fp_glProgramUniformMatrix3dv = void function(GLuint, GLint, GLsizei, GLboolean, const(GLdouble)*);
alias fp_glProgramUniformMatrix4dv = void function(GLuint, GLint, GLsizei, GLboolean, const(GLdouble)*);
alias fp_glProgramUniformMatrix2x3fv = void function(GLuint, GLint, GLsizei, GLboolean, const(GLfloat)*);
alias fp_glProgramUniformMatrix3x2fv = void function(GLuint, GLint, GLsizei, GLboolean, const(GLfloat)*);
alias fp_glProgramUniformMatrix2x4fv = void function(GLuint, GLint, GLsizei, GLboolean, const(GLfloat)*);
alias fp_glProgramUniformMatrix4x2fv = void function(GLuint, GLint, GLsizei, GLboolean, const(GLfloat)*);
alias fp_glProgramUniformMatrix3x4fv = void function(GLuint, GLint, GLsizei, GLboolean, const(GLfloat)*);
alias fp_glProgramUniformMatrix4x3fv = void function(GLuint, GLint, GLsizei, GLboolean, const(GLfloat)*);
alias fp_glProgramUniformMatrix2x3dv = void function(GLuint, GLint, GLsizei, GLboolean, const(GLdouble)*);
alias fp_glProgramUniformMatrix3x2dv = void function(GLuint, GLint, GLsizei, GLboolean, const(GLdouble)*);
alias fp_glProgramUniformMatrix2x4dv = void function(GLuint, GLint, GLsizei, GLboolean, const(GLdouble)*);
alias fp_glProgramUniformMatrix4x2dv = void function(GLuint, GLint, GLsizei, GLboolean, const(GLdouble)*);
alias fp_glProgramUniformMatrix3x4dv = void function(GLuint, GLint, GLsizei, GLboolean, const(GLdouble)*);
alias fp_glProgramUniformMatrix4x3dv = void function(GLuint, GLint, GLsizei, GLboolean, const(GLdouble)*);
alias fp_glValidateProgramPipeline = void function(GLuint);
alias fp_glGetProgramPipelineInfoLog = void function(GLuint, GLsizei, GLsizei*, GLchar*);
alias fp_glVertexAttribL1d = void function(GLuint, GLdouble);
alias fp_glVertexAttribL2d = void function(GLuint, GLdouble, GLdouble);
alias fp_glVertexAttribL3d = void function(GLuint, GLdouble, GLdouble, GLdouble);
alias fp_glVertexAttribL4d = void function(GLuint, GLdouble, GLdouble, GLdouble, GLdouble);
alias fp_glVertexAttribL1dv = void function(GLuint, const(GLdouble)*);
alias fp_glVertexAttribL2dv = void function(GLuint, const(GLdouble)*);
alias fp_glVertexAttribL3dv = void function(GLuint, const(GLdouble)*);
alias fp_glVertexAttribL4dv = void function(GLuint, const(GLdouble)*);
alias fp_glVertexAttribLPointer = void function(GLuint, GLint, GLenum, GLsizei, const(GLvoid)*);
alias fp_glGetVertexAttribLdv = void function(GLuint, GLenum, GLdouble*);
alias fp_glViewportArrayv = void function(GLuint, GLsizei, const(GLfloat)*);
alias fp_glViewportIndexedf = void function(GLuint, GLfloat, GLfloat, GLfloat, GLfloat);
alias fp_glViewportIndexedfv = void function(GLuint, const(GLfloat)*);
alias fp_glScissorArrayv = void function(GLuint, GLsizei, const(GLint)*);
alias fp_glScissorIndexed = void function(GLuint, GLint, GLint, GLsizei, GLsizei);
alias fp_glScissorIndexedv = void function(GLuint, const(GLint)*);
alias fp_glDepthRangeArrayv = void function(GLuint, GLsizei, const(GLdouble)*);
alias fp_glDepthRangeIndexed = void function(GLuint, GLdouble, GLdouble);
alias fp_glGetFloati_v = void function(GLenum, GLuint, GLfloat*);
alias fp_glGetDoublei_v = void function(GLenum, GLuint, GLdouble*);
alias fp_glDrawArraysInstancedBaseInstance = void function(GLenum, GLint, GLsizei, GLsizei, GLuint);
alias fp_glDrawElementsInstancedBaseInstance = void function(GLenum, GLsizei, GLenum, const(void)*, GLsizei, GLuint);
alias fp_glDrawElementsInstancedBaseVertexBaseInstance = void function(GLenum, GLsizei, GLenum, const(void)*, GLsizei, GLint, GLuint);
alias fp_glGetInternalformati64v = void function(GLenum, GLenum, GLenum, GLsizei, GLint64*);
alias fp_glGetActiveAtomicCounterBufferiv = void function(GLuint, GLuint, GLenum, GLint*);
alias fp_glBindImageTexture = void function(GLuint, GLuint, GLint, GLboolean, GLint, GLenum, GLenum);
alias fp_glMemoryBarrier = void function(GLbitfield);
alias fp_glTexStorage1D = void function(GLenum, GLsizei, GLenum, GLsizei);
alias fp_glTexStorage2D = void function(GLenum, GLsizei, GLenum, GLsizei, GLsizei);
alias fp_glTexStorage3D = void function(GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei);
alias fp_glDrawTransformFeedbackInstanced = void function(GLenum, GLuint, GLsizei);
alias fp_glDrawTransformFeedbackStreamInstanced = void function(GLenum, GLuint, GLuint, GLsizei);
alias fp_glClearBufferData = void function(GLenum, GLenum, GLenum, GLenum, const(void)*);
alias fp_glClearBufferSubData = void function(GLenum, GLenum, GLintptr, GLsizeiptr, GLenum, GLenum, const(void)*);
alias fp_glDispatchCompute = void function(GLuint, GLuint, GLuint);
alias fp_glDispatchComputeIndirect = void function(GLintptr);
alias fp_glCopyImageSubData = void function(GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei);
alias fp_glFramebufferParameteri = void function(GLenum, GLenum, GLint);
alias fp_glGetFramebufferParameteriv = void function(GLenum, GLenum, GLint*);
alias fp_glInvalidateTexSubImage = void function(GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei);
alias fp_glInvalidateTexImage = void function(GLuint, GLint);
alias fp_glInvalidateBufferSubData = void function(GLuint, GLintptr, GLsizeiptr);
alias fp_glInvalidateBufferData = void function(GLuint);
alias fp_glInvalidateFramebuffer = void function(GLenum, GLsizei, const(GLenum)*);
alias fp_glInvalidateSubFramebuffer = void function(GLenum, GLsizei, const(GLenum)*, GLint, GLint, GLsizei, GLsizei);
alias fp_glMultiDrawArraysIndirect = void function(GLenum, const(void)*, GLsizei, GLsizei);
alias fp_glMultiDrawElementsIndirect = void function(GLenum, GLenum, const(void)*, GLsizei, GLsizei);
alias fp_glGetProgramInterfaceiv = void function(GLuint, GLenum, GLenum, GLint*);
alias fp_glGetProgramResourceIndex = GLuint function(GLuint, GLenum, const(GLchar)*);
alias fp_glGetProgramResourceName = void function(GLuint, GLenum, GLuint, GLsizei, GLsizei*, GLchar*);
alias fp_glGetProgramResourceiv = void function(GLuint, GLenum, GLuint, GLsizei, const(GLenum)*, GLsizei, GLsizei*, GLint*);
alias fp_glGetProgramResourceLocation = GLint function(GLuint, GLenum, const(GLchar)*);
alias fp_glGetProgramResourceLocationIndex = GLint function(GLuint, GLenum, const(GLchar)*);
alias fp_glShaderStorageBlockBinding = void function(GLuint, GLuint, GLuint);
alias fp_glTexBufferRange = void function(GLenum, GLenum, GLuint, GLintptr, GLsizeiptr);
alias fp_glTexStorage2DMultisample = void function(GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLboolean);
alias fp_glTexStorage3DMultisample = void function(GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei, GLboolean);
alias fp_glTextureView = void function(GLuint, GLenum, GLuint, GLenum, GLuint, GLuint, GLuint, GLuint);
alias fp_glBindVertexBuffer = void function(GLuint, GLuint, GLintptr, GLsizei);
alias fp_glVertexAttribFormat = void function(GLuint, GLint, GLenum, GLboolean, GLuint);
alias fp_glVertexAttribIFormat = void function(GLuint, GLint, GLenum, GLuint);
alias fp_glVertexAttribLFormat = void function(GLuint, GLint, GLenum, GLuint);
alias fp_glVertexAttribBinding = void function(GLuint, GLuint);
alias fp_glVertexBindingDivisor = void function(GLuint, GLuint);
alias fp_glDebugMessageControl = void function(GLenum, GLenum, GLenum, GLsizei, const(GLuint)*, GLboolean);
alias fp_glDebugMessageInsert = void function(GLenum, GLenum, GLuint, GLenum, GLsizei, const(GLchar)*);
alias fp_glDebugMessageCallback = void function(GLDEBUGPROC, const(void)*);
alias fp_glGetDebugMessageLog = GLuint function(GLuint, GLsizei, GLenum*, GLenum*, GLuint*, GLenum*, GLsizei*, GLchar*);
alias fp_glPushDebugGroup = void function(GLenum, GLuint, GLsizei, const(GLchar)*);
alias fp_glPopDebugGroup = void function();
alias fp_glObjectLabel = void function(GLenum, GLuint, GLsizei, const(GLchar)*);
alias fp_glGetObjectLabel = void function(GLenum, GLuint, GLsizei, GLsizei*, GLchar*);
alias fp_glObjectPtrLabel = void function(const(void)*, GLsizei, const(GLchar)*);
alias fp_glGetObjectPtrLabel = void function(const(void)*, GLsizei, GLsizei*, GLchar*);
alias fp_glBufferStorage = void function(GLenum, GLsizeiptr, const(void)*, GLbitfield);
alias fp_glClearTexImage = void function(GLuint, GLint, GLenum, GLenum, const(void)*);
alias fp_glClearTexSubImage = void function(GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const(void)*);
alias fp_glBindBuffersBase = void function(GLenum, GLuint, GLsizei, const(GLuint)*);
alias fp_glBindBuffersRange = void function(GLenum, GLuint, GLsizei, const(GLuint)*, const(GLintptr)*, const(GLsizeiptr)*);
alias fp_glBindTextures = void function(GLuint, GLsizei, const(GLuint)*);
alias fp_glBindSamplers = void function(GLuint, GLsizei, const(GLuint)*);
alias fp_glBindImageTextures = void function(GLuint, GLsizei, const(GLuint)*);
alias fp_glBindVertexBuffers = void function(GLuint, GLsizei, const(GLuint)*, const(GLintptr)*, const(GLsizei)*);
}
__gshared {
fp_glCopyTexImage1D glCopyTexImage1D;
fp_glVertexAttribI3ui glVertexAttribI3ui;
fp_glWindowPos2s glWindowPos2s;
fp_glWindowPos2i glWindowPos2i;
fp_glWindowPos2f glWindowPos2f;
fp_glWindowPos2d glWindowPos2d;
fp_glVertex2fv glVertex2fv;
fp_glIndexi glIndexi;
fp_glFramebufferRenderbuffer glFramebufferRenderbuffer;
fp_glUniformSubroutinesuiv glUniformSubroutinesuiv;
fp_glRectdv glRectdv;
fp_glCompressedTexSubImage3D glCompressedTexSubImage3D;
fp_glEvalCoord2d glEvalCoord2d;
fp_glEvalCoord2f glEvalCoord2f;
fp_glGetDoublei_v glGetDoublei_v;
fp_glIndexd glIndexd;
fp_glVertexAttrib1sv glVertexAttrib1sv;
fp_glIndexf glIndexf;
fp_glBindSampler glBindSampler;
fp_glLineWidth glLineWidth;
fp_glColorP3uiv glColorP3uiv;
fp_glGetIntegeri_v glGetIntegeri_v;
fp_glGetMapfv glGetMapfv;
fp_glIndexs glIndexs;
fp_glCompileShader glCompileShader;
fp_glGetTransformFeedbackVarying glGetTransformFeedbackVarying;
fp_glWindowPos2iv glWindowPos2iv;
fp_glDrawTransformFeedbackStreamInstanced glDrawTransformFeedbackStreamInstanced;
fp_glIndexfv glIndexfv;
fp_glFogiv glFogiv;
fp_glStencilMaskSeparate glStencilMaskSeparate;
fp_glRasterPos2fv glRasterPos2fv;
fp_glLightModeliv glLightModeliv;
fp_glDepthRangef glDepthRangef;
fp_glColor4ui glColor4ui;
fp_glSecondaryColor3fv glSecondaryColor3fv;
fp_glMultiTexCoordP3ui glMultiTexCoordP3ui;
fp_glFogfv glFogfv;
fp_glVertexP4ui glVertexP4ui;
fp_glDrawElementsInstancedBaseInstance glDrawElementsInstancedBaseInstance;
fp_glEnablei glEnablei;
fp_glProgramUniform3dv glProgramUniform3dv;
fp_glVertex4iv glVertex4iv;
fp_glEvalCoord1fv glEvalCoord1fv;
fp_glWindowPos2sv glWindowPos2sv;
fp_glVertexAttribP4ui glVertexAttribP4ui;
fp_glCreateShader glCreateShader;
fp_glIsBuffer glIsBuffer;
fp_glGetMultisamplefv glGetMultisamplefv;
fp_glProgramUniformMatrix2dv glProgramUniformMatrix2dv;
fp_glGenRenderbuffers glGenRenderbuffers;
fp_glCopyTexSubImage2D glCopyTexSubImage2D;
fp_glCompressedTexImage2D glCompressedTexImage2D;
fp_glVertexAttrib1f glVertexAttrib1f;
fp_glBlendFuncSeparate glBlendFuncSeparate;
fp_glVertex4fv glVertex4fv;
fp_glMinSampleShading glMinSampleShading;
fp_glBindTexture glBindTexture;
fp_glVertexAttrib1s glVertexAttrib1s;
fp_glTexCoord2fv glTexCoord2fv;
fp_glSampleMaski glSampleMaski;
fp_glVertexP2ui glVertexP2ui;
fp_glDrawRangeElementsBaseVertex glDrawRangeElementsBaseVertex;
fp_glTexCoord4fv glTexCoord4fv;
fp_glUniformMatrix3x2fv glUniformMatrix3x2fv;
fp_glDebugMessageControl glDebugMessageControl;
fp_glPointSize glPointSize;
fp_glVertexAttrib2dv glVertexAttrib2dv;
fp_glDeleteProgram glDeleteProgram;
fp_glColor4bv glColor4bv;
fp_glRasterPos2f glRasterPos2f;
fp_glRasterPos2d glRasterPos2d;
fp_glLoadIdentity glLoadIdentity;
fp_glRasterPos2i glRasterPos2i;
fp_glMultiDrawArraysIndirect glMultiDrawArraysIndirect;
fp_glRenderbufferStorage glRenderbufferStorage;
fp_glUniformMatrix4x3fv glUniformMatrix4x3fv;
fp_glColor3b glColor3b;
fp_glClearBufferfv glClearBufferfv;
fp_glEdgeFlag glEdgeFlag;
fp_glDeleteSamplers glDeleteSamplers;
fp_glVertex3d glVertex3d;
fp_glVertex3f glVertex3f;
fp_glVertex3i glVertex3i;
fp_glColor3i glColor3i;
fp_glUniform3d glUniform3d;
fp_glUniform3f glUniform3f;
fp_glVertexAttrib4ubv glVertexAttrib4ubv;
fp_glColor3s glColor3s;
fp_glVertex3s glVertex3s;
fp_glTexCoordP2ui glTexCoordP2ui;
fp_glColorMaski glColorMaski;
fp_glClearBufferfi glClearBufferfi;
fp_glDrawArraysIndirect glDrawArraysIndirect;
fp_glTexCoord1iv glTexCoord1iv;
fp_glBlitFramebuffer glBlitFramebuffer;
fp_glPauseTransformFeedback glPauseTransformFeedback;
fp_glMultiTexCoordP2ui glMultiTexCoordP2ui;
fp_glProgramUniformMatrix3x2dv glProgramUniformMatrix3x2dv;
fp_glProgramUniformMatrix3x2fv glProgramUniformMatrix3x2fv;
fp_glGetSamplerParameterIiv glGetSamplerParameterIiv;
fp_glGetFragDataIndex glGetFragDataIndex;
fp_glVertexAttribL4d glVertexAttribL4d;
fp_glBindImageTexture glBindImageTexture;
fp_glVertexAttrib3f glVertexAttrib3f;
fp_glProgramUniformMatrix4fv glProgramUniformMatrix4fv;
fp_glVertex2iv glVertex2iv;
fp_glColor3sv glColor3sv;
fp_glGetVertexAttribdv glGetVertexAttribdv;
fp_glActiveShaderProgram glActiveShaderProgram;
fp_glUniformMatrix3x4fv glUniformMatrix3x4fv;
fp_glUniformMatrix3dv glUniformMatrix3dv;
fp_glNormalPointer glNormalPointer;
fp_glTexCoordP3uiv glTexCoordP3uiv;
fp_glVertex4sv glVertex4sv;
fp_glInvalidateBufferSubData glInvalidateBufferSubData;
fp_glPassThrough glPassThrough;
fp_glMultiTexCoordP4ui glMultiTexCoordP4ui;
fp_glFogi glFogi;
fp_glBegin glBegin;
fp_glEvalCoord2dv glEvalCoord2dv;
fp_glColor3ubv glColor3ubv;
fp_glVertexPointer glVertexPointer;
fp_glSecondaryColor3uiv glSecondaryColor3uiv;
fp_glDeleteFramebuffers glDeleteFramebuffers;
fp_glDrawArrays glDrawArrays;
fp_glUniform1ui glUniform1ui;
fp_glMultiTexCoord1d glMultiTexCoord1d;
fp_glMultiTexCoord1f glMultiTexCoord1f;
fp_glProgramParameteri glProgramParameteri;
fp_glLightfv glLightfv;
fp_glTexCoordP3ui glTexCoordP3ui;
fp_glVertexAttrib3d glVertexAttrib3d;
fp_glClear glClear;
fp_glMultiTexCoord1i glMultiTexCoord1i;
fp_glGetActiveUniformName glGetActiveUniformName;
fp_glMemoryBarrier glMemoryBarrier;
fp_glMultiTexCoord1s glMultiTexCoord1s;
fp_glIsEnabled glIsEnabled;
fp_glStencilOp glStencilOp;
fp_glGetQueryObjectuiv glGetQueryObjectuiv;
fp_glFramebufferTexture2D glFramebufferTexture2D;
fp_glGetFramebufferAttachmentParameteriv glGetFramebufferAttachmentParameteriv;
fp_glTranslatef glTranslatef;
fp_glVertexAttrib4Nub glVertexAttrib4Nub;
fp_glTranslated glTranslated;
fp_glTexCoord3sv glTexCoord3sv;
fp_glGetFragDataLocation glGetFragDataLocation;
fp_glTexImage1D glTexImage1D;
fp_glVertexP3uiv glVertexP3uiv;
fp_glTexParameteriv glTexParameteriv;
fp_glSecondaryColor3bv glSecondaryColor3bv;
fp_glGetMaterialfv glGetMaterialfv;
fp_glGetTexImage glGetTexImage;
fp_glFogCoordfv glFogCoordfv;
fp_glPixelMapuiv glPixelMapuiv;
fp_glGetShaderInfoLog glGetShaderInfoLog;
fp_glGetQueryObjecti64v glGetQueryObjecti64v;
fp_glGenFramebuffers glGenFramebuffers;
fp_glIndexsv glIndexsv;
fp_glClearTexSubImage glClearTexSubImage;
fp_glProgramUniformMatrix3x4dv glProgramUniformMatrix3x4dv;
fp_glGetAttachedShaders glGetAttachedShaders;
fp_glIsRenderbuffer glIsRenderbuffer;
fp_glVertex3iv glVertex3iv;
fp_glBitmap glBitmap;
fp_glGetDebugMessageLog glGetDebugMessageLog;
fp_glProgramUniform1uiv glProgramUniform1uiv;
fp_glMateriali glMateriali;
fp_glIsVertexArray glIsVertexArray;
fp_glDisableVertexAttribArray glDisableVertexAttribArray;
fp_glProgramUniform2iv glProgramUniform2iv;
fp_glGetQueryiv glGetQueryiv;
fp_glTexCoord4f glTexCoord4f;
fp_glTexCoord4d glTexCoord4d;
fp_glGetSamplerParameterfv glGetSamplerParameterfv;
fp_glTexCoord4i glTexCoord4i;
fp_glShaderStorageBlockBinding glShaderStorageBlockBinding;
fp_glMaterialf glMaterialf;
fp_glTexCoord4s glTexCoord4s;
fp_glProgramUniformMatrix4x2dv glProgramUniformMatrix4x2dv;
fp_glGetUniformIndices glGetUniformIndices;
fp_glIsShader glIsShader;
fp_glMultiTexCoord2s glMultiTexCoord2s;
fp_glVertexAttribI4ubv glVertexAttribI4ubv;
fp_glVertex3dv glVertex3dv;
fp_glGetInteger64v glGetInteger64v;
fp_glPointParameteriv glPointParameteriv;
fp_glEnable glEnable;
fp_glGetActiveUniformsiv glGetActiveUniformsiv;
fp_glColor4fv glColor4fv;
fp_glTexCoord1fv glTexCoord1fv;
fp_glPopDebugGroup glPopDebugGroup;
fp_glBlendEquationi glBlendEquationi;
fp_glTexCoord2sv glTexCoord2sv;
fp_glVertexAttrib4dv glVertexAttrib4dv;
fp_glMultiTexCoord1dv glMultiTexCoord1dv;
fp_glGetProgramInterfaceiv glGetProgramInterfaceiv;
fp_glMultiTexCoord2i glMultiTexCoord2i;
fp_glTexCoord3fv glTexCoord3fv;
fp_glSecondaryColor3usv glSecondaryColor3usv;
fp_glTexGenf glTexGenf;
fp_glMultiTexCoordP3uiv glMultiTexCoordP3uiv;
fp_glVertexAttribP3ui glVertexAttribP3ui;
fp_glVertexAttribL1dv glVertexAttribL1dv;
fp_glMultiTexCoordP1ui glMultiTexCoordP1ui;
fp_glProgramUniform3ui glProgramUniform3ui;
fp_glGetPointerv glGetPointerv;
fp_glVertexBindingDivisor glVertexBindingDivisor;
fp_glPolygonOffset glPolygonOffset;
fp_glGetUniformuiv glGetUniformuiv;
fp_glNormal3fv glNormal3fv;
fp_glSecondaryColor3s glSecondaryColor3s;
fp_glDepthRange glDepthRange;
fp_glFrustum glFrustum;
fp_glMultiTexCoord4sv glMultiTexCoord4sv;
fp_glDrawBuffer glDrawBuffer;
fp_glPushMatrix glPushMatrix;
fp_glRasterPos3fv glRasterPos3fv;
fp_glOrtho glOrtho;
fp_glDrawElementsInstanced glDrawElementsInstanced;
fp_glWindowPos3sv glWindowPos3sv;
fp_glVertexAttribL4dv glVertexAttribL4dv;
fp_glProgramUniform1i glProgramUniform1i;
fp_glUniform2dv glUniform2dv;
fp_glProgramUniform1d glProgramUniform1d;
fp_glProgramUniform1f glProgramUniform1f;
fp_glClearIndex glClearIndex;
fp_glMap1d glMap1d;
fp_glMap1f glMap1f;
fp_glFlush glFlush;
fp_glGetRenderbufferParameteriv glGetRenderbufferParameteriv;
fp_glBeginQueryIndexed glBeginQueryIndexed;
fp_glProgramUniform3iv glProgramUniform3iv;
fp_glIndexiv glIndexiv;
fp_glRasterPos3sv glRasterPos3sv;
fp_glGetVertexAttribPointerv glGetVertexAttribPointerv;
fp_glPixelZoom glPixelZoom;
fp_glFenceSync glFenceSync;
fp_glDeleteVertexArrays glDeleteVertexArrays;
fp_glColorP3ui glColorP3ui;
fp_glDrawElementsInstancedBaseVertexBaseInstance glDrawElementsInstancedBaseVertexBaseInstance;
fp_glVertexAttrib3sv glVertexAttrib3sv;
fp_glBeginConditionalRender glBeginConditionalRender;
fp_glPushDebugGroup glPushDebugGroup;
fp_glGetShaderPrecisionFormat glGetShaderPrecisionFormat;
fp_glValidateProgramPipeline glValidateProgramPipeline;
fp_glDrawElementsBaseVertex glDrawElementsBaseVertex;
fp_glGetTexLevelParameteriv glGetTexLevelParameteriv;
fp_glLighti glLighti;
fp_glMultiTexCoordP4uiv glMultiTexCoordP4uiv;
fp_glLightf glLightf;
fp_glBindVertexBuffers glBindVertexBuffers;
fp_glGetAttribLocation glGetAttribLocation;
fp_glTexStorage3DMultisample glTexStorage3DMultisample;
fp_glStencilFuncSeparate glStencilFuncSeparate;
fp_glGenSamplers glGenSamplers;
fp_glClampColor glClampColor;
fp_glUniform4iv glUniform4iv;
fp_glClearStencil glClearStencil;
fp_glTexCoordP1uiv glTexCoordP1uiv;
fp_glDrawTransformFeedbackInstanced glDrawTransformFeedbackInstanced;
fp_glMultiTexCoord3fv glMultiTexCoord3fv;
fp_glGetPixelMapuiv glGetPixelMapuiv;
fp_glGenTextures glGenTextures;
fp_glTexCoord4iv glTexCoord4iv;
fp_glDrawTransformFeedback glDrawTransformFeedback;
fp_glUniform1dv glUniform1dv;
fp_glGetTexParameterIuiv glGetTexParameterIuiv;
fp_glIndexPointer glIndexPointer;
fp_glVertexAttrib4Nbv glVertexAttrib4Nbv;
fp_glIsSync glIsSync;
fp_glVertex2f glVertex2f;
fp_glVertex2d glVertex2d;
fp_glDeleteRenderbuffers glDeleteRenderbuffers;
fp_glUniform2i glUniform2i;
fp_glMapGrid2d glMapGrid2d;
fp_glMapGrid2f glMapGrid2f;
fp_glTexCoordP4ui glTexCoordP4ui;
fp_glVertex2i glVertex2i;
fp_glVertexAttribPointer glVertexAttribPointer;
fp_glProgramUniform1ui glProgramUniform1ui;
fp_glFramebufferTextureLayer glFramebufferTextureLayer;
fp_glVertex2s glVertex2s;
fp_glGetObjectPtrLabel glGetObjectPtrLabel;
fp_glNormal3bv glNormal3bv;
fp_glVertexAttrib4Nuiv glVertexAttrib4Nuiv;
fp_glFlushMappedBufferRange glFlushMappedBufferRange;
fp_glProgramUniform2fv glProgramUniform2fv;
fp_glUniformMatrix2x3dv glUniformMatrix2x3dv;
fp_glProgramUniformMatrix4dv glProgramUniformMatrix4dv;
fp_glSecondaryColor3sv glSecondaryColor3sv;
fp_glProgramUniformMatrix2x4dv glProgramUniformMatrix2x4dv;
fp_glDispatchCompute glDispatchCompute;
fp_glVertex3sv glVertex3sv;
fp_glGenQueries glGenQueries;
fp_glGetPixelMapfv glGetPixelMapfv;
fp_glTexEnvf glTexEnvf;
fp_glVertexAttribP1ui glVertexAttribP1ui;
fp_glTexSubImage3D glTexSubImage3D;
fp_glGetInteger64i_v glGetInteger64i_v;
fp_glFogCoordd glFogCoordd;
fp_glFogCoordf glFogCoordf;
fp_glCopyTexImage2D glCopyTexImage2D;
fp_glTexEnvi glTexEnvi;
fp_glMultiTexCoord1iv glMultiTexCoord1iv;
fp_glIsEnabledi glIsEnabledi;
fp_glBindBuffersRange glBindBuffersRange;
fp_glSecondaryColorP3ui glSecondaryColorP3ui;
fp_glVertexAttribI2i glVertexAttribI2i;
fp_glBindFragDataLocationIndexed glBindFragDataLocationIndexed;
fp_glCopyImageSubData glCopyImageSubData;
fp_glMultiTexCoord2dv glMultiTexCoord2dv;
fp_glUniform2iv glUniform2iv;
fp_glVertexAttrib1fv glVertexAttrib1fv;
fp_glUniform4uiv glUniform4uiv;
fp_glMatrixMode glMatrixMode;
fp_glFeedbackBuffer glFeedbackBuffer;
fp_glProgramUniform2dv glProgramUniform2dv;
fp_glEndQueryIndexed glEndQueryIndexed;
fp_glGetMapiv glGetMapiv;
fp_glFramebufferTexture1D glFramebufferTexture1D;
fp_glUniform4d glUniform4d;
fp_glGetShaderiv glGetShaderiv;
fp_glMultiTexCoord2d glMultiTexCoord2d;
fp_glMultiTexCoord2f glMultiTexCoord2f;
fp_glProgramUniformMatrix3fv glProgramUniformMatrix3fv;
fp_glObjectPtrLabel glObjectPtrLabel;
fp_glInvalidateFramebuffer glInvalidateFramebuffer;
fp_glBindTextures glBindTextures;
fp_glBindFragDataLocation glBindFragDataLocation;
fp_glScissorArrayv glScissorArrayv;
fp_glPrioritizeTextures glPrioritizeTextures;
fp_glCallList glCallList;
fp_glPatchParameterfv glPatchParameterfv;
fp_glSecondaryColor3ubv glSecondaryColor3ubv;
fp_glGetDoublev glGetDoublev;
fp_glMultiTexCoord3iv glMultiTexCoord3iv;
fp_glVertexAttrib1d glVertexAttrib1d;
fp_glUniform4dv glUniform4dv;
fp_glLightModelf glLightModelf;
fp_glGetUniformiv glGetUniformiv;
fp_glInvalidateBufferData glInvalidateBufferData;
fp_glVertex2sv glVertex2sv;
fp_glLightModeli glLightModeli;
fp_glWindowPos3iv glWindowPos3iv;
fp_glMultiTexCoordP1uiv glMultiTexCoordP1uiv;
fp_glUniform3fv glUniform3fv;
fp_glPixelStorei glPixelStorei;
fp_glGetProgramPipelineInfoLog glGetProgramPipelineInfoLog;
fp_glCallLists glCallLists;
fp_glProgramUniformMatrix3x4fv glProgramUniformMatrix3x4fv;
fp_glInvalidateSubFramebuffer glInvalidateSubFramebuffer;
fp_glMapBuffer glMapBuffer;
fp_glSecondaryColor3d glSecondaryColor3d;
fp_glTexCoord3i glTexCoord3i;
fp_glMultiTexCoord4fv glMultiTexCoord4fv;
fp_glRasterPos3i glRasterPos3i;
fp_glSecondaryColor3b glSecondaryColor3b;
fp_glRasterPos3d glRasterPos3d;
fp_glRasterPos3f glRasterPos3f;
fp_glCompressedTexImage3D glCompressedTexImage3D;
fp_glTexCoord3f glTexCoord3f;
fp_glDeleteSync glDeleteSync;
fp_glTexCoord3d glTexCoord3d;
fp_glUniformMatrix4dv glUniformMatrix4dv;
fp_glTexImage2DMultisample glTexImage2DMultisample;
fp_glGetVertexAttribiv glGetVertexAttribiv;
fp_glUniformMatrix4x2dv glUniformMatrix4x2dv;
fp_glMultiDrawElements glMultiDrawElements;
fp_glVertexAttrib3fv glVertexAttrib3fv;
fp_glTexCoord3s glTexCoord3s;
fp_glUniform3iv glUniform3iv;
fp_glRasterPos3s glRasterPos3s;
fp_glPolygonMode glPolygonMode;
fp_glDrawBuffers glDrawBuffers;
fp_glGetActiveUniformBlockiv glGetActiveUniformBlockiv;
fp_glAreTexturesResident glAreTexturesResident;
fp_glProgramUniform2d glProgramUniform2d;
fp_glProgramUniformMatrix4x3dv glProgramUniformMatrix4x3dv;
fp_glIsList glIsList;
fp_glProgramUniform4iv glProgramUniform4iv;
fp_glRasterPos2sv glRasterPos2sv;
fp_glRasterPos4sv glRasterPos4sv;
fp_glColor4s glColor4s;
fp_glGetProgramBinary glGetProgramBinary;
fp_glUseProgram glUseProgram;
fp_glLineStipple glLineStipple;
fp_glMultiTexCoord1sv glMultiTexCoord1sv;
fp_glGetProgramInfoLog glGetProgramInfoLog;
fp_glClearTexImage glClearTexImage;
fp_glGetBufferParameteriv glGetBufferParameteriv;
fp_glMultiTexCoord2iv glMultiTexCoord2iv;
fp_glUniformMatrix2x4fv glUniformMatrix2x4fv;
fp_glBindVertexArray glBindVertexArray;
fp_glColor4b glColor4b;
fp_glSecondaryColor3f glSecondaryColor3f;
fp_glColor4f glColor4f;
fp_glColor4d glColor4d;
fp_glColor4i glColor4i;
fp_glSamplerParameterIiv glSamplerParameterIiv;
fp_glMultiDrawElementsBaseVertex glMultiDrawElementsBaseVertex;
fp_glVertexAttribLFormat glVertexAttribLFormat;
fp_glRasterPos3iv glRasterPos3iv;
fp_glVertex2dv glVertex2dv;
fp_glTexCoord4sv glTexCoord4sv;
fp_glUniform2uiv glUniform2uiv;
fp_glCompressedTexSubImage1D glCompressedTexSubImage1D;
fp_glFinish glFinish;
fp_glDepthRangeIndexed glDepthRangeIndexed;
fp_glGetBooleanv glGetBooleanv;
fp_glDeleteShader glDeleteShader;
fp_glDrawElements glDrawElements;
fp_glGetInternalformati64v glGetInternalformati64v;
fp_glRasterPos2s glRasterPos2s;
fp_glGetMapdv glGetMapdv;
fp_glVertexAttrib4Nsv glVertexAttrib4Nsv;
fp_glMaterialfv glMaterialfv;
fp_glViewport glViewport;
fp_glUniform1uiv glUniform1uiv;
fp_glTransformFeedbackVaryings glTransformFeedbackVaryings;
fp_glIndexdv glIndexdv;
fp_glCopyTexSubImage3D glCopyTexSubImage3D;
fp_glTexCoord3iv glTexCoord3iv;
fp_glDebugMessageCallback glDebugMessageCallback;
fp_glVertexAttribI3i glVertexAttribI3i;
fp_glInvalidateTexImage glInvalidateTexImage;
fp_glVertexAttribFormat glVertexAttribFormat;
fp_glClearDepth glClearDepth;
fp_glVertexAttribI4usv glVertexAttribI4usv;
fp_glTexParameterf glTexParameterf;
fp_glVertexAttribBinding glVertexAttribBinding;
fp_glTexParameteri glTexParameteri;
fp_glGetActiveSubroutineUniformiv glGetActiveSubroutineUniformiv;
fp_glGetShaderSource glGetShaderSource;
fp_glTexBuffer glTexBuffer;
fp_glPopName glPopName;
fp_glValidateProgram glValidateProgram;
fp_glPixelStoref glPixelStoref;
fp_glUniform3uiv glUniform3uiv;
fp_glViewportIndexedf glViewportIndexedf;
fp_glRasterPos4fv glRasterPos4fv;
fp_glEvalCoord1dv glEvalCoord1dv;
fp_glMultiTexCoordP2uiv glMultiTexCoordP2uiv;
fp_glGenProgramPipelines glGenProgramPipelines;
fp_glRecti glRecti;
fp_glColor4ub glColor4ub;
fp_glMultTransposeMatrixf glMultTransposeMatrixf;
fp_glRectf glRectf;
fp_glRectd glRectd;
fp_glNormal3sv glNormal3sv;
fp_glNewList glNewList;
fp_glProgramUniformMatrix2x3dv glProgramUniformMatrix2x3dv;
fp_glColor4us glColor4us;
fp_glVertexAttribP1uiv glVertexAttribP1uiv;
fp_glLinkProgram glLinkProgram;
fp_glHint glHint;
fp_glRects glRects;
fp_glTexCoord2dv glTexCoord2dv;
fp_glRasterPos4iv glRasterPos4iv;
fp_glGetObjectLabel glGetObjectLabel;
fp_glProgramUniform2f glProgramUniform2f;
fp_glGetString glGetString;
fp_glVertexAttribP2uiv glVertexAttribP2uiv;
fp_glEdgeFlagv glEdgeFlagv;
fp_glDetachShader glDetachShader;
fp_glProgramUniform3i glProgramUniform3i;
fp_glScalef glScalef;
fp_glEndQuery glEndQuery;
fp_glScaled glScaled;
fp_glEdgeFlagPointer glEdgeFlagPointer;
fp_glFramebufferParameteri glFramebufferParameteri;
fp_glGetProgramResourceName glGetProgramResourceName;
fp_glUniformMatrix4x3dv glUniformMatrix4x3dv;
fp_glDepthRangeArrayv glDepthRangeArrayv;
fp_glCopyPixels glCopyPixels;
fp_glVertexAttribI2ui glVertexAttribI2ui;
fp_glGetProgramResourceLocation glGetProgramResourceLocation;
fp_glPopAttrib glPopAttrib;
fp_glDeleteTextures glDeleteTextures;
fp_glGetActiveAtomicCounterBufferiv glGetActiveAtomicCounterBufferiv;
fp_glStencilOpSeparate glStencilOpSeparate;
fp_glDeleteQueries glDeleteQueries;
fp_glNormalP3uiv glNormalP3uiv;
fp_glVertexAttrib4f glVertexAttrib4f;
fp_glVertexAttrib4d glVertexAttrib4d;
fp_glViewportIndexedfv glViewportIndexedfv;
fp_glInitNames glInitNames;
fp_glGetBufferParameteri64v glGetBufferParameteri64v;
fp_glColor3dv glColor3dv;
fp_glVertexAttribI1i glVertexAttribI1i;
fp_glGetTexParameteriv glGetTexParameteriv;
fp_glWaitSync glWaitSync;
fp_glProgramUniform1dv glProgramUniform1dv;
fp_glVertexAttrib4s glVertexAttrib4s;
fp_glColorMaterial glColorMaterial;
fp_glSampleCoverage glSampleCoverage;
fp_glSamplerParameteri glSamplerParameteri;
fp_glClearBufferSubData glClearBufferSubData;
fp_glSamplerParameterf glSamplerParameterf;
fp_glTexStorage1D glTexStorage1D;
fp_glUniform1f glUniform1f;
fp_glGetVertexAttribfv glGetVertexAttribfv;
fp_glUniform1d glUniform1d;
fp_glRenderMode glRenderMode;
fp_glGetCompressedTexImage glGetCompressedTexImage;
fp_glWindowPos2dv glWindowPos2dv;
fp_glUniform1i glUniform1i;
fp_glGetActiveAttrib glGetActiveAttrib;
fp_glUniform3i glUniform3i;
fp_glPixelTransferi glPixelTransferi;
fp_glTexSubImage2D glTexSubImage2D;
fp_glDisable glDisable;
fp_glLogicOp glLogicOp;
fp_glEvalPoint2 glEvalPoint2;
fp_glPixelTransferf glPixelTransferf;
fp_glSecondaryColor3i glSecondaryColor3i;
fp_glProgramUniform4uiv glProgramUniform4uiv;
fp_glUniform4ui glUniform4ui;
fp_glColor3f glColor3f;
fp_glBindFramebuffer glBindFramebuffer;
fp_glGetTexEnvfv glGetTexEnvfv;
fp_glRectfv glRectfv;
fp_glCullFace glCullFace;
fp_glGetLightfv glGetLightfv;
fp_glColor3d glColor3d;
fp_glProgramUniform4i glProgramUniform4i;
fp_glTexGend glTexGend;
fp_glProgramUniform4f glProgramUniform4f;
fp_glTexGeni glTexGeni;
fp_glProgramUniform4d glProgramUniform4d;
fp_glMultiTexCoord3s glMultiTexCoord3s;
fp_glGetStringi glGetStringi;
fp_glMultiTexCoord3i glMultiTexCoord3i;
fp_glMultiTexCoord3f glMultiTexCoord3f;
fp_glDrawTransformFeedbackStream glDrawTransformFeedbackStream;
fp_glMultiTexCoord3d glMultiTexCoord3d;
fp_glAttachShader glAttachShader;
fp_glFogCoorddv glFogCoorddv;
fp_glUniformMatrix2x3fv glUniformMatrix2x3fv;
fp_glGetTexGenfv glGetTexGenfv;
fp_glQueryCounter glQueryCounter;
fp_glFogCoordPointer glFogCoordPointer;
fp_glProgramUniformMatrix3dv glProgramUniformMatrix3dv;
fp_glProvokingVertex glProvokingVertex;
fp_glShaderBinary glShaderBinary;
fp_glFramebufferTexture3D glFramebufferTexture3D;
fp_glTexGeniv glTexGeniv;
fp_glRasterPos2dv glRasterPos2dv;
fp_glSecondaryColor3dv glSecondaryColor3dv;
fp_glClientActiveTexture glClientActiveTexture;
fp_glVertexAttribI4sv glVertexAttribI4sv;
fp_glSecondaryColor3us glSecondaryColor3us;
fp_glNormalP3ui glNormalP3ui;
fp_glTexEnvfv glTexEnvfv;
fp_glReadBuffer glReadBuffer;
fp_glViewportArrayv glViewportArrayv;
fp_glTexParameterIuiv glTexParameterIuiv;
fp_glDrawArraysInstanced glDrawArraysInstanced;
fp_glGenerateMipmap glGenerateMipmap;
fp_glProgramUniformMatrix2fv glProgramUniformMatrix2fv;
fp_glWindowPos3fv glWindowPos3fv;
fp_glUniformMatrix3x4dv glUniformMatrix3x4dv;
fp_glLightModelfv glLightModelfv;
fp_glSamplerParameteriv glSamplerParameteriv;
fp_glDeleteLists glDeleteLists;
fp_glGetClipPlane glGetClipPlane;
fp_glVertex4dv glVertex4dv;
fp_glTexCoord2d glTexCoord2d;
fp_glPopMatrix glPopMatrix;
fp_glTexCoord2f glTexCoord2f;
fp_glColor4iv glColor4iv;
fp_glIndexubv glIndexubv;
fp_glUnmapBuffer glUnmapBuffer;
fp_glTexCoord2i glTexCoord2i;
fp_glRasterPos4d glRasterPos4d;
fp_glRasterPos4f glRasterPos4f;
fp_glProgramUniform1iv glProgramUniform1iv;
fp_glVertexAttrib3s glVertexAttrib3s;
fp_glTexCoord2s glTexCoord2s;
fp_glBindRenderbuffer glBindRenderbuffer;
fp_glVertex3fv glVertex3fv;
fp_glTexCoord4dv glTexCoord4dv;
fp_glMaterialiv glMaterialiv;
fp_glVertexAttribP4uiv glVertexAttribP4uiv;
fp_glGetProgramStageiv glGetProgramStageiv;
fp_glIsProgram glIsProgram;
fp_glVertexAttrib4bv glVertexAttrib4bv;
fp_glVertex4s glVertex4s;
fp_glUniformMatrix3x2dv glUniformMatrix3x2dv;
fp_glVertexAttrib4fv glVertexAttrib4fv;
fp_glNormal3dv glNormal3dv;
fp_glIsTransformFeedback glIsTransformFeedback;
fp_glUniform4i glUniform4i;
fp_glActiveTexture glActiveTexture;
fp_glEnableVertexAttribArray glEnableVertexAttribArray;
fp_glRotated glRotated;
fp_glIsProgramPipeline glIsProgramPipeline;
fp_glRotatef glRotatef;
fp_glVertex4i glVertex4i;
fp_glReadPixels glReadPixels;
fp_glVertexAttribI3iv glVertexAttribI3iv;
fp_glLoadName glLoadName;
fp_glUniform4f glUniform4f;
fp_glRenderbufferStorageMultisample glRenderbufferStorageMultisample;
fp_glGenVertexArrays glGenVertexArrays;
fp_glShadeModel glShadeModel;
fp_glMapGrid1d glMapGrid1d;
fp_glGetUniformfv glGetUniformfv;
fp_glMapGrid1f glMapGrid1f;
fp_glSamplerParameterfv glSamplerParameterfv;
fp_glVertexAttribLPointer glVertexAttribLPointer;
fp_glDisableClientState glDisableClientState;
fp_glMultiTexCoord3sv glMultiTexCoord3sv;
fp_glDrawElementsInstancedBaseVertex glDrawElementsInstancedBaseVertex;
fp_glVertexAttribL2dv glVertexAttribL2dv;
fp_glMultiDrawElementsIndirect glMultiDrawElementsIndirect;
fp_glSecondaryColorPointer glSecondaryColorPointer;
fp_glAlphaFunc glAlphaFunc;
fp_glUniform1iv glUniform1iv;
fp_glCreateShaderProgramv glCreateShaderProgramv;
fp_glGetActiveSubroutineName glGetActiveSubroutineName;
fp_glMultiTexCoord4iv glMultiTexCoord4iv;
fp_glVertexAttribL2d glVertexAttribL2d;
fp_glGetQueryObjectiv glGetQueryObjectiv;
fp_glStencilFunc glStencilFunc;
fp_glMultiTexCoord1fv glMultiTexCoord1fv;
fp_glUniformBlockBinding glUniformBlockBinding;
fp_glColor4uiv glColor4uiv;
fp_glRectiv glRectiv;
fp_glColorP4ui glColorP4ui;
fp_glUseProgramStages glUseProgramStages;
fp_glRasterPos3dv glRasterPos3dv;
fp_glEvalMesh2 glEvalMesh2;
fp_glEvalMesh1 glEvalMesh1;
fp_glTexCoordPointer glTexCoordPointer;
fp_glProgramUniform3f glProgramUniform3f;
fp_glProgramUniform3d glProgramUniform3d;
fp_glVertexAttrib4Nubv glVertexAttrib4Nubv;
fp_glVertexAttribI4iv glVertexAttribI4iv;
fp_glGetProgramPipelineiv glGetProgramPipelineiv;
fp_glTexStorage3D glTexStorage3D;
fp_glEvalCoord2fv glEvalCoord2fv;
fp_glGetQueryIndexediv glGetQueryIndexediv;
fp_glColor4ubv glColor4ubv;
fp_glLoadTransposeMatrixd glLoadTransposeMatrixd;
fp_glLoadTransposeMatrixf glLoadTransposeMatrixf;
fp_glObjectLabel glObjectLabel;
fp_glVertexAttribI4i glVertexAttribI4i;
fp_glRasterPos2iv glRasterPos2iv;
fp_glGetBufferSubData glGetBufferSubData;
fp_glGetVertexAttribLdv glGetVertexAttribLdv;
fp_glTexEnviv glTexEnviv;
fp_glBlendEquationSeparate glBlendEquationSeparate;
fp_glVertexAttribI1ui glVertexAttribI1ui;
fp_glGenBuffers glGenBuffers;
fp_glSelectBuffer glSelectBuffer;
fp_glGetSubroutineIndex glGetSubroutineIndex;
fp_glVertexAttrib2sv glVertexAttrib2sv;
fp_glScissorIndexedv glScissorIndexedv;
fp_glPushAttrib glPushAttrib;
fp_glVertexAttribIPointer glVertexAttribIPointer;
fp_glBlendFunc glBlendFunc;
fp_glCreateProgram glCreateProgram;
fp_glTexImage3D glTexImage3D;
fp_glIsFramebuffer glIsFramebuffer;
fp_glLightiv glLightiv;
fp_glPrimitiveRestartIndex glPrimitiveRestartIndex;
fp_glInvalidateTexSubImage glInvalidateTexSubImage;
fp_glTexGenfv glTexGenfv;
fp_glBindImageTextures glBindImageTextures;
fp_glEnd glEnd;
fp_glDeleteBuffers glDeleteBuffers;
fp_glBindProgramPipeline glBindProgramPipeline;
fp_glScissor glScissor;
fp_glTexCoordP4uiv glTexCoordP4uiv;
fp_glClipPlane glClipPlane;
fp_glPushName glPushName;
fp_glTexGendv glTexGendv;
fp_glIndexub glIndexub;
fp_glVertexP2uiv glVertexP2uiv;
fp_glSecondaryColor3iv glSecondaryColor3iv;
fp_glRasterPos4i glRasterPos4i;
fp_glMultTransposeMatrixd glMultTransposeMatrixd;
fp_glClearColor glClearColor;
fp_glVertexAttrib4uiv glVertexAttrib4uiv;
fp_glNormal3s glNormal3s;
fp_glVertexAttrib4Niv glVertexAttrib4Niv;
fp_glProgramUniformMatrix2x3fv glProgramUniformMatrix2x3fv;
fp_glClearBufferiv glClearBufferiv;
fp_glPointParameteri glPointParameteri;
fp_glProgramUniform4dv glProgramUniform4dv;
fp_glColorP4uiv glColorP4uiv;
fp_glBlendColor glBlendColor;
fp_glWindowPos3d glWindowPos3d;
fp_glProgramUniform3fv glProgramUniform3fv;
fp_glVertexAttribI2uiv glVertexAttribI2uiv;
fp_glSamplerParameterIuiv glSamplerParameterIuiv;
fp_glUniform3ui glUniform3ui;
fp_glProgramUniform3uiv glProgramUniform3uiv;
fp_glColor4dv glColor4dv;
fp_glVertexAttribI4uiv glVertexAttribI4uiv;
fp_glPointParameterfv glPointParameterfv;
fp_glResumeTransformFeedback glResumeTransformFeedback;
fp_glUniform2fv glUniform2fv;
fp_glGetActiveSubroutineUniformName glGetActiveSubroutineUniformName;
fp_glGetProgramResourceIndex glGetProgramResourceIndex;
fp_glSecondaryColor3ub glSecondaryColor3ub;
fp_glDrawElementsIndirect glDrawElementsIndirect;
fp_glSecondaryColor3ui glSecondaryColor3ui;
fp_glTexCoord3dv glTexCoord3dv;
fp_glDispatchComputeIndirect glDispatchComputeIndirect;
fp_glGetSamplerParameterIuiv glGetSamplerParameterIuiv;
fp_glBindBufferRange glBindBufferRange;
fp_glNormal3iv glNormal3iv;
fp_glVertexAttribL3dv glVertexAttribL3dv;
fp_glGetUniformdv glGetUniformdv;
fp_glWindowPos3s glWindowPos3s;
fp_glPointParameterf glPointParameterf;
fp_glClearDepthf glClearDepthf;
fp_glGetVertexAttribIuiv glGetVertexAttribIuiv;
fp_glWindowPos3i glWindowPos3i;
fp_glMultiTexCoord4s glMultiTexCoord4s;
fp_glWindowPos3f glWindowPos3f;
fp_glGenTransformFeedbacks glGenTransformFeedbacks;
fp_glColor3us glColor3us;
fp_glColor3uiv glColor3uiv;
fp_glVertexAttrib4Nusv glVertexAttrib4Nusv;
fp_glGetLightiv glGetLightiv;
fp_glDepthFunc glDepthFunc;
fp_glCompressedTexSubImage2D glCompressedTexSubImage2D;
fp_glListBase glListBase;
fp_glMultiTexCoord4f glMultiTexCoord4f;
fp_glColor3ub glColor3ub;
fp_glMultiTexCoord4d glMultiTexCoord4d;
fp_glVertexAttribI4bv glVertexAttribI4bv;
fp_glBlendEquationSeparatei glBlendEquationSeparatei;
fp_glGetTexParameterfv glGetTexParameterfv;
fp_glColor3ui glColor3ui;
fp_glGetProgramResourceLocationIndex glGetProgramResourceLocationIndex;
fp_glMultiTexCoord4i glMultiTexCoord4i;
fp_glBufferStorage glBufferStorage;
fp_glGetPolygonStipple glGetPolygonStipple;
fp_glClientWaitSync glClientWaitSync;
fp_glVertexAttribI4ui glVertexAttribI4ui;
fp_glGetFloati_v glGetFloati_v;
fp_glMultiTexCoord4dv glMultiTexCoord4dv;
fp_glColorMask glColorMask;
fp_glTexParameterIiv glTexParameterIiv;
fp_glBlendEquation glBlendEquation;
fp_glGetUniformLocation glGetUniformLocation;
fp_glGetSamplerParameteriv glGetSamplerParameteriv;
fp_glRasterPos4s glRasterPos4s;
fp_glEndTransformFeedback glEndTransformFeedback;
fp_glVertexAttrib4usv glVertexAttrib4usv;
fp_glGetUniformSubroutineuiv glGetUniformSubroutineuiv;
fp_glMultiTexCoord3dv glMultiTexCoord3dv;
fp_glBindVertexBuffer glBindVertexBuffer;
fp_glColor4sv glColor4sv;
fp_glDebugMessageInsert glDebugMessageInsert;
fp_glPopClientAttrib glPopClientAttrib;
fp_glClearBufferData glClearBufferData;
fp_glBeginTransformFeedback glBeginTransformFeedback;
fp_glFogf glFogf;
fp_glVertexAttribI1iv glVertexAttribI1iv;
fp_glProgramBinary glProgramBinary;
fp_glIsSampler glIsSampler;
fp_glVertexP3ui glVertexP3ui;
fp_glVertexAttribDivisor glVertexAttribDivisor;
fp_glBindSamplers glBindSamplers;
fp_glColor3iv glColor3iv;
fp_glCompressedTexImage1D glCompressedTexImage1D;
fp_glDeleteTransformFeedbacks glDeleteTransformFeedbacks;
fp_glCopyTexSubImage1D glCopyTexSubImage1D;
fp_glTexCoord1i glTexCoord1i;
fp_glCheckFramebufferStatus glCheckFramebufferStatus;
fp_glTexCoord1d glTexCoord1d;
fp_glTexCoord1f glTexCoord1f;
fp_glEndConditionalRender glEndConditionalRender;
fp_glEnableClientState glEnableClientState;
fp_glBindAttribLocation glBindAttribLocation;
fp_glUniformMatrix4x2fv glUniformMatrix4x2fv;
fp_glUniformMatrix2dv glUniformMatrix2dv;
fp_glBlendFunci glBlendFunci;
fp_glMultiTexCoord2sv glMultiTexCoord2sv;
fp_glVertexAttrib1dv glVertexAttrib1dv;
fp_glDrawRangeElements glDrawRangeElements;
fp_glTexCoord1s glTexCoord1s;
fp_glBindBufferBase glBindBufferBase;
fp_glBufferSubData glBufferSubData;
fp_glVertexAttrib4iv glVertexAttrib4iv;
fp_glGenLists glGenLists;
fp_glColor3bv glColor3bv;
fp_glMapBufferRange glMapBufferRange;
fp_glFramebufferTexture glFramebufferTexture;
fp_glBlendFuncSeparatei glBlendFuncSeparatei;
fp_glProgramUniformMatrix4x2fv glProgramUniformMatrix4x2fv;
fp_glVertexAttribL1d glVertexAttribL1d;
fp_glGetTexGendv glGetTexGendv;
fp_glMultiDrawArrays glMultiDrawArrays;
fp_glEndList glEndList;
fp_glScissorIndexed glScissorIndexed;
fp_glVertexP4uiv glVertexP4uiv;
fp_glUniform2ui glUniform2ui;
fp_glVertexAttribI2iv glVertexAttribI2iv;
fp_glColor3usv glColor3usv;
fp_glWindowPos2fv glWindowPos2fv;
fp_glTextureView glTextureView;
fp_glDisablei glDisablei;
fp_glProgramUniformMatrix2x4fv glProgramUniformMatrix2x4fv;
fp_glIndexMask glIndexMask;
fp_glPushClientAttrib glPushClientAttrib;
fp_glShaderSource glShaderSource;
fp_glGetActiveUniformBlockName glGetActiveUniformBlockName;
fp_glVertexAttribI3uiv glVertexAttribI3uiv;
fp_glReleaseShaderCompiler glReleaseShaderCompiler;
fp_glVertexAttribIFormat glVertexAttribIFormat;
fp_glClearAccum glClearAccum;
fp_glGetSynciv glGetSynciv;
fp_glProgramUniform2uiv glProgramUniform2uiv;
fp_glTexCoordP2uiv glTexCoordP2uiv;
fp_glPatchParameteri glPatchParameteri;
fp_glProgramUniform2i glProgramUniform2i;
fp_glUniform2f glUniform2f;
fp_glBeginQuery glBeginQuery;
fp_glGetUniformBlockIndex glGetUniformBlockIndex;
fp_glBindBuffer glBindBuffer;
fp_glMap2d glMap2d;
fp_glMap2f glMap2f;
fp_glTexStorage2DMultisample glTexStorage2DMultisample;
fp_glUniform2d glUniform2d;
fp_glVertex4d glVertex4d;
fp_glUniformMatrix2fv glUniformMatrix2fv;
fp_glTexCoord1sv glTexCoord1sv;
fp_glBufferData glBufferData;
fp_glEvalPoint1 glEvalPoint1;
fp_glGetTexParameterIiv glGetTexParameterIiv;
fp_glTexCoord1dv glTexCoord1dv;
fp_glTexCoordP1ui glTexCoordP1ui;
fp_glGetError glGetError;
fp_glGetTexEnviv glGetTexEnviv;
fp_glGetProgramiv glGetProgramiv;
fp_glVertexAttribP2ui glVertexAttribP2ui;
fp_glGetFloatv glGetFloatv;
fp_glTexSubImage1D glTexSubImage1D;
fp_glMultiTexCoord2fv glMultiTexCoord2fv;
fp_glUniformMatrix2x4dv glUniformMatrix2x4dv;
fp_glVertexAttrib2fv glVertexAttrib2fv;
fp_glEvalCoord1d glEvalCoord1d;
fp_glGetTexLevelParameterfv glGetTexLevelParameterfv;
fp_glEvalCoord1f glEvalCoord1f;
fp_glPixelMapfv glPixelMapfv;
fp_glVertexAttribP3uiv glVertexAttribP3uiv;
fp_glGetPixelMapusv glGetPixelMapusv;
fp_glSecondaryColorP3uiv glSecondaryColorP3uiv;
fp_glGetIntegerv glGetIntegerv;
fp_glAccum glAccum;
fp_glGetBufferPointerv glGetBufferPointerv;
fp_glGetVertexAttribIiv glGetVertexAttribIiv;
fp_glRasterPos4dv glRasterPos4dv;
fp_glProgramUniform4fv glProgramUniform4fv;
fp_glTexCoord2iv glTexCoord2iv;
fp_glIsQuery glIsQuery;
fp_glProgramUniform2ui glProgramUniform2ui;
fp_glProgramUniform4ui glProgramUniform4ui;
fp_glVertexAttrib4sv glVertexAttrib4sv;
fp_glWindowPos3dv glWindowPos3dv;
fp_glTexImage2D glTexImage2D;
fp_glStencilMask glStencilMask;
fp_glDrawPixels glDrawPixels;
fp_glMultMatrixd glMultMatrixd;
fp_glMultMatrixf glMultMatrixf;
fp_glIsTexture glIsTexture;
fp_glGetMaterialiv glGetMaterialiv;
fp_glUniform1fv glUniform1fv;
fp_glLoadMatrixf glLoadMatrixf;
fp_glTexStorage2D glTexStorage2D;
fp_glLoadMatrixd glLoadMatrixd;
fp_glTexParameterfv glTexParameterfv;
fp_glUniformMatrix3fv glUniformMatrix3fv;
fp_glVertex4f glVertex4f;
fp_glRectsv glRectsv;
fp_glColor4usv glColor4usv;
fp_glUniform3dv glUniform3dv;
fp_glProgramUniformMatrix4x3fv glProgramUniformMatrix4x3fv;
fp_glPolygonStipple glPolygonStipple;
fp_glBindBuffersBase glBindBuffersBase;
fp_glInterleavedArrays glInterleavedArrays;
fp_glGetSubroutineUniformLocation glGetSubroutineUniformLocation;
fp_glNormal3i glNormal3i;
fp_glNormal3f glNormal3f;
fp_glNormal3d glNormal3d;
fp_glNormal3b glNormal3b;
fp_glGetFramebufferParameteriv glGetFramebufferParameteriv;
fp_glPixelMapusv glPixelMapusv;
fp_glGetTexGeniv glGetTexGeniv;
fp_glArrayElement glArrayElement;
fp_glCopyBufferSubData glCopyBufferSubData;
fp_glVertexAttribI1uiv glVertexAttribI1uiv;
fp_glVertexAttrib2d glVertexAttrib2d;
fp_glBindTransformFeedback glBindTransformFeedback;
fp_glVertexAttrib2f glVertexAttrib2f;
fp_glVertexAttrib3dv glVertexAttrib3dv;
fp_glGetQueryObjectui64v glGetQueryObjectui64v;
fp_glDepthMask glDepthMask;
fp_glVertexAttrib2s glVertexAttrib2s;
fp_glColor3fv glColor3fv;
fp_glTexImage3DMultisample glTexImage3DMultisample;
fp_glProgramUniform1fv glProgramUniform1fv;
fp_glUniformMatrix4fv glUniformMatrix4fv;
fp_glUniform4fv glUniform4fv;
fp_glGetActiveUniform glGetActiveUniform;
fp_glColorPointer glColorPointer;
fp_glFrontFace glFrontFace;
fp_glTexBufferRange glTexBufferRange;
fp_glDrawArraysInstancedBaseInstance glDrawArraysInstancedBaseInstance;
fp_glGetBooleani_v glGetBooleani_v;
fp_glVertexAttribL3d glVertexAttribL3d;
fp_glDeleteProgramPipelines glDeleteProgramPipelines;
fp_glClearBufferuiv glClearBufferuiv;
fp_glGetProgramResourceiv glGetProgramResourceiv;
}
