|  | #pragma once | 
        
          |  | #include <Windows.h> | 
        
          |  | #include <winternl.h> | 
        
          |  |  | 
        
          |  | namespace msangle | 
        
          |  | { | 
        
          |  | PVOID _msangle_proc[161]; | 
        
          |  |  | 
        
          |  | BOOL msangle_init() | 
        
          |  | { | 
        
          |  | // TEB* -> PEB* -> BitField (Reserved2: 0x3) -> IsPackagedProcess (5th bit) = 1 | 
        
          |  | NtCurrentTeb()->ProcessEnvironmentBlock->Reserved2[0] |= (1 << 4); | 
        
          |  |  | 
        
          |  | // Load module and map its exports | 
        
          |  | HINSTANCE _msangle_module = LoadLibraryA("edgeangle.dll"); | 
        
          |  | if (_msangle_module == NULL) return FALSE; | 
        
          |  | for (int i = 0; i <= 160; i++) _msangle_proc[i] = GetProcAddress(_msangle_module, MAKEINTRESOURCEA(100 + i)); | 
        
          |  | return _msangle_module != NULL; | 
        
          |  | } | 
        
          |  |  | 
        
          |  | // auto loading (optional) | 
        
          |  | auto _msangle_loaded = msangle_init(); | 
        
          |  |  | 
        
          |  | // type definitions (optional) | 
        
          |  |  | 
        
          |  | typedef unsigned int GLenum; | 
        
          |  | typedef unsigned int GLuint; | 
        
          |  | typedef int GLint; | 
        
          |  | typedef char GLchar; | 
        
          |  | typedef float GLfloat; | 
        
          |  | typedef size_t GLsizeiptr; | 
        
          |  | typedef intptr_t GLintptr; | 
        
          |  | typedef unsigned int GLbitfield; | 
        
          |  | typedef int GLint; | 
        
          |  | typedef unsigned char GLboolean; | 
        
          |  | typedef int GLsizei; | 
        
          |  | typedef byte GLubyte; | 
        
          |  | typedef unsigned int EGLBoolean; | 
        
          |  | typedef void* EGLDisplay; | 
        
          |  | typedef void* EGLConfig; | 
        
          |  | typedef void* EGLSurface; | 
        
          |  | typedef void* EGLContext; | 
        
          |  | typedef void* EGLDeviceEXT; | 
        
          |  | typedef int EGLint; | 
        
          |  | typedef unsigned int EGLenum; | 
        
          |  | typedef void* EGLClientBuffer; | 
        
          |  | typedef intptr_t EGLAttrib; | 
        
          |  | typedef void (*DEBUGPROC)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, const void* userParam); | 
        
          |  |  | 
        
          |  | // glue methods | 
        
          |  |  | 
        
          |  | EGLBoolean eglBindAPI(EGLenum api) { return ((decltype(eglBindAPI)*)_msangle_proc[0])(api); } | 
        
          |  | EGLBoolean eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) { return ((decltype(eglBindTexImage)*)_msangle_proc[1])(dpy, surface, buffer); } | 
        
          |  | EGLBoolean eglChooseConfig(EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, EGLint config_size, EGLint* num_config) { return ((decltype(eglChooseConfig)*)_msangle_proc[2])(dpy, attrib_list, configs, config_size, num_config); } | 
        
          |  | EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint* attrib_list) { return ((decltype(eglCreateContext)*)_msangle_proc[3])(dpy, config, share_context, attrib_list); } | 
        
          |  | EGLDeviceEXT eglCreateDeviceANGLE(EGLint device_type, void* native_device, const EGLAttrib* attrib_list) { return ((decltype(eglCreateDeviceANGLE)*)_msangle_proc[4])(device_type, native_device, attrib_list); } | 
        
          |  | EGLSurface eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint* attrib_list) { return ((decltype(eglCreatePbufferFromClientBuffer)*)_msangle_proc[5])(dpy, buftype, buffer, config, attrib_list); } | 
        
          |  | EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx) { return ((decltype(eglDestroyContext)*)_msangle_proc[6])(dpy, ctx); } | 
        
          |  | EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface) { return ((decltype(eglDestroySurface)*)_msangle_proc[7])(dpy, surface); } | 
        
          |  | EGLint eglGetError(void) { return ((decltype(eglGetError)*)_msangle_proc[8])(); } | 
        
          |  | EGLDisplay eglGetPlatformDisplayEXT(EGLenum platform, void* native_display, const EGLint* attrib_list) { return ((decltype(eglGetPlatformDisplayEXT)*)_msangle_proc[9])(platform, native_display, attrib_list); } | 
        
          |  | EGLBoolean eglInitialize(EGLDisplay dpy, EGLint* major, EGLint* minor) { return ((decltype(eglInitialize)*)_msangle_proc[10])(dpy, major, minor); } | 
        
          |  | EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) { return ((decltype(eglMakeCurrent)*)_msangle_proc[11])(dpy, draw, read, ctx); } | 
        
          |  | EGLBoolean eglReleaseDeviceANGLE(EGLDeviceEXT device) { return ((decltype(eglReleaseDeviceANGLE)*)_msangle_proc[12])(device); } | 
        
          |  | EGLBoolean eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) { return ((decltype(eglReleaseTexImage)*)_msangle_proc[13])(dpy, surface, buffer); } | 
        
          |  | EGLBoolean eglTerminate(EGLDisplay dpy) { return ((decltype(eglTerminate)*)_msangle_proc[14])(dpy); } | 
        
          |  |  | 
        
          |  | void glActiveTexture(GLenum texture) { ((decltype(glActiveTexture)*)_msangle_proc[15])(texture); } | 
        
          |  | void glAttachShader(GLuint program, GLuint shader) { ((decltype(glAttachShader)*)_msangle_proc[16])(program, shader); } | 
        
          |  | void glBindAttribLocation(GLuint program, GLuint index, const GLchar* name) { ((decltype(glBindAttribLocation)*)_msangle_proc[17])(program, index, name); } | 
        
          |  | void glBindBuffer(GLenum target, GLuint buffer) { ((decltype(glBindBuffer)*)_msangle_proc[18])(target, buffer); } | 
        
          |  | void glBindFramebuffer(GLenum target, GLuint framebuffer) { ((decltype(glBindFramebuffer)*)_msangle_proc[19])(target, framebuffer); } | 
        
          |  | void glBindRenderbuffer(GLenum target, GLuint renderbuffer) { ((decltype(glBindRenderbuffer)*)_msangle_proc[20])(target, renderbuffer); } | 
        
          |  | void glBindTexture(GLenum target, GLuint texture) { ((decltype(glBindTexture)*)_msangle_proc[21])(target, texture); } | 
        
          |  | void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { ((decltype(glBlendColor)*)_msangle_proc[22])(red, green, blue, alpha); } | 
        
          |  | void glBlendEquation(GLenum mode) { ((decltype(glBlendEquation)*)_msangle_proc[23])(mode); } | 
        
          |  | void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) { ((decltype(glBlendEquationSeparate)*)_msangle_proc[24])(modeRGB, modeAlpha); } | 
        
          |  | void glBlendFunc(GLenum sfactor, GLenum dfactor) { ((decltype(glBlendFunc)*)_msangle_proc[25])(sfactor, dfactor); } | 
        
          |  | void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) { ((decltype(glBlendFuncSeparate)*)_msangle_proc[26])(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); } | 
        
          |  | void glBufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage) { ((decltype(glBufferData)*)_msangle_proc[27])(target, size, data, usage); } | 
        
          |  | void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) { ((decltype(glBufferSubData)*)_msangle_proc[28])(target, offset, size, data); } | 
        
          |  | GLenum glCheckFramebufferStatus(GLenum target) { return ((decltype(glCheckFramebufferStatus)*)_msangle_proc[29])(target); } | 
        
          |  | void glClear(GLbitfield mask) { ((decltype(glClear)*)_msangle_proc[30])(mask); } | 
        
          |  | void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { ((decltype(glClearColor)*)_msangle_proc[31])(red, green, blue, alpha); } | 
        
          |  | void glClearDepthf(GLfloat d) { ((decltype(glClearDepthf)*)_msangle_proc[32])(d); } | 
        
          |  | void glClearStencil(GLint s) { ((decltype(glClearStencil)*)_msangle_proc[33])(s); } | 
        
          |  | void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) { ((decltype(glColorMask)*)_msangle_proc[34])(red, green, blue, alpha); } | 
        
          |  | void glCompileShader(GLuint shader) { ((decltype(glCompileShader)*)_msangle_proc[35])(shader); } | 
        
          |  | void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data) { ((decltype(glCompressedTexImage2D)*)_msangle_proc[36])(target, level, internalformat, width, height, border, imageSize, data); } | 
        
          |  | void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data) { ((decltype(glCompressedTexSubImage2D)*)_msangle_proc[37])(target, level, xoffset, yoffset, width, height, format, imageSize, data); } | 
        
          |  | void glCopySubTextureCHROMIUM(GLenum source_id, GLenum dest_id, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height, GLboolean unpack_flip_y, GLboolean unpack_premultiply_alpha, GLboolean unpack_unmultiply_alpha) { return ((decltype(glCopySubTextureCHROMIUM)*)_msangle_proc[38])(source_id, dest_id, xoffset, yoffset, x, y, width, height, unpack_flip_y, unpack_premultiply_alpha, unpack_unmultiply_alpha); } | 
        
          |  | void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { ((decltype(glCopyTexImage2D)*)_msangle_proc[39])(target, level, internalformat, x, y, width, height, border); } | 
        
          |  | void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { ((decltype(glCopyTexSubImage2D)*)_msangle_proc[40])(target, level, xoffset, yoffset, x, y, width, height); } | 
        
          |  | void glCopyTextureCHROMIUM(GLenum source_id, GLenum dest_id, GLint internal_format, GLenum dest_type, GLboolean unpack_flip_y, GLboolean unpack_premultiply_alpha, GLboolean unpack_unmultiply_alpha) { return ((decltype(glCopyTextureCHROMIUM)*)_msangle_proc[41])(source_id, dest_id, internal_format, dest_type, unpack_flip_y, unpack_premultiply_alpha, unpack_unmultiply_alpha); } | 
        
          |  | GLuint glCreateProgram(void) { return ((decltype(glCreateProgram)*)_msangle_proc[42])(); } | 
        
          |  | GLuint glCreateShader(GLenum type) { return ((decltype(glCreateShader)*)_msangle_proc[43])(type); } | 
        
          |  | void glCullFace(GLenum mode) { ((decltype(glCullFace)*)_msangle_proc[44])(mode); } | 
        
          |  | void glDebugMessageCallback(DEBUGPROC callback, const void* userParam) { return ((decltype(glDebugMessageCallback)*)_msangle_proc[45])(callback, userParam); } | 
        
          |  | void glDeleteBuffers(GLsizei n, const GLuint* buffers) { ((decltype(glDeleteBuffers)*)_msangle_proc[46])(n, buffers); } | 
        
          |  | void glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers) { ((decltype(glDeleteFramebuffers)*)_msangle_proc[47])(n, framebuffers); } | 
        
          |  | void glDeleteProgram(GLuint program) { ((decltype(glDeleteProgram)*)_msangle_proc[48])(program); } | 
        
          |  | void glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) { ((decltype(glDeleteRenderbuffers)*)_msangle_proc[49])(n, renderbuffers); } | 
        
          |  | void glDeleteShader(GLuint shader) { ((decltype(glDeleteShader)*)_msangle_proc[50])(shader); } | 
        
          |  | void glDeleteTextures(GLsizei n, const GLuint* textures) { ((decltype(glDeleteTextures)*)_msangle_proc[51])(n, textures); } | 
        
          |  | void glDepthFunc(GLenum func) { ((decltype(glDepthFunc)*)_msangle_proc[52])(func); } | 
        
          |  | void glDepthMask(GLboolean flag) { ((decltype(glDepthMask)*)_msangle_proc[53])(flag); } | 
        
          |  | void glDepthRangef(GLfloat n, GLfloat f) { ((decltype(glDepthRangef)*)_msangle_proc[54])(n, f); } | 
        
          |  | void glDetachShader(GLuint program, GLuint shader) { ((decltype(glDetachShader)*)_msangle_proc[55])(program, shader); } | 
        
          |  | void glDisable(GLenum cap) { ((decltype(glDisable)*)_msangle_proc[56])(cap); } | 
        
          |  | void glDisableVertexAttribArray(GLuint index) { ((decltype(glDisableVertexAttribArray)*)_msangle_proc[57])(index); } | 
        
          |  | void glDrawArrays(GLenum mode, GLint first, GLsizei count) { ((decltype(glDrawArrays)*)_msangle_proc[58])(mode, first, count); } | 
        
          |  | void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount) { ((decltype(glDrawArraysInstanced)*)_msangle_proc[59])(mode, first, count, instancecount); } | 
        
          |  | void glDrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices) { ((decltype(glDrawElements)*)_msangle_proc[60])(mode, count, type, indices); } | 
        
          |  | void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instancecount) { ((decltype(glDrawElementsInstanced)*)_msangle_proc[61])(mode, count, type, indices, instancecount); } | 
        
          |  | void glEnable(GLenum cap) { ((decltype(glEnable)*)_msangle_proc[62])(cap); } | 
        
          |  | void glEnableVertexAttribArray(GLuint index) { ((decltype(glEnableVertexAttribArray)*)_msangle_proc[63])(index); } | 
        
          |  | void glFinish(void) { ((decltype(glFinish)*)_msangle_proc[64])(); } | 
        
          |  | void glFlush(void) { ((decltype(glFlush)*)_msangle_proc[65])(); } | 
        
          |  | void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) { ((decltype(glFramebufferRenderbuffer)*)_msangle_proc[66])(target, attachment, renderbuffertarget, renderbuffer); } | 
        
          |  | void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { ((decltype(glFramebufferTexture2D)*)_msangle_proc[67])(target, attachment, textarget, texture, level); } | 
        
          |  | void glFrontFace(GLenum mode) { ((decltype(glFrontFace)*)_msangle_proc[68])(mode); } | 
        
          |  | void glGenBuffers(GLsizei n, GLuint* buffers) { ((decltype(glGenBuffers)*)_msangle_proc[69])(n, buffers); } | 
        
          |  | void glGenerateMipmap(GLenum target) { ((decltype(glGenerateMipmap)*)_msangle_proc[70])(target); } | 
        
          |  | void glGenFramebuffers(GLsizei n, GLuint* framebuffers) { ((decltype(glGenFramebuffers)*)_msangle_proc[71])(n, framebuffers); } | 
        
          |  | void glGenRenderbuffers(GLsizei n, GLuint* renderbuffers) { ((decltype(glGenRenderbuffers)*)_msangle_proc[72])(n, renderbuffers); } | 
        
          |  | void glGenTextures(GLsizei n, GLuint* textures) { ((decltype(glGenTextures)*)_msangle_proc[73])(n, textures); } | 
        
          |  | void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* type, GLchar* name) { ((decltype(glGetActiveAttrib)*)_msangle_proc[74])(program, index, bufSize, length, size, type, name); } | 
        
          |  | void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* type, GLchar* name) { ((decltype(glGetActiveUniform)*)_msangle_proc[75])(program, index, bufSize, length, size, type, name); } | 
        
          |  | GLint glGetAttribLocation(GLuint program, const GLchar* name) { return ((decltype(glGetAttribLocation)*)_msangle_proc[76])(program, name); } | 
        
          |  | void glGetBooleanv(GLenum pname, GLboolean* data) { ((decltype(glGetBooleanv)*)_msangle_proc[77])(pname, data); } | 
        
          |  | void glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params) { ((decltype(glGetBufferParameteriv)*)_msangle_proc[78])(target, pname, params); } | 
        
          |  | GLenum glGetError(void) { return ((decltype(glGetError)*)_msangle_proc[79])(); } | 
        
          |  | void glGetFloatv(GLenum pname, GLfloat* data) { ((decltype(glGetFloatv)*)_msangle_proc[80])(pname, data); } | 
        
          |  | void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) { ((decltype(glGetFramebufferAttachmentParameteriv)*)_msangle_proc[81])(target, attachment, pname, params); } | 
        
          |  | void glGetIntegerv(GLenum pname, GLint* data) { ((decltype(glGetIntegerv)*)_msangle_proc[82])(pname, data); } | 
        
          |  | void glGetUniformfv(GLuint program, GLint location, GLfloat* params) { ((decltype(glGetUniformfv)*)_msangle_proc[83])(program, location, params); } | 
        
          |  | void glGetUniformiv(GLuint program, GLint location, GLint* params) { ((decltype(glGetUniformiv)*)_msangle_proc[84])(program, location, params); } | 
        
          |  | void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog) { ((decltype(glGetProgramInfoLog)*)_msangle_proc[85])(program, bufSize, length, infoLog); } | 
        
          |  | void glGetProgramiv(GLuint program, GLenum pname, GLint* params) { ((decltype(glGetProgramiv)*)_msangle_proc[86])(program, pname, params); } | 
        
          |  | void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) { ((decltype(glGetRenderbufferParameteriv)*)_msangle_proc[87])(target, pname, params); } | 
        
          |  | void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog) { ((decltype(glGetShaderInfoLog)*)_msangle_proc[88])(shader, bufSize, length, infoLog); } | 
        
          |  | void glGetShaderiv(GLuint shader, GLenum pname, GLint* params) { ((decltype(glGetShaderiv)*)_msangle_proc[89])(shader, pname, params); } | 
        
          |  | void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) { ((decltype(glGetShaderPrecisionFormat)*)_msangle_proc[90])(shadertype, precisiontype, range, precision); } | 
        
          |  | void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source) { ((decltype(glGetShaderSource)*)_msangle_proc[91])(shader, bufSize, length, source); } | 
        
          |  | const GLubyte* glGetString(GLenum name) { return ((decltype(glGetString)*)_msangle_proc[92])(name); } | 
        
          |  | void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) { ((decltype(glGetTexParameterfv)*)_msangle_proc[93])(target, pname, params); } | 
        
          |  | void glGetTexParameteriv(GLenum target, GLenum pname, GLint* params) { ((decltype(glGetTexParameteriv)*)_msangle_proc[94])(target, pname, params); } | 
        
          |  | GLint glGetUniformLocation(GLuint program, const GLchar* name) { return ((decltype(glGetUniformLocation)*)_msangle_proc[95])(program, name); } | 
        
          |  | void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) { ((decltype(glGetVertexAttribfv)*)_msangle_proc[96])(index, pname, params); } | 
        
          |  | void glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params) { ((decltype(glGetVertexAttribiv)*)_msangle_proc[97])(index, pname, params); } | 
        
          |  | void glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) { ((decltype(glGetVertexAttribPointerv)*)_msangle_proc[98])(index, pname, pointer); } | 
        
          |  | void glHint(GLenum target, GLenum mode) { ((decltype(glHint)*)_msangle_proc[99])(target, mode); } | 
        
          |  | GLboolean glIsBuffer(GLuint buffer) { return ((decltype(glIsBuffer)*)_msangle_proc[100])(buffer); } | 
        
          |  | GLboolean glIsEnabled(GLenum cap) { return ((decltype(glIsEnabled)*)_msangle_proc[101])(cap); } | 
        
          |  | GLboolean glIsFramebuffer(GLuint framebuffer) { return ((decltype(glIsFramebuffer)*)_msangle_proc[102])(framebuffer); } | 
        
          |  | GLboolean glIsProgram(GLuint program) { return ((decltype(glIsProgram)*)_msangle_proc[103])(program); } | 
        
          |  | GLboolean glIsRenderbuffer(GLuint renderbuffer) { return ((decltype(glIsRenderbuffer)*)_msangle_proc[104])(renderbuffer); } | 
        
          |  | GLboolean glIsShader(GLuint shader) { return ((decltype(glIsShader)*)_msangle_proc[105])(shader); } | 
        
          |  | GLboolean glIsTexture(GLuint texture) { return ((decltype(glIsTexture)*)_msangle_proc[106])(texture); } | 
        
          |  | void glLineWidth(GLfloat width) { ((decltype(glLineWidth)*)_msangle_proc[107])(width); } | 
        
          |  | void glLinkProgram(GLuint program) { ((decltype(glLinkProgram)*)_msangle_proc[108])(program); } | 
        
          |  | void glPixelStorei(GLenum pname, GLint param) { ((decltype(glPixelStorei)*)_msangle_proc[109])(pname, param); } | 
        
          |  | void glPolygonOffset(GLfloat factor, GLfloat units) { ((decltype(glPolygonOffset)*)_msangle_proc[110])(factor, units); } | 
        
          |  | void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) { ((decltype(glReadPixels)*)_msangle_proc[111])(x, y, width, height, format, type, pixels); } | 
        
          |  | void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) { ((decltype(glRenderbufferStorage)*)_msangle_proc[112])(target, internalformat, width, height); } | 
        
          |  | void glRequestExtensionANGLE(const char* name) { return ((decltype(glRequestExtensionANGLE)*)_msangle_proc[113])(name); } | 
        
          |  | void glSampleCoverage(GLfloat value, GLboolean invert) { ((decltype(glSampleCoverage)*)_msangle_proc[114])(value, invert); } | 
        
          |  | void glScissor(GLint x, GLint y, GLsizei width, GLsizei height) { ((decltype(glScissor)*)_msangle_proc[115])(x, y, width, height); } | 
        
          |  | void glShaderSource(GLuint shader, GLsizei count, const GLchar* const* string, const GLint* length) { ((decltype(glShaderSource)*)_msangle_proc[116])(shader, count, string, length); } | 
        
          |  | void glStencilFunc(GLenum func, GLint ref, GLuint mask) { ((decltype(glStencilFunc)*)_msangle_proc[117])(func, ref, mask); } | 
        
          |  | void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) { ((decltype(glStencilFuncSeparate)*)_msangle_proc[118])(face, func, ref, mask); } | 
        
          |  | void glStencilMask(GLuint mask) { ((decltype(glStencilMask)*)_msangle_proc[119])(mask); } | 
        
          |  | void glStencilMaskSeparate(GLenum face, GLuint mask) { ((decltype(glStencilMaskSeparate)*)_msangle_proc[120])(face, mask); } | 
        
          |  | void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) { ((decltype(glStencilOp)*)_msangle_proc[121])(fail, zfail, zpass); } | 
        
          |  | void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) { ((decltype(glStencilOpSeparate)*)_msangle_proc[122])(face, sfail, dpfail, dppass); } | 
        
          |  | void glTexParameterf(GLenum target, GLenum pname, GLfloat param) { ((decltype(glTexParameterf)*)_msangle_proc[124])(target, pname, param); } | 
        
          |  | void glTexParameteri(GLenum target, GLenum pname, GLint param) { ((decltype(glTexParameteri)*)_msangle_proc[125])(target, pname, param); } | 
        
          |  | void glUniform1f(GLint location, GLfloat v0) { ((decltype(glUniform1f)*)_msangle_proc[127])(location, v0); } | 
        
          |  | void glUniform1fv(GLint location, GLsizei count, const GLfloat* value) { ((decltype(glUniform1fv)*)_msangle_proc[128])(location, count, value); } | 
        
          |  | void glUniform1i(GLint location, GLint v0) { ((decltype(glUniform1i)*)_msangle_proc[129])(location, v0); } | 
        
          |  | void glUniform1iv(GLint location, GLsizei count, const GLint* value) { ((decltype(glUniform1iv)*)_msangle_proc[130])(location, count, value); } | 
        
          |  | void glUniform2f(GLint location, GLfloat v0, GLfloat v1) { ((decltype(glUniform2f)*)_msangle_proc[131])(location, v0, v1); } | 
        
          |  | void glUniform2fv(GLint location, GLsizei count, const GLfloat* value) { ((decltype(glUniform2fv)*)_msangle_proc[132])(location, count, value); } | 
        
          |  | void glUniform2i(GLint location, GLint v0, GLint v1) { ((decltype(glUniform2i)*)_msangle_proc[133])(location, v0, v1); } | 
        
          |  | void glUniform2iv(GLint location, GLsizei count, const GLint* value) { ((decltype(glUniform2iv)*)_msangle_proc[134])(location, count, value); } | 
        
          |  | void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) { ((decltype(glUniform3f)*)_msangle_proc[135])(location, v0, v1, v2); } | 
        
          |  | void glUniform3fv(GLint location, GLsizei count, const GLfloat* value) { ((decltype(glUniform3fv)*)_msangle_proc[136])(location, count, value); } | 
        
          |  | void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2) { ((decltype(glUniform3i)*)_msangle_proc[137])(location, v0, v1, v2); } | 
        
          |  | void glUniform3iv(GLint location, GLsizei count, const GLint* value) { ((decltype(glUniform3iv)*)_msangle_proc[138])(location, count, value); } | 
        
          |  | void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) { ((decltype(glUniform4f)*)_msangle_proc[139])(location, v0, v1, v2, v3); } | 
        
          |  | void glUniform4fv(GLint location, GLsizei count, const GLfloat* value) { ((decltype(glUniform4fv)*)_msangle_proc[140])(location, count, value); } | 
        
          |  | void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) { ((decltype(glUniform4i)*)_msangle_proc[141])(location, v0, v1, v2, v3); } | 
        
          |  | void glUniform4iv(GLint location, GLsizei count, const GLint* value) { ((decltype(glUniform4iv)*)_msangle_proc[142])(location, count, value); } | 
        
          |  | void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { ((decltype(glUniformMatrix2fv)*)_msangle_proc[143])(location, count, transpose, value); } | 
        
          |  | void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { ((decltype(glUniformMatrix3fv)*)_msangle_proc[144])(location, count, transpose, value); } | 
        
          |  | void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { ((decltype(glUniformMatrix4fv)*)_msangle_proc[145])(location, count, transpose, value); } | 
        
          |  | void glUseProgram(GLuint program) { ((decltype(glUseProgram)*)_msangle_proc[146])(program); } | 
        
          |  | void glValidateProgram(GLuint program) { ((decltype(glValidateProgram)*)_msangle_proc[147])(program); } | 
        
          |  | void glVertexAttrib1f(GLuint index, GLfloat x) { ((decltype(glVertexAttrib1f)*)_msangle_proc[149])(index, x); } | 
        
          |  | void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y) { ((decltype(glVertexAttrib2f)*)_msangle_proc[150])(index, x, y); } | 
        
          |  | void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z) { ((decltype(glVertexAttrib3f)*)_msangle_proc[151])(index, x, y, z); } | 
        
          |  | void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { ((decltype(glVertexAttrib4f)*)_msangle_proc[152])(index, x, y, z, w); } | 
        
          |  | void glVertexAttribDivisor(GLuint index, GLuint divisor) { ((decltype(glVertexAttribDivisor)*)_msangle_proc[153])(index, divisor); } | 
        
          |  | void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* pointer) { ((decltype(glVertexAttribPointer)*)_msangle_proc[154])(index, size, type, normalized, stride, pointer); } | 
        
          |  | void glViewport(GLint x, GLint y, GLsizei width, GLsizei height) { ((decltype(glViewport)*)_msangle_proc[155])(x, y, width, height); } | 
        
          |  | void glGenVertexArrays(GLsizei n, GLuint* arrays) { ((decltype(glGenVertexArrays)*)_msangle_proc[156])(n, arrays); } | 
        
          |  | GLboolean glIsVertexArray(GLuint array) { return ((decltype(glIsVertexArray)*)_msangle_proc[157])(array); } | 
        
          |  | void glDeleteVertexArrays(GLsizei n, const GLuint* arrays) { ((decltype(glDeleteVertexArrays)*)_msangle_proc[158])(n, arrays); } | 
        
          |  | void glBindVertexArray(GLuint array) { ((decltype(glBindVertexArray)*)_msangle_proc[159])(array); } | 
        
          |  | void glDrawBuffers(GLsizei n, const GLenum* bufs) { ((decltype(glDrawBuffers)*)_msangle_proc[160])(n, bufs); } | 
        
          |  |  | 
        
          |  | // gl 3 defines (not full) (optional) | 
        
          |  |  | 
        
          |  | #define GL_DEPTH_BUFFER_BIT               0x00000100 | 
        
          |  | #define GL_STENCIL_BUFFER_BIT             0x00000400 | 
        
          |  | #define GL_COLOR_BUFFER_BIT               0x00004000 | 
        
          |  | #define GL_FALSE                          0 | 
        
          |  | #define GL_TRUE                           1 | 
        
          |  | #define GL_POINTS                         0x0000 | 
        
          |  | #define GL_LINES                          0x0001 | 
        
          |  | #define GL_LINE_LOOP                      0x0002 | 
        
          |  | #define GL_LINE_STRIP                     0x0003 | 
        
          |  | #define GL_TRIANGLES                      0x0004 | 
        
          |  | #define GL_TRIANGLE_STRIP                 0x0005 | 
        
          |  | #define GL_TRIANGLE_FAN                   0x0006 | 
        
          |  | #define GL_ZERO                           0 | 
        
          |  | #define GL_ONE                            1 | 
        
          |  | #define GL_SRC_COLOR                      0x0300 | 
        
          |  | #define GL_ONE_MINUS_SRC_COLOR            0x0301 | 
        
          |  | #define GL_SRC_ALPHA                      0x0302 | 
        
          |  | #define GL_ONE_MINUS_SRC_ALPHA            0x0303 | 
        
          |  | #define GL_DST_ALPHA                      0x0304 | 
        
          |  | #define GL_ONE_MINUS_DST_ALPHA            0x0305 | 
        
          |  | #define GL_DST_COLOR                      0x0306 | 
        
          |  | #define GL_ONE_MINUS_DST_COLOR            0x0307 | 
        
          |  | #define GL_SRC_ALPHA_SATURATE             0x0308 | 
        
          |  | #define GL_FUNC_ADD                       0x8006 | 
        
          |  | #define GL_BLEND_EQUATION                 0x8009 | 
        
          |  | #define GL_BLEND_EQUATION_RGB             0x8009 | 
        
          |  | #define GL_BLEND_EQUATION_ALPHA           0x883D | 
        
          |  | #define GL_FUNC_SUBTRACT                  0x800A | 
        
          |  | #define GL_FUNC_REVERSE_SUBTRACT          0x800B | 
        
          |  | #define GL_BLEND_DST_RGB                  0x80C8 | 
        
          |  | #define GL_BLEND_SRC_RGB                  0x80C9 | 
        
          |  | #define GL_BLEND_DST_ALPHA                0x80CA | 
        
          |  | #define GL_BLEND_SRC_ALPHA                0x80CB | 
        
          |  | #define GL_CONSTANT_COLOR                 0x8001 | 
        
          |  | #define GL_ONE_MINUS_CONSTANT_COLOR       0x8002 | 
        
          |  | #define GL_CONSTANT_ALPHA                 0x8003 | 
        
          |  | #define GL_ONE_MINUS_CONSTANT_ALPHA       0x8004 | 
        
          |  | #define GL_BLEND_COLOR                    0x8005 | 
        
          |  | #define GL_ARRAY_BUFFER                   0x8892 | 
        
          |  | #define GL_ELEMENT_ARRAY_BUFFER           0x8893 | 
        
          |  | #define GL_ARRAY_BUFFER_BINDING           0x8894 | 
        
          |  | #define GL_ELEMENT_ARRAY_BUFFER_BINDING   0x8895 | 
        
          |  | #define GL_STREAM_DRAW                    0x88E0 | 
        
          |  | #define GL_STATIC_DRAW                    0x88E4 | 
        
          |  | #define GL_DYNAMIC_DRAW                   0x88E8 | 
        
          |  | #define GL_BUFFER_SIZE                    0x8764 | 
        
          |  | #define GL_BUFFER_USAGE                   0x8765 | 
        
          |  | #define GL_CURRENT_VERTEX_ATTRIB          0x8626 | 
        
          |  | #define GL_FRONT                          0x0404 | 
        
          |  | #define GL_BACK                           0x0405 | 
        
          |  | #define GL_FRONT_AND_BACK                 0x0408 | 
        
          |  | #define GL_TEXTURE_2D                     0x0DE1 | 
        
          |  | #define GL_CULL_FACE                      0x0B44 | 
        
          |  | #define GL_BLEND                          0x0BE2 | 
        
          |  | #define GL_DITHER                         0x0BD0 | 
        
          |  | #define GL_STENCIL_TEST                   0x0B90 | 
        
          |  | #define GL_DEPTH_TEST                     0x0B71 | 
        
          |  | #define GL_SCISSOR_TEST                   0x0C11 | 
        
          |  | #define GL_POLYGON_OFFSET_FILL            0x8037 | 
        
          |  | #define GL_SAMPLE_ALPHA_TO_COVERAGE       0x809E | 
        
          |  | #define GL_SAMPLE_COVERAGE                0x80A0 | 
        
          |  | #define GL_NO_ERROR                       0 | 
        
          |  | #define GL_INVALID_ENUM                   0x0500 | 
        
          |  | #define GL_INVALID_VALUE                  0x0501 | 
        
          |  | #define GL_INVALID_OPERATION              0x0502 | 
        
          |  | #define GL_OUT_OF_MEMORY                  0x0505 | 
        
          |  | #define GL_CW                             0x0900 | 
        
          |  | #define GL_CCW                            0x0901 | 
        
          |  | #define GL_LINE_WIDTH                     0x0B21 | 
        
          |  | #define GL_ALIASED_POINT_SIZE_RANGE       0x846D | 
        
          |  | #define GL_ALIASED_LINE_WIDTH_RANGE       0x846E | 
        
          |  | #define GL_CULL_FACE_MODE                 0x0B45 | 
        
          |  | #define GL_FRONT_FACE                     0x0B46 | 
        
          |  | #define GL_DEPTH_RANGE                    0x0B70 | 
        
          |  | #define GL_DEPTH_WRITEMASK                0x0B72 | 
        
          |  | #define GL_DEPTH_CLEAR_VALUE              0x0B73 | 
        
          |  | #define GL_DEPTH_FUNC                     0x0B74 | 
        
          |  | #define GL_STENCIL_CLEAR_VALUE            0x0B91 | 
        
          |  | #define GL_STENCIL_FUNC                   0x0B92 | 
        
          |  | #define GL_STENCIL_FAIL                   0x0B94 | 
        
          |  | #define GL_STENCIL_PASS_DEPTH_FAIL        0x0B95 | 
        
          |  | #define GL_STENCIL_PASS_DEPTH_PASS        0x0B96 | 
        
          |  | #define GL_STENCIL_REF                    0x0B97 | 
        
          |  | #define GL_STENCIL_VALUE_MASK             0x0B93 | 
        
          |  | #define GL_STENCIL_WRITEMASK              0x0B98 | 
        
          |  | #define GL_STENCIL_BACK_FUNC              0x8800 | 
        
          |  | #define GL_STENCIL_BACK_FAIL              0x8801 | 
        
          |  | #define GL_STENCIL_BACK_PASS_DEPTH_FAIL   0x8802 | 
        
          |  | #define GL_STENCIL_BACK_PASS_DEPTH_PASS   0x8803 | 
        
          |  | #define GL_STENCIL_BACK_REF               0x8CA3 | 
        
          |  | #define GL_STENCIL_BACK_VALUE_MASK        0x8CA4 | 
        
          |  | #define GL_STENCIL_BACK_WRITEMASK         0x8CA5 | 
        
          |  | #define GL_VIEWPORT                       0x0BA2 | 
        
          |  | #define GL_SCISSOR_BOX                    0x0C10 | 
        
          |  | #define GL_COLOR_CLEAR_VALUE              0x0C22 | 
        
          |  | #define GL_COLOR_WRITEMASK                0x0C23 | 
        
          |  | #define GL_UNPACK_ALIGNMENT               0x0CF5 | 
        
          |  | #define GL_PACK_ALIGNMENT                 0x0D05 | 
        
          |  | #define GL_MAX_TEXTURE_SIZE               0x0D33 | 
        
          |  | #define GL_MAX_VIEWPORT_DIMS              0x0D3A | 
        
          |  | #define GL_SUBPIXEL_BITS                  0x0D50 | 
        
          |  | #define GL_RED_BITS                       0x0D52 | 
        
          |  | #define GL_GREEN_BITS                     0x0D53 | 
        
          |  | #define GL_BLUE_BITS                      0x0D54 | 
        
          |  | #define GL_ALPHA_BITS                     0x0D55 | 
        
          |  | #define GL_DEPTH_BITS                     0x0D56 | 
        
          |  | #define GL_STENCIL_BITS                   0x0D57 | 
        
          |  | #define GL_POLYGON_OFFSET_UNITS           0x2A00 | 
        
          |  | #define GL_POLYGON_OFFSET_FACTOR          0x8038 | 
        
          |  | #define GL_TEXTURE_BINDING_2D             0x8069 | 
        
          |  | #define GL_SAMPLE_BUFFERS                 0x80A8 | 
        
          |  | #define GL_SAMPLES                        0x80A9 | 
        
          |  | #define GL_SAMPLE_COVERAGE_VALUE          0x80AA | 
        
          |  | #define GL_SAMPLE_COVERAGE_INVERT         0x80AB | 
        
          |  | #define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 | 
        
          |  | #define GL_COMPRESSED_TEXTURE_FORMATS     0x86A3 | 
        
          |  | #define GL_DONT_CARE                      0x1100 | 
        
          |  | #define GL_FASTEST                        0x1101 | 
        
          |  | #define GL_NICEST                         0x1102 | 
        
          |  | #define GL_GENERATE_MIPMAP_HINT           0x8192 | 
        
          |  | #define GL_BYTE                           0x1400 | 
        
          |  | #define GL_UNSIGNED_BYTE                  0x1401 | 
        
          |  | #define GL_SHORT                          0x1402 | 
        
          |  | #define GL_UNSIGNED_SHORT                 0x1403 | 
        
          |  | #define GL_INT                            0x1404 | 
        
          |  | #define GL_UNSIGNED_INT                   0x1405 | 
        
          |  | #define GL_FLOAT                          0x1406 | 
        
          |  | #define GL_FIXED                          0x140C | 
        
          |  | #define GL_DEPTH_COMPONENT                0x1902 | 
        
          |  | #define GL_ALPHA                          0x1906 | 
        
          |  | #define GL_RGB                            0x1907 | 
        
          |  | #define GL_RGBA                           0x1908 | 
        
          |  | #define GL_LUMINANCE                      0x1909 | 
        
          |  | #define GL_LUMINANCE_ALPHA                0x190A | 
        
          |  | #define GL_UNSIGNED_SHORT_4_4_4_4         0x8033 | 
        
          |  | #define GL_UNSIGNED_SHORT_5_5_5_1         0x8034 | 
        
          |  | #define GL_UNSIGNED_SHORT_5_6_5           0x8363 | 
        
          |  | #define GL_FRAGMENT_SHADER                0x8B30 | 
        
          |  | #define GL_VERTEX_SHADER                  0x8B31 | 
        
          |  | #define GL_MAX_VERTEX_ATTRIBS             0x8869 | 
        
          |  | #define GL_MAX_VERTEX_UNIFORM_VECTORS     0x8DFB | 
        
          |  | #define GL_MAX_VARYING_VECTORS            0x8DFC | 
        
          |  | #define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D | 
        
          |  | #define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C | 
        
          |  | #define GL_MAX_TEXTURE_IMAGE_UNITS        0x8872 | 
        
          |  | #define GL_MAX_FRAGMENT_UNIFORM_VECTORS   0x8DFD | 
        
          |  | #define GL_SHADER_TYPE                    0x8B4F | 
        
          |  | #define GL_DELETE_STATUS                  0x8B80 | 
        
          |  | #define GL_LINK_STATUS                    0x8B82 | 
        
          |  | #define GL_VALIDATE_STATUS                0x8B83 | 
        
          |  | #define GL_ATTACHED_SHADERS               0x8B85 | 
        
          |  | #define GL_ACTIVE_UNIFORMS                0x8B86 | 
        
          |  | #define GL_ACTIVE_UNIFORM_MAX_LENGTH      0x8B87 | 
        
          |  | #define GL_ACTIVE_ATTRIBUTES              0x8B89 | 
        
          |  | #define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH    0x8B8A | 
        
          |  | #define GL_SHADING_LANGUAGE_VERSION       0x8B8C | 
        
          |  | #define GL_CURRENT_PROGRAM                0x8B8D | 
        
          |  | #define GL_NEVER                          0x0200 | 
        
          |  | #define GL_LESS                           0x0201 | 
        
          |  | #define GL_EQUAL                          0x0202 | 
        
          |  | #define GL_LEQUAL                         0x0203 | 
        
          |  | #define GL_GREATER                        0x0204 | 
        
          |  | #define GL_NOTEQUAL                       0x0205 | 
        
          |  | #define GL_GEQUAL                         0x0206 | 
        
          |  | #define GL_ALWAYS                         0x0207 | 
        
          |  | #define GL_KEEP                           0x1E00 | 
        
          |  | #define GL_REPLACE                        0x1E01 | 
        
          |  | #define GL_INCR                           0x1E02 | 
        
          |  | #define GL_DECR                           0x1E03 | 
        
          |  | #define GL_INVERT                         0x150A | 
        
          |  | #define GL_INCR_WRAP                      0x8507 | 
        
          |  | #define GL_DECR_WRAP                      0x8508 | 
        
          |  | #define GL_VENDOR                         0x1F00 | 
        
          |  | #define GL_RENDERER                       0x1F01 | 
        
          |  | #define GL_VERSION                        0x1F02 | 
        
          |  | #define GL_EXTENSIONS                     0x1F03 | 
        
          |  | #define GL_NEAREST                        0x2600 | 
        
          |  | #define GL_LINEAR                         0x2601 | 
        
          |  | #define GL_NEAREST_MIPMAP_NEAREST         0x2700 | 
        
          |  | #define GL_LINEAR_MIPMAP_NEAREST          0x2701 | 
        
          |  | #define GL_NEAREST_MIPMAP_LINEAR          0x2702 | 
        
          |  | #define GL_LINEAR_MIPMAP_LINEAR           0x2703 | 
        
          |  | #define GL_TEXTURE_MAG_FILTER             0x2800 | 
        
          |  | #define GL_TEXTURE_MIN_FILTER             0x2801 | 
        
          |  | #define GL_TEXTURE_WRAP_S                 0x2802 | 
        
          |  | #define GL_TEXTURE_WRAP_T                 0x2803 | 
        
          |  | #define GL_TEXTURE                        0x1702 | 
        
          |  | #define GL_TEXTURE_CUBE_MAP               0x8513 | 
        
          |  | #define GL_TEXTURE_BINDING_CUBE_MAP       0x8514 | 
        
          |  | #define GL_TEXTURE_CUBE_MAP_POSITIVE_X    0x8515 | 
        
          |  | #define GL_TEXTURE_CUBE_MAP_NEGATIVE_X    0x8516 | 
        
          |  | #define GL_TEXTURE_CUBE_MAP_POSITIVE_Y    0x8517 | 
        
          |  | #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y    0x8518 | 
        
          |  | #define GL_TEXTURE_CUBE_MAP_POSITIVE_Z    0x8519 | 
        
          |  | #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z    0x851A | 
        
          |  | #define GL_MAX_CUBE_MAP_TEXTURE_SIZE      0x851C | 
        
          |  | #define GL_TEXTURE0                       0x84C0 | 
        
          |  | #define GL_TEXTURE1                       0x84C1 | 
        
          |  | #define GL_TEXTURE2                       0x84C2 | 
        
          |  | #define GL_TEXTURE3                       0x84C3 | 
        
          |  | #define GL_TEXTURE4                       0x84C4 | 
        
          |  | #define GL_TEXTURE5                       0x84C5 | 
        
          |  | #define GL_TEXTURE6                       0x84C6 | 
        
          |  | #define GL_TEXTURE7                       0x84C7 | 
        
          |  | #define GL_TEXTURE8                       0x84C8 | 
        
          |  | #define GL_TEXTURE9                       0x84C9 | 
        
          |  | #define GL_TEXTURE10                      0x84CA | 
        
          |  | #define GL_TEXTURE11                      0x84CB | 
        
          |  | #define GL_TEXTURE12                      0x84CC | 
        
          |  | #define GL_TEXTURE13                      0x84CD | 
        
          |  | #define GL_TEXTURE14                      0x84CE | 
        
          |  | #define GL_TEXTURE15                      0x84CF | 
        
          |  | #define GL_TEXTURE16                      0x84D0 | 
        
          |  | #define GL_TEXTURE17                      0x84D1 | 
        
          |  | #define GL_TEXTURE18                      0x84D2 | 
        
          |  | #define GL_TEXTURE19                      0x84D3 | 
        
          |  | #define GL_TEXTURE20                      0x84D4 | 
        
          |  | #define GL_TEXTURE21                      0x84D5 | 
        
          |  | #define GL_TEXTURE22                      0x84D6 | 
        
          |  | #define GL_TEXTURE23                      0x84D7 | 
        
          |  | #define GL_TEXTURE24                      0x84D8 | 
        
          |  | #define GL_TEXTURE25                      0x84D9 | 
        
          |  | #define GL_TEXTURE26                      0x84DA | 
        
          |  | #define GL_TEXTURE27                      0x84DB | 
        
          |  | #define GL_TEXTURE28                      0x84DC | 
        
          |  | #define GL_TEXTURE29                      0x84DD | 
        
          |  | #define GL_TEXTURE30                      0x84DE | 
        
          |  | #define GL_TEXTURE31                      0x84DF | 
        
          |  | #define GL_ACTIVE_TEXTURE                 0x84E0 | 
        
          |  | #define GL_REPEAT                         0x2901 | 
        
          |  | #define GL_CLAMP_TO_EDGE                  0x812F | 
        
          |  | #define GL_MIRRORED_REPEAT                0x8370 | 
        
          |  | #define GL_FLOAT_VEC2                     0x8B50 | 
        
          |  | #define GL_FLOAT_VEC3                     0x8B51 | 
        
          |  | #define GL_FLOAT_VEC4                     0x8B52 | 
        
          |  | #define GL_INT_VEC2                       0x8B53 | 
        
          |  | #define GL_INT_VEC3                       0x8B54 | 
        
          |  | #define GL_INT_VEC4                       0x8B55 | 
        
          |  | #define GL_BOOL                           0x8B56 | 
        
          |  | #define GL_BOOL_VEC2                      0x8B57 | 
        
          |  | #define GL_BOOL_VEC3                      0x8B58 | 
        
          |  | #define GL_BOOL_VEC4                      0x8B59 | 
        
          |  | #define GL_FLOAT_MAT2                     0x8B5A | 
        
          |  | #define GL_FLOAT_MAT3                     0x8B5B | 
        
          |  | #define GL_FLOAT_MAT4                     0x8B5C | 
        
          |  | #define GL_SAMPLER_2D                     0x8B5E | 
        
          |  | #define GL_SAMPLER_CUBE                   0x8B60 | 
        
          |  | #define GL_VERTEX_ATTRIB_ARRAY_ENABLED    0x8622 | 
        
          |  | #define GL_VERTEX_ATTRIB_ARRAY_SIZE       0x8623 | 
        
          |  | #define GL_VERTEX_ATTRIB_ARRAY_STRIDE     0x8624 | 
        
          |  | #define GL_VERTEX_ATTRIB_ARRAY_TYPE       0x8625 | 
        
          |  | #define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A | 
        
          |  | #define GL_VERTEX_ATTRIB_ARRAY_POINTER    0x8645 | 
        
          |  | #define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F | 
        
          |  | #define GL_IMPLEMENTATION_COLOR_READ_TYPE 0x8B9A | 
        
          |  | #define GL_IMPLEMENTATION_COLOR_READ_FORMAT 0x8B9B | 
        
          |  | #define GL_COMPILE_STATUS                 0x8B81 | 
        
          |  | #define GL_INFO_LOG_LENGTH                0x8B84 | 
        
          |  | #define GL_SHADER_SOURCE_LENGTH           0x8B88 | 
        
          |  | #define GL_SHADER_COMPILER                0x8DFA | 
        
          |  | #define GL_SHADER_BINARY_FORMATS          0x8DF8 | 
        
          |  | #define GL_NUM_SHADER_BINARY_FORMATS      0x8DF9 | 
        
          |  | #define GL_LOW_FLOAT                      0x8DF0 | 
        
          |  | #define GL_MEDIUM_FLOAT                   0x8DF1 | 
        
          |  | #define GL_HIGH_FLOAT                     0x8DF2 | 
        
          |  | #define GL_LOW_INT                        0x8DF3 | 
        
          |  | #define GL_MEDIUM_INT                     0x8DF4 | 
        
          |  | #define GL_HIGH_INT                       0x8DF5 | 
        
          |  | #define GL_FRAMEBUFFER                    0x8D40 | 
        
          |  | #define GL_RENDERBUFFER                   0x8D41 | 
        
          |  | #define GL_RGBA4                          0x8056 | 
        
          |  | #define GL_RGB5_A1                        0x8057 | 
        
          |  | #define GL_RGB565                         0x8D62 | 
        
          |  | #define GL_DEPTH_COMPONENT16              0x81A5 | 
        
          |  | #define GL_STENCIL_INDEX8                 0x8D48 | 
        
          |  | #define GL_RENDERBUFFER_WIDTH             0x8D42 | 
        
          |  | #define GL_RENDERBUFFER_HEIGHT            0x8D43 | 
        
          |  | #define GL_RENDERBUFFER_INTERNAL_FORMAT   0x8D44 | 
        
          |  | #define GL_RENDERBUFFER_RED_SIZE          0x8D50 | 
        
          |  | #define GL_RENDERBUFFER_GREEN_SIZE        0x8D51 | 
        
          |  | #define GL_RENDERBUFFER_BLUE_SIZE         0x8D52 | 
        
          |  | #define GL_RENDERBUFFER_ALPHA_SIZE        0x8D53 | 
        
          |  | #define GL_RENDERBUFFER_DEPTH_SIZE        0x8D54 | 
        
          |  | #define GL_RENDERBUFFER_STENCIL_SIZE      0x8D55 | 
        
          |  | #define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0 | 
        
          |  | #define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1 | 
        
          |  | #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2 | 
        
          |  | #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3 | 
        
          |  | #define GL_COLOR_ATTACHMENT0              0x8CE0 | 
        
          |  | #define GL_DEPTH_ATTACHMENT               0x8D00 | 
        
          |  | #define GL_STENCIL_ATTACHMENT             0x8D20 | 
        
          |  | #define GL_NONE                           0 | 
        
          |  | #define GL_FRAMEBUFFER_COMPLETE           0x8CD5 | 
        
          |  | #define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6 | 
        
          |  | #define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 | 
        
          |  | #define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS 0x8CD9 | 
        
          |  | #define GL_FRAMEBUFFER_UNSUPPORTED        0x8CDD | 
        
          |  | #define GL_FRAMEBUFFER_BINDING            0x8CA6 | 
        
          |  | #define GL_RENDERBUFFER_BINDING           0x8CA7 | 
        
          |  | #define GL_MAX_RENDERBUFFER_SIZE          0x84E8 | 
        
          |  | #define GL_INVALID_FRAMEBUFFER_OPERATION  0x0506 | 
        
          |  | #define GL_READ_BUFFER                    0x0C02 | 
        
          |  | #define GL_UNPACK_ROW_LENGTH              0x0CF2 | 
        
          |  | #define GL_UNPACK_SKIP_ROWS               0x0CF3 | 
        
          |  | #define GL_UNPACK_SKIP_PIXELS             0x0CF4 | 
        
          |  | #define GL_PACK_ROW_LENGTH                0x0D02 | 
        
          |  | #define GL_PACK_SKIP_ROWS                 0x0D03 | 
        
          |  | #define GL_PACK_SKIP_PIXELS               0x0D04 | 
        
          |  | #define GL_COLOR                          0x1800 | 
        
          |  | #define GL_DEPTH                          0x1801 | 
        
          |  | #define GL_STENCIL                        0x1802 | 
        
          |  | #define GL_RED                            0x1903 | 
        
          |  | #define GL_RGB8                           0x8051 | 
        
          |  | #define GL_RGBA8                          0x8058 | 
        
          |  | #define GL_RGB10_A2                       0x8059 | 
        
          |  | #define GL_TEXTURE_BINDING_3D             0x806A | 
        
          |  | #define GL_UNPACK_SKIP_IMAGES             0x806D | 
        
          |  | #define GL_UNPACK_IMAGE_HEIGHT            0x806E | 
        
          |  | #define GL_TEXTURE_3D                     0x806F | 
        
          |  | #define GL_TEXTURE_WRAP_R                 0x8072 | 
        
          |  | #define GL_MAX_3D_TEXTURE_SIZE            0x8073 | 
        
          |  | #define GL_UNSIGNED_INT_2_10_10_10_REV    0x8368 | 
        
          |  | #define GL_MAX_ELEMENTS_VERTICES          0x80E8 | 
        
          |  | #define GL_MAX_ELEMENTS_INDICES           0x80E9 | 
        
          |  | #define GL_TEXTURE_MIN_LOD                0x813A | 
        
          |  | #define GL_TEXTURE_MAX_LOD                0x813B | 
        
          |  | #define GL_TEXTURE_BASE_LEVEL             0x813C | 
        
          |  | #define GL_TEXTURE_MAX_LEVEL              0x813D | 
        
          |  | #define GL_MIN                            0x8007 | 
        
          |  | #define GL_MAX                            0x8008 | 
        
          |  | #define GL_DEPTH_COMPONENT24              0x81A6 | 
        
          |  | #define GL_MAX_TEXTURE_LOD_BIAS           0x84FD | 
        
          |  | #define GL_TEXTURE_COMPARE_MODE           0x884C | 
        
          |  | #define GL_TEXTURE_COMPARE_FUNC           0x884D | 
        
          |  | #define GL_CURRENT_QUERY                  0x8865 | 
        
          |  | #define GL_QUERY_RESULT                   0x8866 | 
        
          |  | #define GL_QUERY_RESULT_AVAILABLE         0x8867 | 
        
          |  | #define GL_BUFFER_MAPPED                  0x88BC | 
        
          |  | #define GL_BUFFER_MAP_POINTER             0x88BD | 
        
          |  | #define GL_STREAM_READ                    0x88E1 | 
        
          |  | #define GL_STREAM_COPY                    0x88E2 | 
        
          |  | #define GL_STATIC_READ                    0x88E5 | 
        
          |  | #define GL_STATIC_COPY                    0x88E6 | 
        
          |  | #define GL_DYNAMIC_READ                   0x88E9 | 
        
          |  | #define GL_DYNAMIC_COPY                   0x88EA | 
        
          |  | #define GL_MAX_DRAW_BUFFERS               0x8824 | 
        
          |  | #define GL_DRAW_BUFFER0                   0x8825 | 
        
          |  | #define GL_DRAW_BUFFER1                   0x8826 | 
        
          |  | #define GL_DRAW_BUFFER2                   0x8827 | 
        
          |  | #define GL_DRAW_BUFFER3                   0x8828 | 
        
          |  | #define GL_DRAW_BUFFER4                   0x8829 | 
        
          |  | #define GL_DRAW_BUFFER5                   0x882A | 
        
          |  | #define GL_DRAW_BUFFER6                   0x882B | 
        
          |  | #define GL_DRAW_BUFFER7                   0x882C | 
        
          |  | #define GL_DRAW_BUFFER8                   0x882D | 
        
          |  | #define GL_DRAW_BUFFER9                   0x882E | 
        
          |  | #define GL_DRAW_BUFFER10                  0x882F | 
        
          |  | #define GL_DRAW_BUFFER11                  0x8830 | 
        
          |  | #define GL_DRAW_BUFFER12                  0x8831 | 
        
          |  | #define GL_DRAW_BUFFER13                  0x8832 | 
        
          |  | #define GL_DRAW_BUFFER14                  0x8833 | 
        
          |  | #define GL_DRAW_BUFFER15                  0x8834 | 
        
          |  | #define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 | 
        
          |  | #define GL_MAX_VERTEX_UNIFORM_COMPONENTS  0x8B4A | 
        
          |  | #define GL_SAMPLER_3D                     0x8B5F | 
        
          |  | #define GL_SAMPLER_2D_SHADOW              0x8B62 | 
        
          |  | #define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B | 
        
          |  | #define GL_PIXEL_PACK_BUFFER              0x88EB | 
        
          |  | #define GL_PIXEL_UNPACK_BUFFER            0x88EC | 
        
          |  | #define GL_PIXEL_PACK_BUFFER_BINDING      0x88ED | 
        
          |  | #define GL_PIXEL_UNPACK_BUFFER_BINDING    0x88EF | 
        
          |  | #define GL_FLOAT_MAT2x3                   0x8B65 | 
        
          |  | #define GL_FLOAT_MAT2x4                   0x8B66 | 
        
          |  | #define GL_FLOAT_MAT3x2                   0x8B67 | 
        
          |  | #define GL_FLOAT_MAT3x4                   0x8B68 | 
        
          |  | #define GL_FLOAT_MAT4x2                   0x8B69 | 
        
          |  | #define GL_FLOAT_MAT4x3                   0x8B6A | 
        
          |  | #define GL_SRGB                           0x8C40 | 
        
          |  | #define GL_SRGB8                          0x8C41 | 
        
          |  | #define GL_SRGB8_ALPHA8                   0x8C43 | 
        
          |  | #define GL_COMPARE_REF_TO_TEXTURE         0x884E | 
        
          |  | #define GL_MAJOR_VERSION                  0x821B | 
        
          |  | #define GL_MINOR_VERSION                  0x821C | 
        
          |  | #define GL_NUM_EXTENSIONS                 0x821D | 
        
          |  | #define GL_RGBA32F                        0x8814 | 
        
          |  | #define GL_RGB32F                         0x8815 | 
        
          |  | #define GL_RGBA16F                        0x881A | 
        
          |  | #define GL_RGB16F                         0x881B | 
        
          |  | #define GL_VERTEX_ATTRIB_ARRAY_INTEGER    0x88FD | 
        
          |  | #define GL_MAX_ARRAY_TEXTURE_LAYERS       0x88FF | 
        
          |  | #define GL_MIN_PROGRAM_TEXEL_OFFSET       0x8904 | 
        
          |  | #define GL_MAX_PROGRAM_TEXEL_OFFSET       0x8905 | 
        
          |  | #define GL_MAX_VARYING_COMPONENTS         0x8B4B | 
        
          |  | #define GL_TEXTURE_2D_ARRAY               0x8C1A | 
        
          |  | #define GL_TEXTURE_BINDING_2D_ARRAY       0x8C1D | 
        
          |  | #define GL_R11F_G11F_B10F                 0x8C3A | 
        
          |  | #define GL_UNSIGNED_INT_10F_11F_11F_REV   0x8C3B | 
        
          |  | #define GL_RGB9_E5                        0x8C3D | 
        
          |  | #define GL_UNSIGNED_INT_5_9_9_9_REV       0x8C3E | 
        
          |  | #define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76 | 
        
          |  | #define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F | 
        
          |  | #define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80 | 
        
          |  | #define GL_TRANSFORM_FEEDBACK_VARYINGS    0x8C83 | 
        
          |  | #define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84 | 
        
          |  | #define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85 | 
        
          |  | #define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88 | 
        
          |  | #define GL_RASTERIZER_DISCARD             0x8C89 | 
        
          |  | #define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A | 
        
          |  | #define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B | 
        
          |  | #define GL_INTERLEAVED_ATTRIBS            0x8C8C | 
        
          |  | #define GL_SEPARATE_ATTRIBS               0x8C8D | 
        
          |  | #define GL_TRANSFORM_FEEDBACK_BUFFER      0x8C8E | 
        
          |  | #define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F | 
        
          |  | #define GL_RGBA32UI                       0x8D70 | 
        
          |  | #define GL_RGB32UI                        0x8D71 | 
        
          |  | #define GL_RGBA16UI                       0x8D76 | 
        
          |  | #define GL_RGB16UI                        0x8D77 | 
        
          |  | #define GL_RGBA8UI                        0x8D7C | 
        
          |  | #define GL_RGB8UI                         0x8D7D | 
        
          |  | #define GL_RGBA32I                        0x8D82 | 
        
          |  | #define GL_RGB32I                         0x8D83 | 
        
          |  | #define GL_RGBA16I                        0x8D88 | 
        
          |  | #define GL_RGB16I                         0x8D89 | 
        
          |  | #define GL_RGBA8I                         0x8D8E | 
        
          |  | #define GL_RGB8I                          0x8D8F | 
        
          |  | #define GL_RED_INTEGER                    0x8D94 | 
        
          |  | #define GL_RGB_INTEGER                    0x8D98 | 
        
          |  | #define GL_RGBA_INTEGER                   0x8D99 | 
        
          |  | #define GL_SAMPLER_2D_ARRAY               0x8DC1 | 
        
          |  | #define GL_SAMPLER_2D_ARRAY_SHADOW        0x8DC4 | 
        
          |  | #define GL_SAMPLER_CUBE_SHADOW            0x8DC5 | 
        
          |  | #define GL_UNSIGNED_INT_VEC2              0x8DC6 | 
        
          |  | #define GL_UNSIGNED_INT_VEC3              0x8DC7 | 
        
          |  | #define GL_UNSIGNED_INT_VEC4              0x8DC8 | 
        
          |  | #define GL_INT_SAMPLER_2D                 0x8DCA | 
        
          |  | #define GL_INT_SAMPLER_3D                 0x8DCB | 
        
          |  | #define GL_INT_SAMPLER_CUBE               0x8DCC | 
        
          |  | #define GL_INT_SAMPLER_2D_ARRAY           0x8DCF | 
        
          |  | #define GL_UNSIGNED_INT_SAMPLER_2D        0x8DD2 | 
        
          |  | #define GL_UNSIGNED_INT_SAMPLER_3D        0x8DD3 | 
        
          |  | #define GL_UNSIGNED_INT_SAMPLER_CUBE      0x8DD4 | 
        
          |  | #define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY  0x8DD7 | 
        
          |  | #define GL_BUFFER_ACCESS_FLAGS            0x911F | 
        
          |  | #define GL_BUFFER_MAP_LENGTH              0x9120 | 
        
          |  | #define GL_BUFFER_MAP_OFFSET              0x9121 | 
        
          |  | #define GL_DEPTH_COMPONENT32F             0x8CAC | 
        
          |  | #define GL_DEPTH32F_STENCIL8              0x8CAD | 
        
          |  | #define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD | 
        
          |  | #define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210 | 
        
          |  | #define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211 | 
        
          |  | #define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212 | 
        
          |  | #define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213 | 
        
          |  | #define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214 | 
        
          |  | #define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215 | 
        
          |  | #define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216 | 
        
          |  | #define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217 | 
        
          |  | #define GL_FRAMEBUFFER_DEFAULT            0x8218 | 
        
          |  | #define GL_FRAMEBUFFER_UNDEFINED          0x8219 | 
        
          |  | #define GL_DEPTH_STENCIL_ATTACHMENT       0x821A | 
        
          |  | #define GL_DEPTH_STENCIL                  0x84F9 | 
        
          |  | #define GL_UNSIGNED_INT_24_8              0x84FA | 
        
          |  | #define GL_DEPTH24_STENCIL8               0x88F0 | 
        
          |  | #define GL_UNSIGNED_NORMALIZED            0x8C17 | 
        
          |  | #define GL_DRAW_FRAMEBUFFER_BINDING       0x8CA6 | 
        
          |  | #define GL_READ_FRAMEBUFFER               0x8CA8 | 
        
          |  | #define GL_DRAW_FRAMEBUFFER               0x8CA9 | 
        
          |  | #define GL_READ_FRAMEBUFFER_BINDING       0x8CAA | 
        
          |  | #define GL_RENDERBUFFER_SAMPLES           0x8CAB | 
        
          |  | #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4 | 
        
          |  | #define GL_MAX_COLOR_ATTACHMENTS          0x8CDF | 
        
          |  | #define GL_COLOR_ATTACHMENT1              0x8CE1 | 
        
          |  | #define GL_COLOR_ATTACHMENT2              0x8CE2 | 
        
          |  | #define GL_COLOR_ATTACHMENT3              0x8CE3 | 
        
          |  | #define GL_COLOR_ATTACHMENT4              0x8CE4 | 
        
          |  | #define GL_COLOR_ATTACHMENT5              0x8CE5 | 
        
          |  | #define GL_COLOR_ATTACHMENT6              0x8CE6 | 
        
          |  | #define GL_COLOR_ATTACHMENT7              0x8CE7 | 
        
          |  | #define GL_COLOR_ATTACHMENT8              0x8CE8 | 
        
          |  | #define GL_COLOR_ATTACHMENT9              0x8CE9 | 
        
          |  | #define GL_COLOR_ATTACHMENT10             0x8CEA | 
        
          |  | #define GL_COLOR_ATTACHMENT11             0x8CEB | 
        
          |  | #define GL_COLOR_ATTACHMENT12             0x8CEC | 
        
          |  | #define GL_COLOR_ATTACHMENT13             0x8CED | 
        
          |  | #define GL_COLOR_ATTACHMENT14             0x8CEE | 
        
          |  | #define GL_COLOR_ATTACHMENT15             0x8CEF | 
        
          |  | #define GL_COLOR_ATTACHMENT16             0x8CF0 | 
        
          |  | #define GL_COLOR_ATTACHMENT17             0x8CF1 | 
        
          |  | #define GL_COLOR_ATTACHMENT18             0x8CF2 | 
        
          |  | #define GL_COLOR_ATTACHMENT19             0x8CF3 | 
        
          |  | #define GL_COLOR_ATTACHMENT20             0x8CF4 | 
        
          |  | #define GL_COLOR_ATTACHMENT21             0x8CF5 | 
        
          |  | #define GL_COLOR_ATTACHMENT22             0x8CF6 | 
        
          |  | #define GL_COLOR_ATTACHMENT23             0x8CF7 | 
        
          |  | #define GL_COLOR_ATTACHMENT24             0x8CF8 | 
        
          |  | #define GL_COLOR_ATTACHMENT25             0x8CF9 | 
        
          |  | #define GL_COLOR_ATTACHMENT26             0x8CFA | 
        
          |  | #define GL_COLOR_ATTACHMENT27             0x8CFB | 
        
          |  | #define GL_COLOR_ATTACHMENT28             0x8CFC | 
        
          |  | #define GL_COLOR_ATTACHMENT29             0x8CFD | 
        
          |  | #define GL_COLOR_ATTACHMENT30             0x8CFE | 
        
          |  | #define GL_COLOR_ATTACHMENT31             0x8CFF | 
        
          |  | #define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56 | 
        
          |  | #define GL_MAX_SAMPLES                    0x8D57 | 
        
          |  | #define GL_HALF_FLOAT                     0x140B | 
        
          |  | #define GL_MAP_READ_BIT                   0x0001 | 
        
          |  | #define GL_MAP_WRITE_BIT                  0x0002 | 
        
          |  | #define GL_MAP_INVALIDATE_RANGE_BIT       0x0004 | 
        
          |  | #define GL_MAP_INVALIDATE_BUFFER_BIT      0x0008 | 
        
          |  | #define GL_MAP_FLUSH_EXPLICIT_BIT         0x0010 | 
        
          |  | #define GL_MAP_UNSYNCHRONIZED_BIT         0x0020 | 
        
          |  | #define GL_RG                             0x8227 | 
        
          |  | #define GL_RG_INTEGER                     0x8228 | 
        
          |  | #define GL_R8                             0x8229 | 
        
          |  | #define GL_RG8                            0x822B | 
        
          |  | #define GL_R16F                           0x822D | 
        
          |  | #define GL_R32F                           0x822E | 
        
          |  | #define GL_RG16F                          0x822F | 
        
          |  | #define GL_RG32F                          0x8230 | 
        
          |  | #define GL_R8I                            0x8231 | 
        
          |  | #define GL_R8UI                           0x8232 | 
        
          |  | #define GL_R16I                           0x8233 | 
        
          |  | #define GL_R16UI                          0x8234 | 
        
          |  | #define GL_R32I                           0x8235 | 
        
          |  | #define GL_R32UI                          0x8236 | 
        
          |  | #define GL_RG8I                           0x8237 | 
        
          |  | #define GL_RG8UI                          0x8238 | 
        
          |  | #define GL_RG16I                          0x8239 | 
        
          |  | #define GL_RG16UI                         0x823A | 
        
          |  | #define GL_RG32I                          0x823B | 
        
          |  | #define GL_RG32UI                         0x823C | 
        
          |  | #define GL_VERTEX_ARRAY_BINDING           0x85B5 | 
        
          |  | #define GL_R8_SNORM                       0x8F94 | 
        
          |  | #define GL_RG8_SNORM                      0x8F95 | 
        
          |  | #define GL_RGB8_SNORM                     0x8F96 | 
        
          |  | #define GL_RGBA8_SNORM                    0x8F97 | 
        
          |  | #define GL_SIGNED_NORMALIZED              0x8F9C | 
        
          |  | #define GL_PRIMITIVE_RESTART_FIXED_INDEX  0x8D69 | 
        
          |  | #define GL_COPY_READ_BUFFER               0x8F36 | 
        
          |  | #define GL_COPY_WRITE_BUFFER              0x8F37 | 
        
          |  | #define GL_COPY_READ_BUFFER_BINDING       0x8F36 | 
        
          |  | #define GL_COPY_WRITE_BUFFER_BINDING      0x8F37 | 
        
          |  | #define GL_UNIFORM_BUFFER                 0x8A11 | 
        
          |  | #define GL_UNIFORM_BUFFER_BINDING         0x8A28 | 
        
          |  | #define GL_UNIFORM_BUFFER_START           0x8A29 | 
        
          |  | #define GL_UNIFORM_BUFFER_SIZE            0x8A2A | 
        
          |  | #define GL_MAX_VERTEX_UNIFORM_BLOCKS      0x8A2B | 
        
          |  | #define GL_MAX_FRAGMENT_UNIFORM_BLOCKS    0x8A2D | 
        
          |  | #define GL_MAX_COMBINED_UNIFORM_BLOCKS    0x8A2E | 
        
          |  | #define GL_MAX_UNIFORM_BUFFER_BINDINGS    0x8A2F | 
        
          |  | #define GL_MAX_UNIFORM_BLOCK_SIZE         0x8A30 | 
        
          |  | #define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31 | 
        
          |  | #define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33 | 
        
          |  | #define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34 | 
        
          |  | #define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35 | 
        
          |  | #define GL_ACTIVE_UNIFORM_BLOCKS          0x8A36 | 
        
          |  | #define GL_UNIFORM_TYPE                   0x8A37 | 
        
          |  | #define GL_UNIFORM_SIZE                   0x8A38 | 
        
          |  | #define GL_UNIFORM_NAME_LENGTH            0x8A39 | 
        
          |  | #define GL_UNIFORM_BLOCK_INDEX            0x8A3A | 
        
          |  | #define GL_UNIFORM_OFFSET                 0x8A3B | 
        
          |  | #define GL_UNIFORM_ARRAY_STRIDE           0x8A3C | 
        
          |  | #define GL_UNIFORM_MATRIX_STRIDE          0x8A3D | 
        
          |  | #define GL_UNIFORM_IS_ROW_MAJOR           0x8A3E | 
        
          |  | #define GL_UNIFORM_BLOCK_BINDING          0x8A3F | 
        
          |  | #define GL_UNIFORM_BLOCK_DATA_SIZE        0x8A40 | 
        
          |  | #define GL_UNIFORM_BLOCK_NAME_LENGTH      0x8A41 | 
        
          |  | #define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS  0x8A42 | 
        
          |  | #define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43 | 
        
          |  | #define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44 | 
        
          |  | #define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46 | 
        
          |  | #define GL_INVALID_INDEX                  0xFFFFFFFFu | 
        
          |  | #define GL_MAX_VERTEX_OUTPUT_COMPONENTS   0x9122 | 
        
          |  | #define GL_MAX_FRAGMENT_INPUT_COMPONENTS  0x9125 | 
        
          |  | #define GL_MAX_SERVER_WAIT_TIMEOUT        0x9111 | 
        
          |  | #define GL_OBJECT_TYPE                    0x9112 | 
        
          |  | #define GL_SYNC_CONDITION                 0x9113 | 
        
          |  | #define GL_SYNC_STATUS                    0x9114 | 
        
          |  | #define GL_SYNC_FLAGS                     0x9115 | 
        
          |  | #define GL_SYNC_FENCE                     0x9116 | 
        
          |  | #define GL_SYNC_GPU_COMMANDS_COMPLETE     0x9117 | 
        
          |  | #define GL_UNSIGNALED                     0x9118 | 
        
          |  | #define GL_SIGNALED                       0x9119 | 
        
          |  | #define GL_ALREADY_SIGNALED               0x911A | 
        
          |  | #define GL_TIMEOUT_EXPIRED                0x911B | 
        
          |  | #define GL_CONDITION_SATISFIED            0x911C | 
        
          |  | #define GL_WAIT_FAILED                    0x911D | 
        
          |  | #define GL_SYNC_FLUSH_COMMANDS_BIT        0x00000001 | 
        
          |  | #define GL_TIMEOUT_IGNORED                0xFFFFFFFFFFFFFFFFull | 
        
          |  | #define GL_VERTEX_ATTRIB_ARRAY_DIVISOR    0x88FE | 
        
          |  | #define GL_ANY_SAMPLES_PASSED             0x8C2F | 
        
          |  | #define GL_ANY_SAMPLES_PASSED_CONSERVATIVE 0x8D6A | 
        
          |  | #define GL_SAMPLER_BINDING                0x8919 | 
        
          |  | #define GL_RGB10_A2UI                     0x906F | 
        
          |  | #define GL_TEXTURE_SWIZZLE_R              0x8E42 | 
        
          |  | #define GL_TEXTURE_SWIZZLE_G              0x8E43 | 
        
          |  | #define GL_TEXTURE_SWIZZLE_B              0x8E44 | 
        
          |  | #define GL_TEXTURE_SWIZZLE_A              0x8E45 | 
        
          |  | #define GL_GREEN                          0x1904 | 
        
          |  | #define GL_BLUE                           0x1905 | 
        
          |  | #define GL_INT_2_10_10_10_REV             0x8D9F | 
        
          |  | #define GL_TRANSFORM_FEEDBACK             0x8E22 | 
        
          |  | #define GL_TRANSFORM_FEEDBACK_PAUSED      0x8E23 | 
        
          |  | #define GL_TRANSFORM_FEEDBACK_ACTIVE      0x8E24 | 
        
          |  | #define GL_TRANSFORM_FEEDBACK_BINDING     0x8E25 | 
        
          |  | #define GL_PROGRAM_BINARY_RETRIEVABLE_HINT 0x8257 | 
        
          |  | #define GL_PROGRAM_BINARY_LENGTH          0x8741 | 
        
          |  | #define GL_NUM_PROGRAM_BINARY_FORMATS     0x87FE | 
        
          |  | #define GL_PROGRAM_BINARY_FORMATS         0x87FF | 
        
          |  | #define GL_COMPRESSED_R11_EAC             0x9270 | 
        
          |  | #define GL_COMPRESSED_SIGNED_R11_EAC      0x9271 | 
        
          |  | #define GL_COMPRESSED_RG11_EAC            0x9272 | 
        
          |  | #define GL_COMPRESSED_SIGNED_RG11_EAC     0x9273 | 
        
          |  | #define GL_COMPRESSED_RGB8_ETC2           0x9274 | 
        
          |  | #define GL_COMPRESSED_SRGB8_ETC2          0x9275 | 
        
          |  | #define GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9276 | 
        
          |  | #define GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9277 | 
        
          |  | #define GL_COMPRESSED_RGBA8_ETC2_EAC      0x9278 | 
        
          |  | #define GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC 0x9279 | 
        
          |  | #define GL_TEXTURE_IMMUTABLE_FORMAT       0x912F | 
        
          |  | #define GL_MAX_ELEMENT_INDEX              0x8D6B | 
        
          |  | #define GL_NUM_SAMPLE_COUNTS              0x9380 | 
        
          |  | #define GL_TEXTURE_IMMUTABLE_LEVELS       0x82DF | 
        
          |  |  | 
        
          |  | // egl defines (not full) (optional) | 
        
          |  |  | 
        
          |  | #define EGL_CAST(type, value) (static_cast<type>(value)) | 
        
          |  |  | 
        
          |  | #define EGL_ALPHA_SIZE                    0x3021 | 
        
          |  | #define EGL_BAD_ACCESS                    0x3002 | 
        
          |  | #define EGL_BAD_ALLOC                     0x3003 | 
        
          |  | #define EGL_BAD_ATTRIBUTE                 0x3004 | 
        
          |  | #define EGL_BAD_CONFIG                    0x3005 | 
        
          |  | #define EGL_BAD_CONTEXT                   0x3006 | 
        
          |  | #define EGL_BAD_CURRENT_SURFACE           0x3007 | 
        
          |  | #define EGL_BAD_DISPLAY                   0x3008 | 
        
          |  | #define EGL_BAD_MATCH                     0x3009 | 
        
          |  | #define EGL_BAD_NATIVE_PIXMAP             0x300A | 
        
          |  | #define EGL_BAD_NATIVE_WINDOW             0x300B | 
        
          |  | #define EGL_BAD_PARAMETER                 0x300C | 
        
          |  | #define EGL_BAD_SURFACE                   0x300D | 
        
          |  | #define EGL_BLUE_SIZE                     0x3022 | 
        
          |  | #define EGL_BUFFER_SIZE                   0x3020 | 
        
          |  | #define EGL_CONFIG_CAVEAT                 0x3027 | 
        
          |  | #define EGL_CONFIG_ID                     0x3028 | 
        
          |  | #define EGL_CORE_NATIVE_ENGINE            0x305B | 
        
          |  | #define EGL_DEPTH_SIZE                    0x3025 | 
        
          |  | #define EGL_DONT_CARE                     EGL_CAST(EGLint,-1) | 
        
          |  | #define EGL_DRAW                          0x3059 | 
        
          |  | #define EGL_EXTENSIONS                    0x3055 | 
        
          |  | #define EGL_FALSE                         0 | 
        
          |  | #define EGL_GREEN_SIZE                    0x3023 | 
        
          |  | #define EGL_HEIGHT                        0x3056 | 
        
          |  | #define EGL_LARGEST_PBUFFER               0x3058 | 
        
          |  | #define EGL_LEVEL                         0x3029 | 
        
          |  | #define EGL_MAX_PBUFFER_HEIGHT            0x302A | 
        
          |  | #define EGL_MAX_PBUFFER_PIXELS            0x302B | 
        
          |  | #define EGL_MAX_PBUFFER_WIDTH             0x302C | 
        
          |  | #define EGL_NATIVE_RENDERABLE             0x302D | 
        
          |  | #define EGL_NATIVE_VISUAL_ID              0x302E | 
        
          |  | #define EGL_NATIVE_VISUAL_TYPE            0x302F | 
        
          |  | #define EGL_NONE                          0x3038 | 
        
          |  | #define EGL_NON_CONFORMANT_CONFIG         0x3051 | 
        
          |  | #define EGL_NOT_INITIALIZED               0x3001 | 
        
          |  | #define EGL_NO_CONTEXT                    EGL_CAST(EGLContext,0) | 
        
          |  | #define EGL_NO_DISPLAY                    EGL_CAST(EGLDisplay,0) | 
        
          |  | #define EGL_NO_SURFACE                    EGL_CAST(EGLSurface,0) | 
        
          |  | #define EGL_PBUFFER_BIT                   0x0001 | 
        
          |  | #define EGL_PIXMAP_BIT                    0x0002 | 
        
          |  | #define EGL_READ                          0x305A | 
        
          |  | #define EGL_RED_SIZE                      0x3024 | 
        
          |  | #define EGL_SAMPLES                       0x3031 | 
        
          |  | #define EGL_SAMPLE_BUFFERS                0x3032 | 
        
          |  | #define EGL_SLOW_CONFIG                   0x3050 | 
        
          |  | #define EGL_STENCIL_SIZE                  0x3026 | 
        
          |  | #define EGL_SUCCESS                       0x3000 | 
        
          |  | #define EGL_SURFACE_TYPE                  0x3033 | 
        
          |  | #define EGL_TRANSPARENT_BLUE_VALUE        0x3035 | 
        
          |  | #define EGL_TRANSPARENT_GREEN_VALUE       0x3036 | 
        
          |  | #define EGL_TRANSPARENT_RED_VALUE         0x3037 | 
        
          |  | #define EGL_TRANSPARENT_RGB               0x3052 | 
        
          |  | #define EGL_TRANSPARENT_TYPE              0x3034 | 
        
          |  | #define EGL_TRUE                          1 | 
        
          |  | #define EGL_VENDOR                        0x3053 | 
        
          |  | #define EGL_VERSION                       0x3054 | 
        
          |  | #define EGL_WIDTH                         0x3057 | 
        
          |  | #define EGL_WINDOW_BIT                    0x0004 | 
        
          |  | #define EGL_BACK_BUFFER                   0x3084 | 
        
          |  | #define EGL_BIND_TO_TEXTURE_RGB           0x3039 | 
        
          |  | #define EGL_BIND_TO_TEXTURE_RGBA          0x303A | 
        
          |  | #define EGL_CONTEXT_LOST                  0x300E | 
        
          |  | #define EGL_MIN_SWAP_INTERVAL             0x303B | 
        
          |  | #define EGL_MAX_SWAP_INTERVAL             0x303C | 
        
          |  | #define EGL_MIPMAP_TEXTURE                0x3082 | 
        
          |  | #define EGL_MIPMAP_LEVEL                  0x3083 | 
        
          |  | #define EGL_NO_TEXTURE                    0x305C | 
        
          |  | #define EGL_TEXTURE_2D                    0x305F | 
        
          |  | #define EGL_TEXTURE_FORMAT                0x3080 | 
        
          |  | #define EGL_TEXTURE_RGB                   0x305D | 
        
          |  | #define EGL_TEXTURE_RGBA                  0x305E | 
        
          |  | #define EGL_TEXTURE_TARGET                0x3081 | 
        
          |  | #define EGL_ALPHA_FORMAT                  0x3088 | 
        
          |  | #define EGL_ALPHA_FORMAT_NONPRE           0x308B | 
        
          |  | #define EGL_ALPHA_FORMAT_PRE              0x308C | 
        
          |  | #define EGL_ALPHA_MASK_SIZE               0x303E | 
        
          |  | #define EGL_BUFFER_PRESERVED              0x3094 | 
        
          |  | #define EGL_BUFFER_DESTROYED              0x3095 | 
        
          |  | #define EGL_CLIENT_APIS                   0x308D | 
        
          |  | #define EGL_COLORSPACE                    0x3087 | 
        
          |  | #define EGL_COLORSPACE_sRGB               0x3089 | 
        
          |  | #define EGL_COLORSPACE_LINEAR             0x308A | 
        
          |  | #define EGL_COLOR_BUFFER_TYPE             0x303F | 
        
          |  | #define EGL_CONTEXT_CLIENT_TYPE           0x3097 | 
        
          |  | #define EGL_DISPLAY_SCALING               10000 | 
        
          |  | #define EGL_HORIZONTAL_RESOLUTION         0x3090 | 
        
          |  | #define EGL_LUMINANCE_BUFFER              0x308F | 
        
          |  | #define EGL_LUMINANCE_SIZE                0x303D | 
        
          |  | #define EGL_OPENGL_ES_BIT                 0x0001 | 
        
          |  | #define EGL_OPENVG_BIT                    0x0002 | 
        
          |  | #define EGL_OPENGL_ES_API                 0x30A0 | 
        
          |  | #define EGL_OPENVG_API                    0x30A1 | 
        
          |  | #define EGL_OPENVG_IMAGE                  0x3096 | 
        
          |  | #define EGL_PIXEL_ASPECT_RATIO            0x3092 | 
        
          |  | #define EGL_RENDERABLE_TYPE               0x3040 | 
        
          |  | #define EGL_RENDER_BUFFER                 0x3086 | 
        
          |  | #define EGL_RGB_BUFFER                    0x308E | 
        
          |  | #define EGL_SINGLE_BUFFER                 0x3085 | 
        
          |  | #define EGL_SWAP_BEHAVIOR                 0x3093 | 
        
          |  | #define EGL_UNKNOWN                       EGL_CAST(EGLint,-1) | 
        
          |  | #define EGL_VERTICAL_RESOLUTION           0x3091 | 
        
          |  | #define EGL_CONTEXT_CLIENT_VERSION        0x3098 | 
        
          |  | #define EGL_MATCH_NATIVE_PIXMAP           0x3041 | 
        
          |  | #define EGL_OPENGL_ES2_BIT                0x0004 | 
        
          |  | #define EGL_VG_ALPHA_FORMAT               0x3088 | 
        
          |  | #define EGL_VG_ALPHA_FORMAT_NONPRE        0x308B | 
        
          |  | #define EGL_VG_ALPHA_FORMAT_PRE           0x308C | 
        
          |  | #define EGL_VG_ALPHA_FORMAT_PRE_BIT       0x0040 | 
        
          |  | #define EGL_VG_COLORSPACE                 0x3087 | 
        
          |  | #define EGL_VG_COLORSPACE_sRGB            0x3089 | 
        
          |  | #define EGL_VG_COLORSPACE_LINEAR          0x308A | 
        
          |  | #define EGL_VG_COLORSPACE_LINEAR_BIT      0x0020 | 
        
          |  | #define EGL_DEFAULT_DISPLAY               EGL_CAST(EGLNativeDisplayType,0) | 
        
          |  | #define EGL_MULTISAMPLE_RESOLVE_BOX_BIT   0x0200 | 
        
          |  | #define EGL_MULTISAMPLE_RESOLVE           0x3099 | 
        
          |  | #define EGL_MULTISAMPLE_RESOLVE_DEFAULT   0x309A | 
        
          |  | #define EGL_MULTISAMPLE_RESOLVE_BOX       0x309B | 
        
          |  | #define EGL_OPENGL_API                    0x30A2 | 
        
          |  | #define EGL_OPENGL_BIT                    0x0008 | 
        
          |  | #define EGL_SWAP_BEHAVIOR_PRESERVED_BIT   0x0400 | 
        
          |  | #define EGL_CONTEXT_MAJOR_VERSION         0x3098 | 
        
          |  | #define EGL_CONTEXT_MINOR_VERSION         0x30FB | 
        
          |  | #define EGL_CONTEXT_OPENGL_PROFILE_MASK   0x30FD | 
        
          |  | #define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY 0x31BD | 
        
          |  | #define EGL_NO_RESET_NOTIFICATION         0x31BE | 
        
          |  | #define EGL_LOSE_CONTEXT_ON_RESET         0x31BF | 
        
          |  | #define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT 0x00000001 | 
        
          |  | #define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT 0x00000002 | 
        
          |  | #define EGL_CONTEXT_OPENGL_DEBUG          0x31B0 | 
        
          |  | #define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE 0x31B1 | 
        
          |  | #define EGL_CONTEXT_OPENGL_ROBUST_ACCESS  0x31B2 | 
        
          |  | #define EGL_OPENGL_ES3_BIT                0x00000040 | 
        
          |  | #define EGL_CL_EVENT_HANDLE               0x309C | 
        
          |  | #define EGL_SYNC_CL_EVENT                 0x30FE | 
        
          |  | #define EGL_SYNC_CL_EVENT_COMPLETE        0x30FF | 
        
          |  | #define EGL_SYNC_PRIOR_COMMANDS_COMPLETE  0x30F0 | 
        
          |  | #define EGL_SYNC_TYPE                     0x30F7 | 
        
          |  | #define EGL_SYNC_STATUS                   0x30F1 | 
        
          |  | #define EGL_SYNC_CONDITION                0x30F8 | 
        
          |  | #define EGL_SIGNALED                      0x30F2 | 
        
          |  | #define EGL_UNSIGNALED                    0x30F3 | 
        
          |  | #define EGL_SYNC_FLUSH_COMMANDS_BIT       0x0001 | 
        
          |  | #define EGL_FOREVER                       0xFFFFFFFFFFFFFFFFull | 
        
          |  | #define EGL_TIMEOUT_EXPIRED               0x30F5 | 
        
          |  | #define EGL_CONDITION_SATISFIED           0x30F6 | 
        
          |  | #define EGL_NO_SYNC                       EGL_CAST(EGLSync,0) | 
        
          |  | #define EGL_SYNC_FENCE                    0x30F9 | 
        
          |  | #define EGL_GL_COLORSPACE                 0x309D | 
        
          |  | #define EGL_GL_COLORSPACE_SRGB            0x3089 | 
        
          |  | #define EGL_GL_COLORSPACE_LINEAR          0x308A | 
        
          |  | #define EGL_GL_RENDERBUFFER               0x30B9 | 
        
          |  | #define EGL_GL_TEXTURE_2D                 0x30B1 | 
        
          |  | #define EGL_GL_TEXTURE_LEVEL              0x30BC | 
        
          |  | #define EGL_GL_TEXTURE_3D                 0x30B2 | 
        
          |  | #define EGL_GL_TEXTURE_ZOFFSET            0x30BD | 
        
          |  | #define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x30B3 | 
        
          |  | #define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x30B4 | 
        
          |  | #define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x30B5 | 
        
          |  | #define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x30B6 | 
        
          |  | #define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x30B7 | 
        
          |  | #define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x30B8 | 
        
          |  | #define EGL_IMAGE_PRESERVED               0x30D2 | 
        
          |  | #define EGL_NO_IMAGE                      EGL_CAST(EGLImage,0) | 
        
          |  |  | 
        
          |  | #define EGL_CONTEXT_MAJOR_VERSION_KHR     0x3098 | 
        
          |  | #define EGL_CONTEXT_MINOR_VERSION_KHR     0x30FB | 
        
          |  | #define EGL_CONTEXT_FLAGS_KHR             0x30FC | 
        
          |  | #define EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR 0x30FD | 
        
          |  | #define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR 0x31BD | 
        
          |  | #define EGL_NO_RESET_NOTIFICATION_KHR     0x31BE | 
        
          |  | #define EGL_LOSE_CONTEXT_ON_RESET_KHR     0x31BF | 
        
          |  | #define EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR  0x00000001 | 
        
          |  | #define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR 0x00000002 | 
        
          |  | #define EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR 0x00000004 | 
        
          |  | #define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR 0x00000001 | 
        
          |  | #define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR 0x00000002 | 
        
          |  | #define EGL_OPENGL_ES3_BIT_KHR            0x00000040 | 
        
          |  |  | 
        
          |  | #define EGL_D3D9_DEVICE_ANGLE             0x33A0 | 
        
          |  | #define EGL_D3D11_DEVICE_ANGLE            0x33A1 | 
        
          |  | #define EGL_PLATFORM_DEVICE_EXT           0x313F | 
        
          |  | #define EGL_D3D_TEXTURE_ANGLE             0x33A3 | 
        
          |  | #define EGL_DISPLAY_TEXTURE_SHARE_GROUP_ANGLE 0x3AAF | 
        
          |  |  | 
        
          |  | #define EGL_PLATFORM_ANGLE_ANGLE          0x3202 | 
        
          |  | #define EGL_PLATFORM_ANGLE_TYPE_ANGLE     0x3203 | 
        
          |  | #define EGL_PLATFORM_ANGLE_MAX_VERSION_MAJOR_ANGLE 0x3204 | 
        
          |  | #define EGL_PLATFORM_ANGLE_MAX_VERSION_MINOR_ANGLE 0x3205 | 
        
          |  | #define EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE 0x3206 | 
        
          |  | #define EGL_PLATFORM_ANGLE_DEBUG_LAYERS_ENABLED_ANGLE 0x3451 | 
        
          |  | #define EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE 0x3209 | 
        
          |  | #define EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE 0x320A | 
        
          |  | #define EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE 0x345E | 
        
          |  | #define EGL_PLATFORM_ANGLE_NATIVE_PLATFORM_TYPE_ANGLE 0x348F | 
        
          |  |  | 
        
          |  | #define EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE 0x3207 | 
        
          |  | #define EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE 0x3208 | 
        
          |  | #define EGL_PLATFORM_ANGLE_DEVICE_TYPE_D3D_WARP_ANGLE 0x320B | 
        
          |  | #define EGL_PLATFORM_ANGLE_DEVICE_TYPE_D3D_REFERENCE_ANGLE 0x320C | 
        
          |  | #define EGL_PLATFORM_ANGLE_ENABLE_AUTOMATIC_TRIM_ANGLE 0x320F | 
        
          |  | } |