public import opengl.types.*;
public import opengl.enums.*;
import opengl.lookup.*;
import opengl.platform.*;


record GLFunctions (
    Accum: GLCodePointer[[GLenum, GLfloat], []],
    ActiveTexture: GLCodePointer[[GLenum], []],
    AlphaFunc: GLCodePointer[[GLenum, GLclampf], []],
    AreTexturesResident: GLCodePointer[[GLsizei, Pointer[GLuint], Pointer[GLboolean]], [GLboolean]],
    ArrayElement: GLCodePointer[[GLint], []],
    AttachShader: GLCodePointer[[GLuint, GLuint], []],
    Begin: GLCodePointer[[GLenum], []],
    BeginConditionalRender: GLCodePointer[[GLuint, GLenum], []],
    BeginQuery: GLCodePointer[[GLenum, GLuint], []],
    BeginQueryIndexed: GLCodePointer[[GLenum, GLuint, GLuint], []],
    BeginTransformFeedback: GLCodePointer[[GLenum], []],
    BindAttribLocation: GLCodePointer[[GLuint, GLuint, GLstring], []],
    BindBuffer: GLCodePointer[[GLenum, GLuint], []],
    BindBufferBase: GLCodePointer[[GLenum, GLuint, GLuint], []],
    BindBufferRange: GLCodePointer[[GLenum, GLuint, GLuint, GLintptr, GLsizeiptr], []],
    BindFragDataLocation: GLCodePointer[[GLuint, GLuint, GLstring], []],
    BindFragDataLocationIndexed: GLCodePointer[[GLuint, GLuint, GLuint, GLstring], []],
    BindFramebuffer: GLCodePointer[[GLenum, GLuint], []],
    BindRenderbuffer: GLCodePointer[[GLenum, GLuint], []],
    BindSampler: GLCodePointer[[GLenum, GLuint], []],
    BindTexture: GLCodePointer[[GLenum, GLuint], []],
    BindTransformFeedback: GLCodePointer[[GLenum, GLuint], []],
    BindVertexArray: GLCodePointer[[GLuint], []],
    Bitmap: GLCodePointer[[GLsizei, GLsizei, GLfloat, GLfloat, GLfloat, GLfloat, Pointer[GLubyte]], []],
    BlendColor: GLCodePointer[[GLclampf, GLclampf, GLclampf, GLclampf], []],
    BlendEquation: GLCodePointer[[GLenum], []],
    BlendEquationSeparate: GLCodePointer[[GLenum, GLenum], []],
    BlendFunc: GLCodePointer[[GLenum, GLenum], []],
    BlendFuncSeparate: GLCodePointer[[GLenum, GLenum, GLenum, GLenum], []],
    BlitFramebuffer: GLCodePointer[[GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum], []],
    BufferData: GLCodePointer[[GLenum, GLsizeiptr, Pointer[GLvoid], GLenum], []],
    BufferSubData: GLCodePointer[[GLenum, GLintptr, GLsizeiptr, Pointer[GLvoid]], []],
    CallList: GLCodePointer[[GLuint], []],
    CallLists: GLCodePointer[[GLsizei, GLenum, Pointer[GLvoid]], []],
    CheckFramebufferStatus: GLCodePointer[[GLenum], [GLenum]],
    ClampColor: GLCodePointer[[GLenum, GLenum], []],
    Clear: GLCodePointer[[GLbitfield], []],
    ClearAccum: GLCodePointer[[GLfloat, GLfloat, GLfloat, GLfloat], []],
    ClearBufferfi: GLCodePointer[[GLenum, GLint, GLfloat, GLint], []],
    ClearBufferfv: GLCodePointer[[GLenum, GLint, Pointer[GLfloat]], []],
    ClearBufferiv: GLCodePointer[[GLenum, GLint, Pointer[GLint]], []],
    ClearBufferuiv: GLCodePointer[[GLenum, GLint, Pointer[GLuint]], []],
    ClearColor: GLCodePointer[[GLclampf, GLclampf, GLclampf, GLclampf], []],
    ClearColorIiEXT: GLCodePointer[[GLint, GLint, GLint, GLint], []],
    ClearColorIuiEXT: GLCodePointer[[GLuint, GLuint, GLuint, GLuint], []],
    ClearDepth: GLCodePointer[[GLclampd], []],
    ClearIndex: GLCodePointer[[GLfloat], []],
    ClearStencil: GLCodePointer[[GLint], []],
    ClientActiveTexture: GLCodePointer[[GLenum], []],
    ClientWaitSync: GLCodePointer[[GLsync, GLbitfield, GLuint64], [GLenum]],
    ClipPlane: GLCodePointer[[GLenum, Pointer[GLdouble]], []],
    Color3b: GLCodePointer[[GLbyte, GLbyte, GLbyte], []],
    Color3bv: GLCodePointer[[Pointer[GLbyte]], []],
    Color3d: GLCodePointer[[GLdouble, GLdouble, GLdouble], []],
    Color3dv: GLCodePointer[[Pointer[GLdouble]], []],
    Color3f: GLCodePointer[[GLfloat, GLfloat, GLfloat], []],
    Color3fv: GLCodePointer[[Pointer[GLfloat]], []],
    Color3i: GLCodePointer[[GLint, GLint, GLint], []],
    Color3iv: GLCodePointer[[Pointer[GLint]], []],
    Color3s: GLCodePointer[[GLshort, GLshort, GLshort], []],
    Color3sv: GLCodePointer[[Pointer[GLshort]], []],
    Color3ub: GLCodePointer[[GLubyte, GLubyte, GLubyte], []],
    Color3ubv: GLCodePointer[[Pointer[GLubyte]], []],
    Color3ui: GLCodePointer[[GLuint, GLuint, GLuint], []],
    Color3uiv: GLCodePointer[[Pointer[GLuint]], []],
    Color3us: GLCodePointer[[GLushort, GLushort, GLushort], []],
    Color3usv: GLCodePointer[[Pointer[GLushort]], []],
    Color4b: GLCodePointer[[GLbyte, GLbyte, GLbyte, GLbyte], []],
    Color4bv: GLCodePointer[[Pointer[GLbyte]], []],
    Color4d: GLCodePointer[[GLdouble, GLdouble, GLdouble, GLdouble], []],
    Color4dv: GLCodePointer[[Pointer[GLdouble]], []],
    Color4f: GLCodePointer[[GLfloat, GLfloat, GLfloat, GLfloat], []],
    Color4fv: GLCodePointer[[Pointer[GLfloat]], []],
    Color4i: GLCodePointer[[GLint, GLint, GLint, GLint], []],
    Color4iv: GLCodePointer[[Pointer[GLint]], []],
    Color4s: GLCodePointer[[GLshort, GLshort, GLshort, GLshort], []],
    Color4sv: GLCodePointer[[Pointer[GLshort]], []],
    Color4ub: GLCodePointer[[GLubyte, GLubyte, GLubyte, GLubyte], []],
    Color4ubv: GLCodePointer[[Pointer[GLubyte]], []],
    Color4ui: GLCodePointer[[GLuint, GLuint, GLuint, GLuint], []],
    Color4uiv: GLCodePointer[[Pointer[GLuint]], []],
    Color4us: GLCodePointer[[GLushort, GLushort, GLushort, GLushort], []],
    Color4usv: GLCodePointer[[Pointer[GLushort]], []],
    ColorMask: GLCodePointer[[GLboolean, GLboolean, GLboolean, GLboolean], []],
    ColorMaski: GLCodePointer[[GLuint, GLboolean, GLboolean, GLboolean, GLboolean], []],
    ColorMaterial: GLCodePointer[[GLenum, GLenum], []],
    ColorP3ui: GLCodePointer[[GLenum, GLuint], []],
    ColorP3uiv: GLCodePointer[[GLenum, Pointer[GLuint]], []],
    ColorP4ui: GLCodePointer[[GLenum, GLuint], []],
    ColorP4uiv: GLCodePointer[[GLenum, Pointer[GLuint]], []],
    ColorPointer: GLCodePointer[[GLint, GLenum, GLsizei, Pointer[GLvoid]], []],
    CompileShader: GLCodePointer[[GLuint], []],
    CompressedTexImage1D: GLCodePointer[[GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, Pointer[GLvoid]], []],
    CompressedTexImage2D: GLCodePointer[[GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, Pointer[GLvoid]], []],
    CompressedTexImage3D: GLCodePointer[[GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, Pointer[GLvoid]], []],
    CompressedTexSubImage1D: GLCodePointer[[GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, Pointer[GLvoid]], []],
    CompressedTexSubImage2D: GLCodePointer[[GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, Pointer[GLvoid]], []],
    CompressedTexSubImage3D: GLCodePointer[[GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Pointer[GLvoid]], []],
    CopyBufferSubData: GLCodePointer[[GLenum, GLenum, GLintptr, GLintptr, GLsizeiptr], []],
    CopyPixels: GLCodePointer[[GLint, GLint, GLsizei, GLsizei, GLenum], []],
    CopyTexImage1D: GLCodePointer[[GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint], []],
    CopyTexImage2D: GLCodePointer[[GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint], []],
    CopyTexSubImage1D: GLCodePointer[[GLenum, GLint, GLint, GLint, GLint, GLsizei], []],
    CopyTexSubImage2D: GLCodePointer[[GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei], []],
    CopyTexSubImage3D: GLCodePointer[[GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei], []],
    CreateProgram: GLCodePointer[[], [GLuint]],
    CreateShader: GLCodePointer[[GLenum], [GLuint]],
    CullFace: GLCodePointer[[GLenum], []],
    DeleteBuffers: GLCodePointer[[GLsizei, Pointer[GLuint]], []],
    DeleteFramebuffers: GLCodePointer[[GLsizei, Pointer[GLuint]], []],
    DeleteLists: GLCodePointer[[GLuint, GLsizei], []],
    DeleteProgram: GLCodePointer[[GLuint], []],
    DeleteQueries: GLCodePointer[[GLsizei, Pointer[GLuint]], []],
    DeleteRenderbuffers: GLCodePointer[[GLsizei, Pointer[GLuint]], []],
    DeleteSamplers: GLCodePointer[[GLsizei, Pointer[GLuint]], []],
    DeleteShader: GLCodePointer[[GLuint], []],
    DeleteSync: GLCodePointer[[GLsync], []],
    DeleteTextures: GLCodePointer[[GLsizei, Pointer[GLuint]], []],
    DeleteTransformFeedbacks: GLCodePointer[[GLsizei, Pointer[GLuint]], []],
    DeleteVertexArrays: GLCodePointer[[GLsizei, Pointer[GLuint]], []],
    DepthFunc: GLCodePointer[[GLenum], []],
    DepthMask: GLCodePointer[[GLboolean], []],
    DepthRange: GLCodePointer[[GLclampd, GLclampd], []],
    DetachShader: GLCodePointer[[GLuint, GLuint], []],
    Disable: GLCodePointer[[GLenum], []],
    DisableClientState: GLCodePointer[[GLenum], []],
    DisableVertexAttribArray: GLCodePointer[[GLuint], []],
    Disablei: GLCodePointer[[GLenum, GLuint], []],
    DrawArrays: GLCodePointer[[GLenum, GLint, GLsizei], []],
    DrawArraysInstanced: GLCodePointer[[GLenum, GLint, GLsizei, GLsizei], []],
    DrawBuffer: GLCodePointer[[GLenum], []],
    DrawBuffers: GLCodePointer[[GLsizei, Pointer[GLenum]], []],
    DrawElements: GLCodePointer[[GLenum, GLsizei, GLenum, Pointer[GLvoid]], []],
    DrawElementsInstanced: GLCodePointer[[GLenum, GLsizei, GLenum, Pointer[GLvoid], GLsizei], []],
    DrawPixels: GLCodePointer[[GLsizei, GLsizei, GLenum, GLenum, Pointer[GLvoid]], []],
    DrawRangeElements: GLCodePointer[[GLenum, GLuint, GLuint, GLsizei, GLenum, Pointer[GLvoid]], []],
    DrawTransformFeedback: GLCodePointer[[GLenum, GLuint], []],
    DrawTransformFeedbackStream: GLCodePointer[[GLenum, GLuint, GLuint], []],
    EdgeFlag: GLCodePointer[[GLboolean], []],
    EdgeFlagPointer: GLCodePointer[[GLsizei, Pointer[GLvoid]], []],
    EdgeFlagv: GLCodePointer[[Pointer[GLboolean]], []],
    Enable: GLCodePointer[[GLenum], []],
    EnableClientState: GLCodePointer[[GLenum], []],
    EnableVertexAttribArray: GLCodePointer[[GLuint], []],
    Enablei: GLCodePointer[[GLenum, GLuint], []],
    End: GLCodePointer[[], []],
    EndConditionalRender: GLCodePointer[[], []],
    EndList: GLCodePointer[[], []],
    EndQuery: GLCodePointer[[GLenum], []],
    EndQueryIndexed: GLCodePointer[[GLenum, GLuint], []],
    EndTransformFeedback: GLCodePointer[[], []],
    EvalCoord1d: GLCodePointer[[GLdouble], []],
    EvalCoord1dv: GLCodePointer[[Pointer[GLdouble]], []],
    EvalCoord1f: GLCodePointer[[GLfloat], []],
    EvalCoord1fv: GLCodePointer[[Pointer[GLfloat]], []],
    EvalCoord2d: GLCodePointer[[GLdouble, GLdouble], []],
    EvalCoord2dv: GLCodePointer[[Pointer[GLdouble]], []],
    EvalCoord2f: GLCodePointer[[GLfloat, GLfloat], []],
    EvalCoord2fv: GLCodePointer[[Pointer[GLfloat]], []],
    EvalMesh1: GLCodePointer[[GLenum, GLint, GLint], []],
    EvalMesh2: GLCodePointer[[GLenum, GLint, GLint, GLint, GLint], []],
    EvalPoint1: GLCodePointer[[GLint], []],
    EvalPoint2: GLCodePointer[[GLint, GLint], []],
    FeedbackBuffer: GLCodePointer[[GLsizei, GLenum, Pointer[GLfloat]], []],
    FenceSync: GLCodePointer[[GLenum, GLbitfield], [GLsync]],
    Finish: GLCodePointer[[], []],
    Flush: GLCodePointer[[], []],
    FlushMappedBufferRange: GLCodePointer[[GLenum, GLintptr, GLsizeiptr], []],
    FogCoordPointer: GLCodePointer[[GLenum, GLsizei, Pointer[GLvoid]], []],
    FogCoordd: GLCodePointer[[GLdouble], []],
    FogCoorddv: GLCodePointer[[Pointer[GLdouble]], []],
    FogCoordf: GLCodePointer[[GLfloat], []],
    FogCoordfv: GLCodePointer[[Pointer[GLfloat]], []],
    Fogf: GLCodePointer[[GLenum, GLfloat], []],
    Fogfv: GLCodePointer[[GLenum, Pointer[GLfloat]], []],
    Fogi: GLCodePointer[[GLenum, GLint], []],
    Fogiv: GLCodePointer[[GLenum, Pointer[GLint]], []],
    FramebufferRenderbuffer: GLCodePointer[[GLenum, GLenum, GLenum, GLuint], []],
    FramebufferTexture: GLCodePointer[[GLenum, GLenum, GLuint, GLint], []],
    FramebufferTexture1D: GLCodePointer[[GLenum, GLenum, GLenum, GLuint, GLint], []],
    FramebufferTexture2D: GLCodePointer[[GLenum, GLenum, GLenum, GLuint, GLint], []],
    FramebufferTexture3D: GLCodePointer[[GLenum, GLenum, GLenum, GLuint, GLint, GLint], []],
    FramebufferTextureFaceARB: GLCodePointer[[GLenum, GLenum, GLuint, GLint, GLenum], []],
    FramebufferTextureLayer: GLCodePointer[[GLenum, GLenum, GLuint, GLint, GLint], []],
    FramebufferTextureLayerARB: GLCodePointer[[GLenum, GLenum, GLuint, GLint, GLint], []],
    FrontFace: GLCodePointer[[GLenum], []],
    Frustum: GLCodePointer[[GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble], []],
    GenBuffers: GLCodePointer[[GLsizei, Pointer[GLuint]], []],
    GenFramebuffers: GLCodePointer[[GLsizei, Pointer[GLuint]], []],
    GenLists: GLCodePointer[[GLsizei], [GLuint]],
    GenQueries: GLCodePointer[[GLsizei, Pointer[GLuint]], []],
    GenRenderbuffers: GLCodePointer[[GLsizei, Pointer[GLuint]], []],
    GenSamplers: GLCodePointer[[GLsizei, Pointer[GLuint]], []],
    GenTextures: GLCodePointer[[GLsizei, Pointer[GLuint]], []],
    GenTransformFeedbacks: GLCodePointer[[GLsizei, Pointer[GLuint]], []],
    GenVertexArrays: GLCodePointer[[GLsizei, Pointer[GLuint]], []],
    GenerateMipmap: GLCodePointer[[GLenum], []],
    GetActiveAttrib: GLCodePointer[[GLuint, GLuint, GLsizei, Pointer[GLsizei], Pointer[GLint], Pointer[GLenum], GLstring], []],
    GetActiveSubroutineName: GLCodePointer[[GLuint, GLenum, GLuint, GLsizei, Pointer[GLsizei], GLstring], []],
    GetActiveSubroutineUniformName: GLCodePointer[[GLuint, GLenum, GLuint, GLsizei, Pointer[GLsizei], GLstring], []],
    GetActiveSubroutineUniformiv: GLCodePointer[[GLuint, GLenum, GLuint, GLenum, Pointer[GLint]], []],
    GetActiveUniform: GLCodePointer[[GLuint, GLuint, GLsizei, Pointer[GLsizei], Pointer[GLint], Pointer[GLenum], GLstring], []],
    GetActiveUniformBlockName: GLCodePointer[[GLuint, GLuint, GLsizei, Pointer[GLsizei], GLstring], []],
    GetActiveUniformBlockiv: GLCodePointer[[GLuint, GLuint, GLenum, Pointer[GLint]], []],
    GetActiveUniformName: GLCodePointer[[GLuint, GLuint, GLsizei, Pointer[GLsizei], GLstring], []],
    GetActiveUniformsiv: GLCodePointer[[GLuint, GLsizei, Pointer[GLuint], GLenum, Pointer[GLint]], []],
    GetAttachedShaders: GLCodePointer[[GLuint, GLsizei, Pointer[GLsizei], Pointer[GLuint]], []],
    GetAttribLocation: GLCodePointer[[GLuint, GLstring], [GLint]],
    GetBooleani_v: GLCodePointer[[GLenum, GLuint, Pointer[GLboolean]], []],
    GetBooleanv: GLCodePointer[[GLenum, Pointer[GLboolean]], []],
    GetBufferParameteri64v: GLCodePointer[[GLenum, GLenum, Pointer[GLint64]], []],
    GetBufferParameteriv: GLCodePointer[[GLenum, GLenum, Pointer[GLint]], []],
    GetBufferPointerv: GLCodePointer[[GLenum, GLenum, Pointer[Pointer[GLvoid]]], []],
    GetBufferSubData: GLCodePointer[[GLenum, GLintptr, GLsizeiptr, Pointer[GLvoid]], []],
    GetClipPlane: GLCodePointer[[GLenum, Pointer[GLdouble]], []],
    GetCompressedTexImage: GLCodePointer[[GLenum, GLint, Pointer[GLvoid]], []],
    GetDoublev: GLCodePointer[[GLenum, Pointer[GLdouble]], []],
    GetError: GLCodePointer[[], [GLenum]],
    GetFloatv: GLCodePointer[[GLenum, Pointer[GLfloat]], []],
    GetFragDataIndex: GLCodePointer[[GLuint, GLstring], [GLint]],
    GetFragDataLocation: GLCodePointer[[GLuint, GLstring], [GLint]],
    GetFramebufferAttachmentParameteriv: GLCodePointer[[GLenum, GLenum, GLenum, Pointer[GLint]], []],
    GetInteger64i_v: GLCodePointer[[GLenum, GLuint, Pointer[GLint64]], []],
    GetInteger64v: GLCodePointer[[GLenum, Pointer[GLint64]], []],
    GetIntegeri_v: GLCodePointer[[GLenum, GLuint, Pointer[GLint]], []],
    GetIntegerv: GLCodePointer[[GLenum, Pointer[GLint]], []],
    GetLightfv: GLCodePointer[[GLenum, GLenum, Pointer[GLfloat]], []],
    GetLightiv: GLCodePointer[[GLenum, GLenum, Pointer[GLint]], []],
    GetMapdv: GLCodePointer[[GLenum, GLenum, Pointer[GLdouble]], []],
    GetMapfv: GLCodePointer[[GLenum, GLenum, Pointer[GLfloat]], []],
    GetMapiv: GLCodePointer[[GLenum, GLenum, Pointer[GLint]], []],
    GetMaterialfv: GLCodePointer[[GLenum, GLenum, Pointer[GLfloat]], []],
    GetMaterialiv: GLCodePointer[[GLenum, GLenum, Pointer[GLint]], []],
    GetMultisamplefv: GLCodePointer[[GLenum, GLuint, Pointer[GLfloat]], []],
    GetPixelMapfv: GLCodePointer[[GLenum, Pointer[GLfloat]], []],
    GetPixelMapuiv: GLCodePointer[[GLenum, Pointer[GLuint]], []],
    GetPixelMapusv: GLCodePointer[[GLenum, Pointer[GLushort]], []],
    GetPointerv: GLCodePointer[[GLenum, Pointer[Pointer[GLvoid]]], []],
    GetPolygonStipple: GLCodePointer[[Pointer[GLubyte]], []],
    GetProgramInfoLog: GLCodePointer[[GLuint, GLsizei, Pointer[GLsizei], GLstring], []],
    GetProgramStageiv: GLCodePointer[[GLuint, GLenum, GLenum, Pointer[GLint]], []],
    GetProgramiv: GLCodePointer[[GLuint, GLenum, Pointer[GLint]], []],
    GetQueryIndexediv: GLCodePointer[[GLenum, GLuint, GLenum, Pointer[GLint]], []],
    GetQueryObjecti64v: GLCodePointer[[GLuint, GLenum, Pointer[GLint64]], []],
    GetQueryObjectiv: GLCodePointer[[GLuint, GLenum, Pointer[GLint]], []],
    GetQueryObjectui64v: GLCodePointer[[GLuint, GLenum, Pointer[GLuint64]], []],
    GetQueryObjectuiv: GLCodePointer[[GLuint, GLenum, Pointer[GLuint]], []],
    GetQueryiv: GLCodePointer[[GLenum, GLenum, Pointer[GLint]], []],
    GetRenderbufferParameteriv: GLCodePointer[[GLenum, GLenum, Pointer[GLint]], []],
    GetSamplerParameterIfv: GLCodePointer[[GLuint, GLenum, Pointer[GLfloat]], []],
    GetSamplerParameterIiv: GLCodePointer[[GLuint, GLenum, Pointer[GLint]], []],
    GetSamplerParameterfv: GLCodePointer[[GLuint, GLenum, Pointer[GLfloat]], []],
    GetSamplerParameteriv: GLCodePointer[[GLuint, GLenum, Pointer[GLint]], []],
    GetShaderInfoLog: GLCodePointer[[GLuint, GLsizei, Pointer[GLsizei], GLstring], []],
    GetShaderSource: GLCodePointer[[GLint, GLsizei, Pointer[GLsizei], GLstring], []],
    GetShaderiv: GLCodePointer[[GLuint, GLenum, Pointer[GLint]], []],
    GetString: GLCodePointer[[GLenum], [GLstring]],
    GetStringi: GLCodePointer[[GLenum, GLuint], [Pointer[GLubyte]]],
    GetSubroutineIndex: GLCodePointer[[GLuint, GLenum, GLstring], [GLuint]],
    GetSubroutineUniformLocation: GLCodePointer[[GLuint, GLenum, GLstring], [GLint]],
    GetSynciv: GLCodePointer[[GLsync, GLenum, GLsizei, Pointer[GLsizei], Pointer[GLint]], []],
    GetTexEnvfv: GLCodePointer[[GLenum, GLenum, Pointer[GLfloat]], []],
    GetTexEnviv: GLCodePointer[[GLenum, GLenum, Pointer[GLint]], []],
    GetTexGendv: GLCodePointer[[GLenum, GLenum, Pointer[GLdouble]], []],
    GetTexGenfv: GLCodePointer[[GLenum, GLenum, Pointer[GLfloat]], []],
    GetTexGeniv: GLCodePointer[[GLenum, GLenum, Pointer[GLint]], []],
    GetTexImage: GLCodePointer[[GLenum, GLint, GLenum, GLenum, Pointer[GLvoid]], []],
    GetTexLevelParameterfv: GLCodePointer[[GLenum, GLint, GLenum, Pointer[GLfloat]], []],
    GetTexLevelParameteriv: GLCodePointer[[GLenum, GLint, GLenum, Pointer[GLint]], []],
    GetTexParameterIiv: GLCodePointer[[GLenum, GLenum, Pointer[GLint]], []],
    GetTexParameterIuiv: GLCodePointer[[GLenum, GLenum, Pointer[GLuint]], []],
    GetTexParameterfv: GLCodePointer[[GLenum, GLenum, Pointer[GLfloat]], []],
    GetTexParameteriv: GLCodePointer[[GLenum, GLenum, Pointer[GLint]], []],
    GetTransformFeedbackVarying: GLCodePointer[[GLuint, GLuint, GLsizei, Pointer[GLsizei], Pointer[GLsizei], Pointer[GLenum], GLstring], []],
    GetUniformBlockIndex: GLCodePointer[[GLuint, GLstring], [GLuint]],
    GetUniformIndices: GLCodePointer[[GLuint, GLsizei, Pointer[GLstring], Pointer[GLuint]], []],
    GetUniformLocation: GLCodePointer[[GLint, GLstring], [GLint]],
    GetUniformSubroutineuiv: GLCodePointer[[GLenum, GLint, Pointer[GLuint]], []],
    GetUniformdv: GLCodePointer[[GLuint, GLint, Pointer[GLdouble]], []],
    GetUniformfv: GLCodePointer[[GLuint, GLint, Pointer[GLfloat]], []],
    GetUniformiv: GLCodePointer[[GLuint, GLint, Pointer[GLint]], []],
    GetUniformuiv: GLCodePointer[[GLuint, GLint, Pointer[GLuint]], []],
    GetVertexAttribIiv: GLCodePointer[[GLuint, GLenum, Pointer[GLint]], []],
    GetVertexAttribIuiv: GLCodePointer[[GLuint, GLenum, Pointer[GLuint]], []],
    GetVertexAttribPointerv: GLCodePointer[[GLuint, GLenum, Pointer[Pointer[GLvoid]]], []],
    GetVertexAttribdv: GLCodePointer[[GLuint, GLenum, Pointer[GLdouble]], []],
    GetVertexAttribfv: GLCodePointer[[GLuint, GLenum, Pointer[GLfloat]], []],
    GetVertexAttribiv: GLCodePointer[[GLuint, GLenum, Pointer[GLint]], []],
    Hint: GLCodePointer[[GLenum, GLenum], []],
    IndexMask: GLCodePointer[[GLuint], []],
    IndexPointer: GLCodePointer[[GLenum, GLsizei, Pointer[GLvoid]], []],
    Indexd: GLCodePointer[[GLdouble], []],
    Indexdv: GLCodePointer[[Pointer[GLdouble]], []],
    Indexf: GLCodePointer[[GLfloat], []],
    Indexfv: GLCodePointer[[Pointer[GLfloat]], []],
    Indexi: GLCodePointer[[GLint], []],
    Indexiv: GLCodePointer[[Pointer[GLint]], []],
    Indexs: GLCodePointer[[GLshort], []],
    Indexsv: GLCodePointer[[Pointer[GLshort]], []],
    Indexub: GLCodePointer[[GLubyte], []],
    Indexubv: GLCodePointer[[Pointer[GLubyte]], []],
    InitNames: GLCodePointer[[], []],
    InterleavedArrays: GLCodePointer[[GLenum, GLsizei, Pointer[GLvoid]], []],
    IsBuffer: GLCodePointer[[GLuint], [GLboolean]],
    IsEnabled: GLCodePointer[[GLenum], [GLboolean]],
    IsEnabledi: GLCodePointer[[GLenum, GLuint], [GLboolean]],
    IsFramebuffer: GLCodePointer[[GLuint], [GLboolean]],
    IsList: GLCodePointer[[GLuint], [GLboolean]],
    IsProgram: GLCodePointer[[GLuint], [GLboolean]],
    IsQuery: GLCodePointer[[GLuint], [GLboolean]],
    IsRenderbuffer: GLCodePointer[[GLuint], [GLboolean]],
    IsSampler: GLCodePointer[[GLuint], [GLboolean]],
    IsShader: GLCodePointer[[GLuint], [GLboolean]],
    IsSync: GLCodePointer[[GLsync], [GLboolean]],
    IsTexture: GLCodePointer[[GLuint], [GLboolean]],
    IsTransformFeedback: GLCodePointer[[GLuint], [GLboolean]],
    IsVertexArray: GLCodePointer[[GLuint], [GLboolean]],
    LightModelf: GLCodePointer[[GLenum, GLfloat], []],
    LightModelfv: GLCodePointer[[GLenum, Pointer[GLfloat]], []],
    LightModeli: GLCodePointer[[GLenum, GLint], []],
    LightModeliv: GLCodePointer[[GLenum, Pointer[GLint]], []],
    Lightf: GLCodePointer[[GLenum, GLenum, GLfloat], []],
    Lightfv: GLCodePointer[[GLenum, GLenum, Pointer[GLfloat]], []],
    Lighti: GLCodePointer[[GLenum, GLenum, GLint], []],
    Lightiv: GLCodePointer[[GLenum, GLenum, Pointer[GLint]], []],
    LineStipple: GLCodePointer[[GLint, GLushort], []],
    LineWidth: GLCodePointer[[GLfloat], []],
    LinkProgram: GLCodePointer[[GLuint], []],
    ListBase: GLCodePointer[[GLuint], []],
    LoadIdentity: GLCodePointer[[], []],
    LoadMatrixd: GLCodePointer[[Pointer[GLdouble]], []],
    LoadMatrixf: GLCodePointer[[Pointer[GLfloat]], []],
    LoadName: GLCodePointer[[GLuint], []],
    LoadTransposeMatrixd: GLCodePointer[[Pointer[GLdouble]], []],
    LoadTransposeMatrixf: GLCodePointer[[Pointer[GLfloat]], []],
    LogicOp: GLCodePointer[[GLenum], []],
    Map1d: GLCodePointer[[GLenum, GLdouble, GLdouble, GLint, GLint, Pointer[GLdouble]], []],
    Map1f: GLCodePointer[[GLenum, GLfloat, GLfloat, GLint, GLint, Pointer[GLfloat]], []],
    Map2d: GLCodePointer[[GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, Pointer[GLdouble]], []],
    Map2f: GLCodePointer[[GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, Pointer[GLfloat]], []],
    MapBuffer: GLCodePointer[[GLenum, GLenum], [Pointer[GLvoid]]],
    MapBufferRange: GLCodePointer[[GLenum, GLintptr, GLsizeiptr, GLbitfield], [Pointer[GLvoid]]],
    MapGrid1d: GLCodePointer[[GLint, GLdouble, GLdouble], []],
    MapGrid1f: GLCodePointer[[GLint, GLfloat, GLfloat], []],
    MapGrid2d: GLCodePointer[[GLint, GLdouble, GLdouble, GLint, GLdouble, GLdouble], []],
    MapGrid2f: GLCodePointer[[GLint, GLfloat, GLfloat, GLint, GLfloat, GLfloat], []],
    Materialf: GLCodePointer[[GLenum, GLenum, GLfloat], []],
    Materialfv: GLCodePointer[[GLenum, GLenum, Pointer[GLfloat]], []],
    Materiali: GLCodePointer[[GLenum, GLenum, GLint], []],
    Materialiv: GLCodePointer[[GLenum, GLenum, Pointer[GLint]], []],
    MatrixMode: GLCodePointer[[GLenum], []],
    MultMatrixd: GLCodePointer[[Pointer[GLdouble]], []],
    MultMatrixf: GLCodePointer[[Pointer[GLfloat]], []],
    MultTransposeMatrixd: GLCodePointer[[Pointer[GLdouble]], []],
    MultTransposeMatrixf: GLCodePointer[[Pointer[GLfloat]], []],
    MultiDrawArrays: GLCodePointer[[GLenum, Pointer[GLint], Pointer[GLsizei], GLsizei], []],
    MultiDrawElements: GLCodePointer[[GLenum, Pointer[GLsizei], GLenum, Pointer[Pointer[GLvoid]], GLsizei], []],
    MultiTexCoord1d: GLCodePointer[[GLenum, GLdouble], []],
    MultiTexCoord1dv: GLCodePointer[[GLenum, Pointer[GLdouble]], []],
    MultiTexCoord1f: GLCodePointer[[GLenum, GLfloat], []],
    MultiTexCoord1fv: GLCodePointer[[GLenum, Pointer[GLfloat]], []],
    MultiTexCoord1i: GLCodePointer[[GLenum, GLint], []],
    MultiTexCoord1iv: GLCodePointer[[GLenum, Pointer[GLint]], []],
    MultiTexCoord1s: GLCodePointer[[GLenum, GLshort], []],
    MultiTexCoord1sv: GLCodePointer[[GLenum, Pointer[GLshort]], []],
    MultiTexCoord2d: GLCodePointer[[GLenum, GLdouble, GLdouble], []],
    MultiTexCoord2dv: GLCodePointer[[GLenum, Pointer[GLdouble]], []],
    MultiTexCoord2f: GLCodePointer[[GLenum, GLfloat, GLfloat], []],
    MultiTexCoord2fv: GLCodePointer[[GLenum, Pointer[GLfloat]], []],
    MultiTexCoord2i: GLCodePointer[[GLenum, GLint, GLint], []],
    MultiTexCoord2iv: GLCodePointer[[GLenum, Pointer[GLint]], []],
    MultiTexCoord2s: GLCodePointer[[GLenum, GLshort, GLshort], []],
    MultiTexCoord2sv: GLCodePointer[[GLenum, Pointer[GLshort]], []],
    MultiTexCoord3d: GLCodePointer[[GLenum, GLdouble, GLdouble, GLdouble], []],
    MultiTexCoord3dv: GLCodePointer[[GLenum, Pointer[GLdouble]], []],
    MultiTexCoord3f: GLCodePointer[[GLenum, GLfloat, GLfloat, GLfloat], []],
    MultiTexCoord3fv: GLCodePointer[[GLenum, Pointer[GLfloat]], []],
    MultiTexCoord3i: GLCodePointer[[GLenum, GLint, GLint, GLint], []],
    MultiTexCoord3iv: GLCodePointer[[GLenum, Pointer[GLint]], []],
    MultiTexCoord3s: GLCodePointer[[GLenum, GLshort, GLshort, GLshort], []],
    MultiTexCoord3sv: GLCodePointer[[GLenum, Pointer[GLshort]], []],
    MultiTexCoord4d: GLCodePointer[[GLenum, GLdouble, GLdouble, GLdouble, GLdouble], []],
    MultiTexCoord4dv: GLCodePointer[[GLenum, Pointer[GLdouble]], []],
    MultiTexCoord4f: GLCodePointer[[GLenum, GLfloat, GLfloat, GLfloat, GLfloat], []],
    MultiTexCoord4fv: GLCodePointer[[GLenum, Pointer[GLfloat]], []],
    MultiTexCoord4i: GLCodePointer[[GLenum, GLint, GLint, GLint, GLint], []],
    MultiTexCoord4iv: GLCodePointer[[GLenum, Pointer[GLint]], []],
    MultiTexCoord4s: GLCodePointer[[GLenum, GLshort, GLshort, GLshort, GLshort], []],
    MultiTexCoord4sv: GLCodePointer[[GLenum, Pointer[GLshort]], []],
    MultiTexCoordP1ui: GLCodePointer[[GLenum, GLenum, GLuint], []],
    MultiTexCoordP1uiv: GLCodePointer[[GLenum, GLenum, Pointer[GLuint]], []],
    MultiTexCoordP2ui: GLCodePointer[[GLenum, GLenum, GLuint], []],
    MultiTexCoordP2uiv: GLCodePointer[[GLenum, GLenum, Pointer[GLuint]], []],
    MultiTexCoordP3ui: GLCodePointer[[GLenum, GLenum, GLuint], []],
    MultiTexCoordP3uiv: GLCodePointer[[GLenum, GLenum, Pointer[GLuint]], []],
    MultiTexCoordP4ui: GLCodePointer[[GLenum, GLenum, GLuint], []],
    MultiTexCoordP4uiv: GLCodePointer[[GLenum, GLenum, Pointer[GLuint]], []],
    NewList: GLCodePointer[[GLuint, GLenum], []],
    Normal3b: GLCodePointer[[GLbyte, GLbyte, GLbyte], []],
    Normal3bv: GLCodePointer[[Pointer[GLbyte]], []],
    Normal3d: GLCodePointer[[GLdouble, GLdouble, GLdouble], []],
    Normal3dv: GLCodePointer[[Pointer[GLdouble]], []],
    Normal3f: GLCodePointer[[GLfloat, GLfloat, GLfloat], []],
    Normal3fv: GLCodePointer[[Pointer[GLfloat]], []],
    Normal3i: GLCodePointer[[GLint, GLint, GLint], []],
    Normal3iv: GLCodePointer[[Pointer[GLint]], []],
    Normal3s: GLCodePointer[[GLshort, GLshort, GLshort], []],
    Normal3sv: GLCodePointer[[Pointer[GLshort]], []],
    NormalP3ui: GLCodePointer[[GLenum, GLuint], []],
    NormalP3uiv: GLCodePointer[[GLenum, Pointer[GLuint]], []],
    NormalPointer: GLCodePointer[[GLenum, GLsizei, Pointer[GLvoid]], []],
    Ortho: GLCodePointer[[GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble], []],
    PassThrough: GLCodePointer[[GLfloat], []],
    PatchParameterfv: GLCodePointer[[GLenum, Pointer[GLfloat]], []],
    PatchParameteri: GLCodePointer[[GLenum, GLint], []],
    PauseTransformFeedback: GLCodePointer[[], []],
    PixelMapfv: GLCodePointer[[GLenum, GLsizei, Pointer[GLfloat]], []],
    PixelMapuiv: GLCodePointer[[GLenum, GLsizei, Pointer[GLuint]], []],
    PixelMapusv: GLCodePointer[[GLenum, GLsizei, Pointer[GLushort]], []],
    PixelStoref: GLCodePointer[[GLenum, GLfloat], []],
    PixelStorei: GLCodePointer[[GLenum, GLint], []],
    PixelTransferf: GLCodePointer[[GLenum, GLfloat], []],
    PixelTransferi: GLCodePointer[[GLenum, GLint], []],
    PixelZoom: GLCodePointer[[GLfloat, GLfloat], []],
    PointParameterf: GLCodePointer[[GLenum, GLfloat], []],
    PointParameterfv: GLCodePointer[[GLenum, Pointer[GLfloat]], []],
    PointParameteri: GLCodePointer[[GLenum, GLint], []],
    PointParameteriv: GLCodePointer[[GLenum, Pointer[GLint]], []],
    PointSize: GLCodePointer[[GLfloat], []],
    PolygonMode: GLCodePointer[[GLenum, GLenum], []],
    PolygonOffset: GLCodePointer[[GLfloat, GLfloat], []],
    PolygonStipple: GLCodePointer[[Pointer[GLubyte]], []],
    PopAttrib: GLCodePointer[[], []],
    PopClientAttrib: GLCodePointer[[], []],
    PopMatrix: GLCodePointer[[], []],
    PopName: GLCodePointer[[], []],
    PrimitiveRestartIndex: GLCodePointer[[GLuint], []],
    PrioritizeTextures: GLCodePointer[[GLsizei, Pointer[GLuint], Pointer[GLclampf]], []],
    ProgramParameteriARB: GLCodePointer[[GLuint, GLenum, GLint], []],
    ProgramUniform1d: GLCodePointer[[GLuint, GLint, GLdouble], []],
    ProgramUniform1dv: GLCodePointer[[GLuint, GLint, GLsizei, Pointer[GLdouble]], []],
    ProgramUniform2d: GLCodePointer[[GLuint, GLint, GLdouble, GLdouble], []],
    ProgramUniform2dv: GLCodePointer[[GLuint, GLint, GLsizei, Pointer[GLdouble]], []],
    ProgramUniform3d: GLCodePointer[[GLuint, GLint, GLdouble, GLdouble, GLdouble], []],
    ProgramUniform3dv: GLCodePointer[[GLuint, GLint, GLsizei, Pointer[GLdouble]], []],
    ProgramUniform4d: GLCodePointer[[GLuint, GLint, GLdouble, GLdouble, GLdouble, GLdouble], []],
    ProgramUniform4dv: GLCodePointer[[GLuint, GLint, GLsizei, Pointer[GLdouble]], []],
    ProgramUniformMatrix2dv: GLCodePointer[[GLuint, GLint, GLsizei, GLboolean, Pointer[GLdouble]], []],
    ProgramUniformMatrix2x3dv: GLCodePointer[[GLuint, GLint, GLsizei, GLboolean, Pointer[GLdouble]], []],
    ProgramUniformMatrix2x4dv: GLCodePointer[[GLuint, GLint, GLsizei, GLboolean, Pointer[GLdouble]], []],
    ProgramUniformMatrix3dv: GLCodePointer[[GLuint, GLint, GLsizei, GLboolean, Pointer[GLdouble]], []],
    ProgramUniformMatrix3x2dv: GLCodePointer[[GLuint, GLint, GLsizei, GLboolean, Pointer[GLdouble]], []],
    ProgramUniformMatrix3x4dv: GLCodePointer[[GLuint, GLint, GLsizei, GLboolean, Pointer[GLdouble]], []],
    ProgramUniformMatrix4dv: GLCodePointer[[GLuint, GLint, GLsizei, GLboolean, Pointer[GLdouble]], []],
    ProgramUniformMatrix4x2dv: GLCodePointer[[GLuint, GLint, GLsizei, GLboolean, Pointer[GLdouble]], []],
    ProgramUniformMatrix4x3dv: GLCodePointer[[GLuint, GLint, GLsizei, GLboolean, Pointer[GLdouble]], []],
    ProvokingVertex: GLCodePointer[[GLenum], []],
    PushAttrib: GLCodePointer[[GLbitfield], []],
    PushClientAttrib: GLCodePointer[[GLbitfield], []],
    PushMatrix: GLCodePointer[[], []],
    PushName: GLCodePointer[[GLuint], []],
    QueryCounter: GLCodePointer[[GLuint, GLenum], []],
    RasterPos2d: GLCodePointer[[GLdouble, GLdouble], []],
    RasterPos2dv: GLCodePointer[[Pointer[GLdouble]], []],
    RasterPos2f: GLCodePointer[[GLfloat, GLfloat], []],
    RasterPos2fv: GLCodePointer[[Pointer[GLfloat]], []],
    RasterPos2i: GLCodePointer[[GLint, GLint], []],
    RasterPos2iv: GLCodePointer[[Pointer[GLint]], []],
    RasterPos2s: GLCodePointer[[GLshort, GLshort], []],
    RasterPos2sv: GLCodePointer[[Pointer[GLshort]], []],
    RasterPos3d: GLCodePointer[[GLdouble, GLdouble, GLdouble], []],
    RasterPos3dv: GLCodePointer[[Pointer[GLdouble]], []],
    RasterPos3f: GLCodePointer[[GLfloat, GLfloat, GLfloat], []],
    RasterPos3fv: GLCodePointer[[Pointer[GLfloat]], []],
    RasterPos3i: GLCodePointer[[GLint, GLint, GLint], []],
    RasterPos3iv: GLCodePointer[[Pointer[GLint]], []],
    RasterPos3s: GLCodePointer[[GLshort, GLshort, GLshort], []],
    RasterPos3sv: GLCodePointer[[Pointer[GLshort]], []],
    RasterPos4d: GLCodePointer[[GLdouble, GLdouble, GLdouble, GLdouble], []],
    RasterPos4dv: GLCodePointer[[Pointer[GLdouble]], []],
    RasterPos4f: GLCodePointer[[GLfloat, GLfloat, GLfloat, GLfloat], []],
    RasterPos4fv: GLCodePointer[[Pointer[GLfloat]], []],
    RasterPos4i: GLCodePointer[[GLint, GLint, GLint, GLint], []],
    RasterPos4iv: GLCodePointer[[Pointer[GLint]], []],
    RasterPos4s: GLCodePointer[[GLshort, GLshort, GLshort, GLshort], []],
    RasterPos4sv: GLCodePointer[[Pointer[GLshort]], []],
    ReadBuffer: GLCodePointer[[GLenum], []],
    ReadPixels: GLCodePointer[[GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, Pointer[GLvoid]], []],
    Rectd: GLCodePointer[[GLdouble, GLdouble, GLdouble, GLdouble], []],
    Rectdv: GLCodePointer[[Pointer[GLdouble], Pointer[GLdouble]], []],
    Rectf: GLCodePointer[[GLfloat, GLfloat, GLfloat, GLfloat], []],
    Rectfv: GLCodePointer[[Pointer[GLfloat], Pointer[GLfloat]], []],
    Recti: GLCodePointer[[GLint, GLint, GLint, GLint], []],
    Rectiv: GLCodePointer[[Pointer[GLint], Pointer[GLint]], []],
    Rects: GLCodePointer[[GLshort, GLshort, GLshort, GLshort], []],
    Rectsv: GLCodePointer[[Pointer[GLshort], Pointer[GLshort]], []],
    RenderMode: GLCodePointer[[GLenum], [GLint]],
    RenderbufferStorage: GLCodePointer[[GLenum, GLenum, GLsizei, GLsizei], []],
    RenderbufferStorageMultisample: GLCodePointer[[GLenum, GLsizei, GLenum, GLsizei, GLsizei], []],
    ResumeTransformFeedback: GLCodePointer[[], []],
    Rotated: GLCodePointer[[GLdouble, GLdouble, GLdouble, GLdouble], []],
    Rotatef: GLCodePointer[[GLfloat, GLfloat, GLfloat, GLfloat], []],
    SampleCoverage: GLCodePointer[[GLclampf, GLboolean], []],
    SampleMaski: GLCodePointer[[GLuint, GLbitfield], []],
    SamplerParameterIiv: GLCodePointer[[GLuint, GLenum, Pointer[GLint]], []],
    SamplerParameterIuiv: GLCodePointer[[GLuint, GLenum, Pointer[GLuint]], []],
    SamplerParameterf: GLCodePointer[[GLuint, GLenum, GLfloat], []],
    SamplerParameterfv: GLCodePointer[[GLuint, GLenum, Pointer[GLfloat]], []],
    SamplerParameteri: GLCodePointer[[GLuint, GLenum, GLint], []],
    SamplerParameteriv: GLCodePointer[[GLuint, GLenum, Pointer[GLint]], []],
    Scaled: GLCodePointer[[GLdouble, GLdouble, GLdouble], []],
    Scalef: GLCodePointer[[GLfloat, GLfloat, GLfloat], []],
    Scissor: GLCodePointer[[GLint, GLint, GLsizei, GLsizei], []],
    SecondaryColor3b: GLCodePointer[[GLbyte, GLbyte, GLbyte], []],
    SecondaryColor3bv: GLCodePointer[[Pointer[GLbyte]], []],
    SecondaryColor3d: GLCodePointer[[GLdouble, GLdouble, GLdouble], []],
    SecondaryColor3dv: GLCodePointer[[Pointer[GLdouble]], []],
    SecondaryColor3f: GLCodePointer[[GLfloat, GLfloat, GLfloat], []],
    SecondaryColor3fv: GLCodePointer[[Pointer[GLfloat]], []],
    SecondaryColor3i: GLCodePointer[[GLint, GLint, GLint], []],
    SecondaryColor3iv: GLCodePointer[[Pointer[GLint]], []],
    SecondaryColor3s: GLCodePointer[[GLshort, GLshort, GLshort], []],
    SecondaryColor3sv: GLCodePointer[[Pointer[GLshort]], []],
    SecondaryColor3ub: GLCodePointer[[GLubyte, GLubyte, GLubyte], []],
    SecondaryColor3ubv: GLCodePointer[[Pointer[GLubyte]], []],
    SecondaryColor3ui: GLCodePointer[[GLuint, GLuint, GLuint], []],
    SecondaryColor3uiv: GLCodePointer[[Pointer[GLuint]], []],
    SecondaryColor3us: GLCodePointer[[GLushort, GLushort, GLushort], []],
    SecondaryColor3usv: GLCodePointer[[Pointer[GLushort]], []],
    SecondaryColorP3ui: GLCodePointer[[GLenum, GLuint], []],
    SecondaryColorP3uiv: GLCodePointer[[GLenum, Pointer[GLuint]], []],
    SecondaryColorPointer: GLCodePointer[[GLint, GLenum, GLsizei, Pointer[GLvoid]], []],
    SelectBuffer: GLCodePointer[[GLsizei, Pointer[GLuint]], []],
    ShadeModel: GLCodePointer[[GLenum], []],
    ShaderSource: GLCodePointer[[GLuint, GLsizei, Pointer[GLstring], Pointer[GLint]], []],
    StencilFunc: GLCodePointer[[GLenum, GLint, GLuint], []],
    StencilFuncSeparate: GLCodePointer[[GLenum, GLenum, GLint, GLuint], []],
    StencilMask: GLCodePointer[[GLuint], []],
    StencilMaskSeparate: GLCodePointer[[GLenum, GLuint], []],
    StencilOp: GLCodePointer[[GLenum, GLenum, GLenum], []],
    StencilOpSeparate: GLCodePointer[[GLenum, GLenum, GLenum, GLenum], []],
    TexBuffer: GLCodePointer[[GLenum, GLenum, GLuint], []],
    TexCoord1d: GLCodePointer[[GLdouble], []],
    TexCoord1dv: GLCodePointer[[Pointer[GLdouble]], []],
    TexCoord1f: GLCodePointer[[GLfloat], []],
    TexCoord1fv: GLCodePointer[[Pointer[GLfloat]], []],
    TexCoord1i: GLCodePointer[[GLint], []],
    TexCoord1iv: GLCodePointer[[Pointer[GLint]], []],
    TexCoord1s: GLCodePointer[[GLshort], []],
    TexCoord1sv: GLCodePointer[[Pointer[GLshort]], []],
    TexCoord2d: GLCodePointer[[GLdouble, GLdouble], []],
    TexCoord2dv: GLCodePointer[[Pointer[GLdouble]], []],
    TexCoord2f: GLCodePointer[[GLfloat, GLfloat], []],
    TexCoord2fv: GLCodePointer[[Pointer[GLfloat]], []],
    TexCoord2i: GLCodePointer[[GLint, GLint], []],
    TexCoord2iv: GLCodePointer[[Pointer[GLint]], []],
    TexCoord2s: GLCodePointer[[GLshort, GLshort], []],
    TexCoord2sv: GLCodePointer[[Pointer[GLshort]], []],
    TexCoord3d: GLCodePointer[[GLdouble, GLdouble, GLdouble], []],
    TexCoord3dv: GLCodePointer[[Pointer[GLdouble]], []],
    TexCoord3f: GLCodePointer[[GLfloat, GLfloat, GLfloat], []],
    TexCoord3fv: GLCodePointer[[Pointer[GLfloat]], []],
    TexCoord3i: GLCodePointer[[GLint, GLint, GLint], []],
    TexCoord3iv: GLCodePointer[[Pointer[GLint]], []],
    TexCoord3s: GLCodePointer[[GLshort, GLshort, GLshort], []],
    TexCoord3sv: GLCodePointer[[Pointer[GLshort]], []],
    TexCoord4d: GLCodePointer[[GLdouble, GLdouble, GLdouble, GLdouble], []],
    TexCoord4dv: GLCodePointer[[Pointer[GLdouble]], []],
    TexCoord4f: GLCodePointer[[GLfloat, GLfloat, GLfloat, GLfloat], []],
    TexCoord4fv: GLCodePointer[[Pointer[GLfloat]], []],
    TexCoord4i: GLCodePointer[[GLint, GLint, GLint, GLint], []],
    TexCoord4iv: GLCodePointer[[Pointer[GLint]], []],
    TexCoord4s: GLCodePointer[[GLshort, GLshort, GLshort, GLshort], []],
    TexCoord4sv: GLCodePointer[[Pointer[GLshort]], []],
    TexCoordP1ui: GLCodePointer[[GLenum, GLuint], []],
    TexCoordP1uiv: GLCodePointer[[GLenum, Pointer[GLuint]], []],
    TexCoordP2ui: GLCodePointer[[GLenum, GLuint], []],
    TexCoordP2uiv: GLCodePointer[[GLenum, Pointer[GLuint]], []],
    TexCoordP3ui: GLCodePointer[[GLenum, GLuint], []],
    TexCoordP3uiv: GLCodePointer[[GLenum, Pointer[GLuint]], []],
    TexCoordP4ui: GLCodePointer[[GLenum, GLuint], []],
    TexCoordP4uiv: GLCodePointer[[GLenum, Pointer[GLuint]], []],
    TexCoordPointer: GLCodePointer[[GLint, GLenum, GLsizei, Pointer[GLvoid]], []],
    TexEnvf: GLCodePointer[[GLenum, GLenum, GLfloat], []],
    TexEnvfv: GLCodePointer[[GLenum, GLenum, Pointer[GLfloat]], []],
    TexEnvi: GLCodePointer[[GLenum, GLenum, GLint], []],
    TexEnviv: GLCodePointer[[GLenum, GLenum, Pointer[GLint]], []],
    TexGend: GLCodePointer[[GLenum, GLenum, GLdouble], []],
    TexGendv: GLCodePointer[[GLenum, GLenum, Pointer[GLdouble]], []],
    TexGenf: GLCodePointer[[GLenum, GLenum, GLfloat], []],
    TexGenfv: GLCodePointer[[GLenum, GLenum, Pointer[GLfloat]], []],
    TexGeni: GLCodePointer[[GLenum, GLenum, GLint], []],
    TexGeniv: GLCodePointer[[GLenum, GLenum, Pointer[GLint]], []],
    TexImage1D: GLCodePointer[[GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, Pointer[GLvoid]], []],
    TexImage2D: GLCodePointer[[GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, Pointer[GLvoid]], []],
    TexImage2DMultisample: GLCodePointer[[GLenum, GLsizei, GLint, GLsizei, GLsizei, GLboolean], []],
    TexImage3D: GLCodePointer[[GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, Pointer[GLvoid]], []],
    TexImage3DMultisample: GLCodePointer[[GLenum, GLsizei, GLint, GLsizei, GLsizei, GLsizei, GLboolean], []],
    TexParameterIiv: GLCodePointer[[GLenum, GLenum, Pointer[GLint]], []],
    TexParameterIuiv: GLCodePointer[[GLenum, GLenum, Pointer[GLuint]], []],
    TexParameterf: GLCodePointer[[GLenum, GLenum, GLfloat], []],
    TexParameterfv: GLCodePointer[[GLenum, GLenum, Pointer[GLfloat]], []],
    TexParameteri: GLCodePointer[[GLenum, GLenum, GLint], []],
    TexParameteriv: GLCodePointer[[GLenum, GLenum, Pointer[GLint]], []],
    TexSubImage1D: GLCodePointer[[GLenum, GLint, GLint, GLsizei, GLenum, GLenum, Pointer[GLvoid]], []],
    TexSubImage2D: GLCodePointer[[GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, Pointer[GLvoid]], []],
    TexSubImage3D: GLCodePointer[[GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, Pointer[GLvoid]], []],
    TransformFeedbackVaryings: GLCodePointer[[GLuint, GLsizei, Pointer[GLstring], GLenum], []],
    Translated: GLCodePointer[[GLdouble, GLdouble, GLdouble], []],
    Translatef: GLCodePointer[[GLfloat, GLfloat, GLfloat], []],
    Uniform1d: GLCodePointer[[GLint, GLdouble], []],
    Uniform1dv: GLCodePointer[[GLint, GLsizei, Pointer[GLdouble]], []],
    Uniform1f: GLCodePointer[[GLint, GLfloat], []],
    Uniform1fv: GLCodePointer[[GLint, GLsizei, Pointer[GLfloat]], []],
    Uniform1i: GLCodePointer[[GLint, GLint], []],
    Uniform1iv: GLCodePointer[[GLint, GLsizei, Pointer[GLint]], []],
    Uniform1ui: GLCodePointer[[GLint, GLuint], []],
    Uniform1uiv: GLCodePointer[[GLint, GLsizei, Pointer[GLuint]], []],
    Uniform2d: GLCodePointer[[GLint, GLdouble, GLdouble], []],
    Uniform2dv: GLCodePointer[[GLint, GLsizei, Pointer[GLdouble]], []],
    Uniform2f: GLCodePointer[[GLint, GLfloat, GLfloat], []],
    Uniform2fv: GLCodePointer[[GLint, GLsizei, Pointer[GLfloat]], []],
    Uniform2i: GLCodePointer[[GLint, GLint, GLint], []],
    Uniform2iv: GLCodePointer[[GLint, GLsizei, Pointer[GLint]], []],
    Uniform2ui: GLCodePointer[[GLint, GLuint, GLuint], []],
    Uniform2uiv: GLCodePointer[[GLint, GLsizei, Pointer[GLuint]], []],
    Uniform3d: GLCodePointer[[GLint, GLdouble, GLdouble, GLdouble], []],
    Uniform3dv: GLCodePointer[[GLint, GLsizei, Pointer[GLdouble]], []],
    Uniform3f: GLCodePointer[[GLint, GLfloat, GLfloat, GLfloat], []],
    Uniform3fv: GLCodePointer[[GLint, GLsizei, Pointer[GLfloat]], []],
    Uniform3i: GLCodePointer[[GLint, GLint, GLint, GLint], []],
    Uniform3iv: GLCodePointer[[GLint, GLsizei, Pointer[GLint]], []],
    Uniform3ui: GLCodePointer[[GLint, GLuint, GLuint, GLuint], []],
    Uniform3uiv: GLCodePointer[[GLint, GLsizei, Pointer[GLuint]], []],
    Uniform4d: GLCodePointer[[GLint, GLdouble, GLdouble, GLdouble, GLdouble], []],
    Uniform4dv: GLCodePointer[[GLint, GLsizei, Pointer[GLdouble]], []],
    Uniform4f: GLCodePointer[[GLint, GLfloat, GLfloat, GLfloat, GLfloat], []],
    Uniform4fv: GLCodePointer[[GLint, GLsizei, Pointer[GLfloat]], []],
    Uniform4i: GLCodePointer[[GLint, GLint, GLint, GLint, GLint], []],
    Uniform4iv: GLCodePointer[[GLint, GLsizei, Pointer[GLint]], []],
    Uniform4ui: GLCodePointer[[GLint, GLuint, GLuint, GLuint, GLuint], []],
    Uniform4uiv: GLCodePointer[[GLint, GLsizei, Pointer[GLuint]], []],
    UniformBlockBinding: GLCodePointer[[GLuint, GLuint, GLuint], []],
    UniformMatrix2dv: GLCodePointer[[GLint, GLsizei, GLboolean, Pointer[GLdouble]], []],
    UniformMatrix2fv: GLCodePointer[[GLint, GLsizei, GLboolean, Pointer[GLfloat]], []],
    UniformMatrix2x3dv: GLCodePointer[[GLint, GLsizei, GLboolean, Pointer[GLdouble]], []],
    UniformMatrix2x3fv: GLCodePointer[[GLint, GLsizei, GLboolean, Pointer[GLfloat]], []],
    UniformMatrix2x4dv: GLCodePointer[[GLint, GLsizei, GLboolean, Pointer[GLdouble]], []],
    UniformMatrix2x4fv: GLCodePointer[[GLint, GLsizei, GLboolean, Pointer[GLfloat]], []],
    UniformMatrix3dv: GLCodePointer[[GLint, GLsizei, GLboolean, Pointer[GLdouble]], []],
    UniformMatrix3fv: GLCodePointer[[GLint, GLsizei, GLboolean, Pointer[GLfloat]], []],
    UniformMatrix3x2dv: GLCodePointer[[GLint, GLsizei, GLboolean, Pointer[GLdouble]], []],
    UniformMatrix3x2fv: GLCodePointer[[GLint, GLsizei, GLboolean, Pointer[GLfloat]], []],
    UniformMatrix3x4dv: GLCodePointer[[GLint, GLsizei, GLboolean, Pointer[GLdouble]], []],
    UniformMatrix3x4fv: GLCodePointer[[GLint, GLsizei, GLboolean, Pointer[GLfloat]], []],
    UniformMatrix4dv: GLCodePointer[[GLint, GLsizei, GLboolean, Pointer[GLdouble]], []],
    UniformMatrix4fv: GLCodePointer[[GLint, GLsizei, GLboolean, Pointer[GLfloat]], []],
    UniformMatrix4x2dv: GLCodePointer[[GLint, GLsizei, GLboolean, Pointer[GLdouble]], []],
    UniformMatrix4x2fv: GLCodePointer[[GLint, GLsizei, GLboolean, Pointer[GLfloat]], []],
    UniformMatrix4x3dv: GLCodePointer[[GLint, GLsizei, GLboolean, Pointer[GLdouble]], []],
    UniformMatrix4x3fv: GLCodePointer[[GLint, GLsizei, GLboolean, Pointer[GLfloat]], []],
    UniformSubroutinesuiv: GLCodePointer[[GLenum, GLsizei, Pointer[GLuint]], []],
    UnmapBuffer: GLCodePointer[[GLenum], [GLboolean]],
    UseProgram: GLCodePointer[[GLuint], []],
    ValidateProgram: GLCodePointer[[GLuint], []],
    Vertex2d: GLCodePointer[[GLdouble, GLdouble], []],
    Vertex2dv: GLCodePointer[[Pointer[GLdouble]], []],
    Vertex2f: GLCodePointer[[GLfloat, GLfloat], []],
    Vertex2fv: GLCodePointer[[Pointer[GLfloat]], []],
    Vertex2i: GLCodePointer[[GLint, GLint], []],
    Vertex2iv: GLCodePointer[[Pointer[GLint]], []],
    Vertex2s: GLCodePointer[[GLshort, GLshort], []],
    Vertex2sv: GLCodePointer[[Pointer[GLshort]], []],
    Vertex3d: GLCodePointer[[GLdouble, GLdouble, GLdouble], []],
    Vertex3dv: GLCodePointer[[Pointer[GLdouble]], []],
    Vertex3f: GLCodePointer[[GLfloat, GLfloat, GLfloat], []],
    Vertex3fv: GLCodePointer[[Pointer[GLfloat]], []],
    Vertex3i: GLCodePointer[[GLint, GLint, GLint], []],
    Vertex3iv: GLCodePointer[[Pointer[GLint]], []],
    Vertex3s: GLCodePointer[[GLshort, GLshort, GLshort], []],
    Vertex3sv: GLCodePointer[[Pointer[GLshort]], []],
    Vertex4d: GLCodePointer[[GLdouble, GLdouble, GLdouble, GLdouble], []],
    Vertex4dv: GLCodePointer[[Pointer[GLdouble]], []],
    Vertex4f: GLCodePointer[[GLfloat, GLfloat, GLfloat, GLfloat], []],
    Vertex4fv: GLCodePointer[[Pointer[GLfloat]], []],
    Vertex4i: GLCodePointer[[GLint, GLint, GLint, GLint], []],
    Vertex4iv: GLCodePointer[[Pointer[GLint]], []],
    Vertex4s: GLCodePointer[[GLshort, GLshort, GLshort, GLshort], []],
    Vertex4sv: GLCodePointer[[Pointer[GLshort]], []],
    VertexAttrib1d: GLCodePointer[[GLuint, GLdouble], []],
    VertexAttrib1dv: GLCodePointer[[GLuint, Pointer[GLdouble]], []],
    VertexAttrib1f: GLCodePointer[[GLuint, GLfloat], []],
    VertexAttrib1fv: GLCodePointer[[GLuint, Pointer[GLfloat]], []],
    VertexAttrib1s: GLCodePointer[[GLuint, GLshort], []],
    VertexAttrib1sv: GLCodePointer[[GLuint, Pointer[GLshort]], []],
    VertexAttrib2d: GLCodePointer[[GLuint, GLdouble, GLdouble], []],
    VertexAttrib2dv: GLCodePointer[[GLuint, Pointer[GLdouble]], []],
    VertexAttrib2f: GLCodePointer[[GLuint, GLfloat, GLfloat], []],
    VertexAttrib2fv: GLCodePointer[[GLuint, Pointer[GLfloat]], []],
    VertexAttrib2s: GLCodePointer[[GLuint, GLshort, GLshort], []],
    VertexAttrib2sv: GLCodePointer[[GLuint, Pointer[GLshort]], []],
    VertexAttrib3d: GLCodePointer[[GLuint, GLdouble, GLdouble, GLdouble], []],
    VertexAttrib3dv: GLCodePointer[[GLuint, Pointer[GLdouble]], []],
    VertexAttrib3f: GLCodePointer[[GLuint, GLfloat, GLfloat, GLfloat], []],
    VertexAttrib3fv: GLCodePointer[[GLuint, Pointer[GLfloat]], []],
    VertexAttrib3s: GLCodePointer[[GLuint, GLshort, GLshort, GLshort], []],
    VertexAttrib3sv: GLCodePointer[[GLuint, Pointer[GLshort]], []],
    VertexAttrib4Nbv: GLCodePointer[[GLuint, Pointer[GLbyte]], []],
    VertexAttrib4Niv: GLCodePointer[[GLuint, Pointer[GLint]], []],
    VertexAttrib4Nsv: GLCodePointer[[GLuint, Pointer[GLshort]], []],
    VertexAttrib4Nub: GLCodePointer[[GLuint, GLubyte, GLubyte, GLubyte, GLubyte], []],
    VertexAttrib4Nubv: GLCodePointer[[GLuint, Pointer[GLubyte]], []],
    VertexAttrib4Nuiv: GLCodePointer[[GLuint, Pointer[GLuint]], []],
    VertexAttrib4Nusv: GLCodePointer[[GLuint, Pointer[GLushort]], []],
    VertexAttrib4bv: GLCodePointer[[GLuint, Pointer[GLbyte]], []],
    VertexAttrib4d: GLCodePointer[[GLuint, GLdouble, GLdouble, GLdouble, GLdouble], []],
    VertexAttrib4dv: GLCodePointer[[GLuint, Pointer[GLdouble]], []],
    VertexAttrib4f: GLCodePointer[[GLuint, GLfloat, GLfloat, GLfloat, GLfloat], []],
    VertexAttrib4fv: GLCodePointer[[GLuint, Pointer[GLfloat]], []],
    VertexAttrib4iv: GLCodePointer[[GLuint, Pointer[GLint]], []],
    VertexAttrib4s: GLCodePointer[[GLuint, GLshort, GLshort, GLshort, GLshort], []],
    VertexAttrib4sv: GLCodePointer[[GLuint, Pointer[GLshort]], []],
    VertexAttrib4ubv: GLCodePointer[[GLuint, Pointer[GLubyte]], []],
    VertexAttrib4uiv: GLCodePointer[[GLuint, Pointer[GLuint]], []],
    VertexAttrib4usv: GLCodePointer[[GLuint, Pointer[GLushort]], []],
    VertexAttribIPointer: GLCodePointer[[GLuint, GLint, GLenum, GLsizei, Pointer[GLvoid]], []],
    VertexAttribP1ui: GLCodePointer[[GLuint, GLenum, GLboolean, GLuint], []],
    VertexAttribP1uiv: GLCodePointer[[GLuint, GLenum, GLboolean, Pointer[GLuint]], []],
    VertexAttribP2ui: GLCodePointer[[GLuint, GLenum, GLboolean, GLuint], []],
    VertexAttribP2uiv: GLCodePointer[[GLuint, GLenum, GLboolean, Pointer[GLuint]], []],
    VertexAttribP3ui: GLCodePointer[[GLuint, GLenum, GLboolean, GLuint], []],
    VertexAttribP3uiv: GLCodePointer[[GLuint, GLenum, GLboolean, Pointer[GLuint]], []],
    VertexAttribP4ui: GLCodePointer[[GLuint, GLenum, GLboolean, GLuint], []],
    VertexAttribP4uiv: GLCodePointer[[GLuint, GLenum, GLboolean, Pointer[GLuint]], []],
    VertexAttribPointer: GLCodePointer[[GLuint, GLint, GLenum, GLboolean, GLsizei, Pointer[GLvoid]], []],
    VertexP2ui: GLCodePointer[[GLenum, GLuint], []],
    VertexP2uiv: GLCodePointer[[GLenum, Pointer[GLuint]], []],
    VertexP3ui: GLCodePointer[[GLenum, GLuint], []],
    VertexP3uiv: GLCodePointer[[GLenum, Pointer[GLuint]], []],
    VertexP4ui: GLCodePointer[[GLenum, GLuint], []],
    VertexP4uiv: GLCodePointer[[GLenum, Pointer[GLuint]], []],
    VertexPointer: GLCodePointer[[GLint, GLenum, GLsizei, Pointer[GLvoid]], []],
    Viewport: GLCodePointer[[GLint, GLint, GLsizei, GLsizei], []],
    WaitSync: GLCodePointer[[GLsync, GLbitfield, GLuint64], []],
    WindowPos2d: GLCodePointer[[GLdouble, GLdouble], []],
    WindowPos2dv: GLCodePointer[[Pointer[GLdouble]], []],
    WindowPos2f: GLCodePointer[[GLfloat, GLfloat], []],
    WindowPos2fv: GLCodePointer[[Pointer[GLfloat]], []],
    WindowPos2i: GLCodePointer[[GLint, GLint], []],
    WindowPos2iv: GLCodePointer[[Pointer[GLint]], []],
    WindowPos2s: GLCodePointer[[GLshort, GLshort], []],
    WindowPos2sv: GLCodePointer[[Pointer[GLshort]], []],
    WindowPos3d: GLCodePointer[[GLdouble, GLdouble, GLdouble], []],
    WindowPos3dv: GLCodePointer[[Pointer[GLdouble]], []],
    WindowPos3f: GLCodePointer[[GLfloat, GLfloat, GLfloat], []],
    WindowPos3fv: GLCodePointer[[Pointer[GLfloat]], []],
    WindowPos3i: GLCodePointer[[GLint, GLint, GLint], []],
    WindowPos3iv: GLCodePointer[[Pointer[GLint]], []],
    WindowPos3s: GLCodePointer[[GLshort, GLshort, GLshort], []],
    WindowPos3sv: GLCodePointer[[Pointer[GLshort]], []],
);

overload GLFunctions() --> gl: GLFunctions { }
overload destroy(gl: GLFunctions) { }

private var globalGL = GLFunctions();

initGLFunctions(gl: GLFunctions) {
    gl.Accum = findGLFunction([GLenum, GLfloat], [], "glAccum");
    gl.ActiveTexture = findGLFunction((GLenum), [], "glActiveTexture", "glActiveTextureARB");
    gl.AlphaFunc = findGLFunction([GLenum, GLclampf], [], "glAlphaFunc");
    gl.AreTexturesResident = findGLFunction([GLsizei, Pointer[GLuint], Pointer[GLboolean]], GLboolean, "glAreTexturesResident");
    gl.ArrayElement = findGLFunction((GLint), [], "glArrayElement");
    gl.AttachShader = findGLFunction([GLuint, GLuint], [], "glAttachShader", "glAttachObjectARB");
    gl.Begin = findGLFunction((GLenum), [], "glBegin");
    gl.BeginConditionalRender = findGLFunction([GLuint, GLenum], [], "glBeginConditionalRender", "glBeginConditionalRenderNV");
    gl.BeginQuery = findGLFunction([GLenum, GLuint], [], "glBeginQuery", "glBeginQueryARB");
    gl.BeginQueryIndexed = findGLFunction([GLenum, GLuint, GLuint], [], "glBeginQueryIndexed");
    gl.BeginTransformFeedback = findGLFunction((GLenum), [], "glBeginTransformFeedback", "glBeginTransformFeedbackEXT");
    gl.BindAttribLocation = findGLFunction([GLuint, GLuint, GLstring], [], "glBindAttribLocation", "glBindAttribLocationARB");
    gl.BindBuffer = findGLFunction([GLenum, GLuint], [], "glBindBuffer", "glBindBufferARB");
    gl.BindBufferBase = findGLFunction([GLenum, GLuint, GLuint], [], "glBindBufferBase", "glBindBufferBaseEXT");
    gl.BindBufferRange = findGLFunction([GLenum, GLuint, GLuint, GLintptr, GLsizeiptr], [], "glBindBufferRange", "glBindBufferRangeEXT");
    gl.BindFragDataLocation = findGLFunction([GLuint, GLuint, GLstring], [], "glBindFragDataLocation", "glBindFragDataLocationEXT");
    gl.BindFragDataLocationIndexed = findGLFunction([GLuint, GLuint, GLuint, GLstring], [], "glBindFragDataLocationIndexed");
    gl.BindFramebuffer = findGLFunction([GLenum, GLuint], [], "glBindFramebuffer", "glBindFramebufferEXT");
    gl.BindRenderbuffer = findGLFunction([GLenum, GLuint], [], "glBindRenderbuffer", "glBindRenderbufferEXT");
    gl.BindSampler = findGLFunction([GLenum, GLuint], [], "glBindSampler");
    gl.BindTexture = findGLFunction([GLenum, GLuint], [], "glBindTexture");
    gl.BindTransformFeedback = findGLFunction([GLenum, GLuint], [], "glBindTransformFeedback");
    gl.BindVertexArray = findGLFunction((GLuint), [], "glBindVertexArray", "glBindVertexArrayAPPLE");
    gl.Bitmap = findGLFunction([GLsizei, GLsizei, GLfloat, GLfloat, GLfloat, GLfloat, Pointer[GLubyte]], [], "glBitmap");
    gl.BlendColor = findGLFunction([GLclampf, GLclampf, GLclampf, GLclampf], [], "glBlendColor", "glBlendColorEXT");
    gl.BlendEquation = findGLFunction((GLenum), [], "glBlendEquation", "glBlendEquationEXT");
    gl.BlendEquationSeparate = findGLFunction([GLenum, GLenum], [], "glBlendEquationSeparate", "glBlendEquationSeparateEXT");
    gl.BlendFunc = findGLFunction([GLenum, GLenum], [], "glBlendFunc");
    gl.BlendFuncSeparate = findGLFunction([GLenum, GLenum, GLenum, GLenum], [], "glBlendFuncSeparate", "glBlendFuncSeparateEXT");
    gl.BlitFramebuffer = findGLFunction([GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum], [], "glBlitFramebuffer", "glBlitFramebufferEXT");
    gl.BufferData = findGLFunction([GLenum, GLsizeiptr, Pointer[GLvoid], GLenum], [], "glBufferData", "glBufferDataARB");
    gl.BufferSubData = findGLFunction([GLenum, GLintptr, GLsizeiptr, Pointer[GLvoid]], [], "glBufferSubData", "glBufferSubDataARB");
    gl.CallList = findGLFunction((GLuint), [], "glCallList");
    gl.CallLists = findGLFunction([GLsizei, GLenum, Pointer[GLvoid]], [], "glCallLists");
    gl.CheckFramebufferStatus = findGLFunction((GLenum), GLenum, "glCheckFramebufferStatus", "glCheckFramebufferStatusEXT");
    gl.ClampColor = findGLFunction([GLenum, GLenum], [], "glClampColor", "glClampColorARB");
    gl.Clear = findGLFunction((GLbitfield), [], "glClear");
    gl.ClearAccum = findGLFunction([GLfloat, GLfloat, GLfloat, GLfloat], [], "glClearAccum");
    gl.ClearBufferfi = findGLFunction([GLenum, GLint, GLfloat, GLint], [], "glClearBufferfi");
    gl.ClearBufferfv = findGLFunction([GLenum, GLint, Pointer[GLfloat]], [], "glClearBufferfv");
    gl.ClearBufferiv = findGLFunction([GLenum, GLint, Pointer[GLint]], [], "glClearBufferiv");
    gl.ClearBufferuiv = findGLFunction([GLenum, GLint, Pointer[GLuint]], [], "glClearBufferuiv");
    gl.ClearColor = findGLFunction([GLclampf, GLclampf, GLclampf, GLclampf], [], "glClearColor");
    gl.ClearColorIiEXT = findGLFunction([GLint, GLint, GLint, GLint], [], "glClearColorIiEXT");
    gl.ClearColorIuiEXT = findGLFunction([GLuint, GLuint, GLuint, GLuint], [], "glClearColorIuiEXT");
    gl.ClearDepth = findGLFunction((GLclampd), [], "glClearDepth");
    gl.ClearIndex = findGLFunction((GLfloat), [], "glClearIndex");
    gl.ClearStencil = findGLFunction((GLint), [], "glClearStencil");
    gl.ClientActiveTexture = findGLFunction((GLenum), [], "glClientActiveTexture", "glClientActiveTextureARB");
    gl.ClientWaitSync = findGLFunction([GLsync, GLbitfield, GLuint64], GLenum, "glClientWaitSync");
    gl.ClipPlane = findGLFunction([GLenum, Pointer[GLdouble]], [], "glClipPlane");
    gl.Color3b = findGLFunction([GLbyte, GLbyte, GLbyte], [], "glColor3b");
    gl.Color3bv = findGLFunction((Pointer[GLbyte]), [], "glColor3bv");
    gl.Color3d = findGLFunction([GLdouble, GLdouble, GLdouble], [], "glColor3d");
    gl.Color3dv = findGLFunction((Pointer[GLdouble]), [], "glColor3dv");
    gl.Color3f = findGLFunction([GLfloat, GLfloat, GLfloat], [], "glColor3f");
    gl.Color3fv = findGLFunction((Pointer[GLfloat]), [], "glColor3fv");
    gl.Color3i = findGLFunction([GLint, GLint, GLint], [], "glColor3i");
    gl.Color3iv = findGLFunction((Pointer[GLint]), [], "glColor3iv");
    gl.Color3s = findGLFunction([GLshort, GLshort, GLshort], [], "glColor3s");
    gl.Color3sv = findGLFunction((Pointer[GLshort]), [], "glColor3sv");
    gl.Color3ub = findGLFunction([GLubyte, GLubyte, GLubyte], [], "glColor3ub");
    gl.Color3ubv = findGLFunction((Pointer[GLubyte]), [], "glColor3ubv");
    gl.Color3ui = findGLFunction([GLuint, GLuint, GLuint], [], "glColor3ui");
    gl.Color3uiv = findGLFunction((Pointer[GLuint]), [], "glColor3uiv");
    gl.Color3us = findGLFunction([GLushort, GLushort, GLushort], [], "glColor3us");
    gl.Color3usv = findGLFunction((Pointer[GLushort]), [], "glColor3usv");
    gl.Color4b = findGLFunction([GLbyte, GLbyte, GLbyte, GLbyte], [], "glColor4b");
    gl.Color4bv = findGLFunction((Pointer[GLbyte]), [], "glColor4bv");
    gl.Color4d = findGLFunction([GLdouble, GLdouble, GLdouble, GLdouble], [], "glColor4d");
    gl.Color4dv = findGLFunction((Pointer[GLdouble]), [], "glColor4dv");
    gl.Color4f = findGLFunction([GLfloat, GLfloat, GLfloat, GLfloat], [], "glColor4f");
    gl.Color4fv = findGLFunction((Pointer[GLfloat]), [], "glColor4fv");
    gl.Color4i = findGLFunction([GLint, GLint, GLint, GLint], [], "glColor4i");
    gl.Color4iv = findGLFunction((Pointer[GLint]), [], "glColor4iv");
    gl.Color4s = findGLFunction([GLshort, GLshort, GLshort, GLshort], [], "glColor4s");
    gl.Color4sv = findGLFunction((Pointer[GLshort]), [], "glColor4sv");
    gl.Color4ub = findGLFunction([GLubyte, GLubyte, GLubyte, GLubyte], [], "glColor4ub");
    gl.Color4ubv = findGLFunction((Pointer[GLubyte]), [], "glColor4ubv");
    gl.Color4ui = findGLFunction([GLuint, GLuint, GLuint, GLuint], [], "glColor4ui");
    gl.Color4uiv = findGLFunction((Pointer[GLuint]), [], "glColor4uiv");
    gl.Color4us = findGLFunction([GLushort, GLushort, GLushort, GLushort], [], "glColor4us");
    gl.Color4usv = findGLFunction((Pointer[GLushort]), [], "glColor4usv");
    gl.ColorMask = findGLFunction([GLboolean, GLboolean, GLboolean, GLboolean], [], "glColorMask");
    gl.ColorMaski = findGLFunction([GLuint, GLboolean, GLboolean, GLboolean, GLboolean], [], "glColorMaski", "glColorMaskIndexedEXT");
    gl.ColorMaterial = findGLFunction([GLenum, GLenum], [], "glColorMaterial");
    gl.ColorP3ui = findGLFunction([GLenum, GLuint], [], "glColorP3ui");
    gl.ColorP3uiv = findGLFunction([GLenum, Pointer[GLuint]], [], "glColorP3uiv");
    gl.ColorP4ui = findGLFunction([GLenum, GLuint], [], "glColorP4ui");
    gl.ColorP4uiv = findGLFunction([GLenum, Pointer[GLuint]], [], "glColorP4uiv");
    gl.ColorPointer = findGLFunction([GLint, GLenum, GLsizei, Pointer[GLvoid]], [], "glColorPointer");
    gl.CompileShader = findGLFunction((GLuint), [], "glCompileShader", "glCompileShaderARB");
    gl.CompressedTexImage1D = findGLFunction([GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, Pointer[GLvoid]], [], "glCompressedTexImage1D", "glCompressedTexImage1DARB");
    gl.CompressedTexImage2D = findGLFunction([GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, Pointer[GLvoid]], [], "glCompressedTexImage2D", "glCompressedTexImage2DARB");
    gl.CompressedTexImage3D = findGLFunction([GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, Pointer[GLvoid]], [], "glCompressedTexImage3D", "glCompressedTexImage2DARB");
    gl.CompressedTexSubImage1D = findGLFunction([GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, Pointer[GLvoid]], [], "glCompressedTexSubImage1D", "glCompressedTexSubImage1DARB");
    gl.CompressedTexSubImage2D = findGLFunction([GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, Pointer[GLvoid]], [], "glCompressedTexSubImage2D", "glCompressedTexSubImage2DARB");
    gl.CompressedTexSubImage3D = findGLFunction([GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Pointer[GLvoid]], [], "glCompressedTexSubImage3D", "glCompressedTexSubImage3DARB");
    gl.CopyBufferSubData = findGLFunction([GLenum, GLenum, GLintptr, GLintptr, GLsizeiptr], [], "glCopyBufferSubData", "glCopyBufferSubDataEXT");
    gl.CopyPixels = findGLFunction([GLint, GLint, GLsizei, GLsizei, GLenum], [], "glCopyPixels");
    gl.CopyTexImage1D = findGLFunction([GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint], [], "glCopyTexImage1D");
    gl.CopyTexImage2D = findGLFunction([GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint], [], "glCopyTexImage2D");
    gl.CopyTexSubImage1D = findGLFunction([GLenum, GLint, GLint, GLint, GLint, GLsizei], [], "glCopyTexSubImage1D");
    gl.CopyTexSubImage2D = findGLFunction([GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei], [], "glCopyTexSubImage2D");
    gl.CopyTexSubImage3D = findGLFunction([GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei], [], "glCopyTexSubImage3D", "glCopyTexSubImage3DEXT");
    gl.CreateProgram = findGLFunction([], GLuint, "glCreateProgram", "glCreateProgramObjectARB");
    gl.CreateShader = findGLFunction((GLenum), GLuint, "glCreateShader", "glCreateShaderObjectARB");
    gl.CullFace = findGLFunction((GLenum), [], "glCullFace");
    gl.DeleteBuffers = findGLFunction([GLsizei, Pointer[GLuint]], [], "glDeleteBuffers", "glDeleteBuffersARB");
    gl.DeleteFramebuffers = findGLFunction([GLsizei, Pointer[GLuint]], [], "glDeleteFramebuffers", "glDeleteFramebuffersEXT");
    gl.DeleteLists = findGLFunction([GLuint, GLsizei], [], "glDeleteLists");
    gl.DeleteProgram = findGLFunction((GLuint), [], "glDeleteProgram", "glDeleteObjectARB");
    gl.DeleteQueries = findGLFunction([GLsizei, Pointer[GLuint]], [], "glDeleteQueries", "glDeleteQueriesARB");
    gl.DeleteRenderbuffers = findGLFunction([GLsizei, Pointer[GLuint]], [], "glDeleteRenderbuffers", "glDeleteRenderbuffersEXT");
    gl.DeleteSamplers = findGLFunction([GLsizei, Pointer[GLuint]], [], "glDeleteSamplers");
    gl.DeleteShader = findGLFunction((GLuint), [], "glDeleteShader", "glDeleteObjectARB");
    gl.DeleteSync = findGLFunction((GLsync), [], "glDeleteSync");
    gl.DeleteTextures = findGLFunction([GLsizei, Pointer[GLuint]], [], "glDeleteTextures");
    gl.DeleteTransformFeedbacks = findGLFunction([GLsizei, Pointer[GLuint]], [], "glDeleteTransformFeedbacks");
    gl.DeleteVertexArrays = findGLFunction([GLsizei, Pointer[GLuint]], [], "glDeleteVertexArrays", "glDeleteVertexArraysAPPLE");
    gl.DepthFunc = findGLFunction((GLenum), [], "glDepthFunc");
    gl.DepthMask = findGLFunction((GLboolean), [], "glDepthMask");
    gl.DepthRange = findGLFunction([GLclampd, GLclampd], [], "glDepthRange");
    gl.DetachShader = findGLFunction([GLuint, GLuint], [], "glDetachShader", "glDetachObjectARB");
    gl.Disable = findGLFunction((GLenum), [], "glDisable");
    gl.DisableClientState = findGLFunction((GLenum), [], "glDisableClientState");
    gl.DisableVertexAttribArray = findGLFunction((GLuint), [], "glDisableVertexAttribArray", "glDisableVertexAttribArrayARB");
    gl.Disablei = findGLFunction([GLenum, GLuint], [], "glDisablei", "glDisableIndexedEXT");
    gl.DrawArrays = findGLFunction([GLenum, GLint, GLsizei], [], "glDrawArrays");
    gl.DrawArraysInstanced = findGLFunction([GLenum, GLint, GLsizei, GLsizei], [], "glDrawArraysInstanced", "glDrawArraysInstancedARB");
    gl.DrawBuffer = findGLFunction((GLenum), [], "glDrawBuffer");
    gl.DrawBuffers = findGLFunction([GLsizei, Pointer[GLenum]], [], "glDrawBuffers", "glDrawBuffersARB", "glDrawBuffersATI");
    gl.DrawElements = findGLFunction([GLenum, GLsizei, GLenum, Pointer[GLvoid]], [], "glDrawElements");
    gl.DrawElementsInstanced = findGLFunction([GLenum, GLsizei, GLenum, Pointer[GLvoid], GLsizei], [], "glDrawElementsInstanced", "glDrawElementsInstancedARB");
    gl.DrawPixels = findGLFunction([GLsizei, GLsizei, GLenum, GLenum, Pointer[GLvoid]], [], "glDrawPixels");
    gl.DrawRangeElements = findGLFunction([GLenum, GLuint, GLuint, GLsizei, GLenum, Pointer[GLvoid]], [], "glDrawRangeElements", "glDrawRangeElementsEXT");
    gl.DrawTransformFeedback = findGLFunction([GLenum, GLuint], [], "glDrawTransformFeedback");
    gl.DrawTransformFeedbackStream = findGLFunction([GLenum, GLuint, GLuint], [], "glDrawTransformFeedbackStream");
    gl.EdgeFlag = findGLFunction((GLboolean), [], "glEdgeFlag");
    gl.EdgeFlagPointer = findGLFunction([GLsizei, Pointer[GLvoid]], [], "glEdgeFlagPointer");
    gl.EdgeFlagv = findGLFunction((Pointer[GLboolean]), [], "glEdgeFlagv");
    gl.Enable = findGLFunction((GLenum), [], "glEnable");
    gl.EnableClientState = findGLFunction((GLenum), [], "glEnableClientState");
    gl.EnableVertexAttribArray = findGLFunction((GLuint), [], "glEnableVertexAttribArray", "glEnableVertexAttribArrayARB");
    gl.Enablei = findGLFunction([GLenum, GLuint], [], "glEnablei", "glEnableIndexedEXT");
    gl.End = findGLFunction([], [], "glEnd");
    gl.EndConditionalRender = findGLFunction([], [], "glEndConditionalRender", "glEndConditionalRenderNV");
    gl.EndList = findGLFunction([], [], "glEndList");
    gl.EndQuery = findGLFunction((GLenum), [], "glEndQuery", "glEndQueryARB");
    gl.EndQueryIndexed = findGLFunction([GLenum, GLuint], [], "glEndQueryIndexed");
    gl.EndTransformFeedback = findGLFunction([], [], "glEndTransformFeedback", "glEndTransformFeedbackEXT");
    gl.EvalCoord1d = findGLFunction((GLdouble), [], "glEvalCoord1d");
    gl.EvalCoord1dv = findGLFunction((Pointer[GLdouble]), [], "glEvalCoord1dv");
    gl.EvalCoord1f = findGLFunction((GLfloat), [], "glEvalCoord1f");
    gl.EvalCoord1fv = findGLFunction((Pointer[GLfloat]), [], "glEvalCoord1fv");
    gl.EvalCoord2d = findGLFunction([GLdouble, GLdouble], [], "glEvalCoord2d");
    gl.EvalCoord2dv = findGLFunction((Pointer[GLdouble]), [], "glEvalCoord2dv");
    gl.EvalCoord2f = findGLFunction([GLfloat, GLfloat], [], "glEvalCoord2f");
    gl.EvalCoord2fv = findGLFunction((Pointer[GLfloat]), [], "glEvalCoord2fv");
    gl.EvalMesh1 = findGLFunction([GLenum, GLint, GLint], [], "glEvalMesh1");
    gl.EvalMesh2 = findGLFunction([GLenum, GLint, GLint, GLint, GLint], [], "glEvalMesh2");
    gl.EvalPoint1 = findGLFunction((GLint), [], "glEvalPoint1");
    gl.EvalPoint2 = findGLFunction([GLint, GLint], [], "glEvalPoint2");
    gl.FeedbackBuffer = findGLFunction([GLsizei, GLenum, Pointer[GLfloat]], [], "glFeedbackBuffer");
    gl.FenceSync = findGLFunction([GLenum, GLbitfield], GLsync, "glFenceSync");
    gl.Finish = findGLFunction([], [], "glFinish");
    gl.Flush = findGLFunction([], [], "glFlush");
    gl.FlushMappedBufferRange = findGLFunction([GLenum, GLintptr, GLsizeiptr], [], "glFlushMappedBufferRange", "glFlushMappedBufferRangeAPPLE");
    gl.FogCoordPointer = findGLFunction([GLenum, GLsizei, Pointer[GLvoid]], [], "glFogCoordPointer", "glFogCoordPointerEXT");
    gl.FogCoordd = findGLFunction((GLdouble), [], "glFogCoordd", "glFogCoorddEXT");
    gl.FogCoorddv = findGLFunction((Pointer[GLdouble]), [], "glFogCoorddv", "glFogCoorddvEXT");
    gl.FogCoordf = findGLFunction((GLfloat), [], "glFogCoordf", "glFogCoordfEXT");
    gl.FogCoordfv = findGLFunction((Pointer[GLfloat]), [], "glFogCoordfv", "glFogCoordfvEXT");
    gl.Fogf = findGLFunction([GLenum, GLfloat], [], "glFogf");
    gl.Fogfv = findGLFunction([GLenum, Pointer[GLfloat]], [], "glFogfv");
    gl.Fogi = findGLFunction([GLenum, GLint], [], "glFogi");
    gl.Fogiv = findGLFunction([GLenum, Pointer[GLint]], [], "glFogiv");
    gl.FramebufferRenderbuffer = findGLFunction([GLenum, GLenum, GLenum, GLuint], [], "glFramebufferRenderbuffer", "glFramebufferRenderbufferEXT");
    gl.FramebufferTexture = findGLFunction([GLenum, GLenum, GLuint, GLint], [], "glFramebufferTexture", "glFramebufferTextureARB", "glFramebufferTextureEXT");
    gl.FramebufferTexture1D = findGLFunction([GLenum, GLenum, GLenum, GLuint, GLint], [], "glFramebufferTexture1D", "glFramebufferTexture1DEXT");
    gl.FramebufferTexture2D = findGLFunction([GLenum, GLenum, GLenum, GLuint, GLint], [], "glFramebufferTexture2D", "glFramebufferTexture2DEXT");
    gl.FramebufferTexture3D = findGLFunction([GLenum, GLenum, GLenum, GLuint, GLint, GLint], [], "glFramebufferTexture3D", "glFramebufferTexture3DEXT");
    gl.FramebufferTextureFaceARB = findGLFunction([GLenum, GLenum, GLuint, GLint, GLenum], [], "glFramebufferTextureFaceARB", "glFramebufferTextureFaceEXT");
    gl.FramebufferTextureLayer = findGLFunction([GLenum, GLenum, GLuint, GLint, GLint], [], "glFramebufferTextureLayer", "glFramebufferTextureLayerEXT");
    gl.FramebufferTextureLayerARB = findGLFunction([GLenum, GLenum, GLuint, GLint, GLint], [], "glFramebufferTextureLayerARB", "glFramebufferTextureLayerEXT");
    gl.FrontFace = findGLFunction((GLenum), [], "glFrontFace");
    gl.Frustum = findGLFunction([GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble], [], "glFrustum");
    gl.GenBuffers = findGLFunction([GLsizei, Pointer[GLuint]], [], "glGenBuffers", "glGenBuffersARB");
    gl.GenFramebuffers = findGLFunction([GLsizei, Pointer[GLuint]], [], "glGenFramebuffers", "glGenFramebuffersEXT");
    gl.GenLists = findGLFunction((GLsizei), GLuint, "glGenLists");
    gl.GenQueries = findGLFunction([GLsizei, Pointer[GLuint]], [], "glGenQueries", "glGenQueriesARB");
    gl.GenRenderbuffers = findGLFunction([GLsizei, Pointer[GLuint]], [], "glGenRenderbuffers", "glGenRenderbuffersEXT");
    gl.GenSamplers = findGLFunction([GLsizei, Pointer[GLuint]], [], "glGenSamplers");
    gl.GenTextures = findGLFunction([GLsizei, Pointer[GLuint]], [], "glGenTextures");
    gl.GenTransformFeedbacks = findGLFunction([GLsizei, Pointer[GLuint]], [], "glGenTransformFeedbacks");
    gl.GenVertexArrays = findGLFunction([GLsizei, Pointer[GLuint]], [], "glGenVertexArrays", "glGenVertexArraysAPPLE");
    gl.GenerateMipmap = findGLFunction((GLenum), [], "glGenerateMipmap", "glGenerateMipmapEXT");
    gl.GetActiveAttrib = findGLFunction([GLuint, GLuint, GLsizei, Pointer[GLsizei], Pointer[GLint], Pointer[GLenum], GLstring], [], "glGetActiveAttrib", "glGetActiveAttribARB");
    gl.GetActiveSubroutineName = findGLFunction([GLuint, GLenum, GLuint, GLsizei, Pointer[GLsizei], GLstring], [], "glGetActiveSubroutineName");
    gl.GetActiveSubroutineUniformName = findGLFunction([GLuint, GLenum, GLuint, GLsizei, Pointer[GLsizei], GLstring], [], "glGetActiveSubroutineUniformName");
    gl.GetActiveSubroutineUniformiv = findGLFunction([GLuint, GLenum, GLuint, GLenum, Pointer[GLint]], [], "glGetActiveSubroutineUniformiv");
    gl.GetActiveUniform = findGLFunction([GLuint, GLuint, GLsizei, Pointer[GLsizei], Pointer[GLint], Pointer[GLenum], GLstring], [], "glGetActiveUniform", "glGetActiveUniformARB");
    gl.GetActiveUniformBlockName = findGLFunction([GLuint, GLuint, GLsizei, Pointer[GLsizei], GLstring], [], "glGetActiveUniformBlockName");
    gl.GetActiveUniformBlockiv = findGLFunction([GLuint, GLuint, GLenum, Pointer[GLint]], [], "glGetActiveUniformBlockiv");
    gl.GetActiveUniformName = findGLFunction([GLuint, GLuint, GLsizei, Pointer[GLsizei], GLstring], [], "glGetActiveUniformName");
    gl.GetActiveUniformsiv = findGLFunction([GLuint, GLsizei, Pointer[GLuint], GLenum, Pointer[GLint]], [], "glGetActiveUniformsiv");
    gl.GetAttachedShaders = findGLFunction([GLuint, GLsizei, Pointer[GLsizei], Pointer[GLuint]], [], "glGetAttachedShaders", "glGetAttachedObjectsARB");
    gl.GetAttribLocation = findGLFunction([GLuint, GLstring], GLint, "glGetAttribLocation", "glGetAttribLocationARB");
    gl.GetBooleani_v = findGLFunction([GLenum, GLuint, Pointer[GLboolean]], [], "glGetBooleani_v", "glGetBooleanIndexedvEXT");
    gl.GetBooleanv = findGLFunction([GLenum, Pointer[GLboolean]], [], "glGetBooleanv");
    gl.GetBufferParameteri64v = findGLFunction([GLenum, GLenum, Pointer[GLint64]], [], "glGetBufferParameteri64v");
    gl.GetBufferParameteriv = findGLFunction([GLenum, GLenum, Pointer[GLint]], [], "glGetBufferParameteriv", "glGetBufferParameterivARB");
    gl.GetBufferPointerv = findGLFunction([GLenum, GLenum, Pointer[Pointer[GLvoid]]], [], "glGetBufferPointerv", "glGetBufferPointervARB");
    gl.GetBufferSubData = findGLFunction([GLenum, GLintptr, GLsizeiptr, Pointer[GLvoid]], [], "glGetBufferSubData", "glGetBufferSubDataARB");
    gl.GetClipPlane = findGLFunction([GLenum, Pointer[GLdouble]], [], "glGetClipPlane");
    gl.GetCompressedTexImage = findGLFunction([GLenum, GLint, Pointer[GLvoid]], [], "glGetCompressedTexImage", "glGetCompressedTexImageARB");
    gl.GetDoublev = findGLFunction([GLenum, Pointer[GLdouble]], [], "glGetDoublev");
    gl.GetError = findGLFunction([], GLenum, "glGetError");
    gl.GetFloatv = findGLFunction([GLenum, Pointer[GLfloat]], [], "glGetFloatv");
    gl.GetFragDataIndex = findGLFunction([GLuint, GLstring], GLint, "glGetFragDataIndex");
    gl.GetFragDataLocation = findGLFunction([GLuint, GLstring], GLint, "glGetFragDataLocation", "glGetFragDataLocationEXT");
    gl.GetFramebufferAttachmentParameteriv = findGLFunction([GLenum, GLenum, GLenum, Pointer[GLint]], [], "glGetFramebufferAttachmentParameteriv", "glGetFramebufferAttachmentParameterivEXT");
    gl.GetInteger64i_v = findGLFunction([GLenum, GLuint, Pointer[GLint64]], [], "glGetInteger64i_v");
    gl.GetInteger64v = findGLFunction([GLenum, Pointer[GLint64]], [], "glGetInteger64v");
    gl.GetIntegeri_v = findGLFunction([GLenum, GLuint, Pointer[GLint]], [], "glGetIntegeri_v", "glGetIntegerIndexedvEXT");
    gl.GetIntegerv = findGLFunction([GLenum, Pointer[GLint]], [], "glGetIntegerv");
    gl.GetLightfv = findGLFunction([GLenum, GLenum, Pointer[GLfloat]], [], "glGetLightfv");
    gl.GetLightiv = findGLFunction([GLenum, GLenum, Pointer[GLint]], [], "glGetLightiv");
    gl.GetMapdv = findGLFunction([GLenum, GLenum, Pointer[GLdouble]], [], "glGetMapdv");
    gl.GetMapfv = findGLFunction([GLenum, GLenum, Pointer[GLfloat]], [], "glGetMapfv");
    gl.GetMapiv = findGLFunction([GLenum, GLenum, Pointer[GLint]], [], "glGetMapiv");
    gl.GetMaterialfv = findGLFunction([GLenum, GLenum, Pointer[GLfloat]], [], "glGetMaterialfv");
    gl.GetMaterialiv = findGLFunction([GLenum, GLenum, Pointer[GLint]], [], "glGetMaterialiv");
    gl.GetMultisamplefv = findGLFunction([GLenum, GLuint, Pointer[GLfloat]], [], "glGetMultisamplefv");
    gl.GetPixelMapfv = findGLFunction([GLenum, Pointer[GLfloat]], [], "glGetPixelMapfv");
    gl.GetPixelMapuiv = findGLFunction([GLenum, Pointer[GLuint]], [], "glGetPixelMapuiv");
    gl.GetPixelMapusv = findGLFunction([GLenum, Pointer[GLushort]], [], "glGetPixelMapusv");
    gl.GetPointerv = findGLFunction([GLenum, Pointer[Pointer[GLvoid]]], [], "glGetPointerv");
    gl.GetPolygonStipple = findGLFunction((Pointer[GLubyte]), [], "glGetPolygonStipple");
    gl.GetProgramInfoLog = findGLFunction([GLuint, GLsizei, Pointer[GLsizei], GLstring], [], "glGetProgramInfoLog", "glGetInfoLogARB");
    gl.GetProgramStageiv = findGLFunction([GLuint, GLenum, GLenum, Pointer[GLint]], [], "glGetProgramStageiv");
    gl.GetProgramiv = findGLFunction([GLuint, GLenum, Pointer[GLint]], [], "glGetProgramiv", "glGetObjectParameterivARB");
    gl.GetQueryIndexediv = findGLFunction([GLenum, GLuint, GLenum, Pointer[GLint]], [], "glGetQueryIndexediv");
    gl.GetQueryObjecti64v = findGLFunction([GLuint, GLenum, Pointer[GLint64]], [], "glGetQueryObjecti64v");
    gl.GetQueryObjectiv = findGLFunction([GLuint, GLenum, Pointer[GLint]], [], "glGetQueryObjectiv", "glGetQueryObjectivARB");
    gl.GetQueryObjectui64v = findGLFunction([GLuint, GLenum, Pointer[GLuint64]], [], "glGetQueryObjectui64v");
    gl.GetQueryObjectuiv = findGLFunction([GLuint, GLenum, Pointer[GLuint]], [], "glGetQueryObjectuiv", "glGetQueryObjectuivARB");
    gl.GetQueryiv = findGLFunction([GLenum, GLenum, Pointer[GLint]], [], "glGetQueryiv", "glGetQueryivARB");
    gl.GetRenderbufferParameteriv = findGLFunction([GLenum, GLenum, Pointer[GLint]], [], "glGetRenderbufferParameteriv", "glGetRenderbufferParameterivEXT");
    gl.GetSamplerParameterIfv = findGLFunction([GLuint, GLenum, Pointer[GLfloat]], [], "glGetSamplerParameterIfv");
    gl.GetSamplerParameterIiv = findGLFunction([GLuint, GLenum, Pointer[GLint]], [], "glGetSamplerParameterIiv");
    gl.GetSamplerParameterfv = findGLFunction([GLuint, GLenum, Pointer[GLfloat]], [], "glGetSamplerParameterfv");
    gl.GetSamplerParameteriv = findGLFunction([GLuint, GLenum, Pointer[GLint]], [], "glGetSamplerParameteriv");
    gl.GetShaderInfoLog = findGLFunction([GLuint, GLsizei, Pointer[GLsizei], GLstring], [], "glGetShaderInfoLog", "glGetInfoLogARB");
    gl.GetShaderSource = findGLFunction([GLint, GLsizei, Pointer[GLsizei], GLstring], [], "glGetShaderSource", "glGetShaderSourceARB");
    gl.GetShaderiv = findGLFunction([GLuint, GLenum, Pointer[GLint]], [], "glGetShaderiv", "glGetObjectParameterivARB");
    gl.GetString = findGLFunction((GLenum), GLstring, "glGetString");
    gl.GetStringi = findGLFunction([GLenum, GLuint], Pointer[GLubyte], "glGetStringi");
    gl.GetSubroutineIndex = findGLFunction([GLuint, GLenum, GLstring], GLuint, "glGetSubroutineIndex");
    gl.GetSubroutineUniformLocation = findGLFunction([GLuint, GLenum, GLstring], GLint, "glGetSubroutineUniformLocation");
    gl.GetSynciv = findGLFunction([GLsync, GLenum, GLsizei, Pointer[GLsizei], Pointer[GLint]], [], "glGetSynciv");
    gl.GetTexEnvfv = findGLFunction([GLenum, GLenum, Pointer[GLfloat]], [], "glGetTexEnvfv");
    gl.GetTexEnviv = findGLFunction([GLenum, GLenum, Pointer[GLint]], [], "glGetTexEnviv");
    gl.GetTexGendv = findGLFunction([GLenum, GLenum, Pointer[GLdouble]], [], "glGetTexGendv");
    gl.GetTexGenfv = findGLFunction([GLenum, GLenum, Pointer[GLfloat]], [], "glGetTexGenfv");
    gl.GetTexGeniv = findGLFunction([GLenum, GLenum, Pointer[GLint]], [], "glGetTexGeniv");
    gl.GetTexImage = findGLFunction([GLenum, GLint, GLenum, GLenum, Pointer[GLvoid]], [], "glGetTexImage");
    gl.GetTexLevelParameterfv = findGLFunction([GLenum, GLint, GLenum, Pointer[GLfloat]], [], "glGetTexLevelParameterfv");
    gl.GetTexLevelParameteriv = findGLFunction([GLenum, GLint, GLenum, Pointer[GLint]], [], "glGetTexLevelParameteriv");
    gl.GetTexParameterIiv = findGLFunction([GLenum, GLenum, Pointer[GLint]], [], "glGetTexParameterIiv", "glGetTexParameterIivEXT");
    gl.GetTexParameterIuiv = findGLFunction([GLenum, GLenum, Pointer[GLuint]], [], "glGetTexParameterIuiv", "glGetTexParameterIuivEXT");
    gl.GetTexParameterfv = findGLFunction([GLenum, GLenum, Pointer[GLfloat]], [], "glGetTexParameterfv");
    gl.GetTexParameteriv = findGLFunction([GLenum, GLenum, Pointer[GLint]], [], "glGetTexParameteriv");
    gl.GetTransformFeedbackVarying = findGLFunction([GLuint, GLuint, GLsizei, Pointer[GLsizei], Pointer[GLsizei], Pointer[GLenum], GLstring], [], "glGetTransformFeedbackVarying", "glGetTransformFeedbackVaryingEXT");
    gl.GetUniformBlockIndex = findGLFunction([GLuint, GLstring], GLuint, "glGetUniformBlockIndex");
    gl.GetUniformIndices = findGLFunction([GLuint, GLsizei, Pointer[GLstring], Pointer[GLuint]], [], "glGetUniformIndices");
    gl.GetUniformLocation = findGLFunction([GLint, GLstring], GLint, "glGetUniformLocation", "glGetUniformLocationARB");
    gl.GetUniformSubroutineuiv = findGLFunction([GLenum, GLint, Pointer[GLuint]], [], "glGetUniformSubroutineuiv");
    gl.GetUniformdv = findGLFunction([GLuint, GLint, Pointer[GLdouble]], [], "glGetUniformdv");
    gl.GetUniformfv = findGLFunction([GLuint, GLint, Pointer[GLfloat]], [], "glGetUniformfv", "glGetUniformfvARB");
    gl.GetUniformiv = findGLFunction([GLuint, GLint, Pointer[GLint]], [], "glGetUniformiv", "glGetUniformivARB");
    gl.GetUniformuiv = findGLFunction([GLuint, GLint, Pointer[GLuint]], [], "glGetUniformuiv", "glGetUniformuivEXT");
    gl.GetVertexAttribIiv = findGLFunction([GLuint, GLenum, Pointer[GLint]], [], "glGetVertexAttribIiv", "glGetVertexAttribIivEXT");
    gl.GetVertexAttribIuiv = findGLFunction([GLuint, GLenum, Pointer[GLuint]], [], "glGetVertexAttribIuiv", "glGetVertexAttribIuivEXT");
    gl.GetVertexAttribPointerv = findGLFunction([GLuint, GLenum, Pointer[Pointer[GLvoid]]], [], "glGetVertexAttribPointerv", "glGetVertexAttribPointervARB");
    gl.GetVertexAttribdv = findGLFunction([GLuint, GLenum, Pointer[GLdouble]], [], "glGetVertexAttribdv", "glGetVertexAttribdvARB");
    gl.GetVertexAttribfv = findGLFunction([GLuint, GLenum, Pointer[GLfloat]], [], "glGetVertexAttribfv", "glGetVertexAttribfvARB");
    gl.GetVertexAttribiv = findGLFunction([GLuint, GLenum, Pointer[GLint]], [], "glGetVertexAttribiv", "glGetVertexAttribivARB");
    gl.Hint = findGLFunction([GLenum, GLenum], [], "glHint");
    gl.IndexMask = findGLFunction((GLuint), [], "glIndexMask");
    gl.IndexPointer = findGLFunction([GLenum, GLsizei, Pointer[GLvoid]], [], "glIndexPointer");
    gl.Indexd = findGLFunction((GLdouble), [], "glIndexd");
    gl.Indexdv = findGLFunction((Pointer[GLdouble]), [], "glIndexdv");
    gl.Indexf = findGLFunction((GLfloat), [], "glIndexf");
    gl.Indexfv = findGLFunction((Pointer[GLfloat]), [], "glIndexfv");
    gl.Indexi = findGLFunction((GLint), [], "glIndexi");
    gl.Indexiv = findGLFunction((Pointer[GLint]), [], "glIndexiv");
    gl.Indexs = findGLFunction((GLshort), [], "glIndexs");
    gl.Indexsv = findGLFunction((Pointer[GLshort]), [], "glIndexsv");
    gl.Indexub = findGLFunction((GLubyte), [], "glIndexub");
    gl.Indexubv = findGLFunction((Pointer[GLubyte]), [], "glIndexubv");
    gl.InitNames = findGLFunction([], [], "glInitNames");
    gl.InterleavedArrays = findGLFunction([GLenum, GLsizei, Pointer[GLvoid]], [], "glInterleavedArrays");
    gl.IsBuffer = findGLFunction((GLuint), GLboolean, "glIsBuffer", "glIsBufferARB");
    gl.IsEnabled = findGLFunction((GLenum), GLboolean, "glIsEnabled");
    gl.IsEnabledi = findGLFunction([GLenum, GLuint], GLboolean, "glIsEnabledi", "glIsEnabledIndexedEXT");
    gl.IsFramebuffer = findGLFunction((GLuint), GLboolean, "glIsFramebuffer", "glIsFramebufferEXT");
    gl.IsList = findGLFunction((GLuint), GLboolean, "glIsList");
    gl.IsProgram = findGLFunction((GLuint), GLboolean, "glIsProgram", "glIsProgramARB");
    gl.IsQuery = findGLFunction((GLuint), GLboolean, "glIsQuery", "glIsQueryARB");
    gl.IsRenderbuffer = findGLFunction((GLuint), GLboolean, "glIsRenderbuffer", "glIsRenderbufferEXT");
    gl.IsSampler = findGLFunction((GLuint), GLboolean, "glIsSampler");
    gl.IsShader = findGLFunction((GLuint), GLboolean, "glIsShader", "glIsShaderARB");
    gl.IsSync = findGLFunction((GLsync), GLboolean, "glIsSync");
    gl.IsTexture = findGLFunction((GLuint), GLboolean, "glIsTexture");
    gl.IsTransformFeedback = findGLFunction((GLuint), GLboolean, "glIsTransformFeedback");
    gl.IsVertexArray = findGLFunction((GLuint), GLboolean, "glIsVertexArray", "glIsVertexArrayAPPLE");
    gl.LightModelf = findGLFunction([GLenum, GLfloat], [], "glLightModelf");
    gl.LightModelfv = findGLFunction([GLenum, Pointer[GLfloat]], [], "glLightModelfv");
    gl.LightModeli = findGLFunction([GLenum, GLint], [], "glLightModeli");
    gl.LightModeliv = findGLFunction([GLenum, Pointer[GLint]], [], "glLightModeliv");
    gl.Lightf = findGLFunction([GLenum, GLenum, GLfloat], [], "glLightf");
    gl.Lightfv = findGLFunction([GLenum, GLenum, Pointer[GLfloat]], [], "glLightfv");
    gl.Lighti = findGLFunction([GLenum, GLenum, GLint], [], "glLighti");
    gl.Lightiv = findGLFunction([GLenum, GLenum, Pointer[GLint]], [], "glLightiv");
    gl.LineStipple = findGLFunction([GLint, GLushort], [], "glLineStipple");
    gl.LineWidth = findGLFunction((GLfloat), [], "glLineWidth");
    gl.LinkProgram = findGLFunction((GLuint), [], "glLinkProgram", "glLinkProgramARB");
    gl.ListBase = findGLFunction((GLuint), [], "glListBase");
    gl.LoadIdentity = findGLFunction([], [], "glLoadIdentity");
    gl.LoadMatrixd = findGLFunction((Pointer[GLdouble]), [], "glLoadMatrixd");
    gl.LoadMatrixf = findGLFunction((Pointer[GLfloat]), [], "glLoadMatrixf");
    gl.LoadName = findGLFunction((GLuint), [], "glLoadName");
    gl.LoadTransposeMatrixd = findGLFunction((Pointer[GLdouble]), [], "glLoadTransposeMatrixd", "glLoadTransposeMatrixdARB");
    gl.LoadTransposeMatrixf = findGLFunction((Pointer[GLfloat]), [], "glLoadTransposeMatrixf", "glLoadTransposeMatrixfARB");
    gl.LogicOp = findGLFunction((GLenum), [], "glLogicOp");
    gl.Map1d = findGLFunction([GLenum, GLdouble, GLdouble, GLint, GLint, Pointer[GLdouble]], [], "glMap1d");
    gl.Map1f = findGLFunction([GLenum, GLfloat, GLfloat, GLint, GLint, Pointer[GLfloat]], [], "glMap1f");
    gl.Map2d = findGLFunction([GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, Pointer[GLdouble]], [], "glMap2d");
    gl.Map2f = findGLFunction([GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, Pointer[GLfloat]], [], "glMap2f");
    gl.MapBuffer = findGLFunction([GLenum, GLenum], Pointer[GLvoid], "glMapBuffer", "glMapBufferARB");
    gl.MapBufferRange = findGLFunction([GLenum, GLintptr, GLsizeiptr, GLbitfield], Pointer[GLvoid], "glMapBufferRange");
    gl.MapGrid1d = findGLFunction([GLint, GLdouble, GLdouble], [], "glMapGrid1d");
    gl.MapGrid1f = findGLFunction([GLint, GLfloat, GLfloat], [], "glMapGrid1f");
    gl.MapGrid2d = findGLFunction([GLint, GLdouble, GLdouble, GLint, GLdouble, GLdouble], [], "glMapGrid2d");
    gl.MapGrid2f = findGLFunction([GLint, GLfloat, GLfloat, GLint, GLfloat, GLfloat], [], "glMapGrid2f");
    gl.Materialf = findGLFunction([GLenum, GLenum, GLfloat], [], "glMaterialf");
    gl.Materialfv = findGLFunction([GLenum, GLenum, Pointer[GLfloat]], [], "glMaterialfv");
    gl.Materiali = findGLFunction([GLenum, GLenum, GLint], [], "glMateriali");
    gl.Materialiv = findGLFunction([GLenum, GLenum, Pointer[GLint]], [], "glMaterialiv");
    gl.MatrixMode = findGLFunction((GLenum), [], "glMatrixMode");
    gl.MultMatrixd = findGLFunction((Pointer[GLdouble]), [], "glMultMatrixd");
    gl.MultMatrixf = findGLFunction((Pointer[GLfloat]), [], "glMultMatrixf");
    gl.MultTransposeMatrixd = findGLFunction((Pointer[GLdouble]), [], "glMultTransposeMatrixd", "glMultTransposeMatrixdARB");
    gl.MultTransposeMatrixf = findGLFunction((Pointer[GLfloat]), [], "glMultTransposeMatrixf", "glMultTransposeMatrixfARB");
    gl.MultiDrawArrays = findGLFunction([GLenum, Pointer[GLint], Pointer[GLsizei], GLsizei], [], "glMultiDrawArrays", "glMultiDrawArraysEXT");
    gl.MultiDrawElements = findGLFunction([GLenum, Pointer[GLsizei], GLenum, Pointer[Pointer[GLvoid]], GLsizei], [], "glMultiDrawElements", "glMultiDrawElementsEXT");
    gl.MultiTexCoord1d = findGLFunction([GLenum, GLdouble], [], "glMultiTexCoord1d", "glMultiTexCoord1dARB");
    gl.MultiTexCoord1dv = findGLFunction([GLenum, Pointer[GLdouble]], [], "glMultiTexCoord1dv", "glMultiTexCoord1dvARB");
    gl.MultiTexCoord1f = findGLFunction([GLenum, GLfloat], [], "glMultiTexCoord1f", "glMultiTexCoord1fARB");
    gl.MultiTexCoord1fv = findGLFunction([GLenum, Pointer[GLfloat]], [], "glMultiTexCoord1fv", "glMultiTexCoord1fvARB");
    gl.MultiTexCoord1i = findGLFunction([GLenum, GLint], [], "glMultiTexCoord1i", "glMultiTexCoord1iARB");
    gl.MultiTexCoord1iv = findGLFunction([GLenum, Pointer[GLint]], [], "glMultiTexCoord1iv", "glMultiTexCoord1ivARB");
    gl.MultiTexCoord1s = findGLFunction([GLenum, GLshort], [], "glMultiTexCoord1s", "glMultiTexCoord1sARB");
    gl.MultiTexCoord1sv = findGLFunction([GLenum, Pointer[GLshort]], [], "glMultiTexCoord1sv", "glMultiTexCoord1svARB");
    gl.MultiTexCoord2d = findGLFunction([GLenum, GLdouble, GLdouble], [], "glMultiTexCoord2d", "glMultiTexCoord2dARB");
    gl.MultiTexCoord2dv = findGLFunction([GLenum, Pointer[GLdouble]], [], "glMultiTexCoord2dv", "glMultiTexCoord2dvARB");
    gl.MultiTexCoord2f = findGLFunction([GLenum, GLfloat, GLfloat], [], "glMultiTexCoord2f", "glMultiTexCoord2fARB");
    gl.MultiTexCoord2fv = findGLFunction([GLenum, Pointer[GLfloat]], [], "glMultiTexCoord2fv", "glMultiTexCoord2fvARB");
    gl.MultiTexCoord2i = findGLFunction([GLenum, GLint, GLint], [], "glMultiTexCoord2i", "glMultiTexCoord2iARB");
    gl.MultiTexCoord2iv = findGLFunction([GLenum, Pointer[GLint]], [], "glMultiTexCoord2iv", "glMultiTexCoord2ivARB");
    gl.MultiTexCoord2s = findGLFunction([GLenum, GLshort, GLshort], [], "glMultiTexCoord2s", "glMultiTexCoord2sARB");
    gl.MultiTexCoord2sv = findGLFunction([GLenum, Pointer[GLshort]], [], "glMultiTexCoord2sv", "glMultiTexCoord2svARB");
    gl.MultiTexCoord3d = findGLFunction([GLenum, GLdouble, GLdouble, GLdouble], [], "glMultiTexCoord3d", "glMultiTexCoord3dARB");
    gl.MultiTexCoord3dv = findGLFunction([GLenum, Pointer[GLdouble]], [], "glMultiTexCoord3dv", "glMultiTexCoord3dvARB");
    gl.MultiTexCoord3f = findGLFunction([GLenum, GLfloat, GLfloat, GLfloat], [], "glMultiTexCoord3f", "glMultiTexCoord3fARB");
    gl.MultiTexCoord3fv = findGLFunction([GLenum, Pointer[GLfloat]], [], "glMultiTexCoord3fv", "glMultiTexCoord3fvARB");
    gl.MultiTexCoord3i = findGLFunction([GLenum, GLint, GLint, GLint], [], "glMultiTexCoord3i", "glMultiTexCoord3iARB");
    gl.MultiTexCoord3iv = findGLFunction([GLenum, Pointer[GLint]], [], "glMultiTexCoord3iv", "glMultiTexCoord3ivARB");
    gl.MultiTexCoord3s = findGLFunction([GLenum, GLshort, GLshort, GLshort], [], "glMultiTexCoord3s", "glMultiTexCoord3sARB");
    gl.MultiTexCoord3sv = findGLFunction([GLenum, Pointer[GLshort]], [], "glMultiTexCoord3sv", "glMultiTexCoord3svARB");
    gl.MultiTexCoord4d = findGLFunction([GLenum, GLdouble, GLdouble, GLdouble, GLdouble], [], "glMultiTexCoord4d", "glMultiTexCoord4dARB");
    gl.MultiTexCoord4dv = findGLFunction([GLenum, Pointer[GLdouble]], [], "glMultiTexCoord4dv", "glMultiTexCoord4dvARB");
    gl.MultiTexCoord4f = findGLFunction([GLenum, GLfloat, GLfloat, GLfloat, GLfloat], [], "glMultiTexCoord4f", "glMultiTexCoord4fARB");
    gl.MultiTexCoord4fv = findGLFunction([GLenum, Pointer[GLfloat]], [], "glMultiTexCoord4fv", "glMultiTexCoord4fvARB");
    gl.MultiTexCoord4i = findGLFunction([GLenum, GLint, GLint, GLint, GLint], [], "glMultiTexCoord4i", "glMultiTexCoord4iARB");
    gl.MultiTexCoord4iv = findGLFunction([GLenum, Pointer[GLint]], [], "glMultiTexCoord4iv", "glMultiTexCoord4ivARB");
    gl.MultiTexCoord4s = findGLFunction([GLenum, GLshort, GLshort, GLshort, GLshort], [], "glMultiTexCoord4s", "glMultiTexCoord4sARB");
    gl.MultiTexCoord4sv = findGLFunction([GLenum, Pointer[GLshort]], [], "glMultiTexCoord4sv", "glMultiTexCoord4svARB");
    gl.MultiTexCoordP1ui = findGLFunction([GLenum, GLenum, GLuint], [], "glMultiTexCoordP1ui");
    gl.MultiTexCoordP1uiv = findGLFunction([GLenum, GLenum, Pointer[GLuint]], [], "glMultiTexCoordP1uiv");
    gl.MultiTexCoordP2ui = findGLFunction([GLenum, GLenum, GLuint], [], "glMultiTexCoordP2ui");
    gl.MultiTexCoordP2uiv = findGLFunction([GLenum, GLenum, Pointer[GLuint]], [], "glMultiTexCoordP2uiv");
    gl.MultiTexCoordP3ui = findGLFunction([GLenum, GLenum, GLuint], [], "glMultiTexCoordP3ui");
    gl.MultiTexCoordP3uiv = findGLFunction([GLenum, GLenum, Pointer[GLuint]], [], "glMultiTexCoordP3uiv");
    gl.MultiTexCoordP4ui = findGLFunction([GLenum, GLenum, GLuint], [], "glMultiTexCoordP4ui");
    gl.MultiTexCoordP4uiv = findGLFunction([GLenum, GLenum, Pointer[GLuint]], [], "glMultiTexCoordP4uiv");
    gl.NewList = findGLFunction([GLuint, GLenum], [], "glNewList");
    gl.Normal3b = findGLFunction([GLbyte, GLbyte, GLbyte], [], "glNormal3b");
    gl.Normal3bv = findGLFunction((Pointer[GLbyte]), [], "glNormal3bv");
    gl.Normal3d = findGLFunction([GLdouble, GLdouble, GLdouble], [], "glNormal3d");
    gl.Normal3dv = findGLFunction((Pointer[GLdouble]), [], "glNormal3dv");
    gl.Normal3f = findGLFunction([GLfloat, GLfloat, GLfloat], [], "glNormal3f");
    gl.Normal3fv = findGLFunction((Pointer[GLfloat]), [], "glNormal3fv");
    gl.Normal3i = findGLFunction([GLint, GLint, GLint], [], "glNormal3i");
    gl.Normal3iv = findGLFunction((Pointer[GLint]), [], "glNormal3iv");
    gl.Normal3s = findGLFunction([GLshort, GLshort, GLshort], [], "glNormal3s");
    gl.Normal3sv = findGLFunction((Pointer[GLshort]), [], "glNormal3sv");
    gl.NormalP3ui = findGLFunction([GLenum, GLuint], [], "glNormalP3ui");
    gl.NormalP3uiv = findGLFunction([GLenum, Pointer[GLuint]], [], "glNormalP3uiv");
    gl.NormalPointer = findGLFunction([GLenum, GLsizei, Pointer[GLvoid]], [], "glNormalPointer");
    gl.Ortho = findGLFunction([GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble], [], "glOrtho");
    gl.PassThrough = findGLFunction((GLfloat), [], "glPassThrough");
    gl.PatchParameterfv = findGLFunction([GLenum, Pointer[GLfloat]], [], "glPatchParameterfv");
    gl.PatchParameteri = findGLFunction([GLenum, GLint], [], "glPatchParameteri");
    gl.PauseTransformFeedback = findGLFunction([], [], "glPauseTransformFeedback");
    gl.PixelMapfv = findGLFunction([GLenum, GLsizei, Pointer[GLfloat]], [], "glPixelMapfv");
    gl.PixelMapuiv = findGLFunction([GLenum, GLsizei, Pointer[GLuint]], [], "glPixelMapuiv");
    gl.PixelMapusv = findGLFunction([GLenum, GLsizei, Pointer[GLushort]], [], "glPixelMapusv");
    gl.PixelStoref = findGLFunction([GLenum, GLfloat], [], "glPixelStoref");
    gl.PixelStorei = findGLFunction([GLenum, GLint], [], "glPixelStorei");
    gl.PixelTransferf = findGLFunction([GLenum, GLfloat], [], "glPixelTransferf");
    gl.PixelTransferi = findGLFunction([GLenum, GLint], [], "glPixelTransferi");
    gl.PixelZoom = findGLFunction([GLfloat, GLfloat], [], "glPixelZoom");
    gl.PointParameterf = findGLFunction([GLenum, GLfloat], [], "glPointParameterf", "glPointParameterfARB");
    gl.PointParameterfv = findGLFunction([GLenum, Pointer[GLfloat]], [], "glPointParameterfv", "glPointParameterfvARB");
    gl.PointParameteri = findGLFunction([GLenum, GLint], [], "glPointParameteri", "glPointParameteriARB");
    gl.PointParameteriv = findGLFunction([GLenum, Pointer[GLint]], [], "glPointParameteriv", "glPointParameterivARB");
    gl.PointSize = findGLFunction((GLfloat), [], "glPointSize");
    gl.PolygonMode = findGLFunction([GLenum, GLenum], [], "glPolygonMode");
    gl.PolygonOffset = findGLFunction([GLfloat, GLfloat], [], "glPolygonOffset");
    gl.PolygonStipple = findGLFunction((Pointer[GLubyte]), [], "glPolygonStipple");
    gl.PopAttrib = findGLFunction([], [], "glPopAttrib");
    gl.PopClientAttrib = findGLFunction([], [], "glPopClientAttrib");
    gl.PopMatrix = findGLFunction([], [], "glPopMatrix");
    gl.PopName = findGLFunction([], [], "glPopName");
    gl.PrimitiveRestartIndex = findGLFunction((GLuint), [], "glPrimitiveRestartIndex");
    gl.PrioritizeTextures = findGLFunction([GLsizei, Pointer[GLuint], Pointer[GLclampf]], [], "glPrioritizeTextures");
    gl.ProgramParameteriARB = findGLFunction([GLuint, GLenum, GLint], [], "glProgramParameteriARB", "glProgramParameteriEXT");
    gl.ProgramUniform1d = findGLFunction([GLuint, GLint, GLdouble], [], "glProgramUniform1d", "glProgramUniform1dEXT");
    gl.ProgramUniform1dv = findGLFunction([GLuint, GLint, GLsizei, Pointer[GLdouble]], [], "glProgramUniform1dv", "glProgramUniform1dvEXT");
    gl.ProgramUniform2d = findGLFunction([GLuint, GLint, GLdouble, GLdouble], [], "glProgramUniform2d", "glProgramUniform2dEXT");
    gl.ProgramUniform2dv = findGLFunction([GLuint, GLint, GLsizei, Pointer[GLdouble]], [], "glProgramUniform2dv", "glProgramUniform2dvEXT");
    gl.ProgramUniform3d = findGLFunction([GLuint, GLint, GLdouble, GLdouble, GLdouble], [], "glProgramUniform3d", "glProgramUniform3dEXT");
    gl.ProgramUniform3dv = findGLFunction([GLuint, GLint, GLsizei, Pointer[GLdouble]], [], "glProgramUniform3dv", "glProgramUniform3dvEXT");
    gl.ProgramUniform4d = findGLFunction([GLuint, GLint, GLdouble, GLdouble, GLdouble, GLdouble], [], "glProgramUniform4d", "glProgramUniform4dEXT");
    gl.ProgramUniform4dv = findGLFunction([GLuint, GLint, GLsizei, Pointer[GLdouble]], [], "glProgramUniform4dv", "glProgramUniform4dvEXT");
    gl.ProgramUniformMatrix2dv = findGLFunction([GLuint, GLint, GLsizei, GLboolean, Pointer[GLdouble]], [], "glProgramUniformMatrix2dv", "glProgramUniformMatrix2dvEXT");
    gl.ProgramUniformMatrix2x3dv = findGLFunction([GLuint, GLint, GLsizei, GLboolean, Pointer[GLdouble]], [], "glProgramUniformMatrix2x3dv", "glProgramUniformMatrix2x3dvEXT");
    gl.ProgramUniformMatrix2x4dv = findGLFunction([GLuint, GLint, GLsizei, GLboolean, Pointer[GLdouble]], [], "glProgramUniformMatrix2x4dv", "glProgramUniformMatrix2x4dvEXT");
    gl.ProgramUniformMatrix3dv = findGLFunction([GLuint, GLint, GLsizei, GLboolean, Pointer[GLdouble]], [], "glProgramUniformMatrix3dv", "glProgramUniformMatrix3dvEXT");
    gl.ProgramUniformMatrix3x2dv = findGLFunction([GLuint, GLint, GLsizei, GLboolean, Pointer[GLdouble]], [], "glProgramUniformMatrix3x2dv", "glProgramUniformMatrix3x2dvEXT");
    gl.ProgramUniformMatrix3x4dv = findGLFunction([GLuint, GLint, GLsizei, GLboolean, Pointer[GLdouble]], [], "glProgramUniformMatrix3x4dv", "glProgramUniformMatrix3x4dvEXT");
    gl.ProgramUniformMatrix4dv = findGLFunction([GLuint, GLint, GLsizei, GLboolean, Pointer[GLdouble]], [], "glProgramUniformMatrix4dv", "glProgramUniformMatrix4dvEXT");
    gl.ProgramUniformMatrix4x2dv = findGLFunction([GLuint, GLint, GLsizei, GLboolean, Pointer[GLdouble]], [], "glProgramUniformMatrix4x2dv", "glProgramUniformMatrix4x2dvEXT");
    gl.ProgramUniformMatrix4x3dv = findGLFunction([GLuint, GLint, GLsizei, GLboolean, Pointer[GLdouble]], [], "glProgramUniformMatrix4x3dv", "glProgramUniformMatrix4x3dvEXT");
    gl.ProvokingVertex = findGLFunction((GLenum), [], "glProvokingVertex");
    gl.PushAttrib = findGLFunction((GLbitfield), [], "glPushAttrib");
    gl.PushClientAttrib = findGLFunction((GLbitfield), [], "glPushClientAttrib");
    gl.PushMatrix = findGLFunction([], [], "glPushMatrix");
    gl.PushName = findGLFunction((GLuint), [], "glPushName");
    gl.QueryCounter = findGLFunction([GLuint, GLenum], [], "glQueryCounter");
    gl.RasterPos2d = findGLFunction([GLdouble, GLdouble], [], "glRasterPos2d");
    gl.RasterPos2dv = findGLFunction((Pointer[GLdouble]), [], "glRasterPos2dv");
    gl.RasterPos2f = findGLFunction([GLfloat, GLfloat], [], "glRasterPos2f");
    gl.RasterPos2fv = findGLFunction((Pointer[GLfloat]), [], "glRasterPos2fv");
    gl.RasterPos2i = findGLFunction([GLint, GLint], [], "glRasterPos2i");
    gl.RasterPos2iv = findGLFunction((Pointer[GLint]), [], "glRasterPos2iv");
    gl.RasterPos2s = findGLFunction([GLshort, GLshort], [], "glRasterPos2s");
    gl.RasterPos2sv = findGLFunction((Pointer[GLshort]), [], "glRasterPos2sv");
    gl.RasterPos3d = findGLFunction([GLdouble, GLdouble, GLdouble], [], "glRasterPos3d");
    gl.RasterPos3dv = findGLFunction((Pointer[GLdouble]), [], "glRasterPos3dv");
    gl.RasterPos3f = findGLFunction([GLfloat, GLfloat, GLfloat], [], "glRasterPos3f");
    gl.RasterPos3fv = findGLFunction((Pointer[GLfloat]), [], "glRasterPos3fv");
    gl.RasterPos3i = findGLFunction([GLint, GLint, GLint], [], "glRasterPos3i");
    gl.RasterPos3iv = findGLFunction((Pointer[GLint]), [], "glRasterPos3iv");
    gl.RasterPos3s = findGLFunction([GLshort, GLshort, GLshort], [], "glRasterPos3s");
    gl.RasterPos3sv = findGLFunction((Pointer[GLshort]), [], "glRasterPos3sv");
    gl.RasterPos4d = findGLFunction([GLdouble, GLdouble, GLdouble, GLdouble], [], "glRasterPos4d");
    gl.RasterPos4dv = findGLFunction((Pointer[GLdouble]), [], "glRasterPos4dv");
    gl.RasterPos4f = findGLFunction([GLfloat, GLfloat, GLfloat, GLfloat], [], "glRasterPos4f");
    gl.RasterPos4fv = findGLFunction((Pointer[GLfloat]), [], "glRasterPos4fv");
    gl.RasterPos4i = findGLFunction([GLint, GLint, GLint, GLint], [], "glRasterPos4i");
    gl.RasterPos4iv = findGLFunction((Pointer[GLint]), [], "glRasterPos4iv");
    gl.RasterPos4s = findGLFunction([GLshort, GLshort, GLshort, GLshort], [], "glRasterPos4s");
    gl.RasterPos4sv = findGLFunction((Pointer[GLshort]), [], "glRasterPos4sv");
    gl.ReadBuffer = findGLFunction((GLenum), [], "glReadBuffer");
    gl.ReadPixels = findGLFunction([GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, Pointer[GLvoid]], [], "glReadPixels");
    gl.Rectd = findGLFunction([GLdouble, GLdouble, GLdouble, GLdouble], [], "glRectd");
    gl.Rectdv = findGLFunction([Pointer[GLdouble], Pointer[GLdouble]], [], "glRectdv");
    gl.Rectf = findGLFunction([GLfloat, GLfloat, GLfloat, GLfloat], [], "glRectf");
    gl.Rectfv = findGLFunction([Pointer[GLfloat], Pointer[GLfloat]], [], "glRectfv");
    gl.Recti = findGLFunction([GLint, GLint, GLint, GLint], [], "glRecti");
    gl.Rectiv = findGLFunction([Pointer[GLint], Pointer[GLint]], [], "glRectiv");
    gl.Rects = findGLFunction([GLshort, GLshort, GLshort, GLshort], [], "glRects");
    gl.Rectsv = findGLFunction([Pointer[GLshort], Pointer[GLshort]], [], "glRectsv");
    gl.RenderMode = findGLFunction((GLenum), GLint, "glRenderMode");
    gl.RenderbufferStorage = findGLFunction([GLenum, GLenum, GLsizei, GLsizei], [], "glRenderbufferStorage", "glRenderbufferStorageEXT");
    gl.RenderbufferStorageMultisample = findGLFunction([GLenum, GLsizei, GLenum, GLsizei, GLsizei], [], "glRenderbufferStorageMultisample", "glRenderbufferStorageMultisampleEXT");
    gl.ResumeTransformFeedback = findGLFunction([], [], "glResumeTransformFeedback");
    gl.Rotated = findGLFunction([GLdouble, GLdouble, GLdouble, GLdouble], [], "glRotated");
    gl.Rotatef = findGLFunction([GLfloat, GLfloat, GLfloat, GLfloat], [], "glRotatef");
    gl.SampleCoverage = findGLFunction([GLclampf, GLboolean], [], "glSampleCoverage", "glSampleCoverageARB");
    gl.SampleMaski = findGLFunction([GLuint, GLbitfield], [], "glSampleMaski");
    gl.SamplerParameterIiv = findGLFunction([GLuint, GLenum, Pointer[GLint]], [], "glSamplerParameterIiv");
    gl.SamplerParameterIuiv = findGLFunction([GLuint, GLenum, Pointer[GLuint]], [], "glSamplerParameterIuiv");
    gl.SamplerParameterf = findGLFunction([GLuint, GLenum, GLfloat], [], "glSamplerParameterf");
    gl.SamplerParameterfv = findGLFunction([GLuint, GLenum, Pointer[GLfloat]], [], "glSamplerParameterfv");
    gl.SamplerParameteri = findGLFunction([GLuint, GLenum, GLint], [], "glSamplerParameteri");
    gl.SamplerParameteriv = findGLFunction([GLuint, GLenum, Pointer[GLint]], [], "glSamplerParameteriv");
    gl.Scaled = findGLFunction([GLdouble, GLdouble, GLdouble], [], "glScaled");
    gl.Scalef = findGLFunction([GLfloat, GLfloat, GLfloat], [], "glScalef");
    gl.Scissor = findGLFunction([GLint, GLint, GLsizei, GLsizei], [], "glScissor");
    gl.SecondaryColor3b = findGLFunction([GLbyte, GLbyte, GLbyte], [], "glSecondaryColor3b", "glSecondaryColor3bEXT");
    gl.SecondaryColor3bv = findGLFunction((Pointer[GLbyte]), [], "glSecondaryColor3bv", "glSecondaryColor3bvEXT");
    gl.SecondaryColor3d = findGLFunction([GLdouble, GLdouble, GLdouble], [], "glSecondaryColor3d", "glSecondaryColor3dEXT");
    gl.SecondaryColor3dv = findGLFunction((Pointer[GLdouble]), [], "glSecondaryColor3dv", "glSecondaryColor3dvEXT");
    gl.SecondaryColor3f = findGLFunction([GLfloat, GLfloat, GLfloat], [], "glSecondaryColor3f", "glSecondaryColor3fEXT");
    gl.SecondaryColor3fv = findGLFunction((Pointer[GLfloat]), [], "glSecondaryColor3fv", "glSecondaryColor3fvEXT");
    gl.SecondaryColor3i = findGLFunction([GLint, GLint, GLint], [], "glSecondaryColor3i", "glSecondaryColor3iEXT");
    gl.SecondaryColor3iv = findGLFunction((Pointer[GLint]), [], "glSecondaryColor3iv", "glSecondaryColor3ivEXT");
    gl.SecondaryColor3s = findGLFunction([GLshort, GLshort, GLshort], [], "glSecondaryColor3s", "glSecondaryColor3sEXT");
    gl.SecondaryColor3sv = findGLFunction((Pointer[GLshort]), [], "glSecondaryColor3sv", "glSecondaryColor3svEXT");
    gl.SecondaryColor3ub = findGLFunction([GLubyte, GLubyte, GLubyte], [], "glSecondaryColor3ub", "glSecondaryColor3ubEXT");
    gl.SecondaryColor3ubv = findGLFunction((Pointer[GLubyte]), [], "glSecondaryColor3ubv", "glSecondaryColor3ubvEXT");
    gl.SecondaryColor3ui = findGLFunction([GLuint, GLuint, GLuint], [], "glSecondaryColor3ui", "glSecondaryColor3uiEXT");
    gl.SecondaryColor3uiv = findGLFunction((Pointer[GLuint]), [], "glSecondaryColor3uiv", "glSecondaryColor3uivEXT");
    gl.SecondaryColor3us = findGLFunction([GLushort, GLushort, GLushort], [], "glSecondaryColor3us", "glSecondaryColor3usEXT");
    gl.SecondaryColor3usv = findGLFunction((Pointer[GLushort]), [], "glSecondaryColor3usv", "glSecondaryColor3usvEXT");
    gl.SecondaryColorP3ui = findGLFunction([GLenum, GLuint], [], "glSecondaryColorP3ui");
    gl.SecondaryColorP3uiv = findGLFunction([GLenum, Pointer[GLuint]], [], "glSecondaryColorP3uiv");
    gl.SecondaryColorPointer = findGLFunction([GLint, GLenum, GLsizei, Pointer[GLvoid]], [], "glSecondaryColorPointer", "glSecondaryColorPointerEXT");
    gl.SelectBuffer = findGLFunction([GLsizei, Pointer[GLuint]], [], "glSelectBuffer");
    gl.ShadeModel = findGLFunction((GLenum), [], "glShadeModel");
    gl.ShaderSource = findGLFunction([GLuint, GLsizei, Pointer[GLstring], Pointer[GLint]], [], "glShaderSource", "glShaderSourceARB");
    gl.StencilFunc = findGLFunction([GLenum, GLint, GLuint], [], "glStencilFunc");
    gl.StencilFuncSeparate = findGLFunction([GLenum, GLenum, GLint, GLuint], [], "glStencilFuncSeparate", "glStencilFuncSeparateATI");
    gl.StencilMask = findGLFunction((GLuint), [], "glStencilMask");
    gl.StencilMaskSeparate = findGLFunction([GLenum, GLuint], [], "glStencilMaskSeparate");
    gl.StencilOp = findGLFunction([GLenum, GLenum, GLenum], [], "glStencilOp");
    gl.StencilOpSeparate = findGLFunction([GLenum, GLenum, GLenum, GLenum], [], "glStencilOpSeparate", "glStencilOpSeparateATI");
    gl.TexBuffer = findGLFunction([GLenum, GLenum, GLuint], [], "glTexBuffer", "glTexBufferEXT");
    gl.TexCoord1d = findGLFunction((GLdouble), [], "glTexCoord1d");
    gl.TexCoord1dv = findGLFunction((Pointer[GLdouble]), [], "glTexCoord1dv");
    gl.TexCoord1f = findGLFunction((GLfloat), [], "glTexCoord1f");
    gl.TexCoord1fv = findGLFunction((Pointer[GLfloat]), [], "glTexCoord1fv");
    gl.TexCoord1i = findGLFunction((GLint), [], "glTexCoord1i");
    gl.TexCoord1iv = findGLFunction((Pointer[GLint]), [], "glTexCoord1iv");
    gl.TexCoord1s = findGLFunction((GLshort), [], "glTexCoord1s");
    gl.TexCoord1sv = findGLFunction((Pointer[GLshort]), [], "glTexCoord1sv");
    gl.TexCoord2d = findGLFunction([GLdouble, GLdouble], [], "glTexCoord2d");
    gl.TexCoord2dv = findGLFunction((Pointer[GLdouble]), [], "glTexCoord2dv");
    gl.TexCoord2f = findGLFunction([GLfloat, GLfloat], [], "glTexCoord2f");
    gl.TexCoord2fv = findGLFunction((Pointer[GLfloat]), [], "glTexCoord2fv");
    gl.TexCoord2i = findGLFunction([GLint, GLint], [], "glTexCoord2i");
    gl.TexCoord2iv = findGLFunction((Pointer[GLint]), [], "glTexCoord2iv");
    gl.TexCoord2s = findGLFunction([GLshort, GLshort], [], "glTexCoord2s");
    gl.TexCoord2sv = findGLFunction((Pointer[GLshort]), [], "glTexCoord2sv");
    gl.TexCoord3d = findGLFunction([GLdouble, GLdouble, GLdouble], [], "glTexCoord3d");
    gl.TexCoord3dv = findGLFunction((Pointer[GLdouble]), [], "glTexCoord3dv");
    gl.TexCoord3f = findGLFunction([GLfloat, GLfloat, GLfloat], [], "glTexCoord3f");
    gl.TexCoord3fv = findGLFunction((Pointer[GLfloat]), [], "glTexCoord3fv");
    gl.TexCoord3i = findGLFunction([GLint, GLint, GLint], [], "glTexCoord3i");
    gl.TexCoord3iv = findGLFunction((Pointer[GLint]), [], "glTexCoord3iv");
    gl.TexCoord3s = findGLFunction([GLshort, GLshort, GLshort], [], "glTexCoord3s");
    gl.TexCoord3sv = findGLFunction((Pointer[GLshort]), [], "glTexCoord3sv");
    gl.TexCoord4d = findGLFunction([GLdouble, GLdouble, GLdouble, GLdouble], [], "glTexCoord4d");
    gl.TexCoord4dv = findGLFunction((Pointer[GLdouble]), [], "glTexCoord4dv");
    gl.TexCoord4f = findGLFunction([GLfloat, GLfloat, GLfloat, GLfloat], [], "glTexCoord4f");
    gl.TexCoord4fv = findGLFunction((Pointer[GLfloat]), [], "glTexCoord4fv");
    gl.TexCoord4i = findGLFunction([GLint, GLint, GLint, GLint], [], "glTexCoord4i");
    gl.TexCoord4iv = findGLFunction((Pointer[GLint]), [], "glTexCoord4iv");
    gl.TexCoord4s = findGLFunction([GLshort, GLshort, GLshort, GLshort], [], "glTexCoord4s");
    gl.TexCoord4sv = findGLFunction((Pointer[GLshort]), [], "glTexCoord4sv");
    gl.TexCoordP1ui = findGLFunction([GLenum, GLuint], [], "glTexCoordP1ui");
    gl.TexCoordP1uiv = findGLFunction([GLenum, Pointer[GLuint]], [], "glTexCoordP1uiv");
    gl.TexCoordP2ui = findGLFunction([GLenum, GLuint], [], "glTexCoordP2ui");
    gl.TexCoordP2uiv = findGLFunction([GLenum, Pointer[GLuint]], [], "glTexCoordP2uiv");
    gl.TexCoordP3ui = findGLFunction([GLenum, GLuint], [], "glTexCoordP3ui");
    gl.TexCoordP3uiv = findGLFunction([GLenum, Pointer[GLuint]], [], "glTexCoordP3uiv");
    gl.TexCoordP4ui = findGLFunction([GLenum, GLuint], [], "glTexCoordP4ui");
    gl.TexCoordP4uiv = findGLFunction([GLenum, Pointer[GLuint]], [], "glTexCoordP4uiv");
    gl.TexCoordPointer = findGLFunction([GLint, GLenum, GLsizei, Pointer[GLvoid]], [], "glTexCoordPointer");
    gl.TexEnvf = findGLFunction([GLenum, GLenum, GLfloat], [], "glTexEnvf");
    gl.TexEnvfv = findGLFunction([GLenum, GLenum, Pointer[GLfloat]], [], "glTexEnvfv");
    gl.TexEnvi = findGLFunction([GLenum, GLenum, GLint], [], "glTexEnvi");
    gl.TexEnviv = findGLFunction([GLenum, GLenum, Pointer[GLint]], [], "glTexEnviv");
    gl.TexGend = findGLFunction([GLenum, GLenum, GLdouble], [], "glTexGend");
    gl.TexGendv = findGLFunction([GLenum, GLenum, Pointer[GLdouble]], [], "glTexGendv");
    gl.TexGenf = findGLFunction([GLenum, GLenum, GLfloat], [], "glTexGenf");
    gl.TexGenfv = findGLFunction([GLenum, GLenum, Pointer[GLfloat]], [], "glTexGenfv");
    gl.TexGeni = findGLFunction([GLenum, GLenum, GLint], [], "glTexGeni");
    gl.TexGeniv = findGLFunction([GLenum, GLenum, Pointer[GLint]], [], "glTexGeniv");
    gl.TexImage1D = findGLFunction([GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, Pointer[GLvoid]], [], "glTexImage1D");
    gl.TexImage2D = findGLFunction([GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, Pointer[GLvoid]], [], "glTexImage2D");
    gl.TexImage2DMultisample = findGLFunction([GLenum, GLsizei, GLint, GLsizei, GLsizei, GLboolean], [], "glTexImage2DMultisample");
    gl.TexImage3D = findGLFunction([GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, Pointer[GLvoid]], [], "glTexImage3D", "glTexImage3DEXT");
    gl.TexImage3DMultisample = findGLFunction([GLenum, GLsizei, GLint, GLsizei, GLsizei, GLsizei, GLboolean], [], "glTexImage3DMultisample");
    gl.TexParameterIiv = findGLFunction([GLenum, GLenum, Pointer[GLint]], [], "glTexParameterIiv", "glTexParameterIivEXT");
    gl.TexParameterIuiv = findGLFunction([GLenum, GLenum, Pointer[GLuint]], [], "glTexParameterIuiv", "glTexParameterIuivEXT");
    gl.TexParameterf = findGLFunction([GLenum, GLenum, GLfloat], [], "glTexParameterf");
    gl.TexParameterfv = findGLFunction([GLenum, GLenum, Pointer[GLfloat]], [], "glTexParameterfv");
    gl.TexParameteri = findGLFunction([GLenum, GLenum, GLint], [], "glTexParameteri");
    gl.TexParameteriv = findGLFunction([GLenum, GLenum, Pointer[GLint]], [], "glTexParameteriv");
    gl.TexSubImage1D = findGLFunction([GLenum, GLint, GLint, GLsizei, GLenum, GLenum, Pointer[GLvoid]], [], "glTexSubImage1D");
    gl.TexSubImage2D = findGLFunction([GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, Pointer[GLvoid]], [], "glTexSubImage2D");
    gl.TexSubImage3D = findGLFunction([GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, Pointer[GLvoid]], [], "glTexSubImage3D", "glTexSubImage3DEXT");
    gl.TransformFeedbackVaryings = findGLFunction([GLuint, GLsizei, Pointer[GLstring], GLenum], [], "glTransformFeedbackVaryings", "glTransformFeedbackVaryingsEXT");
    gl.Translated = findGLFunction([GLdouble, GLdouble, GLdouble], [], "glTranslated");
    gl.Translatef = findGLFunction([GLfloat, GLfloat, GLfloat], [], "glTranslatef");
    gl.Uniform1d = findGLFunction([GLint, GLdouble], [], "glUniform1d");
    gl.Uniform1dv = findGLFunction([GLint, GLsizei, Pointer[GLdouble]], [], "glUniform1dv");
    gl.Uniform1f = findGLFunction([GLint, GLfloat], [], "glUniform1f", "glUniform1fARB");
    gl.Uniform1fv = findGLFunction([GLint, GLsizei, Pointer[GLfloat]], [], "glUniform1fv", "glUniform1fvARB");
    gl.Uniform1i = findGLFunction([GLint, GLint], [], "glUniform1i", "glUniform1iARB");
    gl.Uniform1iv = findGLFunction([GLint, GLsizei, Pointer[GLint]], [], "glUniform1iv", "glUniform1ivARB");
    gl.Uniform1ui = findGLFunction([GLint, GLuint], [], "glUniform1ui", "glUniform1uiEXT");
    gl.Uniform1uiv = findGLFunction([GLint, GLsizei, Pointer[GLuint]], [], "glUniform1uiv", "glUniform1uivEXT");
    gl.Uniform2d = findGLFunction([GLint, GLdouble, GLdouble], [], "glUniform2d");
    gl.Uniform2dv = findGLFunction([GLint, GLsizei, Pointer[GLdouble]], [], "glUniform2dv");
    gl.Uniform2f = findGLFunction([GLint, GLfloat, GLfloat], [], "glUniform2f", "glUniform2fARB");
    gl.Uniform2fv = findGLFunction([GLint, GLsizei, Pointer[GLfloat]], [], "glUniform2fv", "glUniform2fvARB");
    gl.Uniform2i = findGLFunction([GLint, GLint, GLint], [], "glUniform2i", "glUniform2iARB");
    gl.Uniform2iv = findGLFunction([GLint, GLsizei, Pointer[GLint]], [], "glUniform2iv", "glUniform2ivARB");
    gl.Uniform2ui = findGLFunction([GLint, GLuint, GLuint], [], "glUniform2ui", "glUniform2uiEXT");
    gl.Uniform2uiv = findGLFunction([GLint, GLsizei, Pointer[GLuint]], [], "glUniform2uiv", "glUniform2uivEXT");
    gl.Uniform3d = findGLFunction([GLint, GLdouble, GLdouble, GLdouble], [], "glUniform3d");
    gl.Uniform3dv = findGLFunction([GLint, GLsizei, Pointer[GLdouble]], [], "glUniform3dv");
    gl.Uniform3f = findGLFunction([GLint, GLfloat, GLfloat, GLfloat], [], "glUniform3f", "glUniform3fARB");
    gl.Uniform3fv = findGLFunction([GLint, GLsizei, Pointer[GLfloat]], [], "glUniform3fv", "glUniform3fvARB");
    gl.Uniform3i = findGLFunction([GLint, GLint, GLint, GLint], [], "glUniform3i", "glUniform3iARB");
    gl.Uniform3iv = findGLFunction([GLint, GLsizei, Pointer[GLint]], [], "glUniform3iv", "glUniform3ivARB");
    gl.Uniform3ui = findGLFunction([GLint, GLuint, GLuint, GLuint], [], "glUniform3ui", "glUniform3uiEXT");
    gl.Uniform3uiv = findGLFunction([GLint, GLsizei, Pointer[GLuint]], [], "glUniform3uiv", "glUniform3uivEXT");
    gl.Uniform4d = findGLFunction([GLint, GLdouble, GLdouble, GLdouble, GLdouble], [], "glUniform4d");
    gl.Uniform4dv = findGLFunction([GLint, GLsizei, Pointer[GLdouble]], [], "glUniform4dv");
    gl.Uniform4f = findGLFunction([GLint, GLfloat, GLfloat, GLfloat, GLfloat], [], "glUniform4f", "glUniform4fARB");
    gl.Uniform4fv = findGLFunction([GLint, GLsizei, Pointer[GLfloat]], [], "glUniform4fv", "glUniform4fvARB");
    gl.Uniform4i = findGLFunction([GLint, GLint, GLint, GLint, GLint], [], "glUniform4i", "glUniform4iARB");
    gl.Uniform4iv = findGLFunction([GLint, GLsizei, Pointer[GLint]], [], "glUniform4iv", "glUniform4ivARB");
    gl.Uniform4ui = findGLFunction([GLint, GLuint, GLuint, GLuint, GLuint], [], "glUniform4ui", "glUniform4uiEXT");
    gl.Uniform4uiv = findGLFunction([GLint, GLsizei, Pointer[GLuint]], [], "glUniform4uiv", "glUniform4uivEXT");
    gl.UniformBlockBinding = findGLFunction([GLuint, GLuint, GLuint], [], "glUniformBlockBinding");
    gl.UniformMatrix2dv = findGLFunction([GLint, GLsizei, GLboolean, Pointer[GLdouble]], [], "glUniformMatrix2dv");
    gl.UniformMatrix2fv = findGLFunction([GLint, GLsizei, GLboolean, Pointer[GLfloat]], [], "glUniformMatrix2fv", "glUniformMatrix2fvARB");
    gl.UniformMatrix2x3dv = findGLFunction([GLint, GLsizei, GLboolean, Pointer[GLdouble]], [], "glUniformMatrix2x3dv");
    gl.UniformMatrix2x3fv = findGLFunction([GLint, GLsizei, GLboolean, Pointer[GLfloat]], [], "glUniformMatrix2x3fv");
    gl.UniformMatrix2x4dv = findGLFunction([GLint, GLsizei, GLboolean, Pointer[GLdouble]], [], "glUniformMatrix2x4dv");
    gl.UniformMatrix2x4fv = findGLFunction([GLint, GLsizei, GLboolean, Pointer[GLfloat]], [], "glUniformMatrix2x4fv");
    gl.UniformMatrix3dv = findGLFunction([GLint, GLsizei, GLboolean, Pointer[GLdouble]], [], "glUniformMatrix3dv");
    gl.UniformMatrix3fv = findGLFunction([GLint, GLsizei, GLboolean, Pointer[GLfloat]], [], "glUniformMatrix3fv", "glUniformMatrix3fvARB");
    gl.UniformMatrix3x2dv = findGLFunction([GLint, GLsizei, GLboolean, Pointer[GLdouble]], [], "glUniformMatrix3x2dv");
    gl.UniformMatrix3x2fv = findGLFunction([GLint, GLsizei, GLboolean, Pointer[GLfloat]], [], "glUniformMatrix3x2fv");
    gl.UniformMatrix3x4dv = findGLFunction([GLint, GLsizei, GLboolean, Pointer[GLdouble]], [], "glUniformMatrix3x4dv");
    gl.UniformMatrix3x4fv = findGLFunction([GLint, GLsizei, GLboolean, Pointer[GLfloat]], [], "glUniformMatrix3x4fv");
    gl.UniformMatrix4dv = findGLFunction([GLint, GLsizei, GLboolean, Pointer[GLdouble]], [], "glUniformMatrix4dv");
    gl.UniformMatrix4fv = findGLFunction([GLint, GLsizei, GLboolean, Pointer[GLfloat]], [], "glUniformMatrix4fv", "glUniformMatrix4fvARB");
    gl.UniformMatrix4x2dv = findGLFunction([GLint, GLsizei, GLboolean, Pointer[GLdouble]], [], "glUniformMatrix4x2dv");
    gl.UniformMatrix4x2fv = findGLFunction([GLint, GLsizei, GLboolean, Pointer[GLfloat]], [], "glUniformMatrix4x2fv");
    gl.UniformMatrix4x3dv = findGLFunction([GLint, GLsizei, GLboolean, Pointer[GLdouble]], [], "glUniformMatrix4x3dv");
    gl.UniformMatrix4x3fv = findGLFunction([GLint, GLsizei, GLboolean, Pointer[GLfloat]], [], "glUniformMatrix4x3fv");
    gl.UniformSubroutinesuiv = findGLFunction([GLenum, GLsizei, Pointer[GLuint]], [], "glUniformSubroutinesuiv");
    gl.UnmapBuffer = findGLFunction((GLenum), GLboolean, "glUnmapBuffer", "glUnmapBufferARB");
    gl.UseProgram = findGLFunction((GLuint), [], "glUseProgram", "glUseProgramObjectARB");
    gl.ValidateProgram = findGLFunction((GLuint), [], "glValidateProgram", "glValidateProgramARB");
    gl.Vertex2d = findGLFunction([GLdouble, GLdouble], [], "glVertex2d");
    gl.Vertex2dv = findGLFunction((Pointer[GLdouble]), [], "glVertex2dv");
    gl.Vertex2f = findGLFunction([GLfloat, GLfloat], [], "glVertex2f");
    gl.Vertex2fv = findGLFunction((Pointer[GLfloat]), [], "glVertex2fv");
    gl.Vertex2i = findGLFunction([GLint, GLint], [], "glVertex2i");
    gl.Vertex2iv = findGLFunction((Pointer[GLint]), [], "glVertex2iv");
    gl.Vertex2s = findGLFunction([GLshort, GLshort], [], "glVertex2s");
    gl.Vertex2sv = findGLFunction((Pointer[GLshort]), [], "glVertex2sv");
    gl.Vertex3d = findGLFunction([GLdouble, GLdouble, GLdouble], [], "glVertex3d");
    gl.Vertex3dv = findGLFunction((Pointer[GLdouble]), [], "glVertex3dv");
    gl.Vertex3f = findGLFunction([GLfloat, GLfloat, GLfloat], [], "glVertex3f");
    gl.Vertex3fv = findGLFunction((Pointer[GLfloat]), [], "glVertex3fv");
    gl.Vertex3i = findGLFunction([GLint, GLint, GLint], [], "glVertex3i");
    gl.Vertex3iv = findGLFunction((Pointer[GLint]), [], "glVertex3iv");
    gl.Vertex3s = findGLFunction([GLshort, GLshort, GLshort], [], "glVertex3s");
    gl.Vertex3sv = findGLFunction((Pointer[GLshort]), [], "glVertex3sv");
    gl.Vertex4d = findGLFunction([GLdouble, GLdouble, GLdouble, GLdouble], [], "glVertex4d");
    gl.Vertex4dv = findGLFunction((Pointer[GLdouble]), [], "glVertex4dv");
    gl.Vertex4f = findGLFunction([GLfloat, GLfloat, GLfloat, GLfloat], [], "glVertex4f");
    gl.Vertex4fv = findGLFunction((Pointer[GLfloat]), [], "glVertex4fv");
    gl.Vertex4i = findGLFunction([GLint, GLint, GLint, GLint], [], "glVertex4i");
    gl.Vertex4iv = findGLFunction((Pointer[GLint]), [], "glVertex4iv");
    gl.Vertex4s = findGLFunction([GLshort, GLshort, GLshort, GLshort], [], "glVertex4s");
    gl.Vertex4sv = findGLFunction((Pointer[GLshort]), [], "glVertex4sv");
    gl.VertexAttrib1d = findGLFunction([GLuint, GLdouble], [], "glVertexAttrib1d", "glVertexAttrib1dARB");
    gl.VertexAttrib1dv = findGLFunction([GLuint, Pointer[GLdouble]], [], "glVertexAttrib1dv", "glVertexAttrib1dvARB");
    gl.VertexAttrib1f = findGLFunction([GLuint, GLfloat], [], "glVertexAttrib1f", "glVertexAttrib1fARB");
    gl.VertexAttrib1fv = findGLFunction([GLuint, Pointer[GLfloat]], [], "glVertexAttrib1fv", "glVertexAttrib1fvARB");
    gl.VertexAttrib1s = findGLFunction([GLuint, GLshort], [], "glVertexAttrib1s", "glVertexAttrib1sARB");
    gl.VertexAttrib1sv = findGLFunction([GLuint, Pointer[GLshort]], [], "glVertexAttrib1sv", "glVertexAttrib1svARB");
    gl.VertexAttrib2d = findGLFunction([GLuint, GLdouble, GLdouble], [], "glVertexAttrib2d", "glVertexAttrib2dARB");
    gl.VertexAttrib2dv = findGLFunction([GLuint, Pointer[GLdouble]], [], "glVertexAttrib2dv", "glVertexAttrib2dvARB");
    gl.VertexAttrib2f = findGLFunction([GLuint, GLfloat, GLfloat], [], "glVertexAttrib2f", "glVertexAttrib2fARB");
    gl.VertexAttrib2fv = findGLFunction([GLuint, Pointer[GLfloat]], [], "glVertexAttrib2fv", "glVertexAttrib2fvARB");
    gl.VertexAttrib2s = findGLFunction([GLuint, GLshort, GLshort], [], "glVertexAttrib2s", "glVertexAttrib2sARB");
    gl.VertexAttrib2sv = findGLFunction([GLuint, Pointer[GLshort]], [], "glVertexAttrib2sv", "glVertexAttrib2svARB");
    gl.VertexAttrib3d = findGLFunction([GLuint, GLdouble, GLdouble, GLdouble], [], "glVertexAttrib3d", "glVertexAttrib3dARB");
    gl.VertexAttrib3dv = findGLFunction([GLuint, Pointer[GLdouble]], [], "glVertexAttrib3dv", "glVertexAttrib3dvARB");
    gl.VertexAttrib3f = findGLFunction([GLuint, GLfloat, GLfloat, GLfloat], [], "glVertexAttrib3f", "glVertexAttrib3fARB");
    gl.VertexAttrib3fv = findGLFunction([GLuint, Pointer[GLfloat]], [], "glVertexAttrib3fv", "glVertexAttrib3fvARB");
    gl.VertexAttrib3s = findGLFunction([GLuint, GLshort, GLshort, GLshort], [], "glVertexAttrib3s", "glVertexAttrib3sARB");
    gl.VertexAttrib3sv = findGLFunction([GLuint, Pointer[GLshort]], [], "glVertexAttrib3sv", "glVertexAttrib3svARB");
    gl.VertexAttrib4Nbv = findGLFunction([GLuint, Pointer[GLbyte]], [], "glVertexAttrib4Nbv", "glVertexAttrib4NbvARB");
    gl.VertexAttrib4Niv = findGLFunction([GLuint, Pointer[GLint]], [], "glVertexAttrib4Niv", "glVertexAttrib4NivARB");
    gl.VertexAttrib4Nsv = findGLFunction([GLuint, Pointer[GLshort]], [], "glVertexAttrib4Nsv", "glVertexAttrib4NsvARB");
    gl.VertexAttrib4Nub = findGLFunction([GLuint, GLubyte, GLubyte, GLubyte, GLubyte], [], "glVertexAttrib4Nub", "glVertexAttrib4NubARB");
    gl.VertexAttrib4Nubv = findGLFunction([GLuint, Pointer[GLubyte]], [], "glVertexAttrib4Nubv", "glVertexAttrib4NubvARB");
    gl.VertexAttrib4Nuiv = findGLFunction([GLuint, Pointer[GLuint]], [], "glVertexAttrib4Nuiv", "glVertexAttrib4NuivARB");
    gl.VertexAttrib4Nusv = findGLFunction([GLuint, Pointer[GLushort]], [], "glVertexAttrib4Nusv", "glVertexAttrib4NusvARB");
    gl.VertexAttrib4bv = findGLFunction([GLuint, Pointer[GLbyte]], [], "glVertexAttrib4bv", "glVertexAttrib4bvARB");
    gl.VertexAttrib4d = findGLFunction([GLuint, GLdouble, GLdouble, GLdouble, GLdouble], [], "glVertexAttrib4d", "glVertexAttrib4dARB");
    gl.VertexAttrib4dv = findGLFunction([GLuint, Pointer[GLdouble]], [], "glVertexAttrib4dv", "glVertexAttrib4dvARB");
    gl.VertexAttrib4f = findGLFunction([GLuint, GLfloat, GLfloat, GLfloat, GLfloat], [], "glVertexAttrib4f", "glVertexAttrib4fARB");
    gl.VertexAttrib4fv = findGLFunction([GLuint, Pointer[GLfloat]], [], "glVertexAttrib4fv", "glVertexAttrib4fvARB");
    gl.VertexAttrib4iv = findGLFunction([GLuint, Pointer[GLint]], [], "glVertexAttrib4iv", "glVertexAttrib4ivARB");
    gl.VertexAttrib4s = findGLFunction([GLuint, GLshort, GLshort, GLshort, GLshort], [], "glVertexAttrib4s", "glVertexAttrib4sARB");
    gl.VertexAttrib4sv = findGLFunction([GLuint, Pointer[GLshort]], [], "glVertexAttrib4sv", "glVertexAttrib4svARB");
    gl.VertexAttrib4ubv = findGLFunction([GLuint, Pointer[GLubyte]], [], "glVertexAttrib4ubv", "glVertexAttrib4ubvARB");
    gl.VertexAttrib4uiv = findGLFunction([GLuint, Pointer[GLuint]], [], "glVertexAttrib4uiv", "glVertexAttrib4uivARB");
    gl.VertexAttrib4usv = findGLFunction([GLuint, Pointer[GLushort]], [], "glVertexAttrib4usv", "glVertexAttrib4usvARB");
    gl.VertexAttribIPointer = findGLFunction([GLuint, GLint, GLenum, GLsizei, Pointer[GLvoid]], [], "glVertexAttribIPointer", "glVertexAttribIPointerEXT");
    gl.VertexAttribP1ui = findGLFunction([GLuint, GLenum, GLboolean, GLuint], [], "glVertexAttribP1ui");
    gl.VertexAttribP1uiv = findGLFunction([GLuint, GLenum, GLboolean, Pointer[GLuint]], [], "glVertexAttribP1uiv");
    gl.VertexAttribP2ui = findGLFunction([GLuint, GLenum, GLboolean, GLuint], [], "glVertexAttribP2ui");
    gl.VertexAttribP2uiv = findGLFunction([GLuint, GLenum, GLboolean, Pointer[GLuint]], [], "glVertexAttribP2uiv");
    gl.VertexAttribP3ui = findGLFunction([GLuint, GLenum, GLboolean, GLuint], [], "glVertexAttribP3ui");
    gl.VertexAttribP3uiv = findGLFunction([GLuint, GLenum, GLboolean, Pointer[GLuint]], [], "glVertexAttribP3uiv");
    gl.VertexAttribP4ui = findGLFunction([GLuint, GLenum, GLboolean, GLuint], [], "glVertexAttribP4ui");
    gl.VertexAttribP4uiv = findGLFunction([GLuint, GLenum, GLboolean, Pointer[GLuint]], [], "glVertexAttribP4uiv");
    gl.VertexAttribPointer = findGLFunction([GLuint, GLint, GLenum, GLboolean, GLsizei, Pointer[GLvoid]], [], "glVertexAttribPointer", "glVertexAttribPointerARB");
    gl.VertexP2ui = findGLFunction([GLenum, GLuint], [], "glVertexP2ui");
    gl.VertexP2uiv = findGLFunction([GLenum, Pointer[GLuint]], [], "glVertexP2uiv");
    gl.VertexP3ui = findGLFunction([GLenum, GLuint], [], "glVertexP3ui");
    gl.VertexP3uiv = findGLFunction([GLenum, Pointer[GLuint]], [], "glVertexP3uiv");
    gl.VertexP4ui = findGLFunction([GLenum, GLuint], [], "glVertexP4ui");
    gl.VertexP4uiv = findGLFunction([GLenum, Pointer[GLuint]], [], "glVertexP4uiv");
    gl.VertexPointer = findGLFunction([GLint, GLenum, GLsizei, Pointer[GLvoid]], [], "glVertexPointer");
    gl.Viewport = findGLFunction([GLint, GLint, GLsizei, GLsizei], [], "glViewport");
    gl.WaitSync = findGLFunction([GLsync, GLbitfield, GLuint64], [], "glWaitSync");
    gl.WindowPos2d = findGLFunction([GLdouble, GLdouble], [], "glWindowPos2d", "glWindowPos2dARB");
    gl.WindowPos2dv = findGLFunction((Pointer[GLdouble]), [], "glWindowPos2dv", "glWindowPos2dvARB");
    gl.WindowPos2f = findGLFunction([GLfloat, GLfloat], [], "glWindowPos2f", "glWindowPos2fARB");
    gl.WindowPos2fv = findGLFunction((Pointer[GLfloat]), [], "glWindowPos2fv", "glWindowPos2fvARB");
    gl.WindowPos2i = findGLFunction([GLint, GLint], [], "glWindowPos2i", "glWindowPos2iARB");
    gl.WindowPos2iv = findGLFunction((Pointer[GLint]), [], "glWindowPos2iv", "glWindowPos2ivARB");
    gl.WindowPos2s = findGLFunction([GLshort, GLshort], [], "glWindowPos2s", "glWindowPos2sARB");
    gl.WindowPos2sv = findGLFunction((Pointer[GLshort]), [], "glWindowPos2sv", "glWindowPos2svARB");
    gl.WindowPos3d = findGLFunction([GLdouble, GLdouble, GLdouble], [], "glWindowPos3d", "glWindowPos3dARB");
    gl.WindowPos3dv = findGLFunction((Pointer[GLdouble]), [], "glWindowPos3dv", "glWindowPos3dvARB");
    gl.WindowPos3f = findGLFunction([GLfloat, GLfloat, GLfloat], [], "glWindowPos3f", "glWindowPos3fARB");
    gl.WindowPos3fv = findGLFunction((Pointer[GLfloat]), [], "glWindowPos3fv", "glWindowPos3fvARB");
    gl.WindowPos3i = findGLFunction([GLint, GLint, GLint], [], "glWindowPos3i", "glWindowPos3iARB");
    gl.WindowPos3iv = findGLFunction((Pointer[GLint]), [], "glWindowPos3iv", "glWindowPos3ivARB");
    gl.WindowPos3s = findGLFunction([GLshort, GLshort, GLshort], [], "glWindowPos3s", "glWindowPos3sARB");
    gl.WindowPos3sv = findGLFunction((Pointer[GLshort]), [], "glWindowPos3sv", "glWindowPos3svARB");
}
overload initGLFunctions() { initGLFunctions(globalGL); }

glAccum(_op: GLenum, _value: GLfloat) { globalGL.Accum(_op, _value); }
glActiveTexture(_texture: GLenum) { globalGL.ActiveTexture(_texture); }
glAlphaFunc(_func: GLenum, _ref: GLclampf) { globalGL.AlphaFunc(_func, _ref); }
glAreTexturesResident(_n: GLsizei, _textures: Pointer[GLuint], _residences: Pointer[GLboolean]) = globalGL.AreTexturesResident(_n, _textures, _residences);
glArrayElement(_i: GLint) { globalGL.ArrayElement(_i); }
glAttachShader(_program: GLuint, _shader: GLuint) { globalGL.AttachShader(_program, _shader); }
glBegin(_mode: GLenum) { globalGL.Begin(_mode); }
glBeginConditionalRender(_id: GLuint, _mode: GLenum) { globalGL.BeginConditionalRender(_id, _mode); }
glBeginQuery(_target: GLenum, _id: GLuint) { globalGL.BeginQuery(_target, _id); }
glBeginQueryIndexed(_target: GLenum, _index: GLuint, _id: GLuint) { globalGL.BeginQueryIndexed(_target, _index, _id); }
glBeginTransformFeedback(_primitiveMode: GLenum) { globalGL.BeginTransformFeedback(_primitiveMode); }
glBindAttribLocation(_program: GLuint, _index: GLuint, _name: GLstring) { globalGL.BindAttribLocation(_program, _index, _name); }
glBindBuffer(_target: GLenum, _buffer: GLuint) { globalGL.BindBuffer(_target, _buffer); }
glBindBufferBase(_target: GLenum, _index: GLuint, _buffer: GLuint) { globalGL.BindBufferBase(_target, _index, _buffer); }
glBindBufferRange(_target: GLenum, _index: GLuint, _buffer: GLuint, _offset: GLintptr, _size: GLsizeiptr) { globalGL.BindBufferRange(_target, _index, _buffer, _offset, _size); }
glBindFragDataLocation(_program: GLuint, _colorNumber: GLuint, _name: GLstring) { globalGL.BindFragDataLocation(_program, _colorNumber, _name); }
glBindFragDataLocationIndexed(_program: GLuint, _colorNumber: GLuint, _index: GLuint, _name: GLstring) { globalGL.BindFragDataLocationIndexed(_program, _colorNumber, _index, _name); }
glBindFramebuffer(_target: GLenum, _framebuffer: GLuint) { globalGL.BindFramebuffer(_target, _framebuffer); }
glBindRenderbuffer(_target: GLenum, _renderbuffer: GLuint) { globalGL.BindRenderbuffer(_target, _renderbuffer); }
glBindSampler(_unit: GLenum, _sampler: GLuint) { globalGL.BindSampler(_unit, _sampler); }
glBindTexture(_target: GLenum, _texture: GLuint) { globalGL.BindTexture(_target, _texture); }
glBindTransformFeedback(_target: GLenum, _id: GLuint) { globalGL.BindTransformFeedback(_target, _id); }
glBindVertexArray(_array: GLuint) { globalGL.BindVertexArray(_array); }
glBitmap(_width: GLsizei, _height: GLsizei, _xorig: GLfloat, _yorig: GLfloat, _xmove: GLfloat, _ymove: GLfloat, _bitmap: Pointer[GLubyte]) { globalGL.Bitmap(_width, _height, _xorig, _yorig, _xmove, _ymove, _bitmap); }
glBlendColor(_red: GLclampf, _green: GLclampf, _blue: GLclampf, _alpha: GLclampf) { globalGL.BlendColor(_red, _green, _blue, _alpha); }
glBlendEquation(_mode: GLenum) { globalGL.BlendEquation(_mode); }
glBlendEquationSeparate(_modeRGB: GLenum, _modeAlpha: GLenum) { globalGL.BlendEquationSeparate(_modeRGB, _modeAlpha); }
glBlendFunc(_sfactor: GLenum, _dfactor: GLenum) { globalGL.BlendFunc(_sfactor, _dfactor); }
glBlendFuncSeparate(_sfactorRGB: GLenum, _dfactorRGB: GLenum, _sfactorAlpha: GLenum, _dfactorAlpha: GLenum) { globalGL.BlendFuncSeparate(_sfactorRGB, _dfactorRGB, _sfactorAlpha, _dfactorAlpha); }
glBlitFramebuffer(_srcX0: GLint, _srcY0: GLint, _srcX1: GLint, _srcY1: GLint, _dstX0: GLint, _dstY0: GLint, _dstX1: GLint, _dstY1: GLint, _mask: GLbitfield, _filter: GLenum) { globalGL.BlitFramebuffer(_srcX0, _srcY0, _srcX1, _srcY1, _dstX0, _dstY0, _dstX1, _dstY1, _mask, _filter); }
glBufferData(_target: GLenum, _size: GLsizeiptr, _data: Pointer[GLvoid], _usage: GLenum) { globalGL.BufferData(_target, _size, _data, _usage); }
glBufferSubData(_target: GLenum, _offset: GLintptr, _size: GLsizeiptr, _data: Pointer[GLvoid]) { globalGL.BufferSubData(_target, _offset, _size, _data); }
glCallList(_list: GLuint) { globalGL.CallList(_list); }
glCallLists(_n: GLsizei, _type: GLenum, _lists: Pointer[GLvoid]) { globalGL.CallLists(_n, _type, _lists); }
glCheckFramebufferStatus(_target: GLenum) = globalGL.CheckFramebufferStatus(_target);
glClampColor(_target: GLenum, _clamp: GLenum) { globalGL.ClampColor(_target, _clamp); }
glClear(_mask: GLbitfield) { globalGL.Clear(_mask); }
glClearAccum(_red: GLfloat, _green: GLfloat, _blue: GLfloat, _alpha: GLfloat) { globalGL.ClearAccum(_red, _green, _blue, _alpha); }
glClearBufferfi(_buffer: GLenum, _drawbuffer: GLint, _depth: GLfloat, _stencil: GLint) { globalGL.ClearBufferfi(_buffer, _drawbuffer, _depth, _stencil); }
glClearBufferfv(_buffer: GLenum, _drawbuffer: GLint, _value: Pointer[GLfloat]) { globalGL.ClearBufferfv(_buffer, _drawbuffer, _value); }
glClearBufferiv(_buffer: GLenum, _drawbuffer: GLint, _value: Pointer[GLint]) { globalGL.ClearBufferiv(_buffer, _drawbuffer, _value); }
glClearBufferuiv(_buffer: GLenum, _drawbuffer: GLint, _value: Pointer[GLuint]) { globalGL.ClearBufferuiv(_buffer, _drawbuffer, _value); }
glClearColor(_red: GLclampf, _green: GLclampf, _blue: GLclampf, _alpha: GLclampf) { globalGL.ClearColor(_red, _green, _blue, _alpha); }
glClearColorIiEXT(_r: GLint, _g: GLint, _b: GLint, _a: GLint) { globalGL.ClearColorIiEXT(_r, _g, _b, _a); }
glClearColorIuiEXT(_r: GLuint, _g: GLuint, _b: GLuint, _a: GLuint) { globalGL.ClearColorIuiEXT(_r, _g, _b, _a); }
glClearDepth(_depth: GLclampd) { globalGL.ClearDepth(_depth); }
glClearIndex(_c: GLfloat) { globalGL.ClearIndex(_c); }
glClearStencil(_s: GLint) { globalGL.ClearStencil(_s); }
glClientActiveTexture(_texture: GLenum) { globalGL.ClientActiveTexture(_texture); }
glClientWaitSync(_sync: GLsync, _flags: GLbitfield, _timeout: GLuint64) = globalGL.ClientWaitSync(_sync, _flags, _timeout);
glClipPlane(_plane: GLenum, _equation: Pointer[GLdouble]) { globalGL.ClipPlane(_plane, _equation); }
glColor3b(_red: GLbyte, _green: GLbyte, _blue: GLbyte) { globalGL.Color3b(_red, _green, _blue); }
glColor3bv(_v: Pointer[GLbyte]) { globalGL.Color3bv(_v); }
glColor3d(_red: GLdouble, _green: GLdouble, _blue: GLdouble) { globalGL.Color3d(_red, _green, _blue); }
glColor3dv(_v: Pointer[GLdouble]) { globalGL.Color3dv(_v); }
glColor3f(_red: GLfloat, _green: GLfloat, _blue: GLfloat) { globalGL.Color3f(_red, _green, _blue); }
glColor3fv(_v: Pointer[GLfloat]) { globalGL.Color3fv(_v); }
glColor3i(_red: GLint, _green: GLint, _blue: GLint) { globalGL.Color3i(_red, _green, _blue); }
glColor3iv(_v: Pointer[GLint]) { globalGL.Color3iv(_v); }
glColor3s(_red: GLshort, _green: GLshort, _blue: GLshort) { globalGL.Color3s(_red, _green, _blue); }
glColor3sv(_v: Pointer[GLshort]) { globalGL.Color3sv(_v); }
glColor3ub(_red: GLubyte, _green: GLubyte, _blue: GLubyte) { globalGL.Color3ub(_red, _green, _blue); }
glColor3ubv(_v: Pointer[GLubyte]) { globalGL.Color3ubv(_v); }
glColor3ui(_red: GLuint, _green: GLuint, _blue: GLuint) { globalGL.Color3ui(_red, _green, _blue); }
glColor3uiv(_v: Pointer[GLuint]) { globalGL.Color3uiv(_v); }
glColor3us(_red: GLushort, _green: GLushort, _blue: GLushort) { globalGL.Color3us(_red, _green, _blue); }
glColor3usv(_v: Pointer[GLushort]) { globalGL.Color3usv(_v); }
glColor4b(_red: GLbyte, _green: GLbyte, _blue: GLbyte, _alpha: GLbyte) { globalGL.Color4b(_red, _green, _blue, _alpha); }
glColor4bv(_v: Pointer[GLbyte]) { globalGL.Color4bv(_v); }
glColor4d(_red: GLdouble, _green: GLdouble, _blue: GLdouble, _alpha: GLdouble) { globalGL.Color4d(_red, _green, _blue, _alpha); }
glColor4dv(_v: Pointer[GLdouble]) { globalGL.Color4dv(_v); }
glColor4f(_red: GLfloat, _green: GLfloat, _blue: GLfloat, _alpha: GLfloat) { globalGL.Color4f(_red, _green, _blue, _alpha); }
glColor4fv(_v: Pointer[GLfloat]) { globalGL.Color4fv(_v); }
glColor4i(_red: GLint, _green: GLint, _blue: GLint, _alpha: GLint) { globalGL.Color4i(_red, _green, _blue, _alpha); }
glColor4iv(_v: Pointer[GLint]) { globalGL.Color4iv(_v); }
glColor4s(_red: GLshort, _green: GLshort, _blue: GLshort, _alpha: GLshort) { globalGL.Color4s(_red, _green, _blue, _alpha); }
glColor4sv(_v: Pointer[GLshort]) { globalGL.Color4sv(_v); }
glColor4ub(_red: GLubyte, _green: GLubyte, _blue: GLubyte, _alpha: GLubyte) { globalGL.Color4ub(_red, _green, _blue, _alpha); }
glColor4ubv(_v: Pointer[GLubyte]) { globalGL.Color4ubv(_v); }
glColor4ui(_red: GLuint, _green: GLuint, _blue: GLuint, _alpha: GLuint) { globalGL.Color4ui(_red, _green, _blue, _alpha); }
glColor4uiv(_v: Pointer[GLuint]) { globalGL.Color4uiv(_v); }
glColor4us(_red: GLushort, _green: GLushort, _blue: GLushort, _alpha: GLushort) { globalGL.Color4us(_red, _green, _blue, _alpha); }
glColor4usv(_v: Pointer[GLushort]) { globalGL.Color4usv(_v); }
glColorMask(_red: GLboolean, _green: GLboolean, _blue: GLboolean, _alpha: GLboolean) { globalGL.ColorMask(_red, _green, _blue, _alpha); }
glColorMaski(_buf: GLuint, _r: GLboolean, _g: GLboolean, _b: GLboolean, _a: GLboolean) { globalGL.ColorMaski(_buf, _r, _g, _b, _a); }
glColorMaterial(_face: GLenum, _mode: GLenum) { globalGL.ColorMaterial(_face, _mode); }
glColorP3ui(_type: GLenum, _color: GLuint) { globalGL.ColorP3ui(_type, _color); }
glColorP3uiv(_type: GLenum, _color: Pointer[GLuint]) { globalGL.ColorP3uiv(_type, _color); }
glColorP4ui(_type: GLenum, _color: GLuint) { globalGL.ColorP4ui(_type, _color); }
glColorP4uiv(_type: GLenum, _color: Pointer[GLuint]) { globalGL.ColorP4uiv(_type, _color); }
glColorPointer(_size: GLint, _type: GLenum, _stride: GLsizei, _ptr: Pointer[GLvoid]) { globalGL.ColorPointer(_size, _type, _stride, _ptr); }
glCompileShader(_shader: GLuint) { globalGL.CompileShader(_shader); }
glCompressedTexImage1D(_target: GLenum, _level: GLint, _internalformat: GLenum, _width: GLsizei, _border: GLint, _imageSize: GLsizei, _data: Pointer[GLvoid]) { globalGL.CompressedTexImage1D(_target, _level, _internalformat, _width, _border, _imageSize, _data); }
glCompressedTexImage2D(_target: GLenum, _level: GLint, _internalformat: GLenum, _width: GLsizei, _height: GLsizei, _border: GLint, _imageSize: GLsizei, _data: Pointer[GLvoid]) { globalGL.CompressedTexImage2D(_target, _level, _internalformat, _width, _height, _border, _imageSize, _data); }
glCompressedTexImage3D(_target: GLenum, _level: GLint, _internalformat: GLenum, _width: GLsizei, _height: GLsizei, _depth: GLsizei, _border: GLint, _imageSize: GLsizei, _data: Pointer[GLvoid]) { globalGL.CompressedTexImage3D(_target, _level, _internalformat, _width, _height, _depth, _border, _imageSize, _data); }
glCompressedTexSubImage1D(_target: GLenum, _level: GLint, _xoffset: GLint, _width: GLsizei, _format: GLenum, _imageSize: GLsizei, _data: Pointer[GLvoid]) { globalGL.CompressedTexSubImage1D(_target, _level, _xoffset, _width, _format, _imageSize, _data); }
glCompressedTexSubImage2D(_target: GLenum, _level: GLint, _xoffset: GLint, _yoffset: GLint, _width: GLsizei, _height: GLsizei, _format: GLenum, _imageSize: GLsizei, _data: Pointer[GLvoid]) { globalGL.CompressedTexSubImage2D(_target, _level, _xoffset, _yoffset, _width, _height, _format, _imageSize, _data); }
glCompressedTexSubImage3D(_target: GLenum, _level: GLint, _xoffset: GLint, _yoffset: GLint, _zoffset: GLint, _width: GLsizei, _height: GLsizei, _depth: GLsizei, _format: GLenum, _imageSize: GLsizei, _data: Pointer[GLvoid]) { globalGL.CompressedTexSubImage3D(_target, _level, _xoffset, _yoffset, _zoffset, _width, _height, _depth, _format, _imageSize, _data); }
glCopyBufferSubData(_readtarget: GLenum, _writetarget: GLenum, _readoffset: GLintptr, _writeoffset: GLintptr, _size: GLsizeiptr) { globalGL.CopyBufferSubData(_readtarget, _writetarget, _readoffset, _writeoffset, _size); }
glCopyPixels(_x: GLint, _y: GLint, _width: GLsizei, _height: GLsizei, _type: GLenum) { globalGL.CopyPixels(_x, _y, _width, _height, _type); }
glCopyTexImage1D(_target: GLenum, _level: GLint, _internalformat: GLenum, _x: GLint, _y: GLint, _width: GLsizei, _border: GLint) { globalGL.CopyTexImage1D(_target, _level, _internalformat, _x, _y, _width, _border); }
glCopyTexImage2D(_target: GLenum, _level: GLint, _internalformat: GLenum, _x: GLint, _y: GLint, _width: GLsizei, _height: GLsizei, _border: GLint) { globalGL.CopyTexImage2D(_target, _level, _internalformat, _x, _y, _width, _height, _border); }
glCopyTexSubImage1D(_target: GLenum, _level: GLint, _xoffset: GLint, _x: GLint, _y: GLint, _width: GLsizei) { globalGL.CopyTexSubImage1D(_target, _level, _xoffset, _x, _y, _width); }
glCopyTexSubImage2D(_target: GLenum, _level: GLint, _xoffset: GLint, _yoffset: GLint, _x: GLint, _y: GLint, _width: GLsizei, _height: GLsizei) { globalGL.CopyTexSubImage2D(_target, _level, _xoffset, _yoffset, _x, _y, _width, _height); }
glCopyTexSubImage3D(_target: GLenum, _level: GLint, _xoffset: GLint, _yoffset: GLint, _zoffset: GLint, _x: GLint, _y: GLint, _width: GLsizei, _height: GLsizei) { globalGL.CopyTexSubImage3D(_target, _level, _xoffset, _yoffset, _zoffset, _x, _y, _width, _height); }
glCreateProgram() = globalGL.CreateProgram();
glCreateShader(_type: GLenum) = globalGL.CreateShader(_type);
glCullFace(_mode: GLenum) { globalGL.CullFace(_mode); }
glDeleteBuffers(_n: GLsizei, _buffers: Pointer[GLuint]) { globalGL.DeleteBuffers(_n, _buffers); }
glDeleteFramebuffers(_n: GLsizei, _framebuffers: Pointer[GLuint]) { globalGL.DeleteFramebuffers(_n, _framebuffers); }
glDeleteLists(_list: GLuint, _range: GLsizei) { globalGL.DeleteLists(_list, _range); }
glDeleteProgram(_program: GLuint) { globalGL.DeleteProgram(_program); }
glDeleteQueries(_n: GLsizei, _ids: Pointer[GLuint]) { globalGL.DeleteQueries(_n, _ids); }
glDeleteRenderbuffers(_n: GLsizei, _renderbuffers: Pointer[GLuint]) { globalGL.DeleteRenderbuffers(_n, _renderbuffers); }
glDeleteSamplers(_count: GLsizei, _samplers: Pointer[GLuint]) { globalGL.DeleteSamplers(_count, _samplers); }
glDeleteShader(_shader: GLuint) { globalGL.DeleteShader(_shader); }
glDeleteSync(_sync: GLsync) { globalGL.DeleteSync(_sync); }
glDeleteTextures(_n: GLsizei, _textures: Pointer[GLuint]) { globalGL.DeleteTextures(_n, _textures); }
glDeleteTransformFeedbacks(_n: GLsizei, _ids: Pointer[GLuint]) { globalGL.DeleteTransformFeedbacks(_n, _ids); }
glDeleteVertexArrays(_n: GLsizei, _arrays: Pointer[GLuint]) { globalGL.DeleteVertexArrays(_n, _arrays); }
glDepthFunc(_func: GLenum) { globalGL.DepthFunc(_func); }
glDepthMask(_flag: GLboolean) { globalGL.DepthMask(_flag); }
glDepthRange(_near_val: GLclampd, _far_val: GLclampd) { globalGL.DepthRange(_near_val, _far_val); }
glDetachShader(_program: GLuint, _shader: GLuint) { globalGL.DetachShader(_program, _shader); }
glDisable(_cap: GLenum) { globalGL.Disable(_cap); }
glDisableClientState(_cap: GLenum) { globalGL.DisableClientState(_cap); }
glDisableVertexAttribArray(_index: GLuint) { globalGL.DisableVertexAttribArray(_index); }
glDisablei(_target: GLenum, _index: GLuint) { globalGL.Disablei(_target, _index); }
glDrawArrays(_mode: GLenum, _first: GLint, _count: GLsizei) { globalGL.DrawArrays(_mode, _first, _count); }
glDrawArraysInstanced(_mode: GLenum, _first: GLint, _count: GLsizei, _primcount: GLsizei) { globalGL.DrawArraysInstanced(_mode, _first, _count, _primcount); }
glDrawBuffer(_mode: GLenum) { globalGL.DrawBuffer(_mode); }
glDrawBuffers(_n: GLsizei, _bufs: Pointer[GLenum]) { globalGL.DrawBuffers(_n, _bufs); }
glDrawElements(_mode: GLenum, _count: GLsizei, _type: GLenum, _indices: Pointer[GLvoid]) { globalGL.DrawElements(_mode, _count, _type, _indices); }
glDrawElementsInstanced(_mode: GLenum, _count: GLsizei, _type: GLenum, _indices: Pointer[GLvoid], _primcount: GLsizei) { globalGL.DrawElementsInstanced(_mode, _count, _type, _indices, _primcount); }
glDrawPixels(_width: GLsizei, _height: GLsizei, _format: GLenum, _type: GLenum, _pixels: Pointer[GLvoid]) { globalGL.DrawPixels(_width, _height, _format, _type, _pixels); }
glDrawRangeElements(_mode: GLenum, _start: GLuint, _end: GLuint, _count: GLsizei, _type: GLenum, _indices: Pointer[GLvoid]) { globalGL.DrawRangeElements(_mode, _start, _end, _count, _type, _indices); }
glDrawTransformFeedback(_mode: GLenum, _id: GLuint) { globalGL.DrawTransformFeedback(_mode, _id); }
glDrawTransformFeedbackStream(_mode: GLenum, _id: GLuint, _stream: GLuint) { globalGL.DrawTransformFeedbackStream(_mode, _id, _stream); }
glEdgeFlag(_flag: GLboolean) { globalGL.EdgeFlag(_flag); }
glEdgeFlagPointer(_stride: GLsizei, _ptr: Pointer[GLvoid]) { globalGL.EdgeFlagPointer(_stride, _ptr); }
glEdgeFlagv(_flag: Pointer[GLboolean]) { globalGL.EdgeFlagv(_flag); }
glEnable(_cap: GLenum) { globalGL.Enable(_cap); }
glEnableClientState(_cap: GLenum) { globalGL.EnableClientState(_cap); }
glEnableVertexAttribArray(_index: GLuint) { globalGL.EnableVertexAttribArray(_index); }
glEnablei(_target: GLenum, _index: GLuint) { globalGL.Enablei(_target, _index); }
glEnd() { globalGL.End(); }
glEndConditionalRender() { globalGL.EndConditionalRender(); }
glEndList() { globalGL.EndList(); }
glEndQuery(_target: GLenum) { globalGL.EndQuery(_target); }
glEndQueryIndexed(_target: GLenum, _index: GLuint) { globalGL.EndQueryIndexed(_target, _index); }
glEndTransformFeedback() { globalGL.EndTransformFeedback(); }
glEvalCoord1d(_u: GLdouble) { globalGL.EvalCoord1d(_u); }
glEvalCoord1dv(_u: Pointer[GLdouble]) { globalGL.EvalCoord1dv(_u); }
glEvalCoord1f(_u: GLfloat) { globalGL.EvalCoord1f(_u); }
glEvalCoord1fv(_u: Pointer[GLfloat]) { globalGL.EvalCoord1fv(_u); }
glEvalCoord2d(_u: GLdouble, _v: GLdouble) { globalGL.EvalCoord2d(_u, _v); }
glEvalCoord2dv(_u: Pointer[GLdouble]) { globalGL.EvalCoord2dv(_u); }
glEvalCoord2f(_u: GLfloat, _v: GLfloat) { globalGL.EvalCoord2f(_u, _v); }
glEvalCoord2fv(_u: Pointer[GLfloat]) { globalGL.EvalCoord2fv(_u); }
glEvalMesh1(_mode: GLenum, _i1: GLint, _i2: GLint) { globalGL.EvalMesh1(_mode, _i1, _i2); }
glEvalMesh2(_mode: GLenum, _i1: GLint, _i2: GLint, _j1: GLint, _j2: GLint) { globalGL.EvalMesh2(_mode, _i1, _i2, _j1, _j2); }
glEvalPoint1(_i: GLint) { globalGL.EvalPoint1(_i); }
glEvalPoint2(_i: GLint, _j: GLint) { globalGL.EvalPoint2(_i, _j); }
glFeedbackBuffer(_size: GLsizei, _type: GLenum, _buffer: Pointer[GLfloat]) { globalGL.FeedbackBuffer(_size, _type, _buffer); }
glFenceSync(_condition: GLenum, _flags: GLbitfield) = globalGL.FenceSync(_condition, _flags);
glFinish() { globalGL.Finish(); }
glFlush() { globalGL.Flush(); }
glFlushMappedBufferRange(_target: GLenum, _offset: GLintptr, _size: GLsizeiptr) { globalGL.FlushMappedBufferRange(_target, _offset, _size); }
glFogCoordPointer(_type: GLenum, _stride: GLsizei, _pointer: Pointer[GLvoid]) { globalGL.FogCoordPointer(_type, _stride, _pointer); }
glFogCoordd(_coord: GLdouble) { globalGL.FogCoordd(_coord); }
glFogCoorddv(_coord: Pointer[GLdouble]) { globalGL.FogCoorddv(_coord); }
glFogCoordf(_coord: GLfloat) { globalGL.FogCoordf(_coord); }
glFogCoordfv(_coord: Pointer[GLfloat]) { globalGL.FogCoordfv(_coord); }
glFogf(_pname: GLenum, _param: GLfloat) { globalGL.Fogf(_pname, _param); }
glFogfv(_pname: GLenum, _params: Pointer[GLfloat]) { globalGL.Fogfv(_pname, _params); }
glFogi(_pname: GLenum, _param: GLint) { globalGL.Fogi(_pname, _param); }
glFogiv(_pname: GLenum, _params: Pointer[GLint]) { globalGL.Fogiv(_pname, _params); }
glFramebufferRenderbuffer(_target: GLenum, _attachment: GLenum, _renderbuffertarget: GLenum, _renderbuffer: GLuint) { globalGL.FramebufferRenderbuffer(_target, _attachment, _renderbuffertarget, _renderbuffer); }
glFramebufferTexture(_target: GLenum, _attachment: GLenum, _texture: GLuint, _level: GLint) { globalGL.FramebufferTexture(_target, _attachment, _texture, _level); }
glFramebufferTexture1D(_target: GLenum, _attachment: GLenum, _textarget: GLenum, _texture: GLuint, _level: GLint) { globalGL.FramebufferTexture1D(_target, _attachment, _textarget, _texture, _level); }
glFramebufferTexture2D(_target: GLenum, _attachment: GLenum, _textarget: GLenum, _texture: GLuint, _level: GLint) { globalGL.FramebufferTexture2D(_target, _attachment, _textarget, _texture, _level); }
glFramebufferTexture3D(_target: GLenum, _attachment: GLenum, _textarget: GLenum, _texture: GLuint, _level: GLint, _zoffset: GLint) { globalGL.FramebufferTexture3D(_target, _attachment, _textarget, _texture, _level, _zoffset); }
glFramebufferTextureFaceARB(_target: GLenum, _attachment: GLenum, _texture: GLuint, _level: GLint, _face: GLenum) { globalGL.FramebufferTextureFaceARB(_target, _attachment, _texture, _level, _face); }
glFramebufferTextureLayer(_target: GLenum, _attachment: GLenum, _texture: GLuint, _level: GLint, _layer: GLint) { globalGL.FramebufferTextureLayer(_target, _attachment, _texture, _level, _layer); }
glFramebufferTextureLayerARB(_target: GLenum, _attachment: GLenum, _texture: GLuint, _level: GLint, _layer: GLint) { globalGL.FramebufferTextureLayerARB(_target, _attachment, _texture, _level, _layer); }
glFrontFace(_mode: GLenum) { globalGL.FrontFace(_mode); }
glFrustum(_left: GLdouble, _right: GLdouble, _bottom: GLdouble, _top: GLdouble, _near_val: GLdouble, _far_val: GLdouble) { globalGL.Frustum(_left, _right, _bottom, _top, _near_val, _far_val); }
glGenBuffers(_n: GLsizei, _buffers: Pointer[GLuint]) { globalGL.GenBuffers(_n, _buffers); }
glGenFramebuffers(_n: GLsizei, _framebuffers: Pointer[GLuint]) { globalGL.GenFramebuffers(_n, _framebuffers); }
glGenLists(_range: GLsizei) = globalGL.GenLists(_range);
glGenQueries(_n: GLsizei, _ids: Pointer[GLuint]) { globalGL.GenQueries(_n, _ids); }
glGenRenderbuffers(_n: GLsizei, _renderbuffers: Pointer[GLuint]) { globalGL.GenRenderbuffers(_n, _renderbuffers); }
glGenSamplers(_count: GLsizei, _samplers: Pointer[GLuint]) { globalGL.GenSamplers(_count, _samplers); }
glGenTextures(_n: GLsizei, _textures: Pointer[GLuint]) { globalGL.GenTextures(_n, _textures); }
glGenTransformFeedbacks(_n: GLsizei, _ids: Pointer[GLuint]) { globalGL.GenTransformFeedbacks(_n, _ids); }
glGenVertexArrays(_n: GLsizei, _arrays: Pointer[GLuint]) { globalGL.GenVertexArrays(_n, _arrays); }
glGenerateMipmap(_target: GLenum) { globalGL.GenerateMipmap(_target); }
glGetActiveAttrib(_program: GLuint, _index: GLuint, _maxLength: GLsizei, _length: Pointer[GLsizei], _size: Pointer[GLint], _type: Pointer[GLenum], _name: GLstring) { globalGL.GetActiveAttrib(_program, _index, _maxLength, _length, _size, _type, _name); }
glGetActiveSubroutineName(_program: GLuint, _shadertype: GLenum, _index: GLuint, _bufsize: GLsizei, _length: Pointer[GLsizei], _name: GLstring) { globalGL.GetActiveSubroutineName(_program, _shadertype, _index, _bufsize, _length, _name); }
glGetActiveSubroutineUniformName(_program: GLuint, _shadertype: GLenum, _index: GLuint, _bufsize: GLsizei, _length: Pointer[GLsizei], _name: GLstring) { globalGL.GetActiveSubroutineUniformName(_program, _shadertype, _index, _bufsize, _length, _name); }
glGetActiveSubroutineUniformiv(_program: GLuint, _shadertype: GLenum, _index: GLuint, _pname: GLenum, _values: Pointer[GLint]) { globalGL.GetActiveSubroutineUniformiv(_program, _shadertype, _index, _pname, _values); }
glGetActiveUniform(_program: GLuint, _index: GLuint, _maxLength: GLsizei, _length: Pointer[GLsizei], _size: Pointer[GLint], _type: Pointer[GLenum], _name: GLstring) { globalGL.GetActiveUniform(_program, _index, _maxLength, _length, _size, _type, _name); }
glGetActiveUniformBlockName(_program: GLuint, _uniformBlockIndex: GLuint, _bufSize: GLsizei, _length: Pointer[GLsizei], _uniformName: GLstring) { globalGL.GetActiveUniformBlockName(_program, _uniformBlockIndex, _bufSize, _length, _uniformName); }
glGetActiveUniformBlockiv(_program: GLuint, _uniformBlockIndex: GLuint, _pname: GLenum, _params: Pointer[GLint]) { globalGL.GetActiveUniformBlockiv(_program, _uniformBlockIndex, _pname, _params); }
glGetActiveUniformName(_program: GLuint, _uniformIndex: GLuint, _bufSize: GLsizei, _length: Pointer[GLsizei], _uniformName: GLstring) { globalGL.GetActiveUniformName(_program, _uniformIndex, _bufSize, _length, _uniformName); }
glGetActiveUniformsiv(_program: GLuint, _uniformCount: GLsizei, _uniformIndices: Pointer[GLuint], _pname: GLenum, _params: Pointer[GLint]) { globalGL.GetActiveUniformsiv(_program, _uniformCount, _uniformIndices, _pname, _params); }
glGetAttachedShaders(_program: GLuint, _maxCount: GLsizei, _count: Pointer[GLsizei], _shaders: Pointer[GLuint]) { globalGL.GetAttachedShaders(_program, _maxCount, _count, _shaders); }
glGetAttribLocation(_program: GLuint, _name: GLstring) = globalGL.GetAttribLocation(_program, _name);
glGetBooleani_v(_value: GLenum, _index: GLuint, _data: Pointer[GLboolean]) { globalGL.GetBooleani_v(_value, _index, _data); }
glGetBooleanv(_pname: GLenum, _params: Pointer[GLboolean]) { globalGL.GetBooleanv(_pname, _params); }
glGetBufferParameteri64v(_target: GLenum, _pname: GLenum, _params: Pointer[GLint64]) { globalGL.GetBufferParameteri64v(_target, _pname, _params); }
glGetBufferParameteriv(_target: GLenum, _pname: GLenum, _params: Pointer[GLint]) { globalGL.GetBufferParameteriv(_target, _pname, _params); }
glGetBufferPointerv(_target: GLenum, _pname: GLenum, _params: Pointer[Pointer[GLvoid]]) { globalGL.GetBufferPointerv(_target, _pname, _params); }
glGetBufferSubData(_target: GLenum, _offset: GLintptr, _size: GLsizeiptr, _data: Pointer[GLvoid]) { globalGL.GetBufferSubData(_target, _offset, _size, _data); }
glGetClipPlane(_plane: GLenum, _equation: Pointer[GLdouble]) { globalGL.GetClipPlane(_plane, _equation); }
glGetCompressedTexImage(_target: GLenum, _lod: GLint, _img: Pointer[GLvoid]) { globalGL.GetCompressedTexImage(_target, _lod, _img); }
glGetDoublev(_pname: GLenum, _params: Pointer[GLdouble]) { globalGL.GetDoublev(_pname, _params); }
glGetError() = globalGL.GetError();
glGetFloatv(_pname: GLenum, _params: Pointer[GLfloat]) { globalGL.GetFloatv(_pname, _params); }
glGetFragDataIndex(_program: GLuint, _name: GLstring) = globalGL.GetFragDataIndex(_program, _name);
glGetFragDataLocation(_program: GLuint, _name: GLstring) = globalGL.GetFragDataLocation(_program, _name);
glGetFramebufferAttachmentParameteriv(_target: GLenum, _attachment: GLenum, _pname: GLenum, _params: Pointer[GLint]) { globalGL.GetFramebufferAttachmentParameteriv(_target, _attachment, _pname, _params); }
glGetInteger64i_v(_target: GLenum, _index: GLuint, _data: Pointer[GLint64]) { globalGL.GetInteger64i_v(_target, _index, _data); }
glGetInteger64v(_pname: GLenum, _params: Pointer[GLint64]) { globalGL.GetInteger64v(_pname, _params); }
glGetIntegeri_v(_value: GLenum, _index: GLuint, _data: Pointer[GLint]) { globalGL.GetIntegeri_v(_value, _index, _data); }
glGetIntegerv(_pname: GLenum, _params: Pointer[GLint]) { globalGL.GetIntegerv(_pname, _params); }
glGetLightfv(_light: GLenum, _pname: GLenum, _params: Pointer[GLfloat]) { globalGL.GetLightfv(_light, _pname, _params); }
glGetLightiv(_light: GLenum, _pname: GLenum, _params: Pointer[GLint]) { globalGL.GetLightiv(_light, _pname, _params); }
glGetMapdv(_target: GLenum, _query: GLenum, _v: Pointer[GLdouble]) { globalGL.GetMapdv(_target, _query, _v); }
glGetMapfv(_target: GLenum, _query: GLenum, _v: Pointer[GLfloat]) { globalGL.GetMapfv(_target, _query, _v); }
glGetMapiv(_target: GLenum, _query: GLenum, _v: Pointer[GLint]) { globalGL.GetMapiv(_target, _query, _v); }
glGetMaterialfv(_face: GLenum, _pname: GLenum, _params: Pointer[GLfloat]) { globalGL.GetMaterialfv(_face, _pname, _params); }
glGetMaterialiv(_face: GLenum, _pname: GLenum, _params: Pointer[GLint]) { globalGL.GetMaterialiv(_face, _pname, _params); }
glGetMultisamplefv(_pname: GLenum, _index: GLuint, _val: Pointer[GLfloat]) { globalGL.GetMultisamplefv(_pname, _index, _val); }
glGetPixelMapfv(_map: GLenum, _values: Pointer[GLfloat]) { globalGL.GetPixelMapfv(_map, _values); }
glGetPixelMapuiv(_map: GLenum, _values: Pointer[GLuint]) { globalGL.GetPixelMapuiv(_map, _values); }
glGetPixelMapusv(_map: GLenum, _values: Pointer[GLushort]) { globalGL.GetPixelMapusv(_map, _values); }
glGetPointerv(_pname: GLenum, _params: Pointer[Pointer[GLvoid]]) { globalGL.GetPointerv(_pname, _params); }
glGetPolygonStipple(_mask: Pointer[GLubyte]) { globalGL.GetPolygonStipple(_mask); }
glGetProgramInfoLog(_program: GLuint, _bufSize: GLsizei, _length: Pointer[GLsizei], _infoLog: GLstring) { globalGL.GetProgramInfoLog(_program, _bufSize, _length, _infoLog); }
glGetProgramStageiv(_program: GLuint, _shadertype: GLenum, _pname: GLenum, _values: Pointer[GLint]) { globalGL.GetProgramStageiv(_program, _shadertype, _pname, _values); }
glGetProgramiv(_program: GLuint, _pname: GLenum, _param: Pointer[GLint]) { globalGL.GetProgramiv(_program, _pname, _param); }
glGetQueryIndexediv(_target: GLenum, _index: GLuint, _pname: GLenum, _params: Pointer[GLint]) { globalGL.GetQueryIndexediv(_target, _index, _pname, _params); }
glGetQueryObjecti64v(_id: GLuint, _pname: GLenum, _params: Pointer[GLint64]) { globalGL.GetQueryObjecti64v(_id, _pname, _params); }
glGetQueryObjectiv(_id: GLuint, _pname: GLenum, _params: Pointer[GLint]) { globalGL.GetQueryObjectiv(_id, _pname, _params); }
glGetQueryObjectui64v(_id: GLuint, _pname: GLenum, _params: Pointer[GLuint64]) { globalGL.GetQueryObjectui64v(_id, _pname, _params); }
glGetQueryObjectuiv(_id: GLuint, _pname: GLenum, _params: Pointer[GLuint]) { globalGL.GetQueryObjectuiv(_id, _pname, _params); }
glGetQueryiv(_target: GLenum, _pname: GLenum, _params: Pointer[GLint]) { globalGL.GetQueryiv(_target, _pname, _params); }
glGetRenderbufferParameteriv(_target: GLenum, _pname: GLenum, _params: Pointer[GLint]) { globalGL.GetRenderbufferParameteriv(_target, _pname, _params); }
glGetSamplerParameterIfv(_sampler: GLuint, _pname: GLenum, _params: Pointer[GLfloat]) { globalGL.GetSamplerParameterIfv(_sampler, _pname, _params); }
glGetSamplerParameterIiv(_sampler: GLuint, _pname: GLenum, _params: Pointer[GLint]) { globalGL.GetSamplerParameterIiv(_sampler, _pname, _params); }
glGetSamplerParameterfv(_sampler: GLuint, _pname: GLenum, _params: Pointer[GLfloat]) { globalGL.GetSamplerParameterfv(_sampler, _pname, _params); }
glGetSamplerParameteriv(_sampler: GLuint, _pname: GLenum, _params: Pointer[GLint]) { globalGL.GetSamplerParameteriv(_sampler, _pname, _params); }
glGetShaderInfoLog(_shader: GLuint, _bufSize: GLsizei, _length: Pointer[GLsizei], _infoLog: GLstring) { globalGL.GetShaderInfoLog(_shader, _bufSize, _length, _infoLog); }
glGetShaderSource(_obj: GLint, _maxLength: GLsizei, _length: Pointer[GLsizei], _source: GLstring) { globalGL.GetShaderSource(_obj, _maxLength, _length, _source); }
glGetShaderiv(_shader: GLuint, _pname: GLenum, _param: Pointer[GLint]) { globalGL.GetShaderiv(_shader, _pname, _param); }
glGetString(_name: GLenum) = globalGL.GetString(_name);
glGetStringi(_value: GLenum, _index: GLuint) = globalGL.GetStringi(_value, _index);
glGetSubroutineIndex(_program: GLuint, _shadertype: GLenum, _name: GLstring) = globalGL.GetSubroutineIndex(_program, _shadertype, _name);
glGetSubroutineUniformLocation(_program: GLuint, _shadertype: GLenum, _name: GLstring) = globalGL.GetSubroutineUniformLocation(_program, _shadertype, _name);
glGetSynciv(_sync: GLsync, _pname: GLenum, _bufSize: GLsizei, _length: Pointer[GLsizei], _values: Pointer[GLint]) { globalGL.GetSynciv(_sync, _pname, _bufSize, _length, _values); }
glGetTexEnvfv(_target: GLenum, _pname: GLenum, _params: Pointer[GLfloat]) { globalGL.GetTexEnvfv(_target, _pname, _params); }
glGetTexEnviv(_target: GLenum, _pname: GLenum, _params: Pointer[GLint]) { globalGL.GetTexEnviv(_target, _pname, _params); }
glGetTexGendv(_coord: GLenum, _pname: GLenum, _params: Pointer[GLdouble]) { globalGL.GetTexGendv(_coord, _pname, _params); }
glGetTexGenfv(_coord: GLenum, _pname: GLenum, _params: Pointer[GLfloat]) { globalGL.GetTexGenfv(_coord, _pname, _params); }
glGetTexGeniv(_coord: GLenum, _pname: GLenum, _params: Pointer[GLint]) { globalGL.GetTexGeniv(_coord, _pname, _params); }
glGetTexImage(_target: GLenum, _level: GLint, _format: GLenum, _type: GLenum, _pixels: Pointer[GLvoid]) { globalGL.GetTexImage(_target, _level, _format, _type, _pixels); }
glGetTexLevelParameterfv(_target: GLenum, _level: GLint, _pname: GLenum, _params: Pointer[GLfloat]) { globalGL.GetTexLevelParameterfv(_target, _level, _pname, _params); }
glGetTexLevelParameteriv(_target: GLenum, _level: GLint, _pname: GLenum, _params: Pointer[GLint]) { globalGL.GetTexLevelParameteriv(_target, _level, _pname, _params); }
glGetTexParameterIiv(_target: GLenum, _pname: GLenum, _params: Pointer[GLint]) { globalGL.GetTexParameterIiv(_target, _pname, _params); }
glGetTexParameterIuiv(_target: GLenum, _pname: GLenum, _params: Pointer[GLuint]) { globalGL.GetTexParameterIuiv(_target, _pname, _params); }
glGetTexParameterfv(_target: GLenum, _pname: GLenum, _params: Pointer[GLfloat]) { globalGL.GetTexParameterfv(_target, _pname, _params); }
glGetTexParameteriv(_target: GLenum, _pname: GLenum, _params: Pointer[GLint]) { globalGL.GetTexParameteriv(_target, _pname, _params); }
glGetTransformFeedbackVarying(_program: GLuint, _index: GLuint, _bufSize: GLsizei, _length: Pointer[GLsizei], _size: Pointer[GLsizei], _type: Pointer[GLenum], _name: GLstring) { globalGL.GetTransformFeedbackVarying(_program, _index, _bufSize, _length, _size, _type, _name); }
glGetUniformBlockIndex(_program: GLuint, _uniformBlockName: GLstring) = globalGL.GetUniformBlockIndex(_program, _uniformBlockName);
glGetUniformIndices(_program: GLuint, _uniformCount: GLsizei, _uniformNames: Pointer[GLstring], _uniformIndices: Pointer[GLuint]) { globalGL.GetUniformIndices(_program, _uniformCount, _uniformNames, _uniformIndices); }
glGetUniformLocation(_programObj: GLint, _name: GLstring) = globalGL.GetUniformLocation(_programObj, _name);
glGetUniformSubroutineuiv(_shadertype: GLenum, _location: GLint, _params: Pointer[GLuint]) { globalGL.GetUniformSubroutineuiv(_shadertype, _location, _params); }
glGetUniformdv(_program: GLuint, _location: GLint, _params: Pointer[GLdouble]) { globalGL.GetUniformdv(_program, _location, _params); }
glGetUniformfv(_program: GLuint, _location: GLint, _params: Pointer[GLfloat]) { globalGL.GetUniformfv(_program, _location, _params); }
glGetUniformiv(_program: GLuint, _location: GLint, _params: Pointer[GLint]) { globalGL.GetUniformiv(_program, _location, _params); }
glGetUniformuiv(_program: GLuint, _location: GLint, _params: Pointer[GLuint]) { globalGL.GetUniformuiv(_program, _location, _params); }
glGetVertexAttribIiv(_index: GLuint, _pname: GLenum, _params: Pointer[GLint]) { globalGL.GetVertexAttribIiv(_index, _pname, _params); }
glGetVertexAttribIuiv(_index: GLuint, _pname: GLenum, _params: Pointer[GLuint]) { globalGL.GetVertexAttribIuiv(_index, _pname, _params); }
glGetVertexAttribPointerv(_index: GLuint, _pname: GLenum, _pointer: Pointer[Pointer[GLvoid]]) { globalGL.GetVertexAttribPointerv(_index, _pname, _pointer); }
glGetVertexAttribdv(_index: GLuint, _pname: GLenum, _params: Pointer[GLdouble]) { globalGL.GetVertexAttribdv(_index, _pname, _params); }
glGetVertexAttribfv(_index: GLuint, _pname: GLenum, _params: Pointer[GLfloat]) { globalGL.GetVertexAttribfv(_index, _pname, _params); }
glGetVertexAttribiv(_index: GLuint, _pname: GLenum, _params: Pointer[GLint]) { globalGL.GetVertexAttribiv(_index, _pname, _params); }
glHint(_target: GLenum, _mode: GLenum) { globalGL.Hint(_target, _mode); }
glIndexMask(_mask: GLuint) { globalGL.IndexMask(_mask); }
glIndexPointer(_type: GLenum, _stride: GLsizei, _ptr: Pointer[GLvoid]) { globalGL.IndexPointer(_type, _stride, _ptr); }
glIndexd(_c: GLdouble) { globalGL.Indexd(_c); }
glIndexdv(_c: Pointer[GLdouble]) { globalGL.Indexdv(_c); }
glIndexf(_c: GLfloat) { globalGL.Indexf(_c); }
glIndexfv(_c: Pointer[GLfloat]) { globalGL.Indexfv(_c); }
glIndexi(_c: GLint) { globalGL.Indexi(_c); }
glIndexiv(_c: Pointer[GLint]) { globalGL.Indexiv(_c); }
glIndexs(_c: GLshort) { globalGL.Indexs(_c); }
glIndexsv(_c: Pointer[GLshort]) { globalGL.Indexsv(_c); }
glIndexub(_c: GLubyte) { globalGL.Indexub(_c); }
glIndexubv(_c: Pointer[GLubyte]) { globalGL.Indexubv(_c); }
glInitNames() { globalGL.InitNames(); }
glInterleavedArrays(_format: GLenum, _stride: GLsizei, _pointer: Pointer[GLvoid]) { globalGL.InterleavedArrays(_format, _stride, _pointer); }
glIsBuffer(_buffer: GLuint) = globalGL.IsBuffer(_buffer);
glIsEnabled(_cap: GLenum) = globalGL.IsEnabled(_cap);
glIsEnabledi(_target: GLenum, _index: GLuint) = globalGL.IsEnabledi(_target, _index);
glIsFramebuffer(_framebuffer: GLuint) = globalGL.IsFramebuffer(_framebuffer);
glIsList(_list: GLuint) = globalGL.IsList(_list);
glIsProgram(_program: GLuint) = globalGL.IsProgram(_program);
glIsQuery(_id: GLuint) = globalGL.IsQuery(_id);
glIsRenderbuffer(_renderbuffer: GLuint) = globalGL.IsRenderbuffer(_renderbuffer);
glIsSampler(_sampler: GLuint) = globalGL.IsSampler(_sampler);
glIsShader(_shader: GLuint) = globalGL.IsShader(_shader);
glIsSync(_sync: GLsync) = globalGL.IsSync(_sync);
glIsTexture(_texture: GLuint) = globalGL.IsTexture(_texture);
glIsTransformFeedback(_id: GLuint) = globalGL.IsTransformFeedback(_id);
glIsVertexArray(_array: GLuint) = globalGL.IsVertexArray(_array);
glLightModelf(_pname: GLenum, _param: GLfloat) { globalGL.LightModelf(_pname, _param); }
glLightModelfv(_pname: GLenum, _params: Pointer[GLfloat]) { globalGL.LightModelfv(_pname, _params); }
glLightModeli(_pname: GLenum, _param: GLint) { globalGL.LightModeli(_pname, _param); }
glLightModeliv(_pname: GLenum, _params: Pointer[GLint]) { globalGL.LightModeliv(_pname, _params); }
glLightf(_light: GLenum, _pname: GLenum, _param: GLfloat) { globalGL.Lightf(_light, _pname, _param); }
glLightfv(_light: GLenum, _pname: GLenum, _params: Pointer[GLfloat]) { globalGL.Lightfv(_light, _pname, _params); }
glLighti(_light: GLenum, _pname: GLenum, _param: GLint) { globalGL.Lighti(_light, _pname, _param); }
glLightiv(_light: GLenum, _pname: GLenum, _params: Pointer[GLint]) { globalGL.Lightiv(_light, _pname, _params); }
glLineStipple(_factor: GLint, _pattern: GLushort) { globalGL.LineStipple(_factor, _pattern); }
glLineWidth(_width: GLfloat) { globalGL.LineWidth(_width); }
glLinkProgram(_program: GLuint) { globalGL.LinkProgram(_program); }
glListBase(_base: GLuint) { globalGL.ListBase(_base); }
glLoadIdentity() { globalGL.LoadIdentity(); }
glLoadMatrixd(_m: Pointer[GLdouble]) { globalGL.LoadMatrixd(_m); }
glLoadMatrixf(_m: Pointer[GLfloat]) { globalGL.LoadMatrixf(_m); }
glLoadName(_name: GLuint) { globalGL.LoadName(_name); }
glLoadTransposeMatrixd(_m: Pointer[GLdouble]) { globalGL.LoadTransposeMatrixd(_m); }
glLoadTransposeMatrixf(_m: Pointer[GLfloat]) { globalGL.LoadTransposeMatrixf(_m); }
glLogicOp(_opcode: GLenum) { globalGL.LogicOp(_opcode); }
glMap1d(_target: GLenum, _u1: GLdouble, _u2: GLdouble, _stride: GLint, _order: GLint, _points: Pointer[GLdouble]) { globalGL.Map1d(_target, _u1, _u2, _stride, _order, _points); }
glMap1f(_target: GLenum, _u1: GLfloat, _u2: GLfloat, _stride: GLint, _order: GLint, _points: Pointer[GLfloat]) { globalGL.Map1f(_target, _u1, _u2, _stride, _order, _points); }
glMap2d(_target: GLenum, _u1: GLdouble, _u2: GLdouble, _ustride: GLint, _uorder: GLint, _v1: GLdouble, _v2: GLdouble, _vstride: GLint, _vorder: GLint, _points: Pointer[GLdouble]) { globalGL.Map2d(_target, _u1, _u2, _ustride, _uorder, _v1, _v2, _vstride, _vorder, _points); }
glMap2f(_target: GLenum, _u1: GLfloat, _u2: GLfloat, _ustride: GLint, _uorder: GLint, _v1: GLfloat, _v2: GLfloat, _vstride: GLint, _vorder: GLint, _points: Pointer[GLfloat]) { globalGL.Map2f(_target, _u1, _u2, _ustride, _uorder, _v1, _v2, _vstride, _vorder, _points); }
glMapBuffer(_target: GLenum, _access: GLenum) = globalGL.MapBuffer(_target, _access);
glMapBufferRange(_target: GLenum, _offset: GLintptr, _length: GLsizeiptr, _access: GLbitfield) = globalGL.MapBufferRange(_target, _offset, _length, _access);
glMapGrid1d(_un: GLint, _u1: GLdouble, _u2: GLdouble) { globalGL.MapGrid1d(_un, _u1, _u2); }
glMapGrid1f(_un: GLint, _u1: GLfloat, _u2: GLfloat) { globalGL.MapGrid1f(_un, _u1, _u2); }
glMapGrid2d(_un: GLint, _u1: GLdouble, _u2: GLdouble, _vn: GLint, _v1: GLdouble, _v2: GLdouble) { globalGL.MapGrid2d(_un, _u1, _u2, _vn, _v1, _v2); }
glMapGrid2f(_un: GLint, _u1: GLfloat, _u2: GLfloat, _vn: GLint, _v1: GLfloat, _v2: GLfloat) { globalGL.MapGrid2f(_un, _u1, _u2, _vn, _v1, _v2); }
glMaterialf(_face: GLenum, _pname: GLenum, _param: GLfloat) { globalGL.Materialf(_face, _pname, _param); }
glMaterialfv(_face: GLenum, _pname: GLenum, _params: Pointer[GLfloat]) { globalGL.Materialfv(_face, _pname, _params); }
glMateriali(_face: GLenum, _pname: GLenum, _param: GLint) { globalGL.Materiali(_face, _pname, _param); }
glMaterialiv(_face: GLenum, _pname: GLenum, _params: Pointer[GLint]) { globalGL.Materialiv(_face, _pname, _params); }
glMatrixMode(_mode: GLenum) { globalGL.MatrixMode(_mode); }
glMultMatrixd(_m: Pointer[GLdouble]) { globalGL.MultMatrixd(_m); }
glMultMatrixf(_m: Pointer[GLfloat]) { globalGL.MultMatrixf(_m); }
glMultTransposeMatrixd(_m: Pointer[GLdouble]) { globalGL.MultTransposeMatrixd(_m); }
glMultTransposeMatrixf(_m: Pointer[GLfloat]) { globalGL.MultTransposeMatrixf(_m); }
glMultiDrawArrays(_mode: GLenum, _first: Pointer[GLint], _count: Pointer[GLsizei], _primcount: GLsizei) { globalGL.MultiDrawArrays(_mode, _first, _count, _primcount); }
glMultiDrawElements(_mode: GLenum, _count: Pointer[GLsizei], _type: GLenum, _indices: Pointer[Pointer[GLvoid]], _primcount: GLsizei) { globalGL.MultiDrawElements(_mode, _count, _type, _indices, _primcount); }
glMultiTexCoord1d(_target: GLenum, _s: GLdouble) { globalGL.MultiTexCoord1d(_target, _s); }
glMultiTexCoord1dv(_target: GLenum, _v: Pointer[GLdouble]) { globalGL.MultiTexCoord1dv(_target, _v); }
glMultiTexCoord1f(_target: GLenum, _s: GLfloat) { globalGL.MultiTexCoord1f(_target, _s); }
glMultiTexCoord1fv(_target: GLenum, _v: Pointer[GLfloat]) { globalGL.MultiTexCoord1fv(_target, _v); }
glMultiTexCoord1i(_target: GLenum, _s: GLint) { globalGL.MultiTexCoord1i(_target, _s); }
glMultiTexCoord1iv(_target: GLenum, _v: Pointer[GLint]) { globalGL.MultiTexCoord1iv(_target, _v); }
glMultiTexCoord1s(_target: GLenum, _s: GLshort) { globalGL.MultiTexCoord1s(_target, _s); }
glMultiTexCoord1sv(_target: GLenum, _v: Pointer[GLshort]) { globalGL.MultiTexCoord1sv(_target, _v); }
glMultiTexCoord2d(_target: GLenum, _s: GLdouble, _t: GLdouble) { globalGL.MultiTexCoord2d(_target, _s, _t); }
glMultiTexCoord2dv(_target: GLenum, _v: Pointer[GLdouble]) { globalGL.MultiTexCoord2dv(_target, _v); }
glMultiTexCoord2f(_target: GLenum, _s: GLfloat, _t: GLfloat) { globalGL.MultiTexCoord2f(_target, _s, _t); }
glMultiTexCoord2fv(_target: GLenum, _v: Pointer[GLfloat]) { globalGL.MultiTexCoord2fv(_target, _v); }
glMultiTexCoord2i(_target: GLenum, _s: GLint, _t: GLint) { globalGL.MultiTexCoord2i(_target, _s, _t); }
glMultiTexCoord2iv(_target: GLenum, _v: Pointer[GLint]) { globalGL.MultiTexCoord2iv(_target, _v); }
glMultiTexCoord2s(_target: GLenum, _s: GLshort, _t: GLshort) { globalGL.MultiTexCoord2s(_target, _s, _t); }
glMultiTexCoord2sv(_target: GLenum, _v: Pointer[GLshort]) { globalGL.MultiTexCoord2sv(_target, _v); }
glMultiTexCoord3d(_target: GLenum, _s: GLdouble, _t: GLdouble, _r: GLdouble) { globalGL.MultiTexCoord3d(_target, _s, _t, _r); }
glMultiTexCoord3dv(_target: GLenum, _v: Pointer[GLdouble]) { globalGL.MultiTexCoord3dv(_target, _v); }
glMultiTexCoord3f(_target: GLenum, _s: GLfloat, _t: GLfloat, _r: GLfloat) { globalGL.MultiTexCoord3f(_target, _s, _t, _r); }
glMultiTexCoord3fv(_target: GLenum, _v: Pointer[GLfloat]) { globalGL.MultiTexCoord3fv(_target, _v); }
glMultiTexCoord3i(_target: GLenum, _s: GLint, _t: GLint, _r: GLint) { globalGL.MultiTexCoord3i(_target, _s, _t, _r); }
glMultiTexCoord3iv(_target: GLenum, _v: Pointer[GLint]) { globalGL.MultiTexCoord3iv(_target, _v); }
glMultiTexCoord3s(_target: GLenum, _s: GLshort, _t: GLshort, _r: GLshort) { globalGL.MultiTexCoord3s(_target, _s, _t, _r); }
glMultiTexCoord3sv(_target: GLenum, _v: Pointer[GLshort]) { globalGL.MultiTexCoord3sv(_target, _v); }
glMultiTexCoord4d(_target: GLenum, _s: GLdouble, _t: GLdouble, _r: GLdouble, _q: GLdouble) { globalGL.MultiTexCoord4d(_target, _s, _t, _r, _q); }
glMultiTexCoord4dv(_target: GLenum, _v: Pointer[GLdouble]) { globalGL.MultiTexCoord4dv(_target, _v); }
glMultiTexCoord4f(_target: GLenum, _s: GLfloat, _t: GLfloat, _r: GLfloat, _q: GLfloat) { globalGL.MultiTexCoord4f(_target, _s, _t, _r, _q); }
glMultiTexCoord4fv(_target: GLenum, _v: Pointer[GLfloat]) { globalGL.MultiTexCoord4fv(_target, _v); }
glMultiTexCoord4i(_target: GLenum, _s: GLint, _t: GLint, _r: GLint, _q: GLint) { globalGL.MultiTexCoord4i(_target, _s, _t, _r, _q); }
glMultiTexCoord4iv(_target: GLenum, _v: Pointer[GLint]) { globalGL.MultiTexCoord4iv(_target, _v); }
glMultiTexCoord4s(_target: GLenum, _s: GLshort, _t: GLshort, _r: GLshort, _q: GLshort) { globalGL.MultiTexCoord4s(_target, _s, _t, _r, _q); }
glMultiTexCoord4sv(_target: GLenum, _v: Pointer[GLshort]) { globalGL.MultiTexCoord4sv(_target, _v); }
glMultiTexCoordP1ui(_texture: GLenum, _type: GLenum, _coords: GLuint) { globalGL.MultiTexCoordP1ui(_texture, _type, _coords); }
glMultiTexCoordP1uiv(_texture: GLenum, _type: GLenum, _coords: Pointer[GLuint]) { globalGL.MultiTexCoordP1uiv(_texture, _type, _coords); }
glMultiTexCoordP2ui(_texture: GLenum, _type: GLenum, _coords: GLuint) { globalGL.MultiTexCoordP2ui(_texture, _type, _coords); }
glMultiTexCoordP2uiv(_texture: GLenum, _type: GLenum, _coords: Pointer[GLuint]) { globalGL.MultiTexCoordP2uiv(_texture, _type, _coords); }
glMultiTexCoordP3ui(_texture: GLenum, _type: GLenum, _coords: GLuint) { globalGL.MultiTexCoordP3ui(_texture, _type, _coords); }
glMultiTexCoordP3uiv(_texture: GLenum, _type: GLenum, _coords: Pointer[GLuint]) { globalGL.MultiTexCoordP3uiv(_texture, _type, _coords); }
glMultiTexCoordP4ui(_texture: GLenum, _type: GLenum, _coords: GLuint) { globalGL.MultiTexCoordP4ui(_texture, _type, _coords); }
glMultiTexCoordP4uiv(_texture: GLenum, _type: GLenum, _coords: Pointer[GLuint]) { globalGL.MultiTexCoordP4uiv(_texture, _type, _coords); }
glNewList(_list: GLuint, _mode: GLenum) { globalGL.NewList(_list, _mode); }
glNormal3b(_nx: GLbyte, _ny: GLbyte, _nz: GLbyte) { globalGL.Normal3b(_nx, _ny, _nz); }
glNormal3bv(_v: Pointer[GLbyte]) { globalGL.Normal3bv(_v); }
glNormal3d(_nx: GLdouble, _ny: GLdouble, _nz: GLdouble) { globalGL.Normal3d(_nx, _ny, _nz); }
glNormal3dv(_v: Pointer[GLdouble]) { globalGL.Normal3dv(_v); }
glNormal3f(_nx: GLfloat, _ny: GLfloat, _nz: GLfloat) { globalGL.Normal3f(_nx, _ny, _nz); }
glNormal3fv(_v: Pointer[GLfloat]) { globalGL.Normal3fv(_v); }
glNormal3i(_nx: GLint, _ny: GLint, _nz: GLint) { globalGL.Normal3i(_nx, _ny, _nz); }
glNormal3iv(_v: Pointer[GLint]) { globalGL.Normal3iv(_v); }
glNormal3s(_nx: GLshort, _ny: GLshort, _nz: GLshort) { globalGL.Normal3s(_nx, _ny, _nz); }
glNormal3sv(_v: Pointer[GLshort]) { globalGL.Normal3sv(_v); }
glNormalP3ui(_type: GLenum, _coords: GLuint) { globalGL.NormalP3ui(_type, _coords); }
glNormalP3uiv(_type: GLenum, _coords: Pointer[GLuint]) { globalGL.NormalP3uiv(_type, _coords); }
glNormalPointer(_type: GLenum, _stride: GLsizei, _ptr: Pointer[GLvoid]) { globalGL.NormalPointer(_type, _stride, _ptr); }
glOrtho(_left: GLdouble, _right: GLdouble, _bottom: GLdouble, _top: GLdouble, _near_val: GLdouble, _far_val: GLdouble) { globalGL.Ortho(_left, _right, _bottom, _top, _near_val, _far_val); }
glPassThrough(_token: GLfloat) { globalGL.PassThrough(_token); }
glPatchParameterfv(_pname: GLenum, _values: Pointer[GLfloat]) { globalGL.PatchParameterfv(_pname, _values); }
glPatchParameteri(_pname: GLenum, _value: GLint) { globalGL.PatchParameteri(_pname, _value); }
glPauseTransformFeedback() { globalGL.PauseTransformFeedback(); }
glPixelMapfv(_map: GLenum, _mapsize: GLsizei, _values: Pointer[GLfloat]) { globalGL.PixelMapfv(_map, _mapsize, _values); }
glPixelMapuiv(_map: GLenum, _mapsize: GLsizei, _values: Pointer[GLuint]) { globalGL.PixelMapuiv(_map, _mapsize, _values); }
glPixelMapusv(_map: GLenum, _mapsize: GLsizei, _values: Pointer[GLushort]) { globalGL.PixelMapusv(_map, _mapsize, _values); }
glPixelStoref(_pname: GLenum, _param: GLfloat) { globalGL.PixelStoref(_pname, _param); }
glPixelStorei(_pname: GLenum, _param: GLint) { globalGL.PixelStorei(_pname, _param); }
glPixelTransferf(_pname: GLenum, _param: GLfloat) { globalGL.PixelTransferf(_pname, _param); }
glPixelTransferi(_pname: GLenum, _param: GLint) { globalGL.PixelTransferi(_pname, _param); }
glPixelZoom(_xfactor: GLfloat, _yfactor: GLfloat) { globalGL.PixelZoom(_xfactor, _yfactor); }
glPointParameterf(_pname: GLenum, _param: GLfloat) { globalGL.PointParameterf(_pname, _param); }
glPointParameterfv(_pname: GLenum, _params: Pointer[GLfloat]) { globalGL.PointParameterfv(_pname, _params); }
glPointParameteri(_pname: GLenum, _param: GLint) { globalGL.PointParameteri(_pname, _param); }
glPointParameteriv(_pname: GLenum, _params: Pointer[GLint]) { globalGL.PointParameteriv(_pname, _params); }
glPointSize(_size: GLfloat) { globalGL.PointSize(_size); }
glPolygonMode(_face: GLenum, _mode: GLenum) { globalGL.PolygonMode(_face, _mode); }
glPolygonOffset(_factor: GLfloat, _units: GLfloat) { globalGL.PolygonOffset(_factor, _units); }
glPolygonStipple(_mask: Pointer[GLubyte]) { globalGL.PolygonStipple(_mask); }
glPopAttrib() { globalGL.PopAttrib(); }
glPopClientAttrib() { globalGL.PopClientAttrib(); }
glPopMatrix() { globalGL.PopMatrix(); }
glPopName() { globalGL.PopName(); }
glPrimitiveRestartIndex(_index: GLuint) { globalGL.PrimitiveRestartIndex(_index); }
glPrioritizeTextures(_n: GLsizei, _textures: Pointer[GLuint], _priorities: Pointer[GLclampf]) { globalGL.PrioritizeTextures(_n, _textures, _priorities); }
glProgramParameteriARB(_program: GLuint, _pname: GLenum, _value: GLint) { globalGL.ProgramParameteriARB(_program, _pname, _value); }
glProgramUniform1d(_program: GLuint, _location: GLint, _x: GLdouble) { globalGL.ProgramUniform1d(_program, _location, _x); }
glProgramUniform1dv(_program: GLuint, _location: GLint, _count: GLsizei, _value: Pointer[GLdouble]) { globalGL.ProgramUniform1dv(_program, _location, _count, _value); }
glProgramUniform2d(_program: GLuint, _location: GLint, _x: GLdouble, _y: GLdouble) { globalGL.ProgramUniform2d(_program, _location, _x, _y); }
glProgramUniform2dv(_program: GLuint, _location: GLint, _count: GLsizei, _value: Pointer[GLdouble]) { globalGL.ProgramUniform2dv(_program, _location, _count, _value); }
glProgramUniform3d(_program: GLuint, _location: GLint, _x: GLdouble, _y: GLdouble, _z: GLdouble) { globalGL.ProgramUniform3d(_program, _location, _x, _y, _z); }
glProgramUniform3dv(_program: GLuint, _location: GLint, _count: GLsizei, _value: Pointer[GLdouble]) { globalGL.ProgramUniform3dv(_program, _location, _count, _value); }
glProgramUniform4d(_program: GLuint, _location: GLint, _x: GLdouble, _y: GLdouble, _z: GLdouble, _w: GLdouble) { globalGL.ProgramUniform4d(_program, _location, _x, _y, _z, _w); }
glProgramUniform4dv(_program: GLuint, _location: GLint, _count: GLsizei, _value: Pointer[GLdouble]) { globalGL.ProgramUniform4dv(_program, _location, _count, _value); }
glProgramUniformMatrix2dv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLdouble]) { globalGL.ProgramUniformMatrix2dv(_program, _location, _count, _transpose, _value); }
glProgramUniformMatrix2x3dv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLdouble]) { globalGL.ProgramUniformMatrix2x3dv(_program, _location, _count, _transpose, _value); }
glProgramUniformMatrix2x4dv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLdouble]) { globalGL.ProgramUniformMatrix2x4dv(_program, _location, _count, _transpose, _value); }
glProgramUniformMatrix3dv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLdouble]) { globalGL.ProgramUniformMatrix3dv(_program, _location, _count, _transpose, _value); }
glProgramUniformMatrix3x2dv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLdouble]) { globalGL.ProgramUniformMatrix3x2dv(_program, _location, _count, _transpose, _value); }
glProgramUniformMatrix3x4dv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLdouble]) { globalGL.ProgramUniformMatrix3x4dv(_program, _location, _count, _transpose, _value); }
glProgramUniformMatrix4dv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLdouble]) { globalGL.ProgramUniformMatrix4dv(_program, _location, _count, _transpose, _value); }
glProgramUniformMatrix4x2dv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLdouble]) { globalGL.ProgramUniformMatrix4x2dv(_program, _location, _count, _transpose, _value); }
glProgramUniformMatrix4x3dv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLdouble]) { globalGL.ProgramUniformMatrix4x3dv(_program, _location, _count, _transpose, _value); }
glProvokingVertex(_mode: GLenum) { globalGL.ProvokingVertex(_mode); }
glPushAttrib(_mask: GLbitfield) { globalGL.PushAttrib(_mask); }
glPushClientAttrib(_mask: GLbitfield) { globalGL.PushClientAttrib(_mask); }
glPushMatrix() { globalGL.PushMatrix(); }
glPushName(_name: GLuint) { globalGL.PushName(_name); }
glQueryCounter(_id: GLuint, _target: GLenum) { globalGL.QueryCounter(_id, _target); }
glRasterPos2d(_x: GLdouble, _y: GLdouble) { globalGL.RasterPos2d(_x, _y); }
glRasterPos2dv(_v: Pointer[GLdouble]) { globalGL.RasterPos2dv(_v); }
glRasterPos2f(_x: GLfloat, _y: GLfloat) { globalGL.RasterPos2f(_x, _y); }
glRasterPos2fv(_v: Pointer[GLfloat]) { globalGL.RasterPos2fv(_v); }
glRasterPos2i(_x: GLint, _y: GLint) { globalGL.RasterPos2i(_x, _y); }
glRasterPos2iv(_v: Pointer[GLint]) { globalGL.RasterPos2iv(_v); }
glRasterPos2s(_x: GLshort, _y: GLshort) { globalGL.RasterPos2s(_x, _y); }
glRasterPos2sv(_v: Pointer[GLshort]) { globalGL.RasterPos2sv(_v); }
glRasterPos3d(_x: GLdouble, _y: GLdouble, _z: GLdouble) { globalGL.RasterPos3d(_x, _y, _z); }
glRasterPos3dv(_v: Pointer[GLdouble]) { globalGL.RasterPos3dv(_v); }
glRasterPos3f(_x: GLfloat, _y: GLfloat, _z: GLfloat) { globalGL.RasterPos3f(_x, _y, _z); }
glRasterPos3fv(_v: Pointer[GLfloat]) { globalGL.RasterPos3fv(_v); }
glRasterPos3i(_x: GLint, _y: GLint, _z: GLint) { globalGL.RasterPos3i(_x, _y, _z); }
glRasterPos3iv(_v: Pointer[GLint]) { globalGL.RasterPos3iv(_v); }
glRasterPos3s(_x: GLshort, _y: GLshort, _z: GLshort) { globalGL.RasterPos3s(_x, _y, _z); }
glRasterPos3sv(_v: Pointer[GLshort]) { globalGL.RasterPos3sv(_v); }
glRasterPos4d(_x: GLdouble, _y: GLdouble, _z: GLdouble, _w: GLdouble) { globalGL.RasterPos4d(_x, _y, _z, _w); }
glRasterPos4dv(_v: Pointer[GLdouble]) { globalGL.RasterPos4dv(_v); }
glRasterPos4f(_x: GLfloat, _y: GLfloat, _z: GLfloat, _w: GLfloat) { globalGL.RasterPos4f(_x, _y, _z, _w); }
glRasterPos4fv(_v: Pointer[GLfloat]) { globalGL.RasterPos4fv(_v); }
glRasterPos4i(_x: GLint, _y: GLint, _z: GLint, _w: GLint) { globalGL.RasterPos4i(_x, _y, _z, _w); }
glRasterPos4iv(_v: Pointer[GLint]) { globalGL.RasterPos4iv(_v); }
glRasterPos4s(_x: GLshort, _y: GLshort, _z: GLshort, _w: GLshort) { globalGL.RasterPos4s(_x, _y, _z, _w); }
glRasterPos4sv(_v: Pointer[GLshort]) { globalGL.RasterPos4sv(_v); }
glReadBuffer(_mode: GLenum) { globalGL.ReadBuffer(_mode); }
glReadPixels(_x: GLint, _y: GLint, _width: GLsizei, _height: GLsizei, _format: GLenum, _type: GLenum, _pixels: Pointer[GLvoid]) { globalGL.ReadPixels(_x, _y, _width, _height, _format, _type, _pixels); }
glRectd(_x1: GLdouble, _y1: GLdouble, _x2: GLdouble, _y2: GLdouble) { globalGL.Rectd(_x1, _y1, _x2, _y2); }
glRectdv(_v1: Pointer[GLdouble], _v2: Pointer[GLdouble]) { globalGL.Rectdv(_v1, _v2); }
glRectf(_x1: GLfloat, _y1: GLfloat, _x2: GLfloat, _y2: GLfloat) { globalGL.Rectf(_x1, _y1, _x2, _y2); }
glRectfv(_v1: Pointer[GLfloat], _v2: Pointer[GLfloat]) { globalGL.Rectfv(_v1, _v2); }
glRecti(_x1: GLint, _y1: GLint, _x2: GLint, _y2: GLint) { globalGL.Recti(_x1, _y1, _x2, _y2); }
glRectiv(_v1: Pointer[GLint], _v2: Pointer[GLint]) { globalGL.Rectiv(_v1, _v2); }
glRects(_x1: GLshort, _y1: GLshort, _x2: GLshort, _y2: GLshort) { globalGL.Rects(_x1, _y1, _x2, _y2); }
glRectsv(_v1: Pointer[GLshort], _v2: Pointer[GLshort]) { globalGL.Rectsv(_v1, _v2); }
glRenderMode(_mode: GLenum) = globalGL.RenderMode(_mode);
glRenderbufferStorage(_target: GLenum, _internalformat: GLenum, _width: GLsizei, _height: GLsizei) { globalGL.RenderbufferStorage(_target, _internalformat, _width, _height); }
glRenderbufferStorageMultisample(_target: GLenum, _samples: GLsizei, _internalformat: GLenum, _width: GLsizei, _height: GLsizei) { globalGL.RenderbufferStorageMultisample(_target, _samples, _internalformat, _width, _height); }
glResumeTransformFeedback() { globalGL.ResumeTransformFeedback(); }
glRotated(_angle: GLdouble, _x: GLdouble, _y: GLdouble, _z: GLdouble) { globalGL.Rotated(_angle, _x, _y, _z); }
glRotatef(_angle: GLfloat, _x: GLfloat, _y: GLfloat, _z: GLfloat) { globalGL.Rotatef(_angle, _x, _y, _z); }
glSampleCoverage(_value: GLclampf, _invert: GLboolean) { globalGL.SampleCoverage(_value, _invert); }
glSampleMaski(_index: GLuint, _mask: GLbitfield) { globalGL.SampleMaski(_index, _mask); }
glSamplerParameterIiv(_sampler: GLuint, _pname: GLenum, _param: Pointer[GLint]) { globalGL.SamplerParameterIiv(_sampler, _pname, _param); }
glSamplerParameterIuiv(_sampler: GLuint, _pname: GLenum, _param: Pointer[GLuint]) { globalGL.SamplerParameterIuiv(_sampler, _pname, _param); }
glSamplerParameterf(_sampler: GLuint, _pname: GLenum, _param: GLfloat) { globalGL.SamplerParameterf(_sampler, _pname, _param); }
glSamplerParameterfv(_sampler: GLuint, _pname: GLenum, _param: Pointer[GLfloat]) { globalGL.SamplerParameterfv(_sampler, _pname, _param); }
glSamplerParameteri(_sampler: GLuint, _pname: GLenum, _param: GLint) { globalGL.SamplerParameteri(_sampler, _pname, _param); }
glSamplerParameteriv(_sampler: GLuint, _pname: GLenum, _param: Pointer[GLint]) { globalGL.SamplerParameteriv(_sampler, _pname, _param); }
glScaled(_x: GLdouble, _y: GLdouble, _z: GLdouble) { globalGL.Scaled(_x, _y, _z); }
glScalef(_x: GLfloat, _y: GLfloat, _z: GLfloat) { globalGL.Scalef(_x, _y, _z); }
glScissor(_x: GLint, _y: GLint, _width: GLsizei, _height: GLsizei) { globalGL.Scissor(_x, _y, _width, _height); }
glSecondaryColor3b(_red: GLbyte, _green: GLbyte, _blue: GLbyte) { globalGL.SecondaryColor3b(_red, _green, _blue); }
glSecondaryColor3bv(_v: Pointer[GLbyte]) { globalGL.SecondaryColor3bv(_v); }
glSecondaryColor3d(_red: GLdouble, _green: GLdouble, _blue: GLdouble) { globalGL.SecondaryColor3d(_red, _green, _blue); }
glSecondaryColor3dv(_v: Pointer[GLdouble]) { globalGL.SecondaryColor3dv(_v); }
glSecondaryColor3f(_red: GLfloat, _green: GLfloat, _blue: GLfloat) { globalGL.SecondaryColor3f(_red, _green, _blue); }
glSecondaryColor3fv(_v: Pointer[GLfloat]) { globalGL.SecondaryColor3fv(_v); }
glSecondaryColor3i(_red: GLint, _green: GLint, _blue: GLint) { globalGL.SecondaryColor3i(_red, _green, _blue); }
glSecondaryColor3iv(_v: Pointer[GLint]) { globalGL.SecondaryColor3iv(_v); }
glSecondaryColor3s(_red: GLshort, _green: GLshort, _blue: GLshort) { globalGL.SecondaryColor3s(_red, _green, _blue); }
glSecondaryColor3sv(_v: Pointer[GLshort]) { globalGL.SecondaryColor3sv(_v); }
glSecondaryColor3ub(_red: GLubyte, _green: GLubyte, _blue: GLubyte) { globalGL.SecondaryColor3ub(_red, _green, _blue); }
glSecondaryColor3ubv(_v: Pointer[GLubyte]) { globalGL.SecondaryColor3ubv(_v); }
glSecondaryColor3ui(_red: GLuint, _green: GLuint, _blue: GLuint) { globalGL.SecondaryColor3ui(_red, _green, _blue); }
glSecondaryColor3uiv(_v: Pointer[GLuint]) { globalGL.SecondaryColor3uiv(_v); }
glSecondaryColor3us(_red: GLushort, _green: GLushort, _blue: GLushort) { globalGL.SecondaryColor3us(_red, _green, _blue); }
glSecondaryColor3usv(_v: Pointer[GLushort]) { globalGL.SecondaryColor3usv(_v); }
glSecondaryColorP3ui(_type: GLenum, _color: GLuint) { globalGL.SecondaryColorP3ui(_type, _color); }
glSecondaryColorP3uiv(_type: GLenum, _color: Pointer[GLuint]) { globalGL.SecondaryColorP3uiv(_type, _color); }
glSecondaryColorPointer(_size: GLint, _type: GLenum, _stride: GLsizei, _pointer: Pointer[GLvoid]) { globalGL.SecondaryColorPointer(_size, _type, _stride, _pointer); }
glSelectBuffer(_size: GLsizei, _buffer: Pointer[GLuint]) { globalGL.SelectBuffer(_size, _buffer); }
glShadeModel(_mode: GLenum) { globalGL.ShadeModel(_mode); }
glShaderSource(_shader: GLuint, _count: GLsizei, _strings: Pointer[GLstring], _lengths: Pointer[GLint]) { globalGL.ShaderSource(_shader, _count, _strings, _lengths); }
glStencilFunc(_func: GLenum, _ref: GLint, _mask: GLuint) { globalGL.StencilFunc(_func, _ref, _mask); }
glStencilFuncSeparate(_frontfunc: GLenum, _backfunc: GLenum, _ref: GLint, _mask: GLuint) { globalGL.StencilFuncSeparate(_frontfunc, _backfunc, _ref, _mask); }
glStencilMask(_mask: GLuint) { globalGL.StencilMask(_mask); }
glStencilMaskSeparate(_face: GLenum, _mask: GLuint) { globalGL.StencilMaskSeparate(_face, _mask); }
glStencilOp(_fail: GLenum, _zfail: GLenum, _zpass: GLenum) { globalGL.StencilOp(_fail, _zfail, _zpass); }
glStencilOpSeparate(_face: GLenum, _sfail: GLenum, _dpfail: GLenum, _dppass: GLenum) { globalGL.StencilOpSeparate(_face, _sfail, _dpfail, _dppass); }
glTexBuffer(_target: GLenum, _internalformat: GLenum, _buffer: GLuint) { globalGL.TexBuffer(_target, _internalformat, _buffer); }
glTexCoord1d(_s: GLdouble) { globalGL.TexCoord1d(_s); }
glTexCoord1dv(_v: Pointer[GLdouble]) { globalGL.TexCoord1dv(_v); }
glTexCoord1f(_s: GLfloat) { globalGL.TexCoord1f(_s); }
glTexCoord1fv(_v: Pointer[GLfloat]) { globalGL.TexCoord1fv(_v); }
glTexCoord1i(_s: GLint) { globalGL.TexCoord1i(_s); }
glTexCoord1iv(_v: Pointer[GLint]) { globalGL.TexCoord1iv(_v); }
glTexCoord1s(_s: GLshort) { globalGL.TexCoord1s(_s); }
glTexCoord1sv(_v: Pointer[GLshort]) { globalGL.TexCoord1sv(_v); }
glTexCoord2d(_s: GLdouble, _t: GLdouble) { globalGL.TexCoord2d(_s, _t); }
glTexCoord2dv(_v: Pointer[GLdouble]) { globalGL.TexCoord2dv(_v); }
glTexCoord2f(_s: GLfloat, _t: GLfloat) { globalGL.TexCoord2f(_s, _t); }
glTexCoord2fv(_v: Pointer[GLfloat]) { globalGL.TexCoord2fv(_v); }
glTexCoord2i(_s: GLint, _t: GLint) { globalGL.TexCoord2i(_s, _t); }
glTexCoord2iv(_v: Pointer[GLint]) { globalGL.TexCoord2iv(_v); }
glTexCoord2s(_s: GLshort, _t: GLshort) { globalGL.TexCoord2s(_s, _t); }
glTexCoord2sv(_v: Pointer[GLshort]) { globalGL.TexCoord2sv(_v); }
glTexCoord3d(_s: GLdouble, _t: GLdouble, _r: GLdouble) { globalGL.TexCoord3d(_s, _t, _r); }
glTexCoord3dv(_v: Pointer[GLdouble]) { globalGL.TexCoord3dv(_v); }
glTexCoord3f(_s: GLfloat, _t: GLfloat, _r: GLfloat) { globalGL.TexCoord3f(_s, _t, _r); }
glTexCoord3fv(_v: Pointer[GLfloat]) { globalGL.TexCoord3fv(_v); }
glTexCoord3i(_s: GLint, _t: GLint, _r: GLint) { globalGL.TexCoord3i(_s, _t, _r); }
glTexCoord3iv(_v: Pointer[GLint]) { globalGL.TexCoord3iv(_v); }
glTexCoord3s(_s: GLshort, _t: GLshort, _r: GLshort) { globalGL.TexCoord3s(_s, _t, _r); }
glTexCoord3sv(_v: Pointer[GLshort]) { globalGL.TexCoord3sv(_v); }
glTexCoord4d(_s: GLdouble, _t: GLdouble, _r: GLdouble, _q: GLdouble) { globalGL.TexCoord4d(_s, _t, _r, _q); }
glTexCoord4dv(_v: Pointer[GLdouble]) { globalGL.TexCoord4dv(_v); }
glTexCoord4f(_s: GLfloat, _t: GLfloat, _r: GLfloat, _q: GLfloat) { globalGL.TexCoord4f(_s, _t, _r, _q); }
glTexCoord4fv(_v: Pointer[GLfloat]) { globalGL.TexCoord4fv(_v); }
glTexCoord4i(_s: GLint, _t: GLint, _r: GLint, _q: GLint) { globalGL.TexCoord4i(_s, _t, _r, _q); }
glTexCoord4iv(_v: Pointer[GLint]) { globalGL.TexCoord4iv(_v); }
glTexCoord4s(_s: GLshort, _t: GLshort, _r: GLshort, _q: GLshort) { globalGL.TexCoord4s(_s, _t, _r, _q); }
glTexCoord4sv(_v: Pointer[GLshort]) { globalGL.TexCoord4sv(_v); }
glTexCoordP1ui(_type: GLenum, _coords: GLuint) { globalGL.TexCoordP1ui(_type, _coords); }
glTexCoordP1uiv(_type: GLenum, _coords: Pointer[GLuint]) { globalGL.TexCoordP1uiv(_type, _coords); }
glTexCoordP2ui(_type: GLenum, _coords: GLuint) { globalGL.TexCoordP2ui(_type, _coords); }
glTexCoordP2uiv(_type: GLenum, _coords: Pointer[GLuint]) { globalGL.TexCoordP2uiv(_type, _coords); }
glTexCoordP3ui(_type: GLenum, _coords: GLuint) { globalGL.TexCoordP3ui(_type, _coords); }
glTexCoordP3uiv(_type: GLenum, _coords: Pointer[GLuint]) { globalGL.TexCoordP3uiv(_type, _coords); }
glTexCoordP4ui(_type: GLenum, _coords: GLuint) { globalGL.TexCoordP4ui(_type, _coords); }
glTexCoordP4uiv(_type: GLenum, _coords: Pointer[GLuint]) { globalGL.TexCoordP4uiv(_type, _coords); }
glTexCoordPointer(_size: GLint, _type: GLenum, _stride: GLsizei, _ptr: Pointer[GLvoid]) { globalGL.TexCoordPointer(_size, _type, _stride, _ptr); }
glTexEnvf(_target: GLenum, _pname: GLenum, _param: GLfloat) { globalGL.TexEnvf(_target, _pname, _param); }
glTexEnvfv(_target: GLenum, _pname: GLenum, _params: Pointer[GLfloat]) { globalGL.TexEnvfv(_target, _pname, _params); }
glTexEnvi(_target: GLenum, _pname: GLenum, _param: GLint) { globalGL.TexEnvi(_target, _pname, _param); }
glTexEnviv(_target: GLenum, _pname: GLenum, _params: Pointer[GLint]) { globalGL.TexEnviv(_target, _pname, _params); }
glTexGend(_coord: GLenum, _pname: GLenum, _param: GLdouble) { globalGL.TexGend(_coord, _pname, _param); }
glTexGendv(_coord: GLenum, _pname: GLenum, _params: Pointer[GLdouble]) { globalGL.TexGendv(_coord, _pname, _params); }
glTexGenf(_coord: GLenum, _pname: GLenum, _param: GLfloat) { globalGL.TexGenf(_coord, _pname, _param); }
glTexGenfv(_coord: GLenum, _pname: GLenum, _params: Pointer[GLfloat]) { globalGL.TexGenfv(_coord, _pname, _params); }
glTexGeni(_coord: GLenum, _pname: GLenum, _param: GLint) { globalGL.TexGeni(_coord, _pname, _param); }
glTexGeniv(_coord: GLenum, _pname: GLenum, _params: Pointer[GLint]) { globalGL.TexGeniv(_coord, _pname, _params); }
glTexImage1D(_target: GLenum, _level: GLint, _internalFormat: GLint, _width: GLsizei, _border: GLint, _format: GLenum, _type: GLenum, _pixels: Pointer[GLvoid]) { globalGL.TexImage1D(_target, _level, _internalFormat, _width, _border, _format, _type, _pixels); }
glTexImage2D(_target: GLenum, _level: GLint, _internalFormat: GLint, _width: GLsizei, _height: GLsizei, _border: GLint, _format: GLenum, _type: GLenum, _pixels: Pointer[GLvoid]) { globalGL.TexImage2D(_target, _level, _internalFormat, _width, _height, _border, _format, _type, _pixels); }
glTexImage2DMultisample(_target: GLenum, _samples: GLsizei, _internalformat: GLint, _width: GLsizei, _height: GLsizei, _fixedsamplelocations: GLboolean) { globalGL.TexImage2DMultisample(_target, _samples, _internalformat, _width, _height, _fixedsamplelocations); }
glTexImage3D(_target: GLenum, _level: GLint, _internalFormat: GLint, _width: GLsizei, _height: GLsizei, _depth: GLsizei, _border: GLint, _format: GLenum, _type: GLenum, _pixels: Pointer[GLvoid]) { globalGL.TexImage3D(_target, _level, _internalFormat, _width, _height, _depth, _border, _format, _type, _pixels); }
glTexImage3DMultisample(_target: GLenum, _samples: GLsizei, _internalformat: GLint, _width: GLsizei, _height: GLsizei, _depth: GLsizei, _fixedsamplelocations: GLboolean) { globalGL.TexImage3DMultisample(_target, _samples, _internalformat, _width, _height, _depth, _fixedsamplelocations); }
glTexParameterIiv(_target: GLenum, _pname: GLenum, _params: Pointer[GLint]) { globalGL.TexParameterIiv(_target, _pname, _params); }
glTexParameterIuiv(_target: GLenum, _pname: GLenum, _params: Pointer[GLuint]) { globalGL.TexParameterIuiv(_target, _pname, _params); }
glTexParameterf(_target: GLenum, _pname: GLenum, _param: GLfloat) { globalGL.TexParameterf(_target, _pname, _param); }
glTexParameterfv(_target: GLenum, _pname: GLenum, _params: Pointer[GLfloat]) { globalGL.TexParameterfv(_target, _pname, _params); }
glTexParameteri(_target: GLenum, _pname: GLenum, _param: GLint) { globalGL.TexParameteri(_target, _pname, _param); }
glTexParameteriv(_target: GLenum, _pname: GLenum, _params: Pointer[GLint]) { globalGL.TexParameteriv(_target, _pname, _params); }
glTexSubImage1D(_target: GLenum, _level: GLint, _xoffset: GLint, _width: GLsizei, _format: GLenum, _type: GLenum, _pixels: Pointer[GLvoid]) { globalGL.TexSubImage1D(_target, _level, _xoffset, _width, _format, _type, _pixels); }
glTexSubImage2D(_target: GLenum, _level: GLint, _xoffset: GLint, _yoffset: GLint, _width: GLsizei, _height: GLsizei, _format: GLenum, _type: GLenum, _pixels: Pointer[GLvoid]) { globalGL.TexSubImage2D(_target, _level, _xoffset, _yoffset, _width, _height, _format, _type, _pixels); }
glTexSubImage3D(_target: GLenum, _level: GLint, _xoffset: GLint, _yoffset: GLint, _zoffset: GLint, _width: GLsizei, _height: GLsizei, _depth: GLsizei, _format: GLenum, _type: GLenum, _pixels: Pointer[GLvoid]) { globalGL.TexSubImage3D(_target, _level, _xoffset, _yoffset, _zoffset, _width, _height, _depth, _format, _type, _pixels); }
glTransformFeedbackVaryings(_program: GLuint, _count: GLsizei, _varyings: Pointer[GLstring], _bufferMode: GLenum) { globalGL.TransformFeedbackVaryings(_program, _count, _varyings, _bufferMode); }
glTranslated(_x: GLdouble, _y: GLdouble, _z: GLdouble) { globalGL.Translated(_x, _y, _z); }
glTranslatef(_x: GLfloat, _y: GLfloat, _z: GLfloat) { globalGL.Translatef(_x, _y, _z); }
glUniform1d(_location: GLint, _x: GLdouble) { globalGL.Uniform1d(_location, _x); }
glUniform1dv(_location: GLint, _count: GLsizei, _value: Pointer[GLdouble]) { globalGL.Uniform1dv(_location, _count, _value); }
glUniform1f(_location: GLint, _v0: GLfloat) { globalGL.Uniform1f(_location, _v0); }
glUniform1fv(_location: GLint, _count: GLsizei, _value: Pointer[GLfloat]) { globalGL.Uniform1fv(_location, _count, _value); }
glUniform1i(_location: GLint, _v0: GLint) { globalGL.Uniform1i(_location, _v0); }
glUniform1iv(_location: GLint, _count: GLsizei, _value: Pointer[GLint]) { globalGL.Uniform1iv(_location, _count, _value); }
glUniform1ui(_location: GLint, _v0: GLuint) { globalGL.Uniform1ui(_location, _v0); }
glUniform1uiv(_location: GLint, _count: GLsizei, _value: Pointer[GLuint]) { globalGL.Uniform1uiv(_location, _count, _value); }
glUniform2d(_location: GLint, _x: GLdouble, _y: GLdouble) { globalGL.Uniform2d(_location, _x, _y); }
glUniform2dv(_location: GLint, _count: GLsizei, _value: Pointer[GLdouble]) { globalGL.Uniform2dv(_location, _count, _value); }
glUniform2f(_location: GLint, _v0: GLfloat, _v1: GLfloat) { globalGL.Uniform2f(_location, _v0, _v1); }
glUniform2fv(_location: GLint, _count: GLsizei, _value: Pointer[GLfloat]) { globalGL.Uniform2fv(_location, _count, _value); }
glUniform2i(_location: GLint, _v0: GLint, _v1: GLint) { globalGL.Uniform2i(_location, _v0, _v1); }
glUniform2iv(_location: GLint, _count: GLsizei, _value: Pointer[GLint]) { globalGL.Uniform2iv(_location, _count, _value); }
glUniform2ui(_location: GLint, _v0: GLuint, _v1: GLuint) { globalGL.Uniform2ui(_location, _v0, _v1); }
glUniform2uiv(_location: GLint, _count: GLsizei, _value: Pointer[GLuint]) { globalGL.Uniform2uiv(_location, _count, _value); }
glUniform3d(_location: GLint, _x: GLdouble, _y: GLdouble, _z: GLdouble) { globalGL.Uniform3d(_location, _x, _y, _z); }
glUniform3dv(_location: GLint, _count: GLsizei, _value: Pointer[GLdouble]) { globalGL.Uniform3dv(_location, _count, _value); }
glUniform3f(_location: GLint, _v0: GLfloat, _v1: GLfloat, _v2: GLfloat) { globalGL.Uniform3f(_location, _v0, _v1, _v2); }
glUniform3fv(_location: GLint, _count: GLsizei, _value: Pointer[GLfloat]) { globalGL.Uniform3fv(_location, _count, _value); }
glUniform3i(_location: GLint, _v0: GLint, _v1: GLint, _v2: GLint) { globalGL.Uniform3i(_location, _v0, _v1, _v2); }
glUniform3iv(_location: GLint, _count: GLsizei, _value: Pointer[GLint]) { globalGL.Uniform3iv(_location, _count, _value); }
glUniform3ui(_location: GLint, _v0: GLuint, _v1: GLuint, _v2: GLuint) { globalGL.Uniform3ui(_location, _v0, _v1, _v2); }
glUniform3uiv(_location: GLint, _count: GLsizei, _value: Pointer[GLuint]) { globalGL.Uniform3uiv(_location, _count, _value); }
glUniform4d(_location: GLint, _x: GLdouble, _y: GLdouble, _z: GLdouble, _w: GLdouble) { globalGL.Uniform4d(_location, _x, _y, _z, _w); }
glUniform4dv(_location: GLint, _count: GLsizei, _value: Pointer[GLdouble]) { globalGL.Uniform4dv(_location, _count, _value); }
glUniform4f(_location: GLint, _v0: GLfloat, _v1: GLfloat, _v2: GLfloat, _v3: GLfloat) { globalGL.Uniform4f(_location, _v0, _v1, _v2, _v3); }
glUniform4fv(_location: GLint, _count: GLsizei, _value: Pointer[GLfloat]) { globalGL.Uniform4fv(_location, _count, _value); }
glUniform4i(_location: GLint, _v0: GLint, _v1: GLint, _v2: GLint, _v3: GLint) { globalGL.Uniform4i(_location, _v0, _v1, _v2, _v3); }
glUniform4iv(_location: GLint, _count: GLsizei, _value: Pointer[GLint]) { globalGL.Uniform4iv(_location, _count, _value); }
glUniform4ui(_location: GLint, _v0: GLuint, _v1: GLuint, _v2: GLuint, _v3: GLuint) { globalGL.Uniform4ui(_location, _v0, _v1, _v2, _v3); }
glUniform4uiv(_location: GLint, _count: GLsizei, _value: Pointer[GLuint]) { globalGL.Uniform4uiv(_location, _count, _value); }
glUniformBlockBinding(_buffer: GLuint, _uniformBlockIndex: GLuint, _uniformBlockBinding: GLuint) { globalGL.UniformBlockBinding(_buffer, _uniformBlockIndex, _uniformBlockBinding); }
glUniformMatrix2dv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLdouble]) { globalGL.UniformMatrix2dv(_location, _count, _transpose, _value); }
glUniformMatrix2fv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLfloat]) { globalGL.UniformMatrix2fv(_location, _count, _transpose, _value); }
glUniformMatrix2x3dv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLdouble]) { globalGL.UniformMatrix2x3dv(_location, _count, _transpose, _value); }
glUniformMatrix2x3fv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLfloat]) { globalGL.UniformMatrix2x3fv(_location, _count, _transpose, _value); }
glUniformMatrix2x4dv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLdouble]) { globalGL.UniformMatrix2x4dv(_location, _count, _transpose, _value); }
glUniformMatrix2x4fv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLfloat]) { globalGL.UniformMatrix2x4fv(_location, _count, _transpose, _value); }
glUniformMatrix3dv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLdouble]) { globalGL.UniformMatrix3dv(_location, _count, _transpose, _value); }
glUniformMatrix3fv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLfloat]) { globalGL.UniformMatrix3fv(_location, _count, _transpose, _value); }
glUniformMatrix3x2dv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLdouble]) { globalGL.UniformMatrix3x2dv(_location, _count, _transpose, _value); }
glUniformMatrix3x2fv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLfloat]) { globalGL.UniformMatrix3x2fv(_location, _count, _transpose, _value); }
glUniformMatrix3x4dv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLdouble]) { globalGL.UniformMatrix3x4dv(_location, _count, _transpose, _value); }
glUniformMatrix3x4fv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLfloat]) { globalGL.UniformMatrix3x4fv(_location, _count, _transpose, _value); }
glUniformMatrix4dv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLdouble]) { globalGL.UniformMatrix4dv(_location, _count, _transpose, _value); }
glUniformMatrix4fv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLfloat]) { globalGL.UniformMatrix4fv(_location, _count, _transpose, _value); }
glUniformMatrix4x2dv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLdouble]) { globalGL.UniformMatrix4x2dv(_location, _count, _transpose, _value); }
glUniformMatrix4x2fv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLfloat]) { globalGL.UniformMatrix4x2fv(_location, _count, _transpose, _value); }
glUniformMatrix4x3dv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLdouble]) { globalGL.UniformMatrix4x3dv(_location, _count, _transpose, _value); }
glUniformMatrix4x3fv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: Pointer[GLfloat]) { globalGL.UniformMatrix4x3fv(_location, _count, _transpose, _value); }
glUniformSubroutinesuiv(_shadertype: GLenum, _count: GLsizei, _indices: Pointer[GLuint]) { globalGL.UniformSubroutinesuiv(_shadertype, _count, _indices); }
glUnmapBuffer(_target: GLenum) = globalGL.UnmapBuffer(_target);
glUseProgram(_program: GLuint) { globalGL.UseProgram(_program); }
glValidateProgram(_program: GLuint) { globalGL.ValidateProgram(_program); }
glVertex2d(_x: GLdouble, _y: GLdouble) { globalGL.Vertex2d(_x, _y); }
glVertex2dv(_v: Pointer[GLdouble]) { globalGL.Vertex2dv(_v); }
glVertex2f(_x: GLfloat, _y: GLfloat) { globalGL.Vertex2f(_x, _y); }
glVertex2fv(_v: Pointer[GLfloat]) { globalGL.Vertex2fv(_v); }
glVertex2i(_x: GLint, _y: GLint) { globalGL.Vertex2i(_x, _y); }
glVertex2iv(_v: Pointer[GLint]) { globalGL.Vertex2iv(_v); }
glVertex2s(_x: GLshort, _y: GLshort) { globalGL.Vertex2s(_x, _y); }
glVertex2sv(_v: Pointer[GLshort]) { globalGL.Vertex2sv(_v); }
glVertex3d(_x: GLdouble, _y: GLdouble, _z: GLdouble) { globalGL.Vertex3d(_x, _y, _z); }
glVertex3dv(_v: Pointer[GLdouble]) { globalGL.Vertex3dv(_v); }
glVertex3f(_x: GLfloat, _y: GLfloat, _z: GLfloat) { globalGL.Vertex3f(_x, _y, _z); }
glVertex3fv(_v: Pointer[GLfloat]) { globalGL.Vertex3fv(_v); }
glVertex3i(_x: GLint, _y: GLint, _z: GLint) { globalGL.Vertex3i(_x, _y, _z); }
glVertex3iv(_v: Pointer[GLint]) { globalGL.Vertex3iv(_v); }
glVertex3s(_x: GLshort, _y: GLshort, _z: GLshort) { globalGL.Vertex3s(_x, _y, _z); }
glVertex3sv(_v: Pointer[GLshort]) { globalGL.Vertex3sv(_v); }
glVertex4d(_x: GLdouble, _y: GLdouble, _z: GLdouble, _w: GLdouble) { globalGL.Vertex4d(_x, _y, _z, _w); }
glVertex4dv(_v: Pointer[GLdouble]) { globalGL.Vertex4dv(_v); }
glVertex4f(_x: GLfloat, _y: GLfloat, _z: GLfloat, _w: GLfloat) { globalGL.Vertex4f(_x, _y, _z, _w); }
glVertex4fv(_v: Pointer[GLfloat]) { globalGL.Vertex4fv(_v); }
glVertex4i(_x: GLint, _y: GLint, _z: GLint, _w: GLint) { globalGL.Vertex4i(_x, _y, _z, _w); }
glVertex4iv(_v: Pointer[GLint]) { globalGL.Vertex4iv(_v); }
glVertex4s(_x: GLshort, _y: GLshort, _z: GLshort, _w: GLshort) { globalGL.Vertex4s(_x, _y, _z, _w); }
glVertex4sv(_v: Pointer[GLshort]) { globalGL.Vertex4sv(_v); }
glVertexAttrib1d(_index: GLuint, _x: GLdouble) { globalGL.VertexAttrib1d(_index, _x); }
glVertexAttrib1dv(_index: GLuint, _v: Pointer[GLdouble]) { globalGL.VertexAttrib1dv(_index, _v); }
glVertexAttrib1f(_index: GLuint, _x: GLfloat) { globalGL.VertexAttrib1f(_index, _x); }
glVertexAttrib1fv(_index: GLuint, _v: Pointer[GLfloat]) { globalGL.VertexAttrib1fv(_index, _v); }
glVertexAttrib1s(_index: GLuint, _x: GLshort) { globalGL.VertexAttrib1s(_index, _x); }
glVertexAttrib1sv(_index: GLuint, _v: Pointer[GLshort]) { globalGL.VertexAttrib1sv(_index, _v); }
glVertexAttrib2d(_index: GLuint, _x: GLdouble, _y: GLdouble) { globalGL.VertexAttrib2d(_index, _x, _y); }
glVertexAttrib2dv(_index: GLuint, _v: Pointer[GLdouble]) { globalGL.VertexAttrib2dv(_index, _v); }
glVertexAttrib2f(_index: GLuint, _x: GLfloat, _y: GLfloat) { globalGL.VertexAttrib2f(_index, _x, _y); }
glVertexAttrib2fv(_index: GLuint, _v: Pointer[GLfloat]) { globalGL.VertexAttrib2fv(_index, _v); }
glVertexAttrib2s(_index: GLuint, _x: GLshort, _y: GLshort) { globalGL.VertexAttrib2s(_index, _x, _y); }
glVertexAttrib2sv(_index: GLuint, _v: Pointer[GLshort]) { globalGL.VertexAttrib2sv(_index, _v); }
glVertexAttrib3d(_index: GLuint, _x: GLdouble, _y: GLdouble, _z: GLdouble) { globalGL.VertexAttrib3d(_index, _x, _y, _z); }
glVertexAttrib3dv(_index: GLuint, _v: Pointer[GLdouble]) { globalGL.VertexAttrib3dv(_index, _v); }
glVertexAttrib3f(_index: GLuint, _x: GLfloat, _y: GLfloat, _z: GLfloat) { globalGL.VertexAttrib3f(_index, _x, _y, _z); }
glVertexAttrib3fv(_index: GLuint, _v: Pointer[GLfloat]) { globalGL.VertexAttrib3fv(_index, _v); }
glVertexAttrib3s(_index: GLuint, _x: GLshort, _y: GLshort, _z: GLshort) { globalGL.VertexAttrib3s(_index, _x, _y, _z); }
glVertexAttrib3sv(_index: GLuint, _v: Pointer[GLshort]) { globalGL.VertexAttrib3sv(_index, _v); }
glVertexAttrib4Nbv(_index: GLuint, _v: Pointer[GLbyte]) { globalGL.VertexAttrib4Nbv(_index, _v); }
glVertexAttrib4Niv(_index: GLuint, _v: Pointer[GLint]) { globalGL.VertexAttrib4Niv(_index, _v); }
glVertexAttrib4Nsv(_index: GLuint, _v: Pointer[GLshort]) { globalGL.VertexAttrib4Nsv(_index, _v); }
glVertexAttrib4Nub(_index: GLuint, _x: GLubyte, _y: GLubyte, _z: GLubyte, _w: GLubyte) { globalGL.VertexAttrib4Nub(_index, _x, _y, _z, _w); }
glVertexAttrib4Nubv(_index: GLuint, _v: Pointer[GLubyte]) { globalGL.VertexAttrib4Nubv(_index, _v); }
glVertexAttrib4Nuiv(_index: GLuint, _v: Pointer[GLuint]) { globalGL.VertexAttrib4Nuiv(_index, _v); }
glVertexAttrib4Nusv(_index: GLuint, _v: Pointer[GLushort]) { globalGL.VertexAttrib4Nusv(_index, _v); }
glVertexAttrib4bv(_index: GLuint, _v: Pointer[GLbyte]) { globalGL.VertexAttrib4bv(_index, _v); }
glVertexAttrib4d(_index: GLuint, _x: GLdouble, _y: GLdouble, _z: GLdouble, _w: GLdouble) { globalGL.VertexAttrib4d(_index, _x, _y, _z, _w); }
glVertexAttrib4dv(_index: GLuint, _v: Pointer[GLdouble]) { globalGL.VertexAttrib4dv(_index, _v); }
glVertexAttrib4f(_index: GLuint, _x: GLfloat, _y: GLfloat, _z: GLfloat, _w: GLfloat) { globalGL.VertexAttrib4f(_index, _x, _y, _z, _w); }
glVertexAttrib4fv(_index: GLuint, _v: Pointer[GLfloat]) { globalGL.VertexAttrib4fv(_index, _v); }
glVertexAttrib4iv(_index: GLuint, _v: Pointer[GLint]) { globalGL.VertexAttrib4iv(_index, _v); }
glVertexAttrib4s(_index: GLuint, _x: GLshort, _y: GLshort, _z: GLshort, _w: GLshort) { globalGL.VertexAttrib4s(_index, _x, _y, _z, _w); }
glVertexAttrib4sv(_index: GLuint, _v: Pointer[GLshort]) { globalGL.VertexAttrib4sv(_index, _v); }
glVertexAttrib4ubv(_index: GLuint, _v: Pointer[GLubyte]) { globalGL.VertexAttrib4ubv(_index, _v); }
glVertexAttrib4uiv(_index: GLuint, _v: Pointer[GLuint]) { globalGL.VertexAttrib4uiv(_index, _v); }
glVertexAttrib4usv(_index: GLuint, _v: Pointer[GLushort]) { globalGL.VertexAttrib4usv(_index, _v); }
glVertexAttribIPointer(_index: GLuint, _size: GLint, _type: GLenum, _stride: GLsizei, _pointer: Pointer[GLvoid]) { globalGL.VertexAttribIPointer(_index, _size, _type, _stride, _pointer); }
glVertexAttribP1ui(_index: GLuint, _type: GLenum, _normalized: GLboolean, _value: GLuint) { globalGL.VertexAttribP1ui(_index, _type, _normalized, _value); }
glVertexAttribP1uiv(_index: GLuint, _type: GLenum, _normalized: GLboolean, _value: Pointer[GLuint]) { globalGL.VertexAttribP1uiv(_index, _type, _normalized, _value); }
glVertexAttribP2ui(_index: GLuint, _type: GLenum, _normalized: GLboolean, _value: GLuint) { globalGL.VertexAttribP2ui(_index, _type, _normalized, _value); }
glVertexAttribP2uiv(_index: GLuint, _type: GLenum, _normalized: GLboolean, _value: Pointer[GLuint]) { globalGL.VertexAttribP2uiv(_index, _type, _normalized, _value); }
glVertexAttribP3ui(_index: GLuint, _type: GLenum, _normalized: GLboolean, _value: GLuint) { globalGL.VertexAttribP3ui(_index, _type, _normalized, _value); }
glVertexAttribP3uiv(_index: GLuint, _type: GLenum, _normalized: GLboolean, _value: Pointer[GLuint]) { globalGL.VertexAttribP3uiv(_index, _type, _normalized, _value); }
glVertexAttribP4ui(_index: GLuint, _type: GLenum, _normalized: GLboolean, _value: GLuint) { globalGL.VertexAttribP4ui(_index, _type, _normalized, _value); }
glVertexAttribP4uiv(_index: GLuint, _type: GLenum, _normalized: GLboolean, _value: Pointer[GLuint]) { globalGL.VertexAttribP4uiv(_index, _type, _normalized, _value); }
glVertexAttribPointer(_index: GLuint, _size: GLint, _type: GLenum, _normalized: GLboolean, _stride: GLsizei, _pointer: Pointer[GLvoid]) { globalGL.VertexAttribPointer(_index, _size, _type, _normalized, _stride, _pointer); }
glVertexP2ui(_type: GLenum, _value: GLuint) { globalGL.VertexP2ui(_type, _value); }
glVertexP2uiv(_type: GLenum, _value: Pointer[GLuint]) { globalGL.VertexP2uiv(_type, _value); }
glVertexP3ui(_type: GLenum, _value: GLuint) { globalGL.VertexP3ui(_type, _value); }
glVertexP3uiv(_type: GLenum, _value: Pointer[GLuint]) { globalGL.VertexP3uiv(_type, _value); }
glVertexP4ui(_type: GLenum, _value: GLuint) { globalGL.VertexP4ui(_type, _value); }
glVertexP4uiv(_type: GLenum, _value: Pointer[GLuint]) { globalGL.VertexP4uiv(_type, _value); }
glVertexPointer(_size: GLint, _type: GLenum, _stride: GLsizei, _ptr: Pointer[GLvoid]) { globalGL.VertexPointer(_size, _type, _stride, _ptr); }
glViewport(_x: GLint, _y: GLint, _width: GLsizei, _height: GLsizei) { globalGL.Viewport(_x, _y, _width, _height); }
glWaitSync(_sync: GLsync, _flags: GLbitfield, _timeout: GLuint64) { globalGL.WaitSync(_sync, _flags, _timeout); }
glWindowPos2d(_x: GLdouble, _y: GLdouble) { globalGL.WindowPos2d(_x, _y); }
glWindowPos2dv(_p: Pointer[GLdouble]) { globalGL.WindowPos2dv(_p); }
glWindowPos2f(_x: GLfloat, _y: GLfloat) { globalGL.WindowPos2f(_x, _y); }
glWindowPos2fv(_p: Pointer[GLfloat]) { globalGL.WindowPos2fv(_p); }
glWindowPos2i(_x: GLint, _y: GLint) { globalGL.WindowPos2i(_x, _y); }
glWindowPos2iv(_p: Pointer[GLint]) { globalGL.WindowPos2iv(_p); }
glWindowPos2s(_x: GLshort, _y: GLshort) { globalGL.WindowPos2s(_x, _y); }
glWindowPos2sv(_p: Pointer[GLshort]) { globalGL.WindowPos2sv(_p); }
glWindowPos3d(_x: GLdouble, _y: GLdouble, _z: GLdouble) { globalGL.WindowPos3d(_x, _y, _z); }
glWindowPos3dv(_p: Pointer[GLdouble]) { globalGL.WindowPos3dv(_p); }
glWindowPos3f(_x: GLfloat, _y: GLfloat, _z: GLfloat) { globalGL.WindowPos3f(_x, _y, _z); }
glWindowPos3fv(_p: Pointer[GLfloat]) { globalGL.WindowPos3fv(_p); }
glWindowPos3i(_x: GLint, _y: GLint, _z: GLint) { globalGL.WindowPos3i(_x, _y, _z); }
glWindowPos3iv(_p: Pointer[GLint]) { globalGL.WindowPos3iv(_p); }
glWindowPos3s(_x: GLshort, _y: GLshort, _z: GLshort) { globalGL.WindowPos3s(_x, _y, _z); }
glWindowPos3sv(_p: Pointer[GLshort]) { globalGL.WindowPos3sv(_p); }

