Joseph Marshall avatar Joseph Marshall committed da84104

Updated to include glext.h

Comments (0)

Files changed (2)

 import re
 
-HEADER_FILE = "/usr/include/GL/gl.h"
+
+# Special functions.
+def InfoLogTPL(name):
+    output(
+"""fn {name}(shader: uint) -> str unsafe {{
+    let length = 0i32;
+    let mut infoLog = [];
+    vec::grow(infoLog, 255u, 0u8);
+    let infoLog_c_str = vec::unsafe::to_ptr(infoLog);
+    GL::{name}(shader as u32, 255i32, ptr::addr_of(length), infoLog_c_str);
+    ret str::from_bytes(infoLog);
+}}""".format(name=name))
+
+
+
+HEADER_FILES = ("/usr/include/GL/gl.h", "/usr/include/GL/glext.h")
+OUT = "gl.rs"
+SKIP = ('MESA', 'ATI', 'AMD', 'NV', 'APPLE', 'ARB', 'Feedback', 'SGI',
+    'SUN', 'IBM', 'GREMEDY', 'HP', 'INTEL', 'INGR', 'OES', 'PGI', '3DFX')
 
 types = {
     "double": "f64",
     "float": "f32",
     "unsigned int": "u32",
+    "unsigned long int": "u32",
+    "long int": "i32",
     "int": "i32",
     "short": "i16",
     "unsigned short": "u16",
     "unsigned char": "u8",
     "signed char": "i8",
+    "char": "u8",
     "void": "()",
+    "void*": "*()",
+    "GLvoid*": "*()",
+    "GLvoid *": "*()",
+    "const GLubyte *": "*u8",
+    "GLenum": "u32",
+    "GLboolean": "u8",
+    "GLsizeiptr": "libc::ptrdiff_t",
+    "GLintptr": "libc::intptr_t",
+    "GLuint": "u32",
+    "GLint64 *": "*i64",
+    "GLint64": "i64",
+    "GLuint64": "u64",
 }
 class errors:
-    unknown = []
+    unknown = set()
     unknown_api = []
+    skipped_api = []
 
+_out = ""
 def output(l):
-    print(l)
+    global _out
+    _out += "\n"+l
+def flush_output():
+    fp = open(OUT, "w")
+    fp.write(_out)
+    fp.close()
 
 
+typedefd = set()
 def typedef(l):
-    m = re.match(r'typedef\s+([\w\s]+)\s+(\w+);(.*)', l)
+    m = re.match(r'typedef\s+([\w\s\*]+)\s+(\w+);(.*)', l)
     if m:
         g = m.groups()
-        output("type "+g[1].strip()+" = "+types[g[0].strip()]+"; "+g[2].strip())
-        types[g[1].strip()] = types[g[0].strip()]
+        name = g[1].strip()
+        if name in ('int64_t', 'uint64_t', 'int32_t'):
+            return
+        if name in typedefd:
+            return
+        for n in SKIP:
+            if n in name:
+                errors.unknown.add(l)
+                return
+        if name.endswith("EXT"):
+            errors.unknown.add(l)
+            return
+        typedefd.add(name)
+        if g[0].strip() not in types:
+            return
+        type = types[g[0].strip()]
+        output("type "+name+" = "+type+"; "+g[2].strip())
+        types[name] = type
     else:
-        errors.unknown.append(l)
+        errors.unknown.add(l)
 
 
+defined = {}
 def define(l):
     m = re.match(r'\#define\s+(\w+)\s+(\w+).*', l)
     if m:
         g = m.groups()
+        name = g[0]
+        if name in defined:
+            return
         if g[1] in ('extern', 'GLAPIENTRY', 'APIENTRY'):
             return
-        output("const "+g[0]+":uint = "+g[1]+"u;")
+
+        for n in SKIP:
+            if n in name:
+                errors.unknown.add(l)
+                return
+        if name.endswith('_EXT') or '_EXT_' in name:
+            errors.unknown.add(l)
+            return
+
+        value = g[1]
+        if value in defined:
+            value = defined[value]
+        else:
+            defined[name] = g[1]
+
+        o = "const "+name+":uint = "+value
+        if o.endswith('ull'):
+            o = o[:-2]
+        elif o[-1] != 'u':
+            o += 'u'
+        output(o+';')
     else:
-        errors.unknown.append(l)
+        errors.unknown.add(l)
 
 
 funcs = []
+defined_funcs = set()
 def GLAPI(l):
-    m = re.match(r'GLAPI\s+(\w+)\s+GLAPIENTRY\s+(\w+)\s*\(([\w\s\,\*\[\]]+)\).*', l)
+    m = re.match(r'GLAPI\s+([\w\s\*]+)\s+G?L?APIENTRY\s+(\w+)\s*\(([\w\s\,\*\[\]]+)\).*', l)
     if m:
+        name = m.group(2)
+        if name in defined_funcs:
+            return
+        for n in SKIP:
+            if n in name:
+                errors.skipped_api.append(l)
+                return
+        if name.endswith("EXT"):
+            errors.skipped_api.append(l)
+            return
         funcs.append(m.groups())
+        defined_funcs.add(name)
     else:
         errors.unknown_api.append(l)
 
 
-fn = open(HEADER_FILE, "r")
+
+lines = []
+for f in HEADER_FILES:
+    fp = open(f, "r")
+    lines.extend(fp.readlines())
+    fp.close()
 
 r = ""
-for l in fn.readlines():
+for l in lines:
     if l.startswith("typedef"):
         typedef(l)
     elif l.startswith("#define"):
             p = p.replace('*', '')
 
         m = re.match(r'([\w\s]+)\s+(\w+)', p)
-        if not m:
-            print p
         type = m.group(1)
         name = m.group(2)
         if name in ('type', 'fail'):
             name = name+"_"
 
         type = type.replace('const', '').strip()
+        if type == 'GLsync':
+            continue
         r.append(name+': '+ptr+types[type])
     return ', '.join(r)
 
 for g in funcs:
     ret = g[0].strip()
     name = g[1].strip()
-    if "MESA" in name or 'ATI' in name:
+    params = g[2].strip()
+    if "GLDEBUGPRO" in params:
         continue
-    params = g[2].strip()
+    if ret == 'GLsync':
+        continue
     output_funcs.append((name, parse_params(params), types[ret]))
 
 output("native mod GL {");
     'f16': 'float',
     'f8': 'float',
 
-    '()':'()'
+    '*u8': 'str',
 }
 def nice_types(params):
     if not params:
     r = []
     for p in params.split(', '):
         n,t = p.split(": ")
-        if t[0] == '*':
-            t = '*'+nice[t[1:]]
-        else:
+        if t in nice:
             t = nice[t]
         r.append(n+': '+t)
     return ', '.join(r)
 
 def cast(params):
     if not params:
-        return ''
+        return [], ''
     r = []
+    conv = []
     for p in params.split(', '):
         n,t = p.split(": ")
-        n = n+' as '+t
+        if t == '*u8':
+            conv.append(n)
+            n = n+'_c_str'
+        if t in nice:
+            n = n+' as '+t
         r.append(n)
-    return ', '.join(r)
+    return conv, ', '.join(r)
+
 
 for f in output_funcs:
     name,params,ret = f
+    if name in ('glGetShaderInfoLog', 'glGetProgramInfoLog'):
+        InfoLogTPL(name);
+        continue
+    if ret in nice:
+        ret = nice[ret]
+        ret_rep = ' as '+ret
+    else:
+        ret_rep = ''
     output('fn '+name+'('+nice_types(params)+') -> '+ret+' unsafe {')
-    output('    ret GL::'+name+'('+cast(params)+');')
+    conv, p = cast(params)
+    for n in conv:
+        output('    let '+n+'_c_str = str::as_c_str('+n+') { |'+n+'_| '+n+'_ };')
+    if ret == 'str':
+        output('    ret str::unsafe::from_buf(GL::'+name+'('+p+'));')
+    else:
+        output('    ret GL::'+name+'('+p+')'+ret_rep+';')
     output('}')
+
+flush_output()
+
+for e in errors.unknown_api:
+    print ("[failed] "+e)
+
+print('skipped '+str(len(errors.unknown))+' defines and typedefs')
+print('skipped '+str(len(errors.skipped_api))+' functions')
+print('failed to export '+str(len(errors.unknown_api))+' functions')
+
 const WIN32_LEAN_AND_MEAN:uint = 1u;
 const GL_VERSION_1_1:uint = 1u;
 const GL_VERSION_1_2:uint = 1u;
 const GL_VERSION_1_3:uint = 1u;
-const GL_ARB_imaging:uint = 1u;
 type GLenum = u32; 
 type GLboolean = u8; 
 type GLbitfield = u32; 
 const GL_LIGHT7:uint = 0x4007u;
 const GL_SPOT_EXPONENT:uint = 0x1205u;
 const GL_SPOT_CUTOFF:uint = 0x1206u;
-const GL_CONSTANT_ATTENUATION:uint = 0x1207u;
-const GL_LINEAR_ATTENUATION:uint = 0x1208u;
-const GL_QUADRATIC_ATTENUATION:uint = 0x1209u;
 const GL_AMBIENT:uint = 0x1200u;
 const GL_DIFFUSE:uint = 0x1201u;
 const GL_SPECULAR:uint = 0x1202u;
 const GL_CLEAR:uint = 0x1500u;
 const GL_SET:uint = 0x150Fu;
 const GL_COPY:uint = 0x1503u;
-const GL_COPY_INVERTED:uint = 0x150Cu;
 const GL_NOOP:uint = 0x1505u;
-const GL_INVERT:uint = 0x150Au;
 const GL_AND:uint = 0x1501u;
 const GL_NAND:uint = 0x150Eu;
 const GL_OR:uint = 0x1507u;
 const GL_XOR:uint = 0x1506u;
 const GL_EQUIV:uint = 0x1509u;
 const GL_AND_REVERSE:uint = 0x1502u;
-const GL_AND_INVERTED:uint = 0x1504u;
 const GL_OR_REVERSE:uint = 0x150Bu;
-const GL_OR_INVERTED:uint = 0x150Du;
 const GL_STENCIL_BITS:uint = 0x0D57u;
 const GL_STENCIL_TEST:uint = 0x0B90u;
 const GL_STENCIL_CLEAR_VALUE:uint = 0x0B91u;
 const GL_UNPACK_SWAP_BYTES:uint = 0x0CF0u;
 const GL_ZOOM_X:uint = 0x0D16u;
 const GL_ZOOM_Y:uint = 0x0D17u;
-const GL_TEXTURE_ENV:uint = 0x2300u;
-const GL_TEXTURE_ENV_MODE:uint = 0x2200u;
 const GL_TEXTURE_1D:uint = 0x0DE0u;
 const GL_TEXTURE_2D:uint = 0x0DE1u;
 const GL_TEXTURE_WRAP_S:uint = 0x2802u;
 const GL_TEXTURE_WRAP_T:uint = 0x2803u;
 const GL_TEXTURE_MAG_FILTER:uint = 0x2800u;
 const GL_TEXTURE_MIN_FILTER:uint = 0x2801u;
-const GL_TEXTURE_ENV_COLOR:uint = 0x2201u;
 const GL_TEXTURE_GEN_S:uint = 0x0C60u;
 const GL_TEXTURE_GEN_T:uint = 0x0C61u;
 const GL_TEXTURE_GEN_R:uint = 0x0C62u;
 const GL_VERSION:uint = 0x1F02u;
 const GL_EXTENSIONS:uint = 0x1F03u;
 const GL_NO_ERROR:uint = 0x0u;
-const GL_INVALID_ENUM:uint = 0x0500u;
-const GL_INVALID_VALUE:uint = 0x0501u;
-const GL_INVALID_OPERATION:uint = 0x0502u;
 const GL_STACK_OVERFLOW:uint = 0x0503u;
 const GL_STACK_UNDERFLOW:uint = 0x0504u;
 const GL_OUT_OF_MEMORY:uint = 0x0505u;
 const GL_CONSTANT_ALPHA:uint = 0x8003u;
 const GL_ONE_MINUS_CONSTANT_ALPHA:uint = 0x8004u;
 const GL_COLOR_TABLE:uint = 0x80D0u;
-const GL_POST_CONVOLUTION_COLOR_TABLE:uint = 0x80D1u;
 const GL_POST_COLOR_MATRIX_COLOR_TABLE:uint = 0x80D2u;
 const GL_PROXY_COLOR_TABLE:uint = 0x80D3u;
-const GL_PROXY_POST_CONVOLUTION_COLOR_TABLE:uint = 0x80D4u;
 const GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE:uint = 0x80D5u;
 const GL_COLOR_TABLE_SCALE:uint = 0x80D6u;
 const GL_COLOR_TABLE_BIAS:uint = 0x80D7u;
 const GL_COLOR_TABLE_ALPHA_SIZE:uint = 0x80DDu;
 const GL_COLOR_TABLE_LUMINANCE_SIZE:uint = 0x80DEu;
 const GL_COLOR_TABLE_INTENSITY_SIZE:uint = 0x80DFu;
-const GL_CONVOLUTION_1D:uint = 0x8010u;
-const GL_CONVOLUTION_2D:uint = 0x8011u;
 const GL_SEPARABLE_2D:uint = 0x8012u;
-const GL_CONVOLUTION_BORDER_MODE:uint = 0x8013u;
-const GL_CONVOLUTION_FILTER_SCALE:uint = 0x8014u;
-const GL_CONVOLUTION_FILTER_BIAS:uint = 0x8015u;
 const GL_REDUCE:uint = 0x8016u;
-const GL_CONVOLUTION_FORMAT:uint = 0x8017u;
-const GL_CONVOLUTION_WIDTH:uint = 0x8018u;
-const GL_CONVOLUTION_HEIGHT:uint = 0x8019u;
-const GL_MAX_CONVOLUTION_WIDTH:uint = 0x801Au;
-const GL_MAX_CONVOLUTION_HEIGHT:uint = 0x801Bu;
-const GL_POST_CONVOLUTION_RED_SCALE:uint = 0x801Cu;
-const GL_POST_CONVOLUTION_GREEN_SCALE:uint = 0x801Du;
-const GL_POST_CONVOLUTION_BLUE_SCALE:uint = 0x801Eu;
-const GL_POST_CONVOLUTION_ALPHA_SCALE:uint = 0x801Fu;
-const GL_POST_CONVOLUTION_RED_BIAS:uint = 0x8020u;
-const GL_POST_CONVOLUTION_GREEN_BIAS:uint = 0x8021u;
-const GL_POST_CONVOLUTION_BLUE_BIAS:uint = 0x8022u;
-const GL_POST_CONVOLUTION_ALPHA_BIAS:uint = 0x8023u;
 const GL_CONSTANT_BORDER:uint = 0x8151u;
 const GL_REPLICATE_BORDER:uint = 0x8153u;
-const GL_CONVOLUTION_BORDER_COLOR:uint = 0x8154u;
 const GL_COLOR_MATRIX:uint = 0x80B1u;
 const GL_COLOR_MATRIX_STACK_DEPTH:uint = 0x80B2u;
 const GL_MAX_COLOR_MATRIX_STACK_DEPTH:uint = 0x80B3u;
 const GL_MINMAX_FORMAT:uint = 0x802Fu;
 const GL_MINMAX_SINK:uint = 0x8030u;
 const GL_TABLE_TOO_LARGE:uint = 0x8031u;
-const GL_BLEND_EQUATION:uint = 0x8009u;
 const GL_MIN:uint = 0x8007u;
 const GL_MAX:uint = 0x8008u;
 const GL_FUNC_ADD:uint = 0x8006u;
 const GL_TEXTURE_CUBE_MAP:uint = 0x8513u;
 const GL_TEXTURE_BINDING_CUBE_MAP:uint = 0x8514u;
 const GL_TEXTURE_CUBE_MAP_POSITIVE_X:uint = 0x8515u;
-const GL_TEXTURE_CUBE_MAP_NEGATIVE_X:uint = 0x8516u;
 const GL_TEXTURE_CUBE_MAP_POSITIVE_Y:uint = 0x8517u;
-const GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:uint = 0x8518u;
 const GL_TEXTURE_CUBE_MAP_POSITIVE_Z:uint = 0x8519u;
-const GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:uint = 0x851Au;
 const GL_PROXY_TEXTURE_CUBE_MAP:uint = 0x851Bu;
 const GL_MAX_CUBE_MAP_TEXTURE_SIZE:uint = 0x851Cu;
 const GL_COMPRESSED_ALPHA:uint = 0x84E9u;
 const GL_SAMPLE_BUFFERS:uint = 0x80A8u;
 const GL_SAMPLES:uint = 0x80A9u;
 const GL_SAMPLE_COVERAGE_VALUE:uint = 0x80AAu;
-const GL_SAMPLE_COVERAGE_INVERT:uint = 0x80ABu;
 const GL_MULTISAMPLE_BIT:uint = 0x20000000u;
 const GL_TRANSPOSE_MODELVIEW_MATRIX:uint = 0x84E3u;
 const GL_TRANSPOSE_PROJECTION_MATRIX:uint = 0x84E4u;
 const GL_DOT3_RGB:uint = 0x86AEu;
 const GL_DOT3_RGBA:uint = 0x86AFu;
 const GL_CLAMP_TO_BORDER:uint = 0x812Du;
-const GL_ARB_multitexture:uint = 1u;
-const GL_TEXTURE0_ARB:uint = 0x84C0u;
-const GL_TEXTURE1_ARB:uint = 0x84C1u;
-const GL_TEXTURE2_ARB:uint = 0x84C2u;
-const GL_TEXTURE3_ARB:uint = 0x84C3u;
-const GL_TEXTURE4_ARB:uint = 0x84C4u;
-const GL_TEXTURE5_ARB:uint = 0x84C5u;
-const GL_TEXTURE6_ARB:uint = 0x84C6u;
-const GL_TEXTURE7_ARB:uint = 0x84C7u;
-const GL_TEXTURE8_ARB:uint = 0x84C8u;
-const GL_TEXTURE9_ARB:uint = 0x84C9u;
-const GL_TEXTURE10_ARB:uint = 0x84CAu;
-const GL_TEXTURE11_ARB:uint = 0x84CBu;
-const GL_TEXTURE12_ARB:uint = 0x84CCu;
-const GL_TEXTURE13_ARB:uint = 0x84CDu;
-const GL_TEXTURE14_ARB:uint = 0x84CEu;
-const GL_TEXTURE15_ARB:uint = 0x84CFu;
-const GL_TEXTURE16_ARB:uint = 0x84D0u;
-const GL_TEXTURE17_ARB:uint = 0x84D1u;
-const GL_TEXTURE18_ARB:uint = 0x84D2u;
-const GL_TEXTURE19_ARB:uint = 0x84D3u;
-const GL_TEXTURE20_ARB:uint = 0x84D4u;
-const GL_TEXTURE21_ARB:uint = 0x84D5u;
-const GL_TEXTURE22_ARB:uint = 0x84D6u;
-const GL_TEXTURE23_ARB:uint = 0x84D7u;
-const GL_TEXTURE24_ARB:uint = 0x84D8u;
-const GL_TEXTURE25_ARB:uint = 0x84D9u;
-const GL_TEXTURE26_ARB:uint = 0x84DAu;
-const GL_TEXTURE27_ARB:uint = 0x84DBu;
-const GL_TEXTURE28_ARB:uint = 0x84DCu;
-const GL_TEXTURE29_ARB:uint = 0x84DDu;
-const GL_TEXTURE30_ARB:uint = 0x84DEu;
-const GL_TEXTURE31_ARB:uint = 0x84DFu;
-const GL_ACTIVE_TEXTURE_ARB:uint = 0x84E0u;
-const GL_CLIENT_ACTIVE_TEXTURE_ARB:uint = 0x84E1u;
-const GL_MAX_TEXTURE_UNITS_ARB:uint = 0x84E2u;
-const GL_MESA_shader_debug:uint = 1u;
-const GL_DEBUG_OBJECT_MESA:uint = 0x8759u;
-const GL_DEBUG_PRINT_MESA:uint = 0x875Au;
-const GL_DEBUG_ASSERT_MESA:uint = 0x875Bu;
-const GL_MESA_packed_depth_stencil:uint = 1u;
-const GL_DEPTH_STENCIL_MESA:uint = 0x8750u;
-const GL_UNSIGNED_INT_24_8_MESA:uint = 0x8751u;
-const GL_UNSIGNED_INT_8_24_REV_MESA:uint = 0x8752u;
-const GL_UNSIGNED_SHORT_15_1_MESA:uint = 0x8753u;
-const GL_UNSIGNED_SHORT_1_15_REV_MESA:uint = 0x8754u;
-const GL_MESA_program_debug:uint = 1u;
-const GL_FRAGMENT_PROGRAM_POSITION_MESA:uint = 0x8bb0u;
-const GL_FRAGMENT_PROGRAM_CALLBACK_MESA:uint = 0x8bb1u;
-const GL_FRAGMENT_PROGRAM_CALLBACK_FUNC_MESA:uint = 0x8bb2u;
-const GL_FRAGMENT_PROGRAM_CALLBACK_DATA_MESA:uint = 0x8bb3u;
-const GL_VERTEX_PROGRAM_POSITION_MESA:uint = 0x8bb4u;
-const GL_VERTEX_PROGRAM_CALLBACK_MESA:uint = 0x8bb5u;
-const GL_VERTEX_PROGRAM_CALLBACK_FUNC_MESA:uint = 0x8bb6u;
-const GL_VERTEX_PROGRAM_CALLBACK_DATA_MESA:uint = 0x8bb7u;
-const GL_MESA_texture_array:uint = 1u;
-const GL_TEXTURE_1D_ARRAY_EXT:uint = 0x8C18u;
-const GL_PROXY_TEXTURE_1D_ARRAY_EXT:uint = 0x8C19u;
-const GL_TEXTURE_2D_ARRAY_EXT:uint = 0x8C1Au;
-const GL_PROXY_TEXTURE_2D_ARRAY_EXT:uint = 0x8C1Bu;
-const GL_TEXTURE_BINDING_1D_ARRAY_EXT:uint = 0x8C1Cu;
-const GL_TEXTURE_BINDING_2D_ARRAY_EXT:uint = 0x8C1Du;
-const GL_MAX_ARRAY_TEXTURE_LAYERS_EXT:uint = 0x88FFu;
-const GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT:uint = 0x8CD4u;
-const GL_ATI_blend_equation_separate:uint = 1u;
-const GL_ALPHA_BLEND_EQUATION_ATI:uint = 0x883Du;
-const GL_OES_EGL_image:uint = 1u;
+const GL_GLEXT_VERSION:uint = 71u;
+const GL_BLEND_DST_RGB:uint = 0x80C8u;
+const GL_BLEND_SRC_RGB:uint = 0x80C9u;
+const GL_BLEND_DST_ALPHA:uint = 0x80CAu;
+const GL_BLEND_SRC_ALPHA:uint = 0x80CBu;
+const GL_POINT_FADE_THRESHOLD_SIZE:uint = 0x8128u;
+const GL_DEPTH_COMPONENT16:uint = 0x81A5u;
+const GL_DEPTH_COMPONENT24:uint = 0x81A6u;
+const GL_DEPTH_COMPONENT32:uint = 0x81A7u;
+const GL_MIRRORED_REPEAT:uint = 0x8370u;
+const GL_MAX_TEXTURE_LOD_BIAS:uint = 0x84FDu;
+const GL_TEXTURE_LOD_BIAS:uint = 0x8501u;
+const GL_INCR_WRAP:uint = 0x8507u;
+const GL_DECR_WRAP:uint = 0x8508u;
+const GL_TEXTURE_DEPTH_SIZE:uint = 0x884Au;
+const GL_TEXTURE_COMPARE_MODE:uint = 0x884Cu;
+const GL_TEXTURE_COMPARE_FUNC:uint = 0x884Du;
+const GL_POINT_SIZE_MIN:uint = 0x8126u;
+const GL_POINT_SIZE_MAX:uint = 0x8127u;
+const GL_GENERATE_MIPMAP:uint = 0x8191u;
+const GL_GENERATE_MIPMAP_HINT:uint = 0x8192u;
+const GL_FOG_COORDINATE_SOURCE:uint = 0x8450u;
+const GL_FOG_COORDINATE:uint = 0x8451u;
+const GL_FRAGMENT_DEPTH:uint = 0x8452u;
+const GL_CURRENT_FOG_COORDINATE:uint = 0x8453u;
+const GL_FOG_COORDINATE_ARRAY_TYPE:uint = 0x8454u;
+const GL_FOG_COORDINATE_ARRAY_STRIDE:uint = 0x8455u;
+const GL_FOG_COORDINATE_ARRAY_POINTER:uint = 0x8456u;
+const GL_FOG_COORDINATE_ARRAY:uint = 0x8457u;
+const GL_COLOR_SUM:uint = 0x8458u;
+const GL_CURRENT_SECONDARY_COLOR:uint = 0x8459u;
+const GL_SECONDARY_COLOR_ARRAY_SIZE:uint = 0x845Au;
+const GL_SECONDARY_COLOR_ARRAY_TYPE:uint = 0x845Bu;
+const GL_SECONDARY_COLOR_ARRAY_STRIDE:uint = 0x845Cu;
+const GL_SECONDARY_COLOR_ARRAY_POINTER:uint = 0x845Du;
+const GL_SECONDARY_COLOR_ARRAY:uint = 0x845Eu;
+const GL_TEXTURE_FILTER_CONTROL:uint = 0x8500u;
+const GL_DEPTH_TEXTURE_MODE:uint = 0x884Bu;
+const GL_COMPARE_R_TO_TEXTURE:uint = 0x884Eu;
+const GL_BUFFER_SIZE:uint = 0x8764u;
+const GL_BUFFER_USAGE:uint = 0x8765u;
+const GL_QUERY_COUNTER_BITS:uint = 0x8864u;
+const GL_CURRENT_QUERY:uint = 0x8865u;
+const GL_QUERY_RESULT:uint = 0x8866u;
+const GL_QUERY_RESULT_AVAILABLE:uint = 0x8867u;
+const GL_ARRAY_BUFFER:uint = 0x8892u;
+const GL_ELEMENT_ARRAY_BUFFER:uint = 0x8893u;
+const GL_ARRAY_BUFFER_BINDING:uint = 0x8894u;
+const GL_ELEMENT_ARRAY_BUFFER_BINDING:uint = 0x8895u;
+const GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:uint = 0x889Fu;
+const GL_READ_ONLY:uint = 0x88B8u;
+const GL_WRITE_ONLY:uint = 0x88B9u;
+const GL_READ_WRITE:uint = 0x88BAu;
+const GL_BUFFER_ACCESS:uint = 0x88BBu;
+const GL_BUFFER_MAPPED:uint = 0x88BCu;
+const GL_BUFFER_MAP_POINTER:uint = 0x88BDu;
+const GL_STREAM_DRAW:uint = 0x88E0u;
+const GL_STREAM_READ:uint = 0x88E1u;
+const GL_STREAM_COPY:uint = 0x88E2u;
+const GL_DYNAMIC_DRAW:uint = 0x88E8u;
+const GL_DYNAMIC_READ:uint = 0x88E9u;
+const GL_DYNAMIC_COPY:uint = 0x88EAu;
+const GL_SAMPLES_PASSED:uint = 0x8914u;
+const GL_VERTEX_ARRAY_BUFFER_BINDING:uint = 0x8896u;
+const GL_NORMAL_ARRAY_BUFFER_BINDING:uint = 0x8897u;
+const GL_COLOR_ARRAY_BUFFER_BINDING:uint = 0x8898u;
+const GL_INDEX_ARRAY_BUFFER_BINDING:uint = 0x8899u;
+const GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING:uint = 0x889Au;
+const GL_EDGE_FLAG_ARRAY_BUFFER_BINDING:uint = 0x889Bu;
+const GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING:uint = 0x889Cu;
+const GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING:uint = 0x889Du;
+const GL_WEIGHT_ARRAY_BUFFER_BINDING:uint = 0x889Eu;
+const GL_FOG_COORD_SRC:uint = 0x8450u;
+const GL_FOG_COORD:uint = 0x8451u;
+const GL_CURRENT_FOG_COORD:uint = 0x8453u;
+const GL_FOG_COORD_ARRAY_TYPE:uint = 0x8454u;
+const GL_FOG_COORD_ARRAY_STRIDE:uint = 0x8455u;
+const GL_FOG_COORD_ARRAY_POINTER:uint = 0x8456u;
+const GL_FOG_COORD_ARRAY:uint = 0x8457u;
+const GL_FOG_COORD_ARRAY_BUFFER_BINDING:uint = 0x889Du;
+const GL_SRC0_RGB:uint = 0x8580u;
+const GL_SRC1_RGB:uint = 0x8581u;
+const GL_SRC2_RGB:uint = 0x8582u;
+const GL_SRC0_ALPHA:uint = 0x8588u;
+const GL_SRC1_ALPHA:uint = 0x8589u;
+const GL_SRC2_ALPHA:uint = 0x858Au;
+const GL_VERTEX_ATTRIB_ARRAY_ENABLED:uint = 0x8622u;
+const GL_VERTEX_ATTRIB_ARRAY_SIZE:uint = 0x8623u;
+const GL_VERTEX_ATTRIB_ARRAY_STRIDE:uint = 0x8624u;
+const GL_VERTEX_ATTRIB_ARRAY_TYPE:uint = 0x8625u;
+const GL_CURRENT_VERTEX_ATTRIB:uint = 0x8626u;
+const GL_VERTEX_PROGRAM_POINT_SIZE:uint = 0x8642u;
+const GL_VERTEX_ATTRIB_ARRAY_POINTER:uint = 0x8645u;
+const GL_STENCIL_BACK_FUNC:uint = 0x8800u;
+const GL_STENCIL_BACK_FAIL:uint = 0x8801u;
+const GL_STENCIL_BACK_PASS_DEPTH_FAIL:uint = 0x8802u;
+const GL_STENCIL_BACK_PASS_DEPTH_PASS:uint = 0x8803u;
+const GL_MAX_DRAW_BUFFERS:uint = 0x8824u;
+const GL_DRAW_BUFFER0:uint = 0x8825u;
+const GL_DRAW_BUFFER1:uint = 0x8826u;
+const GL_DRAW_BUFFER2:uint = 0x8827u;
+const GL_DRAW_BUFFER3:uint = 0x8828u;
+const GL_DRAW_BUFFER4:uint = 0x8829u;
+const GL_DRAW_BUFFER5:uint = 0x882Au;
+const GL_DRAW_BUFFER6:uint = 0x882Bu;
+const GL_DRAW_BUFFER7:uint = 0x882Cu;
+const GL_DRAW_BUFFER8:uint = 0x882Du;
+const GL_DRAW_BUFFER9:uint = 0x882Eu;
+const GL_DRAW_BUFFER10:uint = 0x882Fu;
+const GL_DRAW_BUFFER11:uint = 0x8830u;
+const GL_DRAW_BUFFER12:uint = 0x8831u;
+const GL_DRAW_BUFFER13:uint = 0x8832u;
+const GL_DRAW_BUFFER14:uint = 0x8833u;
+const GL_DRAW_BUFFER15:uint = 0x8834u;
+const GL_MAX_VERTEX_ATTRIBS:uint = 0x8869u;
+const GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:uint = 0x886Au;
+const GL_MAX_TEXTURE_IMAGE_UNITS:uint = 0x8872u;
+const GL_FRAGMENT_SHADER:uint = 0x8B30u;
+const GL_VERTEX_SHADER:uint = 0x8B31u;
+const GL_MAX_FRAGMENT_UNIFORM_COMPONENTS:uint = 0x8B49u;
+const GL_MAX_VERTEX_UNIFORM_COMPONENTS:uint = 0x8B4Au;
+const GL_MAX_VARYING_FLOATS:uint = 0x8B4Bu;
+const GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:uint = 0x8B4Cu;
+const GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:uint = 0x8B4Du;
+const GL_SHADER_TYPE:uint = 0x8B4Fu;
+const GL_FLOAT_VEC2:uint = 0x8B50u;
+const GL_FLOAT_VEC3:uint = 0x8B51u;
+const GL_FLOAT_VEC4:uint = 0x8B52u;
+const GL_INT_VEC2:uint = 0x8B53u;
+const GL_INT_VEC3:uint = 0x8B54u;
+const GL_INT_VEC4:uint = 0x8B55u;
+const GL_BOOL:uint = 0x8B56u;
+const GL_BOOL_VEC2:uint = 0x8B57u;
+const GL_BOOL_VEC3:uint = 0x8B58u;
+const GL_BOOL_VEC4:uint = 0x8B59u;
+const GL_FLOAT_MAT2:uint = 0x8B5Au;
+const GL_FLOAT_MAT3:uint = 0x8B5Bu;
+const GL_FLOAT_MAT4:uint = 0x8B5Cu;
+const GL_SAMPLER_1D:uint = 0x8B5Du;
+const GL_SAMPLER_2D:uint = 0x8B5Eu;
+const GL_SAMPLER_3D:uint = 0x8B5Fu;
+const GL_SAMPLER_CUBE:uint = 0x8B60u;
+const GL_SAMPLER_1D_SHADOW:uint = 0x8B61u;
+const GL_SAMPLER_2D_SHADOW:uint = 0x8B62u;
+const GL_DELETE_STATUS:uint = 0x8B80u;
+const GL_COMPILE_STATUS:uint = 0x8B81u;
+const GL_LINK_STATUS:uint = 0x8B82u;
+const GL_VALIDATE_STATUS:uint = 0x8B83u;
+const GL_INFO_LOG_LENGTH:uint = 0x8B84u;
+const GL_ATTACHED_SHADERS:uint = 0x8B85u;
+const GL_ACTIVE_UNIFORMS:uint = 0x8B86u;
+const GL_ACTIVE_UNIFORM_MAX_LENGTH:uint = 0x8B87u;
+const GL_SHADER_SOURCE_LENGTH:uint = 0x8B88u;
+const GL_ACTIVE_ATTRIBUTES:uint = 0x8B89u;
+const GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:uint = 0x8B8Au;
+const GL_SHADING_LANGUAGE_VERSION:uint = 0x8B8Cu;
+const GL_CURRENT_PROGRAM:uint = 0x8B8Du;
+const GL_POINT_SPRITE_COORD_ORIGIN:uint = 0x8CA0u;
+const GL_LOWER_LEFT:uint = 0x8CA1u;
+const GL_UPPER_LEFT:uint = 0x8CA2u;
+const GL_STENCIL_BACK_REF:uint = 0x8CA3u;
+const GL_STENCIL_BACK_VALUE_MASK:uint = 0x8CA4u;
+const GL_STENCIL_BACK_WRITEMASK:uint = 0x8CA5u;
+const GL_VERTEX_PROGRAM_TWO_SIDE:uint = 0x8643u;
+const GL_POINT_SPRITE:uint = 0x8861u;
+const GL_COORD_REPLACE:uint = 0x8862u;
+const GL_MAX_TEXTURE_COORDS:uint = 0x8871u;
+const GL_PIXEL_PACK_BUFFER:uint = 0x88EBu;
+const GL_PIXEL_UNPACK_BUFFER:uint = 0x88ECu;
+const GL_PIXEL_PACK_BUFFER_BINDING:uint = 0x88EDu;
+const GL_PIXEL_UNPACK_BUFFER_BINDING:uint = 0x88EFu;
+const GL_FLOAT_MAT2x3:uint = 0x8B65u;
+const GL_FLOAT_MAT2x4:uint = 0x8B66u;
+const GL_FLOAT_MAT3x2:uint = 0x8B67u;
+const GL_FLOAT_MAT3x4:uint = 0x8B68u;
+const GL_FLOAT_MAT4x2:uint = 0x8B69u;
+const GL_FLOAT_MAT4x3:uint = 0x8B6Au;
+const GL_SRGB:uint = 0x8C40u;
+const GL_SRGB8:uint = 0x8C41u;
+const GL_SRGB_ALPHA:uint = 0x8C42u;
+const GL_SRGB8_ALPHA8:uint = 0x8C43u;
+const GL_COMPRESSED_SRGB:uint = 0x8C48u;
+const GL_COMPRESSED_SRGB_ALPHA:uint = 0x8C49u;
+const GL_CURRENT_RASTER_SECONDARY_COLOR:uint = 0x845Fu;
+const GL_SLUMINANCE_ALPHA:uint = 0x8C44u;
+const GL_SLUMINANCE8_ALPHA8:uint = 0x8C45u;
+const GL_SLUMINANCE:uint = 0x8C46u;
+const GL_SLUMINANCE8:uint = 0x8C47u;
+const GL_COMPRESSED_SLUMINANCE:uint = 0x8C4Au;
+const GL_COMPRESSED_SLUMINANCE_ALPHA:uint = 0x8C4Bu;
+const GL_COMPARE_REF_TO_TEXTURE:uint = 0x884Eu;
+const GL_CLIP_DISTANCE0:uint = 0x3000u;
+const GL_CLIP_DISTANCE1:uint = 0x3001u;
+const GL_CLIP_DISTANCE2:uint = 0x3002u;
+const GL_CLIP_DISTANCE3:uint = 0x3003u;
+const GL_CLIP_DISTANCE4:uint = 0x3004u;
+const GL_CLIP_DISTANCE5:uint = 0x3005u;
+const GL_CLIP_DISTANCE6:uint = 0x3006u;
+const GL_CLIP_DISTANCE7:uint = 0x3007u;
+const GL_MAX_CLIP_DISTANCES:uint = 0x0D32u;
+const GL_MAJOR_VERSION:uint = 0x821Bu;
+const GL_MINOR_VERSION:uint = 0x821Cu;
+const GL_NUM_EXTENSIONS:uint = 0x821Du;
+const GL_CONTEXT_FLAGS:uint = 0x821Eu;
+const GL_DEPTH_BUFFER:uint = 0x8223u;
+const GL_STENCIL_BUFFER:uint = 0x8224u;
+const GL_COMPRESSED_RED:uint = 0x8225u;
+const GL_COMPRESSED_RG:uint = 0x8226u;
+const GL_RGBA32F:uint = 0x8814u;
+const GL_RGB32F:uint = 0x8815u;
+const GL_RGBA16F:uint = 0x881Au;
+const GL_RGB16F:uint = 0x881Bu;
+const GL_VERTEX_ATTRIB_ARRAY_INTEGER:uint = 0x88FDu;
+const GL_MAX_ARRAY_TEXTURE_LAYERS:uint = 0x88FFu;
+const GL_MIN_PROGRAM_TEXEL_OFFSET:uint = 0x8904u;
+const GL_MAX_PROGRAM_TEXEL_OFFSET:uint = 0x8905u;
+const GL_CLAMP_READ_COLOR:uint = 0x891Cu;
+const GL_FIXED_ONLY:uint = 0x891Du;
+const GL_MAX_VARYING_COMPONENTS:uint = 0x8B4Bu;
+const GL_TEXTURE_1D_ARRAY:uint = 0x8C18u;
+const GL_PROXY_TEXTURE_1D_ARRAY:uint = 0x8C19u;
+const GL_TEXTURE_2D_ARRAY:uint = 0x8C1Au;
+const GL_PROXY_TEXTURE_2D_ARRAY:uint = 0x8C1Bu;
+const GL_TEXTURE_BINDING_1D_ARRAY:uint = 0x8C1Cu;
+const GL_TEXTURE_BINDING_2D_ARRAY:uint = 0x8C1Du;
+const GL_R11F_G11F_B10F:uint = 0x8C3Au;
+const GL_UNSIGNED_INT_10F_11F_11F_REV:uint = 0x8C3Bu;
+const GL_RGB9_E5:uint = 0x8C3Du;
+const GL_UNSIGNED_INT_5_9_9_9_REV:uint = 0x8C3Eu;
+const GL_TEXTURE_SHARED_SIZE:uint = 0x8C3Fu;
+const GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH:uint = 0x8C76u;
+const GL_TRANSFORM_FEEDBACK_BUFFER_MODE:uint = 0x8C7Fu;
+const GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS:uint = 0x8C80u;
+const GL_TRANSFORM_FEEDBACK_VARYINGS:uint = 0x8C83u;
+const GL_TRANSFORM_FEEDBACK_BUFFER_START:uint = 0x8C84u;
+const GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:uint = 0x8C85u;
+const GL_PRIMITIVES_GENERATED:uint = 0x8C87u;
+const GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:uint = 0x8C88u;
+const GL_RASTERIZER_DISCARD:uint = 0x8C89u;
+const GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS:uint = 0x8C8Au;
+const GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS:uint = 0x8C8Bu;
+const GL_INTERLEAVED_ATTRIBS:uint = 0x8C8Cu;
+const GL_SEPARATE_ATTRIBS:uint = 0x8C8Du;
+const GL_TRANSFORM_FEEDBACK_BUFFER:uint = 0x8C8Eu;
+const GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:uint = 0x8C8Fu;
+const GL_RGBA32UI:uint = 0x8D70u;
+const GL_RGB32UI:uint = 0x8D71u;
+const GL_RGBA16UI:uint = 0x8D76u;
+const GL_RGB16UI:uint = 0x8D77u;
+const GL_RGBA8UI:uint = 0x8D7Cu;
+const GL_RGB8UI:uint = 0x8D7Du;
+const GL_RGBA32I:uint = 0x8D82u;
+const GL_RGB32I:uint = 0x8D83u;
+const GL_RGBA16I:uint = 0x8D88u;
+const GL_RGB16I:uint = 0x8D89u;
+const GL_RGBA8I:uint = 0x8D8Eu;
+const GL_RGB8I:uint = 0x8D8Fu;
+const GL_RED_INTEGER:uint = 0x8D94u;
+const GL_GREEN_INTEGER:uint = 0x8D95u;
+const GL_BLUE_INTEGER:uint = 0x8D96u;
+const GL_RGB_INTEGER:uint = 0x8D98u;
+const GL_RGBA_INTEGER:uint = 0x8D99u;
+const GL_BGR_INTEGER:uint = 0x8D9Au;
+const GL_BGRA_INTEGER:uint = 0x8D9Bu;
+const GL_SAMPLER_1D_ARRAY:uint = 0x8DC0u;
+const GL_SAMPLER_2D_ARRAY:uint = 0x8DC1u;
+const GL_SAMPLER_1D_ARRAY_SHADOW:uint = 0x8DC3u;
+const GL_SAMPLER_2D_ARRAY_SHADOW:uint = 0x8DC4u;
+const GL_SAMPLER_CUBE_SHADOW:uint = 0x8DC5u;
+const GL_UNSIGNED_INT_VEC2:uint = 0x8DC6u;
+const GL_UNSIGNED_INT_VEC3:uint = 0x8DC7u;
+const GL_UNSIGNED_INT_VEC4:uint = 0x8DC8u;
+const GL_INT_SAMPLER_1D:uint = 0x8DC9u;
+const GL_INT_SAMPLER_2D:uint = 0x8DCAu;
+const GL_INT_SAMPLER_3D:uint = 0x8DCBu;
+const GL_INT_SAMPLER_CUBE:uint = 0x8DCCu;
+const GL_INT_SAMPLER_1D_ARRAY:uint = 0x8DCEu;
+const GL_INT_SAMPLER_2D_ARRAY:uint = 0x8DCFu;
+const GL_UNSIGNED_INT_SAMPLER_1D:uint = 0x8DD1u;
+const GL_UNSIGNED_INT_SAMPLER_2D:uint = 0x8DD2u;
+const GL_UNSIGNED_INT_SAMPLER_3D:uint = 0x8DD3u;
+const GL_UNSIGNED_INT_SAMPLER_CUBE:uint = 0x8DD4u;
+const GL_UNSIGNED_INT_SAMPLER_1D_ARRAY:uint = 0x8DD6u;
+const GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:uint = 0x8DD7u;
+const GL_QUERY_WAIT:uint = 0x8E13u;
+const GL_QUERY_NO_WAIT:uint = 0x8E14u;
+const GL_QUERY_BY_REGION_WAIT:uint = 0x8E15u;
+const GL_QUERY_BY_REGION_NO_WAIT:uint = 0x8E16u;
+const GL_BUFFER_ACCESS_FLAGS:uint = 0x911Fu;
+const GL_BUFFER_MAP_LENGTH:uint = 0x9120u;
+const GL_BUFFER_MAP_OFFSET:uint = 0x9121u;
+const GL_CLAMP_VERTEX_COLOR:uint = 0x891Au;
+const GL_CLAMP_FRAGMENT_COLOR:uint = 0x891Bu;
+const GL_ALPHA_INTEGER:uint = 0x8D97u;
+const GL_SAMPLER_2D_RECT:uint = 0x8B63u;
+const GL_SAMPLER_2D_RECT_SHADOW:uint = 0x8B64u;
+const GL_SAMPLER_BUFFER:uint = 0x8DC2u;
+const GL_INT_SAMPLER_2D_RECT:uint = 0x8DCDu;
+const GL_INT_SAMPLER_BUFFER:uint = 0x8DD0u;
+const GL_UNSIGNED_INT_SAMPLER_2D_RECT:uint = 0x8DD5u;
+const GL_UNSIGNED_INT_SAMPLER_BUFFER:uint = 0x8DD8u;
+const GL_TEXTURE_BUFFER:uint = 0x8C2Au;
+const GL_MAX_TEXTURE_BUFFER_SIZE:uint = 0x8C2Bu;
+const GL_TEXTURE_BINDING_BUFFER:uint = 0x8C2Cu;
+const GL_TEXTURE_BUFFER_DATA_STORE_BINDING:uint = 0x8C2Du;
+const GL_TEXTURE_BUFFER_FORMAT:uint = 0x8C2Eu;
+const GL_TEXTURE_RECTANGLE:uint = 0x84F5u;
+const GL_TEXTURE_BINDING_RECTANGLE:uint = 0x84F6u;
+const GL_PROXY_TEXTURE_RECTANGLE:uint = 0x84F7u;
+const GL_MAX_RECTANGLE_TEXTURE_SIZE:uint = 0x84F8u;
+const GL_RED_SNORM:uint = 0x8F90u;
+const GL_RG_SNORM:uint = 0x8F91u;
+const GL_RGB_SNORM:uint = 0x8F92u;
+const GL_RGBA_SNORM:uint = 0x8F93u;
+const GL_R8_SNORM:uint = 0x8F94u;
+const GL_RG8_SNORM:uint = 0x8F95u;
+const GL_RGB8_SNORM:uint = 0x8F96u;
+const GL_RGBA8_SNORM:uint = 0x8F97u;
+const GL_R16_SNORM:uint = 0x8F98u;
+const GL_RG16_SNORM:uint = 0x8F99u;
+const GL_RGB16_SNORM:uint = 0x8F9Au;
+const GL_RGBA16_SNORM:uint = 0x8F9Bu;
+const GL_SIGNED_NORMALIZED:uint = 0x8F9Cu;
+const GL_PRIMITIVE_RESTART:uint = 0x8F9Du;
+const GL_PRIMITIVE_RESTART_INDEX:uint = 0x8F9Eu;
+const GL_CONTEXT_CORE_PROFILE_BIT:uint = 0x00000001u;
+const GL_LINES_ADJACENCY:uint = 0x000Au;
+const GL_LINE_STRIP_ADJACENCY:uint = 0x000Bu;
+const GL_TRIANGLES_ADJACENCY:uint = 0x000Cu;
+const GL_TRIANGLE_STRIP_ADJACENCY:uint = 0x000Du;
+const GL_PROGRAM_POINT_SIZE:uint = 0x8642u;
+const GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS:uint = 0x8C29u;
+const GL_FRAMEBUFFER_ATTACHMENT_LAYERED:uint = 0x8DA7u;
+const GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS:uint = 0x8DA8u;
+const GL_GEOMETRY_SHADER:uint = 0x8DD9u;
+const GL_GEOMETRY_VERTICES_OUT:uint = 0x8916u;
+const GL_GEOMETRY_INPUT_TYPE:uint = 0x8917u;
+const GL_GEOMETRY_OUTPUT_TYPE:uint = 0x8918u;
+const GL_MAX_GEOMETRY_UNIFORM_COMPONENTS:uint = 0x8DDFu;
+const GL_MAX_GEOMETRY_OUTPUT_VERTICES:uint = 0x8DE0u;
+const GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS:uint = 0x8DE1u;
+const GL_MAX_VERTEX_OUTPUT_COMPONENTS:uint = 0x9122u;
+const GL_MAX_GEOMETRY_INPUT_COMPONENTS:uint = 0x9123u;
+const GL_MAX_GEOMETRY_OUTPUT_COMPONENTS:uint = 0x9124u;
+const GL_MAX_FRAGMENT_INPUT_COMPONENTS:uint = 0x9125u;
+const GL_CONTEXT_PROFILE_MASK:uint = 0x9126u;
+const GL_VERTEX_ATTRIB_ARRAY_DIVISOR:uint = 0x88FEu;
+const GL_SAMPLE_SHADING:uint = 0x8C36u;
+const GL_MIN_SAMPLE_SHADING_VALUE:uint = 0x8C37u;
+const GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET:uint = 0x8E5Eu;
+const GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET:uint = 0x8E5Fu;
+const GL_TEXTURE_CUBE_MAP_ARRAY:uint = 0x9009u;
+const GL_TEXTURE_BINDING_CUBE_MAP_ARRAY:uint = 0x900Au;
+const GL_PROXY_TEXTURE_CUBE_MAP_ARRAY:uint = 0x900Bu;
+const GL_SAMPLER_CUBE_MAP_ARRAY:uint = 0x900Cu;
+const GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW:uint = 0x900Du;
+const GL_INT_SAMPLER_CUBE_MAP_ARRAY:uint = 0x900Eu;
+const GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY:uint = 0x900Fu;
+const GL_DEPTH_COMPONENT32F:uint = 0x8CACu;
+const GL_DEPTH32F_STENCIL8:uint = 0x8CADu;
+const GL_FLOAT_32_UNSIGNED_INT_24_8_REV:uint = 0x8DADu;
+const GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING:uint = 0x8210u;
+const GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE:uint = 0x8211u;
+const GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:uint = 0x8212u;
+const GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:uint = 0x8213u;
+const GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:uint = 0x8214u;
+const GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:uint = 0x8215u;
+const GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:uint = 0x8216u;
+const GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:uint = 0x8217u;
+const GL_FRAMEBUFFER_DEFAULT:uint = 0x8218u;
+const GL_FRAMEBUFFER_UNDEFINED:uint = 0x8219u;
+const GL_DEPTH_STENCIL_ATTACHMENT:uint = 0x821Au;
+const GL_MAX_RENDERBUFFER_SIZE:uint = 0x84E8u;
+const GL_DEPTH_STENCIL:uint = 0x84F9u;
+const GL_UNSIGNED_INT_24_8:uint = 0x84FAu;
+const GL_DEPTH24_STENCIL8:uint = 0x88F0u;
+const GL_TEXTURE_STENCIL_SIZE:uint = 0x88F1u;
+const GL_TEXTURE_RED_TYPE:uint = 0x8C10u;
+const GL_TEXTURE_GREEN_TYPE:uint = 0x8C11u;
+const GL_TEXTURE_BLUE_TYPE:uint = 0x8C12u;
+const GL_TEXTURE_ALPHA_TYPE:uint = 0x8C13u;
+const GL_TEXTURE_DEPTH_TYPE:uint = 0x8C16u;
+const GL_UNSIGNED_NORMALIZED:uint = 0x8C17u;
+const GL_FRAMEBUFFER_BINDING:uint = 0x8CA6u;
+const GL_DRAW_FRAMEBUFFER_BINDING:uint = 0x8CA6u;
+const GL_RENDERBUFFER_BINDING:uint = 0x8CA7u;
+const GL_READ_FRAMEBUFFER:uint = 0x8CA8u;
+const GL_DRAW_FRAMEBUFFER:uint = 0x8CA9u;
+const GL_READ_FRAMEBUFFER_BINDING:uint = 0x8CAAu;
+const GL_RENDERBUFFER_SAMPLES:uint = 0x8CABu;
+const GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:uint = 0x8CD0u;
+const GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:uint = 0x8CD1u;
+const GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:uint = 0x8CD2u;
+const GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:uint = 0x8CD3u;
+const GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER:uint = 0x8CD4u;
+const GL_FRAMEBUFFER_COMPLETE:uint = 0x8CD5u;
+const GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:uint = 0x8CD6u;
+const GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:uint = 0x8CD7u;
+const GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER:uint = 0x8CDBu;
+const GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER:uint = 0x8CDCu;
+const GL_FRAMEBUFFER_UNSUPPORTED:uint = 0x8CDDu;
+const GL_MAX_COLOR_ATTACHMENTS:uint = 0x8CDFu;
+const GL_COLOR_ATTACHMENT0:uint = 0x8CE0u;
+const GL_COLOR_ATTACHMENT1:uint = 0x8CE1u;
+const GL_COLOR_ATTACHMENT2:uint = 0x8CE2u;
+const GL_COLOR_ATTACHMENT3:uint = 0x8CE3u;
+const GL_COLOR_ATTACHMENT4:uint = 0x8CE4u;
+const GL_COLOR_ATTACHMENT5:uint = 0x8CE5u;
+const GL_COLOR_ATTACHMENT6:uint = 0x8CE6u;
+const GL_COLOR_ATTACHMENT7:uint = 0x8CE7u;
+const GL_COLOR_ATTACHMENT8:uint = 0x8CE8u;
+const GL_COLOR_ATTACHMENT9:uint = 0x8CE9u;
+const GL_COLOR_ATTACHMENT10:uint = 0x8CEAu;
+const GL_COLOR_ATTACHMENT11:uint = 0x8CEBu;
+const GL_COLOR_ATTACHMENT12:uint = 0x8CECu;
+const GL_COLOR_ATTACHMENT13:uint = 0x8CEDu;
+const GL_COLOR_ATTACHMENT14:uint = 0x8CEEu;
+const GL_COLOR_ATTACHMENT15:uint = 0x8CEFu;
+const GL_DEPTH_ATTACHMENT:uint = 0x8D00u;
+const GL_STENCIL_ATTACHMENT:uint = 0x8D20u;
+const GL_FRAMEBUFFER:uint = 0x8D40u;
+const GL_RENDERBUFFER:uint = 0x8D41u;
+const GL_RENDERBUFFER_WIDTH:uint = 0x8D42u;
+const GL_RENDERBUFFER_HEIGHT:uint = 0x8D43u;
+const GL_RENDERBUFFER_INTERNAL_FORMAT:uint = 0x8D44u;
+const GL_STENCIL_INDEX1:uint = 0x8D46u;
+const GL_STENCIL_INDEX4:uint = 0x8D47u;
+const GL_STENCIL_INDEX8:uint = 0x8D48u;
+const GL_STENCIL_INDEX16:uint = 0x8D49u;
+const GL_RENDERBUFFER_RED_SIZE:uint = 0x8D50u;
+const GL_RENDERBUFFER_GREEN_SIZE:uint = 0x8D51u;
+const GL_RENDERBUFFER_BLUE_SIZE:uint = 0x8D52u;
+const GL_RENDERBUFFER_ALPHA_SIZE:uint = 0x8D53u;
+const GL_RENDERBUFFER_DEPTH_SIZE:uint = 0x8D54u;
+const GL_RENDERBUFFER_STENCIL_SIZE:uint = 0x8D55u;
+const GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:uint = 0x8D56u;
+const GL_MAX_SAMPLES:uint = 0x8D57u;
+const GL_INDEX:uint = 0x8222u;
+const GL_TEXTURE_LUMINANCE_TYPE:uint = 0x8C14u;
+const GL_TEXTURE_INTENSITY_TYPE:uint = 0x8C15u;
+const GL_FRAMEBUFFER_SRGB:uint = 0x8DB9u;
+const GL_HALF_FLOAT:uint = 0x140Bu;
+const GL_MAP_READ_BIT:uint = 0x0001u;
+const GL_MAP_WRITE_BIT:uint = 0x0002u;
+const GL_MAP_FLUSH_EXPLICIT_BIT:uint = 0x0010u;
+const GL_MAP_UNSYNCHRONIZED_BIT:uint = 0x0020u;
+const GL_COMPRESSED_RED_RGTC1:uint = 0x8DBBu;
+const GL_COMPRESSED_SIGNED_RED_RGTC1:uint = 0x8DBCu;
+const GL_COMPRESSED_RG_RGTC2:uint = 0x8DBDu;
+const GL_COMPRESSED_SIGNED_RG_RGTC2:uint = 0x8DBEu;
+const GL_RG:uint = 0x8227u;
+const GL_RG_INTEGER:uint = 0x8228u;
+const GL_R8:uint = 0x8229u;
+const GL_R16:uint = 0x822Au;
+const GL_RG8:uint = 0x822Bu;
+const GL_RG16:uint = 0x822Cu;
+const GL_R16F:uint = 0x822Du;
+const GL_R32F:uint = 0x822Eu;
+const GL_RG16F:uint = 0x822Fu;
+const GL_RG32F:uint = 0x8230u;
+const GL_R8I:uint = 0x8231u;
+const GL_R8UI:uint = 0x8232u;
+const GL_R16I:uint = 0x8233u;
+const GL_R16UI:uint = 0x8234u;
+const GL_R32I:uint = 0x8235u;
+const GL_R32UI:uint = 0x8236u;
+const GL_RG8I:uint = 0x8237u;
+const GL_RG8UI:uint = 0x8238u;
+const GL_RG16I:uint = 0x8239u;
+const GL_RG16UI:uint = 0x823Au;
+const GL_RG32I:uint = 0x823Bu;
+const GL_RG32UI:uint = 0x823Cu;
+const GL_VERTEX_ARRAY_BINDING:uint = 0x85B5u;
+const GL_UNIFORM_BUFFER:uint = 0x8A11u;
+const GL_UNIFORM_BUFFER_BINDING:uint = 0x8A28u;
+const GL_UNIFORM_BUFFER_START:uint = 0x8A29u;
+const GL_UNIFORM_BUFFER_SIZE:uint = 0x8A2Au;
+const GL_MAX_VERTEX_UNIFORM_BLOCKS:uint = 0x8A2Bu;
+const GL_MAX_GEOMETRY_UNIFORM_BLOCKS:uint = 0x8A2Cu;
+const GL_MAX_FRAGMENT_UNIFORM_BLOCKS:uint = 0x8A2Du;
+const GL_MAX_COMBINED_UNIFORM_BLOCKS:uint = 0x8A2Eu;
+const GL_MAX_UNIFORM_BUFFER_BINDINGS:uint = 0x8A2Fu;
+const GL_MAX_UNIFORM_BLOCK_SIZE:uint = 0x8A30u;
+const GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS:uint = 0x8A31u;
+const GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS:uint = 0x8A32u;
+const GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS:uint = 0x8A33u;
+const GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:uint = 0x8A34u;
+const GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH:uint = 0x8A35u;
+const GL_ACTIVE_UNIFORM_BLOCKS:uint = 0x8A36u;
+const GL_UNIFORM_TYPE:uint = 0x8A37u;
+const GL_UNIFORM_SIZE:uint = 0x8A38u;
+const GL_UNIFORM_NAME_LENGTH:uint = 0x8A39u;
+const GL_UNIFORM_BLOCK_INDEX:uint = 0x8A3Au;
+const GL_UNIFORM_OFFSET:uint = 0x8A3Bu;
+const GL_UNIFORM_ARRAY_STRIDE:uint = 0x8A3Cu;
+const GL_UNIFORM_MATRIX_STRIDE:uint = 0x8A3Du;
+const GL_UNIFORM_IS_ROW_MAJOR:uint = 0x8A3Eu;
+const GL_UNIFORM_BLOCK_BINDING:uint = 0x8A3Fu;
+const GL_UNIFORM_BLOCK_DATA_SIZE:uint = 0x8A40u;
+const GL_UNIFORM_BLOCK_NAME_LENGTH:uint = 0x8A41u;
+const GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS:uint = 0x8A42u;
+const GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES:uint = 0x8A43u;
+const GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER:uint = 0x8A44u;
+const GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER:uint = 0x8A45u;
+const GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER:uint = 0x8A46u;
+const GL_COPY_READ_BUFFER:uint = 0x8F36u;
+const GL_COPY_WRITE_BUFFER:uint = 0x8F37u;
+const GL_DEPTH_CLAMP:uint = 0x864Fu;
+const GL_PROVOKING_VERTEX:uint = 0x8E4Fu;
+const GL_TEXTURE_CUBE_MAP_SEAMLESS:uint = 0x884Fu;
+const GL_MAX_SERVER_WAIT_TIMEOUT:uint = 0x9111u;
+const GL_OBJECT_TYPE:uint = 0x9112u;
+const GL_SYNC_CONDITION:uint = 0x9113u;
+const GL_SYNC_STATUS:uint = 0x9114u;
+const GL_SYNC_FLAGS:uint = 0x9115u;
+const GL_SYNC_FENCE:uint = 0x9116u;
+const GL_SYNC_GPU_COMMANDS_COMPLETE:uint = 0x9117u;
+const GL_UNSIGNALED:uint = 0x9118u;
+const GL_SIGNALED:uint = 0x9119u;
+const GL_ALREADY_SIGNALED:uint = 0x911Au;
+const GL_TIMEOUT_EXPIRED:uint = 0x911Bu;
+const GL_WAIT_FAILED:uint = 0x911Du;
+const GL_SYNC_FLUSH_COMMANDS_BIT:uint = 0x00000001u;
+const GL_TIMEOUT_IGNORED:uint = 0xFFFFFFFFFFFFFFFFu;
+const GL_SAMPLE_POSITION:uint = 0x8E50u;
+const GL_SAMPLE_MASK:uint = 0x8E51u;
+const GL_SAMPLE_MASK_VALUE:uint = 0x8E52u;
+const GL_MAX_SAMPLE_MASK_WORDS:uint = 0x8E59u;
+const GL_TEXTURE_2D_MULTISAMPLE:uint = 0x9100u;
+const GL_PROXY_TEXTURE_2D_MULTISAMPLE:uint = 0x9101u;
+const GL_TEXTURE_2D_MULTISAMPLE_ARRAY:uint = 0x9102u;
+const GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY:uint = 0x9103u;
+const GL_TEXTURE_BINDING_2D_MULTISAMPLE:uint = 0x9104u;
+const GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY:uint = 0x9105u;
+const GL_TEXTURE_SAMPLES:uint = 0x9106u;
+const GL_SAMPLER_2D_MULTISAMPLE:uint = 0x9108u;
+const GL_INT_SAMPLER_2D_MULTISAMPLE:uint = 0x9109u;
+const GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:uint = 0x910Au;
+const GL_SAMPLER_2D_MULTISAMPLE_ARRAY:uint = 0x910Bu;
+const GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:uint = 0x910Cu;
+const GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:uint = 0x910Du;
+const GL_MAX_COLOR_TEXTURE_SAMPLES:uint = 0x910Eu;
+const GL_MAX_DEPTH_TEXTURE_SAMPLES:uint = 0x910Fu;
+const GL_MAX_INTEGER_SAMPLES:uint = 0x9110u;
+const GL_SRC1_COLOR:uint = 0x88F9u;
+const GL_ONE_MINUS_SRC1_COLOR:uint = 0x88FAu;
+const GL_ONE_MINUS_SRC1_ALPHA:uint = 0x88FBu;
+const GL_MAX_DUAL_SOURCE_DRAW_BUFFERS:uint = 0x88FCu;
+const GL_ANY_SAMPLES_PASSED:uint = 0x8C2Fu;
+const GL_SAMPLER_BINDING:uint = 0x8919u;
+const GL_RGB10_A2UI:uint = 0x906Fu;
+const GL_TEXTURE_SWIZZLE_R:uint = 0x8E42u;
+const GL_TEXTURE_SWIZZLE_G:uint = 0x8E43u;
+const GL_TEXTURE_SWIZZLE_B:uint = 0x8E44u;
+const GL_TEXTURE_SWIZZLE_A:uint = 0x8E45u;
+const GL_TEXTURE_SWIZZLE_RGBA:uint = 0x8E46u;
+const GL_TIME_ELAPSED:uint = 0x88BFu;
+const GL_TIMESTAMP:uint = 0x8E28u;
+const GL_INT_2_10_10_10_REV:uint = 0x8D9Fu;
+const GL_DRAW_INDIRECT_BUFFER:uint = 0x8F3Fu;
+const GL_DRAW_INDIRECT_BUFFER_BINDING:uint = 0x8F43u;
+const GL_DOUBLE_VEC2:uint = 0x8FFCu;
+const GL_DOUBLE_VEC3:uint = 0x8FFDu;
+const GL_DOUBLE_VEC4:uint = 0x8FFEu;
+const GL_DOUBLE_MAT2:uint = 0x8F46u;
+const GL_DOUBLE_MAT3:uint = 0x8F47u;
+const GL_DOUBLE_MAT4:uint = 0x8F48u;
+const GL_DOUBLE_MAT2x3:uint = 0x8F49u;
+const GL_DOUBLE_MAT2x4:uint = 0x8F4Au;
+const GL_DOUBLE_MAT3x2:uint = 0x8F4Bu;
+const GL_DOUBLE_MAT3x4:uint = 0x8F4Cu;
+const GL_DOUBLE_MAT4x2:uint = 0x8F4Du;
+const GL_DOUBLE_MAT4x3:uint = 0x8F4Eu;
+const GL_ACTIVE_SUBROUTINES:uint = 0x8DE5u;
+const GL_ACTIVE_SUBROUTINE_UNIFORMS:uint = 0x8DE6u;
+const GL_ACTIVE_SUBROUTINE_MAX_LENGTH:uint = 0x8E48u;
+const GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH:uint = 0x8E49u;
+const GL_MAX_SUBROUTINES:uint = 0x8DE7u;
+const GL_PATCHES:uint = 0x000Eu;
+const GL_PATCH_VERTICES:uint = 0x8E72u;
+const GL_PATCH_DEFAULT_INNER_LEVEL:uint = 0x8E73u;
+const GL_PATCH_DEFAULT_OUTER_LEVEL:uint = 0x8E74u;
+const GL_TESS_CONTROL_OUTPUT_VERTICES:uint = 0x8E75u;
+const GL_TESS_GEN_MODE:uint = 0x8E76u;
+const GL_TESS_GEN_SPACING:uint = 0x8E77u;
+const GL_TESS_GEN_VERTEX_ORDER:uint = 0x8E78u;
+const GL_TESS_GEN_POINT_MODE:uint = 0x8E79u;
+const GL_ISOLINES:uint = 0x8E7Au;
+const GL_FRACTIONAL_ODD:uint = 0x8E7Bu;
+const GL_FRACTIONAL_EVEN:uint = 0x8E7Cu;
+const GL_MAX_PATCH_VERTICES:uint = 0x8E7Du;
+const GL_MAX_TESS_GEN_LEVEL:uint = 0x8E7Eu;
+const GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS:uint = 0x8E7Fu;
+const GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS:uint = 0x8E81u;
+const GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS:uint = 0x8E83u;
+const GL_MAX_TESS_PATCH_COMPONENTS:uint = 0x8E84u;
+const GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS:uint = 0x8E85u;
+const GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS:uint = 0x8E89u;
+const GL_MAX_TESS_CONTROL_INPUT_COMPONENTS:uint = 0x886Cu;
+const GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS:uint = 0x8E1Eu;
+const GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER:uint = 0x84F0u;
+const GL_TESS_CONTROL_SHADER:uint = 0x8E88u;
+const GL_TRANSFORM_FEEDBACK:uint = 0x8E22u;
+const GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED:uint = 0x8E23u;
+const GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE:uint = 0x8E24u;
+const GL_TRANSFORM_FEEDBACK_BINDING:uint = 0x8E25u;
+const GL_MAX_TRANSFORM_FEEDBACK_BUFFERS:uint = 0x8E70u;
+const GL_MAX_VERTEX_STREAMS:uint = 0x8E71u;
+const GL_FIXED:uint = 0x140Cu;
+const GL_LOW_FLOAT:uint = 0x8DF0u;
+const GL_MEDIUM_FLOAT:uint = 0x8DF1u;
+const GL_HIGH_FLOAT:uint = 0x8DF2u;
+const GL_LOW_INT:uint = 0x8DF3u;
+const GL_MEDIUM_INT:uint = 0x8DF4u;
+const GL_HIGH_INT:uint = 0x8DF5u;
+const GL_SHADER_COMPILER:uint = 0x8DFAu;
+const GL_NUM_SHADER_BINARY_FORMATS:uint = 0x8DF9u;
+const GL_MAX_VERTEX_UNIFORM_VECTORS:uint = 0x8DFBu;
+const GL_MAX_VARYING_VECTORS:uint = 0x8DFCu;
+const GL_MAX_FRAGMENT_UNIFORM_VECTORS:uint = 0x8DFDu;
+const GL_PROGRAM_BINARY_RETRIEVABLE_HINT:uint = 0x8257u;
+const GL_PROGRAM_BINARY_LENGTH:uint = 0x8741u;
+const GL_NUM_PROGRAM_BINARY_FORMATS:uint = 0x87FEu;
+const GL_PROGRAM_BINARY_FORMATS:uint = 0x87FFu;
+const GL_VERTEX_SHADER_BIT:uint = 0x00000001u;
+const GL_FRAGMENT_SHADER_BIT:uint = 0x00000002u;
+const GL_GEOMETRY_SHADER_BIT:uint = 0x00000004u;
+const GL_TESS_CONTROL_SHADER_BIT:uint = 0x00000008u;
+const GL_ALL_SHADER_BITS:uint = 0xFFFFFFFFu;
+const GL_PROGRAM_SEPARABLE:uint = 0x8258u;
+const GL_ACTIVE_PROGRAM:uint = 0x8259u;
+const GL_PROGRAM_PIPELINE_BINDING:uint = 0x825Au;
+const GL_MAX_VIEWPORTS:uint = 0x825Bu;
+const GL_VIEWPORT_SUBPIXEL_BITS:uint = 0x825Cu;
+const GL_VIEWPORT_BOUNDS_RANGE:uint = 0x825Du;
+const GL_LAYER_PROVOKING_VERTEX:uint = 0x825Eu;
+const GL_VIEWPORT_INDEX_PROVOKING_VERTEX:uint = 0x825Fu;
+const GL_UNDEFINED_VERTEX:uint = 0x8260u;
+const GL_PHONG_WIN:uint = 0x80EAu;
+const GL_PHONG_HINT_WIN:uint = 0x80EBu;
+const GL_FOG_SPECULAR_TEXTURE_WIN:uint = 0x80ECu;
+const GL_SCREEN_COORDINATES_REND:uint = 0x8490u;
+const GL_INTERLACE_OML:uint = 0x8980u;
+const GL_INTERLACE_READ_OML:uint = 0x8981u;
+const GL_FORMAT_SUBSAMPLE_24_24_OML:uint = 0x8982u;
+const GL_FORMAT_SUBSAMPLE_244_244_OML:uint = 0x8983u;
+const GL_PACK_RESAMPLE_OML:uint = 0x8984u;
+const GL_UNPACK_RESAMPLE_OML:uint = 0x8985u;
+const GL_RESAMPLE_REPLICATE_OML:uint = 0x8986u;
+const GL_RESAMPLE_ZERO_FILL_OML:uint = 0x8987u;
+const GL_RESAMPLE_AVERAGE_OML:uint = 0x8988u;
+const GL_RESAMPLE_DECIMATE_OML:uint = 0x8989u;
+const GL_RGB_S3TC:uint = 0x83A0u;
+const GL_RGB4_S3TC:uint = 0x83A1u;
+const GL_RGBA_S3TC:uint = 0x83A2u;
+const GL_RGBA4_S3TC:uint = 0x83A3u;
+const GL_ALPHA_SNORM:uint = 0x9010u;
+const GL_LUMINANCE_SNORM:uint = 0x9011u;
+const GL_LUMINANCE_ALPHA_SNORM:uint = 0x9012u;
+const GL_INTENSITY_SNORM:uint = 0x9013u;
+const GL_ALPHA8_SNORM:uint = 0x9014u;
+const GL_LUMINANCE8_SNORM:uint = 0x9015u;
+const GL_LUMINANCE8_ALPHA8_SNORM:uint = 0x9016u;
+const GL_INTENSITY8_SNORM:uint = 0x9017u;
+const GL_ALPHA16_SNORM:uint = 0x9018u;
+const GL_LUMINANCE16_SNORM:uint = 0x9019u;
+const GL_LUMINANCE16_ALPHA16_SNORM:uint = 0x901Au;
+const GL_INTENSITY16_SNORM:uint = 0x901Bu;
+type GLchar = u8; 
+const GL_VERSION_1_2_DEPRECATED:uint = 1u;
+const GL_VERSION_1_3_DEPRECATED:uint = 1u;
+const GL_VERSION_1_4:uint = 1u;
+const GL_VERSION_1_4_DEPRECATED:uint = 1u;
+const GL_VERSION_1_5:uint = 1u;
+const GL_VERSION_2_0:uint = 1u;
+const GL_VERSION_2_1:uint = 1u;
+const GL_VERSION_3_0:uint = 1u;
+const GL_VERSION_3_1:uint = 1u;
+const GL_VERSION_3_2:uint = 1u;
+const GL_VERSION_3_3:uint = 1u;
+const GL_VERSION_4_0:uint = 1u;
+const GL_VERSION_4_1:uint = 1u;
+const GL_WIN_phong_shading:uint = 1u;
+const GL_WIN_specular_fog:uint = 1u;
+const GL_REND_screen_coordinates:uint = 1u;
+const GL_OML_interlace:uint = 1u;
+const GL_OML_subsample:uint = 1u;
+const GL_OML_resample:uint = 1u;
+const GL_S3_s3tc:uint = 1u;
 native mod GL {
     fn SDL_GL_SwapBuffers();
     fn glClearColor(red: f32, green: f32, blue: f32, alpha: f32) -> ();
     fn glPopAttrib() -> ();
     fn glPushClientAttrib(mask: u32) -> ();
     fn glGetError() -> u32;
+    fn glGetString(name: u32) -> *u8;
     fn glFinish() -> ();
     fn glFlush() -> ();
     fn glHint(target: u32, mode: u32) -> ();
     fn glFogi(pname: u32, param: i32) -> ();
     fn glFogfv(pname: u32, params: *f32) -> ();
     fn glFogiv(pname: u32, params: *i32) -> ();
-    fn glFeedbackBuffer(size: i32, type_: u32, buffer: *f32) -> ();
     fn glPassThrough(token: f32) -> ();
     fn glSelectBuffer(size: i32, buffer: *u32) -> ();
     fn glInitNames() -> ();
     fn glMultTransposeMatrixd(m: f64) -> ();
     fn glMultTransposeMatrixf(m: f32) -> ();
     fn glSampleCoverage(value: f32, invert: u8) -> ();
-    fn glActiveTextureARB(texture: u32) -> ();
-    fn glClientActiveTextureARB(texture: u32) -> ();
-    fn glMultiTexCoord1dARB(target: u32, s: f64) -> ();
-    fn glMultiTexCoord1dvARB(target: u32, v: *f64) -> ();
-    fn glMultiTexCoord1fARB(target: u32, s: f32) -> ();
-    fn glMultiTexCoord1fvARB(target: u32, v: *f32) -> ();
-    fn glMultiTexCoord1iARB(target: u32, s: i32) -> ();
-    fn glMultiTexCoord1ivARB(target: u32, v: *i32) -> ();
-    fn glMultiTexCoord1sARB(target: u32, s: i16) -> ();
-    fn glMultiTexCoord1svARB(target: u32, v: *i16) -> ();
-    fn glMultiTexCoord2dARB(target: u32, s: f64, t: f64) -> ();
-    fn glMultiTexCoord2dvARB(target: u32, v: *f64) -> ();
-    fn glMultiTexCoord2fARB(target: u32, s: f32, t: f32) -> ();
-    fn glMultiTexCoord2fvARB(target: u32, v: *f32) -> ();
-    fn glMultiTexCoord2iARB(target: u32, s: i32, t: i32) -> ();
-    fn glMultiTexCoord2ivARB(target: u32, v: *i32) -> ();
-    fn glMultiTexCoord2sARB(target: u32, s: i16, t: i16) -> ();
-    fn glMultiTexCoord2svARB(target: u32, v: *i16) -> ();
-    fn glMultiTexCoord3dARB(target: u32, s: f64, t: f64, r: f64) -> ();
-    fn glMultiTexCoord3dvARB(target: u32, v: *f64) -> ();
-    fn glMultiTexCoord3fARB(target: u32, s: f32, t: f32, r: f32) -> ();
-    fn glMultiTexCoord3fvARB(target: u32, v: *f32) -> ();
-    fn glMultiTexCoord3iARB(target: u32, s: i32, t: i32, r: i32) -> ();
-    fn glMultiTexCoord3ivARB(target: u32, v: *i32) -> ();
-    fn glMultiTexCoord3sARB(target: u32, s: i16, t: i16, r: i16) -> ();
-    fn glMultiTexCoord3svARB(target: u32, v: *i16) -> ();
-    fn glMultiTexCoord4dARB(target: u32, s: f64, t: f64, r: f64, q: f64) -> ();
-    fn glMultiTexCoord4dvARB(target: u32, v: *f64) -> ();
-    fn glMultiTexCoord4fARB(target: u32, s: f32, t: f32, r: f32, q: f32) -> ();
-    fn glMultiTexCoord4fvARB(target: u32, v: *f32) -> ();
-    fn glMultiTexCoord4iARB(target: u32, s: i32, t: i32, r: i32, q: i32) -> ();
-    fn glMultiTexCoord4ivARB(target: u32, v: *i32) -> ();
-    fn glMultiTexCoord4sARB(target: u32, s: i16, t: i16, r: i16, q: i16) -> ();
-    fn glMultiTexCoord4svARB(target: u32, v: *i16) -> ();
+    fn glBlendFuncSeparate(sfactorRGB: u32, dfactorRGB: u32, sfactorAlpha: u32, dfactorAlpha: u32) -> ();
+    fn glMultiDrawArrays(mode: u32, first: *i32, count: *i32, primcount: i32) -> ();
+    fn glMultiDrawElements(mode: u32, count: *i32, type_: u32, indices: *(), primcount: i32) -> ();
+    fn glPointParameterf(pname: u32, param: f32) -> ();
+    fn glPointParameterfv(pname: u32, params: *f32) -> ();
+    fn glPointParameteri(pname: u32, param: i32) -> ();
+    fn glPointParameteriv(pname: u32, params: *i32) -> ();
+    fn glFogCoordf(coord: f32) -> ();
+    fn glFogCoordfv(coord: *f32) -> ();
+    fn glFogCoordd(coord: f64) -> ();
+    fn glFogCoorddv(coord: *f64) -> ();
+    fn glFogCoordPointer(type_: u32, stride: i32, pointer: *()) -> ();
+    fn glSecondaryColor3b(red: i8, green: i8, blue: i8) -> ();
+    fn glSecondaryColor3bv(v: *i8) -> ();
+    fn glSecondaryColor3d(red: f64, green: f64, blue: f64) -> ();
+    fn glSecondaryColor3dv(v: *f64) -> ();
+    fn glSecondaryColor3f(red: f32, green: f32, blue: f32) -> ();
+    fn glSecondaryColor3fv(v: *f32) -> ();
+    fn glSecondaryColor3i(red: i32, green: i32, blue: i32) -> ();
+    fn glSecondaryColor3iv(v: *i32) -> ();
+    fn glSecondaryColor3s(red: i16, green: i16, blue: i16) -> ();
+    fn glSecondaryColor3sv(v: *i16) -> ();
+    fn glSecondaryColor3ub(red: u8, green: u8, blue: u8) -> ();
+    fn glSecondaryColor3ubv(v: *u8) -> ();
+    fn glSecondaryColor3ui(red: u32, green: u32, blue: u32) -> ();
+    fn glSecondaryColor3uiv(v: *u32) -> ();
+    fn glSecondaryColor3us(red: u16, green: u16, blue: u16) -> ();
+    fn glSecondaryColor3usv(v: *u16) -> ();
+    fn glSecondaryColorPointer(size: i32, type_: u32, stride: i32, pointer: *()) -> ();
+    fn glWindowPos2d(x: f64, y: f64) -> ();
+    fn glWindowPos2dv(v: *f64) -> ();
+    fn glWindowPos2f(x: f32, y: f32) -> ();
+    fn glWindowPos2fv(v: *f32) -> ();
+    fn glWindowPos2i(x: i32, y: i32) -> ();
+    fn glWindowPos2iv(v: *i32) -> ();
+    fn glWindowPos2s(x: i16, y: i16) -> ();
+    fn glWindowPos2sv(v: *i16) -> ();
+    fn glWindowPos3d(x: f64, y: f64, z: f64) -> ();
+    fn glWindowPos3dv(v: *f64) -> ();
+    fn glWindowPos3f(x: f32, y: f32, z: f32) -> ();
+    fn glWindowPos3fv(v: *f32) -> ();
+    fn glWindowPos3i(x: i32, y: i32, z: i32) -> ();
+    fn glWindowPos3iv(v: *i32) -> ();
+    fn glWindowPos3s(x: i16, y: i16, z: i16) -> ();
+    fn glWindowPos3sv(v: *i16) -> ();
+    fn glGenQueries(n: i32, ids: *u32) -> ();
+    fn glDeleteQueries(n: i32, ids: *u32) -> ();
+    fn glIsQuery(id: u32) -> u8;
+    fn glBeginQuery(target: u32, id: u32) -> ();
+    fn glEndQuery(target: u32) -> ();
+    fn glGetQueryiv(target: u32, pname: u32, params: *i32) -> ();
+    fn glGetQueryObjectiv(id: u32, pname: u32, params: *i32) -> ();
+    fn glGetQueryObjectuiv(id: u32, pname: u32, params: *u32) -> ();
+    fn glBindBuffer(target: u32, buffer: u32) -> ();
+    fn glDeleteBuffers(n: i32, buffers: *u32) -> ();
+    fn glGenBuffers(n: i32, buffers: *u32) -> ();
+    fn glIsBuffer(buffer: u32) -> u8;
+    fn glBufferData(target: u32, size: libc::ptrdiff_t, data: *(), usage: u32) -> ();
+    fn glBufferSubData(target: u32, offset: libc::intptr_t, size: libc::ptrdiff_t, data: *()) -> ();
+    fn glGetBufferSubData(target: u32, offset: libc::intptr_t, size: libc::ptrdiff_t, data: *()) -> ();
+    fn glMapBuffer(target: u32, access: u32) -> *();
+    fn glUnmapBuffer(target: u32) -> u8;
+    fn glGetBufferParameteriv(target: u32, pname: u32, params: *i32) -> ();
+    fn glGetBufferPointerv(target: u32, pname: u32, params: *()) -> ();
+    fn glBlendEquationSeparate(modeRGB: u32, modeAlpha: u32) -> ();
+    fn glDrawBuffers(n: i32, bufs: *u32) -> ();
+    fn glStencilOpSeparate(face: u32, sfail: u32, dpfail: u32, dppass: u32) -> ();
+    fn glStencilFuncSeparate(face: u32, func: u32, ref: i32, mask: u32) -> ();
+    fn glStencilMaskSeparate(face: u32, mask: u32) -> ();
+    fn glAttachShader(program: u32, shader: u32) -> ();
+    fn glBindAttribLocation(program: u32, index: u32, name: *u8) -> ();
+    fn glCompileShader(shader: u32) -> ();
+    fn glCreateProgram() -> u32;
+    fn glCreateShader(type_: u32) -> u32;
+    fn glDeleteProgram(program: u32) -> ();
+    fn glDeleteShader(shader: u32) -> ();
+    fn glDetachShader(program: u32, shader: u32) -> ();
+    fn glDisableVertexAttribArray(index: u32) -> ();
+    fn glEnableVertexAttribArray(index: u32) -> ();
+    fn glGetActiveAttrib(program: u32, index: u32, bufSize: i32, length: *i32, size: *i32, type_: *u32, name: *u8) -> ();
+    fn glGetActiveUniform(program: u32, index: u32, bufSize: i32, length: *i32, size: *i32, type_: *u32, name: *u8) -> ();
+    fn glGetAttachedShaders(program: u32, maxCount: i32, count: *i32, obj: *u32) -> ();
+    fn glGetAttribLocation(program: u32, name: *u8) -> i32;
+    fn glGetProgramiv(program: u32, pname: u32, params: *i32) -> ();
+    fn glGetProgramInfoLog(program: u32, bufSize: i32, length: *i32, infoLog: *u8) -> ();
+    fn glGetShaderiv(shader: u32, pname: u32, params: *i32) -> ();
+    fn glGetShaderInfoLog(shader: u32, bufSize: i32, length: *i32, infoLog: *u8) -> ();
+    fn glGetShaderSource(shader: u32, bufSize: i32, length: *i32, source: *u8) -> ();
+    fn glGetUniformLocation(program: u32, name: *u8) -> i32;
+    fn glGetUniformfv(program: u32, location: i32, params: *f32) -> ();
+    fn glGetUniformiv(program: u32, location: i32, params: *i32) -> ();
+    fn glGetVertexAttribdv(index: u32, pname: u32, params: *f64) -> ();
+    fn glGetVertexAttribfv(index: u32, pname: u32, params: *f32) -> ();
+    fn glGetVertexAttribiv(index: u32, pname: u32, params: *i32) -> ();
+    fn glGetVertexAttribPointerv(index: u32, pname: u32, pointer: *()) -> ();
+    fn glIsProgram(program: u32) -> u8;
+    fn glIsShader(shader: u32) -> u8;
+    fn glLinkProgram(program: u32) -> ();
+    fn glShaderSource(shader: u32, count: i32, string: *u8, length: *i32) -> ();
+    fn glUseProgram(program: u32) -> ();
+    fn glUniform1f(location: i32, v0: f32) -> ();
+    fn glUniform2f(location: i32, v0: f32, v1: f32) -> ();
+    fn glUniform3f(location: i32, v0: f32, v1: f32, v2: f32) -> ();
+    fn glUniform4f(location: i32, v0: f32, v1: f32, v2: f32, v3: f32) -> ();
+    fn glUniform1i(location: i32, v0: i32) -> ();
+    fn glUniform2i(location: i32, v0: i32, v1: i32) -> ();
+    fn glUniform3i(location: i32, v0: i32, v1: i32, v2: i32) -> ();
+    fn glUniform4i(location: i32, v0: i32, v1: i32, v2: i32, v3: i32) -> ();
+    fn glUniform1fv(location: i32, count: i32, value: *f32) -> ();
+    fn glUniform2fv(location: i32, count: i32, value: *f32) -> ();
+    fn glUniform3fv(location: i32, count: i32, value: *f32) -> ();
+    fn glUniform4fv(location: i32, count: i32, value: *f32) -> ();
+    fn glUniform1iv(location: i32, count: i32, value: *i32) -> ();
+    fn glUniform2iv(location: i32, count: i32, value: *i32) -> ();
+    fn glUniform3iv(location: i32, count: i32, value: *i32) -> ();
+    fn glUniform4iv(location: i32, count: i32, value: *i32) -> ();
+    fn glUniformMatrix2fv(location: i32, count: i32, transpose: u8, value: *f32) -> ();
+    fn glUniformMatrix3fv(location: i32, count: i32, transpose: u8, value: *f32) -> ();
+    fn glUniformMatrix4fv(location: i32, count: i32, transpose: u8, value: *f32) -> ();
+    fn glValidateProgram(program: u32) -> ();
+    fn glVertexAttrib1d(index: u32, x: f64) -> ();
+    fn glVertexAttrib1dv(index: u32, v: *f64) -> ();
+    fn glVertexAttrib1f(index: u32, x: f32) -> ();
+    fn glVertexAttrib1fv(index: u32, v: *f32) -> ();
+    fn glVertexAttrib1s(index: u32, x: i16) -> ();
+    fn glVertexAttrib1sv(index: u32, v: *i16) -> ();
+    fn glVertexAttrib2d(index: u32, x: f64, y: f64) -> ();
+    fn glVertexAttrib2dv(index: u32, v: *f64) -> ();
+    fn glVertexAttrib2f(index: u32, x: f32, y: f32) -> ();
+    fn glVertexAttrib2fv(index: u32, v: *f32) -> ();
+    fn glVertexAttrib2s(index: u32, x: i16, y: i16) -> ();
+    fn glVertexAttrib2sv(index: u32, v: *i16) -> ();
+    fn glVertexAttrib3d(index: u32, x: f64, y: f64, z: f64) -> ();
+    fn glVertexAttrib3dv(index: u32, v: *f64) -> ();
+    fn glVertexAttrib3f(index: u32, x: f32, y: f32, z: f32) -> ();
+    fn glVertexAttrib3fv(index: u32, v: *f32) -> ();
+    fn glVertexAttrib3s(index: u32, x: i16, y: i16, z: i16) -> ();
+    fn glVertexAttrib3sv(index: u32, v: *i16) -> ();
+    fn glVertexAttrib4Nbv(index: u32, v: *i8) -> ();
+    fn glVertexAttrib4Niv(index: u32, v: *i32) -> ();
+    fn glVertexAttrib4Nsv(index: u32, v: *i16) -> ();
+    fn glVertexAttrib4Nub(index: u32, x: u8, y: u8, z: u8, w: u8) -> ();
+    fn glVertexAttrib4Nubv(index: u32, v: *u8) -> ();
+    fn glVertexAttrib4Nuiv(index: u32, v: *u32) -> ();
+    fn glVertexAttrib4Nusv(index: u32, v: *u16) -> ();
+    fn glVertexAttrib4bv(index: u32, v: *i8) -> ();
+    fn glVertexAttrib4d(index: u32, x: f64, y: f64, z: f64, w: f64) -> ();
+    fn glVertexAttrib4dv(index: u32, v: *f64) -> ();
+    fn glVertexAttrib4f(index: u32, x: f32, y: f32, z: f32, w: f32) -> ();
+    fn glVertexAttrib4fv(index: u32, v: *f32) -> ();
+    fn glVertexAttrib4iv(index: u32, v: *i32) -> ();
+    fn glVertexAttrib4s(index: u32, x: i16, y: i16, z: i16, w: i16) -> ();
+    fn glVertexAttrib4sv(index: u32, v: *i16) -> ();
+    fn glVertexAttrib4ubv(index: u32, v: *u8) -> ();
+    fn glVertexAttrib4uiv(index: u32, v: *u32) -> ();
+    fn glVertexAttrib4usv(index: u32, v: *u16) -> ();
+    fn glVertexAttribPointer(index: u32, size: i32, type_: u32, normalized: u8, stride: i32, pointer: *()) -> ();
+    fn glUniformMatrix2x3fv(location: i32, count: i32, transpose: u8, value: *f32) -> ();
+    fn glUniformMatrix3x2fv(location: i32, count: i32, transpose: u8, value: *f32) -> ();
+    fn glUniformMatrix2x4fv(location: i32, count: i32, transpose: u8, value: *f32) -> ();
+    fn glUniformMatrix4x2fv(location: i32, count: i32, transpose: u8, value: *f32) -> ();
+    fn glUniformMatrix3x4fv(location: i32, count: i32, transpose: u8, value: *f32) -> ();
+    fn glUniformMatrix4x3fv(location: i32, count: i32, transpose: u8, value: *f32) -> ();
+    fn glColorMaski(index: u32, r: u8, g: u8, b: u8, a: u8) -> ();
+    fn glGetBooleani_v(target: u32, index: u32, data: *u8) -> ();
+    fn glGetIntegeri_v(target: u32, index: u32, data: *i32) -> ();
+    fn glEnablei(target: u32, index: u32) -> ();
+    fn glDisablei(target: u32, index: u32) -> ();
+    fn glIsEnabledi(target: u32, index: u32) -> u8;
+    fn glBindBufferRange(target: u32, index: u32, buffer: u32, offset: libc::intptr_t, size: libc::ptrdiff_t) -> ();
+    fn glBindBufferBase(target: u32, index: u32, buffer: u32) -> ();
+    fn glClampColor(target: u32, clamp: u32) -> ();
+    fn glBeginConditionalRender(id: u32, mode: u32) -> ();
+    fn glEndConditionalRender() -> ();
+    fn glVertexAttribIPointer(index: u32, size: i32, type_: u32, stride: i32, pointer: *()) -> ();
+    fn glGetVertexAttribIiv(index: u32, pname: u32, params: *i32) -> ();
+    fn glGetVertexAttribIuiv(index: u32, pname: u32, params: *u32) -> ();
+    fn glVertexAttribI1i(index: u32, x: i32) -> ();
+    fn glVertexAttribI2i(index: u32, x: i32, y: i32) -> ();
+    fn glVertexAttribI3i(index: u32, x: i32, y: i32, z: i32) -> ();
+    fn glVertexAttribI4i(index: u32, x: i32, y: i32, z: i32, w: i32) -> ();
+    fn glVertexAttribI1ui(index: u32, x: u32) -> ();
+    fn glVertexAttribI2ui(index: u32, x: u32, y: u32) -> ();
+    fn glVertexAttribI3ui(index: u32, x: u32, y: u32, z: u32) -> ();
+    fn glVertexAttribI4ui(index: u32, x: u32, y: u32, z: u32, w: u32) -> ();
+    fn glVertexAttribI1iv(index: u32, v: *i32) -> ();
+    fn glVertexAttribI2iv(index: u32, v: *i32) -> ();
+    fn glVertexAttribI3iv(index: u32, v: *i32) -> ();
+    fn glVertexAttribI4iv(index: u32, v: *i32) -> ();
+    fn glVertexAttribI1uiv(index: u32, v: *u32) -> ();
+    fn glVertexAttribI2uiv(index: u32, v: *u32) -> ();
+    fn glVertexAttribI3uiv(index: u32, v: *u32) -> ();
+    fn glVertexAttribI4uiv(index: u32, v: *u32) -> ();
+    fn glVertexAttribI4bv(index: u32, v: *i8) -> ();
+    fn glVertexAttribI4sv(index: u32, v: *i16) -> ();
+    fn glVertexAttribI4ubv(index: u32, v: *u8) -> ();
+    fn glVertexAttribI4usv(index: u32, v: *u16) -> ();
+    fn glGetUniformuiv(program: u32, location: i32, params: *u32) -> ();
+    fn glBindFragDataLocation(program: u32, color: u32, name: *u8) -> ();
+    fn glGetFragDataLocation(program: u32, name: *u8) -> i32;
+    fn glUniform1ui(location: i32, v0: u32) -> ();
+    fn glUniform2ui(location: i32, v0: u32, v1: u32) -> ();
+    fn glUniform3ui(location: i32, v0: u32, v1: u32, v2: u32) -> ();
+    fn glUniform4ui(location: i32, v0: u32, v1: u32, v2: u32, v3: u32) -> ();
+    fn glUniform1uiv(location: i32, count: i32, value: *u32) -> ();
+    fn glUniform2uiv(location: i32, count: i32, value: *u32) -> ();
+    fn glUniform3uiv(location: i32, count: i32, value: *u32) -> ();
+    fn glUniform4uiv(location: i32, count: i32, value: *u32) -> ();
+    fn glTexParameterIiv(target: u32, pname: u32, params: *i32) -> ();
+    fn glTexParameterIuiv(target: u32, pname: u32, params: *u32) -> ();
+    fn glGetTexParameterIiv(target: u32, pname: u32, params: *i32) -> ();
+    fn glGetTexParameterIuiv(target: u32, pname: u32, params: *u32) -> ();
+    fn glClearBufferiv(buffer: u32, drawbuffer: i32, value: *i32) -> ();
+    fn glClearBufferuiv(buffer: u32, drawbuffer: i32, value: *u32) -> ();
+    fn glClearBufferfv(buffer: u32, drawbuffer: i32, value: *f32) -> ();
+    fn glClearBufferfi(buffer: u32, drawbuffer: i32, depth: f32, stencil: i32) -> ();
+    fn glGetStringi(name: u32, index: u32) -> *u8;
+    fn glDrawArraysInstanced(mode: u32, first: i32, count: i32, primcount: i32) -> ();
+    fn glDrawElementsInstanced(mode: u32, count: i32, type_: u32, indices: *(), primcount: i32) -> ();
+    fn glTexBuffer(target: u32, internalformat: u32, buffer: u32) -> ();
+    fn glPrimitiveRestartIndex(index: u32) -> ();
+    fn glGetInteger64i_v(target: u32, index: u32, data: *i64) -> ();
+    fn glGetBufferParameteri64v(target: u32, pname: u32, params: *i64) -> ();
+    fn glFramebufferTexture(target: u32, attachment: u32, texture: u32, level: i32) -> ();
+    fn glVertexAttribDivisor(index: u32, divisor: u32) -> ();
+    fn glMinSampleShading(value: f32) -> ();
+    fn glBlendEquationi(buf: u32, mode: u32) -> ();
+    fn glBlendEquationSeparatei(buf: u32, modeRGB: u32, modeAlpha: u32) -> ();
+    fn glBlendFunci(buf: u32, src: u32, dst: u32) -> ();
+    fn glBlendFuncSeparatei(buf: u32, srcRGB: u32, dstRGB: u32, srcAlpha: u32, dstAlpha: u32) -> ();
+    fn glIsRenderbuffer(renderbuffer: u32) -> u8;
+    fn glBindRenderbuffer(target: u32, renderbuffer: u32) -> ();
+    fn glDeleteRenderbuffers(n: i32, renderbuffers: *u32) -> ();
+    fn glGenRenderbuffers(n: i32, renderbuffers: *u32) -> ();
+    fn glRenderbufferStorage(target: u32, internalformat: u32, width: i32, height: i32) -> ();
+    fn glGetRenderbufferParameteriv(target: u32, pname: u32, params: *i32) -> ();
+    fn glIsFramebuffer(framebuffer: u32) -> u8;
+    fn glBindFramebuffer(target: u32, framebuffer: u32) -> ();
+    fn glDeleteFramebuffers(n: i32, framebuffers: *u32) -> ();
+    fn glGenFramebuffers(n: i32, framebuffers: *u32) -> ();
+    fn glCheckFramebufferStatus(target: u32) -> u32;
+    fn glFramebufferTexture1D(target: u32, attachment: u32, textarget: u32, texture: u32, level: i32) -> ();
+    fn glFramebufferTexture2D(target: u32, attachment: u32, textarget: u32, texture: u32, level: i32) -> ();
+    fn glFramebufferTexture3D(target: u32, attachment: u32, textarget: u32, texture: u32, level: i32, zoffset: i32) -> ();
+    fn glFramebufferRenderbuffer(target: u32, attachment: u32, renderbuffertarget: u32, renderbuffer: u32) -> ();
+    fn glGetFramebufferAttachmentParameteriv(target: u32, attachment: u32, pname: u32, params: *i32) -> ();
+    fn glGenerateMipmap(target: u32) -> ();
+    fn glBlitFramebuffer(srcX0: i32, srcY0: i32, srcX1: i32, srcY1: i32, dstX0: i32, dstY0: i32, dstX1: i32, dstY1: i32, mask: u32, filter: u32) -> ();
+    fn glRenderbufferStorageMultisample(target: u32, samples: i32, internalformat: u32, width: i32, height: i32) -> ();
+    fn glFramebufferTextureLayer(target: u32, attachment: u32, texture: u32, level: i32, layer: i32) -> ();
+    fn glMapBufferRange(target: u32, offset: libc::intptr_t, length: libc::ptrdiff_t, access: u32) -> *();
+    fn glFlushMappedBufferRange(target: u32, offset: libc::intptr_t, length: libc::ptrdiff_t) -> ();
+    fn glBindVertexArray(array: u32) -> ();
+    fn glDeleteVertexArrays(n: i32, arrays: *u32) -> ();
+    fn glGenVertexArrays(n: i32, arrays: *u32) -> ();
+    fn glIsVertexArray(array: u32) -> u8;
+    fn glGetUniformIndices(program: u32, uniformCount: i32, uniformNames: *u8, uniformIndices: *u32) -> ();
+    fn glGetActiveUniformsiv(program: u32, uniformCount: i32, uniformIndices: *u32, pname: u32, params: *i32) -> ();
+    fn glGetActiveUniformName(program: u32, uniformIndex: u32, bufSize: i32, length: *i32, uniformName: *u8) -> ();
+    fn glGetUniformBlockIndex(program: u32, uniformBlockName: *u8) -> u32;
+    fn glGetActiveUniformBlockiv(program: u32, uniformBlockIndex: u32, pname: u32, params: *i32) -> ();
+    fn glGetActiveUniformBlockName(program: u32, uniformBlockIndex: u32, bufSize: i32, length: *i32, uniformBlockName: *u8) -> ();
+    fn glUniformBlockBinding(program: u32, uniformBlockIndex: u32, uniformBlockBinding: u32) -> ();
+    fn glCopyBufferSubData(readTarget: u32, writeTarget: u32, readOffset: libc::intptr_t, writeOffset: libc::intptr_t, size: libc::ptrdiff_t) -> ();
+    fn glDrawElementsBaseVertex(mode: u32, count: i32, type_: u32, indices: *(), basevertex: i32) -> ();
+    fn glDrawRangeElementsBaseVertex(mode: u32, start: u32, end: u32, count: i32, type_: u32, indices: *(), basevertex: i32) -> ();
+    fn glDrawElementsInstancedBaseVertex(mode: u32, count: i32, type_: u32, indices: *(), primcount: i32, basevertex: i32) -> ();
+    fn glMultiDrawElementsBaseVertex(mode: u32, count: *i32, type_: u32, indices: *(), primcount: i32, basevertex: *i32) -> ();
+    fn glProvokingVertex(mode: u32) -> ();
+    fn glIsSync() -> u8;
+    fn glDeleteSync() -> ();
+    fn glClientWaitSync(flags: u32, timeout: u64) -> u32;
+    fn glWaitSync(flags: u32, timeout: u64) -> ();
+    fn glGetInteger64v(pname: u32, params: *i64) -> ();
+    fn glGetSynciv(pname: u32, bufSize: i32, length: *i32, values: *i32) -> ();
+    fn glTexImage2DMultisample(target: u32, samples: i32, internalformat: i32, width: i32, height: i32, fixedsamplelocations: u8) -> ();
+    fn glTexImage3DMultisample(target: u32, samples: i32, internalformat: i32, width: i32, height: i32, depth: i32, fixedsamplelocations: u8) -> ();
+    fn glGetMultisamplefv(pname: u32, index: u32, val: *f32) -> ();
+    fn glSampleMaski(index: u32, mask: u32) -> ();
+    fn glBindFragDataLocationIndexed(program: u32, colorNumber: u32, index: u32, name: *u8) -> ();
+    fn glGetFragDataIndex(program: u32, name: *u8) -> i32;
+    fn glGenSamplers(count: i32, samplers: *u32) -> ();
+    fn glDeleteSamplers(count: i32, samplers: *u32) -> ();
+    fn glIsSampler(sampler: u32) -> u8;
+    fn glBindSampler(unit: u32, sampler: u32) -> ();
+    fn glSamplerParameteri(sampler: u32, pname: u32, param: i32) -> ();
+    fn glSamplerParameteriv(sampler: u32, pname: u32, param: *i32) -> ();
+    fn glSamplerParameterf(sampler: u32, pname: u32, param: f32) -> ();
+    fn glSamplerParameterfv(sampler: u32, pname: u32, param: *f32) -> ();
+    fn glSamplerParameterIiv(sampler: u32, pname: u32, param: *i32) -> ();
+    fn glSamplerParameterIuiv(sampler: u32, pname: u32, param: *u32) -> ();
+    fn glGetSamplerParameteriv(sampler: u32, pname: u32, params: *i32) -> ();
+    fn glGetSamplerParameterIiv(sampler: u32, pname: u32, params: *i32) -> ();
+    fn glGetSamplerParameterfv(sampler: u32, pname: u32, params: *f32) -> ();
+    fn glGetSamplerParameterIuiv(sampler: u32, pname: u32, params: *u32) -> ();
+    fn glQueryCounter(id: u32, target: u32) -> ();
+    fn glGetQueryObjecti64v(id: u32, pname: u32, params: *i64) -> ();
+    fn glGetQueryObjectui64v(id: u32, pname: u32, params: *u64) -> ();
+    fn glVertexP2ui(type_: u32, value: u32) -> ();
+    fn glVertexP2uiv(type_: u32, value: *u32) -> ();
+    fn glVertexP3ui(type_: u32, value: u32) -> ();
+    fn glVertexP3uiv(type_: u32, value: *u32) -> ();
+    fn glVertexP4ui(type_: u32, value: u32) -> ();
+    fn glVertexP4uiv(type_: u32, value: *u32) -> ();
+    fn glTexCoordP1ui(type_: u32, coords: u32) -> ();
+    fn glTexCoordP1uiv(type_: u32, coords: *u32) -> ();
+    fn glTexCoordP2ui(type_: u32, coords: u32) -> ();
+    fn glTexCoordP2uiv(type_: u32, coords: *u32) -> ();
+    fn glTexCoordP3ui(type_: u32, coords: u32) -> ();
+    fn glTexCoordP3uiv(type_: u32, coords: *u32) -> ();
+    fn glTexCoordP4ui(type_: u32, coords: u32) -> ();
+    fn glTexCoordP4uiv(type_: u32, coords: *u32) -> ();
+    fn glMultiTexCoordP1ui(texture: u32, type_: u32, coords: u32) -> ();
+    fn glMultiTexCoordP1uiv(texture: u32, type_: u32, coords: *u32) -> ();
+    fn glMultiTexCoordP2ui(texture: u32, type_: u32, coords: u32) -> ();
+    fn glMultiTexCoordP2uiv(texture: u32, type_: u32, coords: *u32) -> ();
+    fn glMultiTexCoordP3ui(texture: u32, type_: u32, coords: u32) -> ();
+    fn glMultiTexCoordP3uiv(texture: u32, type_: u32, coords: *u32) -> ();
+    fn glMultiTexCoordP4ui(texture: u32, type_: u32, coords: u32) -> ();
+    fn glMultiTexCoordP4uiv(texture: u32, type_: u32, coords: *u32) -> ();
+    fn glNormalP3ui(type_: u32, coords: u32) -> ();
+    fn glNormalP3uiv(type_: u32, coords: *u32) -> ();
+    fn glColorP3ui(type_: u32, color: u32) -> ();
+    fn glColorP3uiv(type_: u32, color: *u32) -> ();
+    fn glColorP4ui(type_: u32, color: u32) -> ();
+    fn glColorP4uiv(type_: u32, color: *u32) -> ();
+    fn glSecondaryColorP3ui(type_: u32, color: u32) -> ();
+    fn glSecondaryColorP3uiv(type_: u32, color: *u32) -> ();
+    fn glVertexAttribP1ui(index: u32, type_: u32, normalized: u8, value: u32) -> ();
+    fn glVertexAttribP1uiv(index: u32, type_: u32, normalized: u8, value: *u32) -> ();
+    fn glVertexAttribP2ui(index: u32, type_: u32, normalized: u8, value: u32) -> ();
+    fn glVertexAttribP2uiv(index: u32, type_: u32, normalized: u8, value: *u32) -> ();
+    fn glVertexAttribP3ui(index: u32, type_: u32, normalized: u8, value: u32) -> ();
+    fn glVertexAttribP3uiv(index: u32, type_: u32, normalized: u8, value: *u32) -> ();
+    fn glVertexAttribP4ui(index: u32, type_: u32, normalized: u8, value: u32) -> ();
+    fn glVertexAttribP4uiv(index: u32, type_: u32, normalized: u8, value: *u32) -> ();
+    fn glDrawArraysIndirect(mode: u32, indirect: *()) -> ();
+    fn glDrawElementsIndirect(mode: u32, type_: u32, indirect: *()) -> ();
+    fn glUniform1d(location: i32, x: f64) -> ();
+    fn glUniform2d(location: i32, x: f64, y: f64) -> ();
+    fn glUniform3d(location: i32, x: f64, y: f64, z: f64) -> ();
+    fn glUniform4d(location: i32, x: f64, y: f64, z: f64, w: f64) -> ();
+    fn glUniform1dv(location: i32, count: i32, value: *f64) -> ();
+    fn glUniform2dv(location: i32, count: i32, value: *f64) -> ();
+    fn glUniform3dv(location: i32, count: i32, value: *f64) -> ();
+    fn glUniform4dv(location: i32, count: i32, value: *f64) -> ();
+    fn glUniformMatrix2dv(location: i32, count: i32, transpose: u8, value: *f64) -> ();
+    fn glUniformMatrix3dv(location: i32, count: i32, transpose: u8, value: *f64) -> ();
+    fn glUniformMatrix4dv(location: i32, count: i32, transpose: u8, value: *f64) -> ();
+    fn glUniformMatrix2x3dv(location: i32, count: i32, transpose: u8, value: *f64) -> ();
+    fn glUniformMatrix2x4dv(location: i32, count: i32, transpose: u8, value: *f64) -> ();
+    fn glUniformMatrix3x2dv(location: i32, count: i32, transpose: u8, value: *f64) -> ();
+    fn glUniformMatrix3x4dv(location: i32, count: i32, transpose: u8, value: *f64) -> ();
+    fn glUniformMatrix4x2dv(location: i32, count: i32, transpose: u8, value: *f64) -> ();
+    fn glUniformMatrix4x3dv(location: i32, count: i32, transpose: u8, value: *f64) -> ();
+    fn glGetUniformdv(program: u32, location: i32, params: *f64) -> ();
+    fn glGetSubroutineUniformLocation(program: u32, shadertype: u32, name: *u8) -> i32;
+    fn glGetSubroutineIndex(program: u32, shadertype: u32, name: *u8) -> u32;
+    fn glGetActiveSubroutineUniformiv(program: u32, shadertype: u32, index: u32, pname: u32, values: *i32) -> ();
+    fn glGetActiveSubroutineUniformName(program: u32, shadertype: u32, index: u32, bufsize: i32, length: *i32, name: *u8) -> ();
+    fn glGetActiveSubroutineName(program: u32, shadertype: u32, index: u32, bufsize: i32, length: *i32, name: *u8) -> ();
+    fn glUniformSubroutinesuiv(shadertype: u32, count: i32, indices: *u32) -> ();
+    fn glGetUniformSubroutineuiv(shadertype: u32, location: i32, params: *u32) -> ();
+    fn glGetProgramStageiv(program: u32, shadertype: u32, pname: u32, values: *i32) -> ();
+    fn glPatchParameteri(pname: u32, value: i32) -> ();
+    fn glPatchParameterfv(pname: u32, values: *f32) -> ();
+    fn glBeginQueryIndexed(target: u32, index: u32, id: u32) -> ();
+    fn glEndQueryIndexed(target: u32, index: u32) -> ();
+    fn glGetQueryIndexediv(target: u32, index: u32, pname: u32, params: *i32) -> ();
+    fn glReleaseShaderCompiler() -> ();
+    fn glShaderBinary(count: i32, shaders: *u32, binaryformat: u32, binary: *(), length: i32) -> ();
+    fn glGetShaderPrecisionFormat(shadertype: u32, precisiontype: u32, range: *i32, precision: *i32) -> ();
+    fn glDepthRangef(n: f32, f: f32) -> ();
+    fn glClearDepthf(d: f32) -> ();
+    fn glGetProgramBinary(program: u32, bufSize: i32, length: *i32, binaryFormat: *u32, binary: *()) -> ();
+    fn glProgramBinary(program: u32, binaryFormat: u32, binary: *(), length: i32) -> ();
+    fn glProgramParameteri(program: u32, pname: u32, value: i32) -> ();
+    fn glUseProgramStages(pipeline: u32, stages: u32, program: u32) -> ();
+    fn glActiveShaderProgram(pipeline: u32, program: u32) -> ();
+    fn glCreateShaderProgramv(type_: u32, count: i32, strings: *u8) -> u32;
+    fn glBindProgramPipeline(pipeline: u32) -> ();
+    fn glDeleteProgramPipelines(n: i32, pipelines: *u32) -> ();
+    fn glGenProgramPipelines(n: i32, pipelines: *u32) -> ();
+    fn glIsProgramPipeline(pipeline: u32) -> u8;
+    fn glGetProgramPipelineiv(pipeline: u32, pname: u32, params: *i32) -> ();
+    fn glProgramUniform1i(program: u32, location: i32, v0: i32) -> ();
+    fn glProgramUniform1iv(program: u32, location: i32, count: i32, value: *i32) -> ();
+    fn glProgramUniform1f(program: u32, location: i32, v0: f32) -> ();
+    fn glProgramUniform1fv(program: u32, location: i32, count: i32, value: *f32) -> ();
+    fn glProgramUniform1d(program: u32, location: i32, v0: f64) -> ();
+    fn glProgramUniform1dv(program: u32, location: i32, count: i32, value: *f64) -> ();
+    fn glProgramUniform1ui(program: u32, location: i32, v0: u32) -> ();
+    fn glProgramUniform1uiv(program: u32, location: i32, count: i32, value: *u32) -> ();
+    fn glProgramUniform2i(program: u32, location: i32, v0: i32, v1: i32) -> ();
+    fn glProgramUniform2iv(program: u32, location: i32, count: i32, value: *i32) -> ();
+    fn glProgramUniform2f(program: u32, location: i32, v0: f32, v1: f32) -> ();
+    fn glProgramUniform2fv(program: u32, location: i32, count: i32, value: *f32) -> ();
+    fn glProgramUniform2d(program: u32, location: i32, v0: f64, v1: f64) -> ();
+    fn glProgramUniform2dv(program: u32, location: i32, count: i32, value: *f64) -> ();
+    fn glProgramUniform2ui(program: u32, location: i32, v0: u32, v1: u32) -> ();
+    fn glProgramUniform2uiv(program: u32, location: i32, count: i32, value: *u32) -> ();
+    fn glProgramUniform3i(program: u32, location: i32, v0: i32, v1: i32, v2: i32) -> ();
+    fn glProgramUniform3iv(program: u32, location: i32, count: i32, value: *i32) -> ();
+    fn glProgramUniform3f(program: u32, location: i32, v0: f32, v1: f32, v2: f32) -> ();
+    fn glProgramUniform3fv(program: u32, location: i32, count: i32, value: *f32) -> ();
+    fn glProgramUniform3d(program: u32, location: i32, v0: f64, v1: f64, v2: f64) -> ();
+    fn glProgramUniform3dv(program: u32, location: i32, count: i32, value: *f64) -> ();
+    fn glProgramUniform3ui(program: u32, location: i32, v0: u32, v1: u32, v2: u32) -> ();
+    fn glProgramUniform3uiv(program: u32, location: i32, count: i32, value: *u32) -> ();
+    fn glProgramUniform4i(program: u32, location: i32, v0: i32, v1: i32, v2: i32, v3: i32) -> ();
+    fn glProgramUniform4iv(program: u32, location: i32, count: i32, value: *i32) -> ();
+    fn glProgramUniform4f(program: u32, location: i32, v0: f32, v1: f32, v2: f32, v3: f32) -> ();
+    fn glProgramUniform4fv(program: u32, location: i32, count: i32, value: *f32) -> ();
+    fn glProgramUniform4d(program: u32, location: i32, v0: f64, v1: f64, v2: f64, v3: f64) -> ();
+    fn glProgramUniform4dv(program: u32, location: i32, count: i32, value: *f64) -> ();
+    fn glProgramUniform4ui(program: u32, location: i32, v0: u32, v1: u32, v2: u32, v3: u32) -> ();
+    fn glProgramUniform4uiv(program: u32, location: i32, count: i32, value: *u32) -> ();
+    fn glProgramUniformMatrix2fv(program: u32, location: i32, count: i32, transpose: u8, value: *f32) -> ();
+    fn glProgramUniformMatrix3fv(program: u32, location: i32, count: i32, transpose: u8, value: *f32) -> ();
+    fn glProgramUniformMatrix4fv(program: u32, location: i32, count: i32, transpose: u8, value: *f32) -> ();
+    fn glProgramUniformMatrix2dv(program: u32, location: i32, count: i32, transpose: u8, value: *f64) -> ();
+    fn glProgramUniformMatrix3dv(program: u32, location: i32, count: i32, transpose: u8, value: *f64) -> ();
+    fn glProgramUniformMatrix4dv(program: u32, location: i32, count: i32, transpose: u8, value: *f64) -> ();
+    fn glProgramUniformMatrix2x3fv(program: u32, location: i32, count: i32, transpose: u8, value: *f32) -> ();
+    fn glProgramUniformMatrix3x2fv(program: u32, location: i32, count: i32, transpose: u8, value: *f32) -> ();
+    fn glProgramUniformMatrix2x4fv(program: u32, location: i32, count: i32, transpose: u8, value: *f32) -> ();
+    fn glProgramUniformMatrix4x2fv(program: u32, location: i32, count: i32, transpose: u8, value: *f32) -> ();
+    fn glProgramUniformMatrix3x4fv(program: u32, location: i32, count: i32, transpose: u8, value: *f32) -> ();
+    fn glProgramUniformMatrix4x3fv(program: u32, location: i32, count: i32, transpose: u8, value: *f32) -> ();
+    fn glProgramUniformMatrix2x3dv(program: u32, location: i32, count: i32, transpose: u8, value: *f64) -> ();
+    fn glProgramUniformMatrix3x2dv(program: u32, location: i32, count: i32, transpose: u8, value: *f64) -> ();
+    fn glProgramUniformMatrix2x4dv(program: u32, location: i32, count: i32, transpose: u8, value: *f64) -> ();
+    fn glProgramUniformMatrix4x2dv(program: u32, location: i32, count: i32, transpose: u8, value: *f64) -> ();
+    fn glProgramUniformMatrix3x4dv(program: u32, location: i32, count: i32, transpose: u8, value: *f64) -> ();
+    fn glProgramUniformMatrix4x3dv(program: u32, location: i32, count: i32, transpose: u8, value: *f64) -> ();
+    fn glValidateProgramPipeline(pipeline: u32) -> ();
+    fn glGetProgramPipelineInfoLog(pipeline: u32, bufSize: i32, length: *i32, infoLog: *u8) -> ();
+    fn glVertexAttribL1d(index: u32, x: f64) -> ();
+    fn glVertexAttribL2d(index: u32, x: f64, y: f64) -> ();
+    fn glVertexAttribL3d(index: u32, x: f64, y: f64, z: f64) -> ();
+    fn glVertexAttribL4d(index: u32, x: f64, y: f64, z: f64, w: f64) -> ();
+    fn glVertexAttribL1dv(index: u32, v: *f64) -> ();
+    fn glVertexAttribL2dv(index: u32, v: *f64) -> ();
+    fn glVertexAttribL3dv(index: u32, v: *f64) -> ();
+    fn glVertexAttribL4dv(index: u32, v: *f64) -> ();
+    fn glVertexAttribLPointer(index: u32, size: i32, type_: u32, stride: i32, pointer: *()) -> ();
+    fn glGetVertexAttribLdv(index: u32, pname: u32, params: *f64) -> ();
+    fn glViewportArrayv(first: u32, count: i32, v: *f32) -> ();
+    fn glViewportIndexedf(index: u32, x: f32, y: f32, w: f32, h: f32) -> ();
+    fn glViewportIndexedfv(index: u32, v: *f32) -> ();
+    fn glScissorArrayv(first: u32, count: i32, v: *i32) -> ();
+    fn glScissorIndexed(index: u32, left: i32, bottom: i32, width: i32, height: i32) -> ();
+    fn glScissorIndexedv(index: u32, v: *i32) -> ();
+    fn glDepthRangeArrayv(first: u32, count: i32, v: *f64) -> ();
+    fn glDepthRangeIndexed(index: u32, n: f64, f: f64) -> ();
+    fn glGetFloati_v(target: u32, index: u32, data: *f32) -> ();
+    fn glGetDoublei_v(target: u32, index: u32, data: *f64) -> ();
 }
 fn glClearColor(red: float, green: float, blue: float, alpha: float) -> () unsafe {
     ret GL::glClearColor(red as f32, green as f32, blue as f32, alpha as f32);
 fn glPolygonOffset(factor: float, units: float) -> () unsafe {
     ret GL::glPolygonOffset(factor as f32, units as f32);
 }
-fn glPolygonStipple(mask: *uint) -> () unsafe {
-    ret GL::glPolygonStipple(mask as *u8);
-}
-fn glGetPolygonStipple(mask: *uint) -> () unsafe {
-    ret GL::glGetPolygonStipple(mask as *u8);
+fn glPolygonStipple(mask: str) -> () unsafe {
+    let mask_c_str = str::as_c_str(mask) { |mask_| mask_ };
+    ret GL::glPolygonStipple(mask_c_str as *u8);
+}
+fn glGetPolygonStipple(mask: str) -> () unsafe {
+    let mask_c_str = str::as_c_str(mask) { |mask_| mask_ };
+    ret GL::glGetPolygonStipple(mask_c_str as *u8);
 }
 fn glEdgeFlag(flag: uint) -> () unsafe {
     ret GL::glEdgeFlag(flag as u8);
 }
-fn glEdgeFlagv(flag: *uint) -> () unsafe {
-    ret GL::glEdgeFlagv(flag as *u8);
+fn glEdgeFlagv(flag: str) -> () unsafe {
+    let flag_c_str = str::as_c_str(flag) { |flag_| flag_ };
+    ret GL::glEdgeFlagv(flag_c_str as *u8);
 }
 fn glScissor(x: int, y: int, width: int, height: int) -> () unsafe {
     ret GL::glScissor(x as i32, y as i32, width as i32, height as i32);
 }
-fn glClipPlane(plane: uint, equation: *float) -> () unsafe {
-    ret GL::glClipPlane(plane as u32, equation as *f64);
-}
-fn glGetClipPlane(plane: uint, equation: *float) -> () unsafe {
-    ret GL::glGetClipPlane(plane as u32, equation as *f64);
+fn glClipPlane(plane: uint, equation: *f64) -> () unsafe {
+    ret GL::glClipPlane(plane as u32, equation);
+}
+fn glGetClipPlane(plane: uint, equation: *f64) -> () unsafe {
+    ret GL::glGetClipPlane(plane as u32, equation);
 }
 fn glDrawBuffer(mode: uint) -> () unsafe {
     ret GL::glDrawBuffer(mode as u32);
 fn glDisable(cap: uint) -> () unsafe {
     ret GL::glDisable(cap as u32);
 }
-fn glIsEnabled(cap: uint) -> u8 unsafe {
-    ret GL::glIsEnabled(cap as u32);
+fn glIsEnabled(cap: uint) -> uint unsafe {
+    ret GL::glIsEnabled(cap as u32) as uint;
 }
 fn glEnableClientState(cap: uint) -> () unsafe {
     ret GL::glEnableClientState(cap as u32);
 }
-fn glGetDoublev(pname: uint, params: *float) -> () unsafe {
-    ret GL::glGetDoublev(pname as u32, params as *f64);
-}
-fn glGetFloatv(pname: uint, params: *float) -> () unsafe {
-    ret GL::glGetFloatv(pname as u32, params as *f32);
-}
-fn glGetIntegerv(pname: uint, params: *int) -> () unsafe {
-    ret GL::glGetIntegerv(pname as u32, params as *i32);
+fn glGetDoublev(pname: uint, params: *f64) -> () unsafe {
+    ret GL::glGetDoublev(pname as u32, params);
+}
+fn glGetFloatv(pname: uint, params: *f32) -> () unsafe {
+    ret GL::glGetFloatv(pname as u32, params);
+}
+fn glGetIntegerv(pname: uint, params: *i32) -> () unsafe {
+    ret GL::glGetIntegerv(pname as u32, params);
 }
 fn glPushAttrib(mask: uint) -> () unsafe {
     ret GL::glPushAttrib(mask as u32);
 fn glPushClientAttrib(mask: uint) -> () unsafe {
     ret GL::glPushClientAttrib(mask as u32);
 }
-fn glGetError() -> u32 unsafe {
-    ret GL::glGetError();
+fn glGetError() -> uint unsafe {
+    ret GL::glGetError() as uint;
+}
+fn glGetString(name: uint) -> str unsafe {
+    ret str::unsafe::from_buf(GL::glGetString(name as u32));
 }
 fn glFinish() -> () unsafe {
     ret GL::glFinish();
 fn glLoadIdentity() -> () unsafe {
     ret GL::glLoadIdentity();
 }
-fn glLoadMatrixd(m: *float) -> () unsafe {
-    ret GL::glLoadMatrixd(m as *f64);
-}
-fn glLoadMatrixf(m: *float) -> () unsafe {
-    ret GL::glLoadMatrixf(m as *f32);
-}
-fn glMultMatrixd(m: *float) -> () unsafe {
-    ret GL::glMultMatrixd(m as *f64);
-}
-fn glMultMatrixf(m: *float) -> () unsafe {
-    ret GL::glMultMatrixf(m as *f32);
+fn glLoadMatrixd(m: *f64) -> () unsafe {
+    ret GL::glLoadMatrixd(m);
+}
+fn glLoadMatrixf(m: *f32) -> () unsafe {
+    ret GL::glLoadMatrixf(m);
+}
+fn glMultMatrixd(m: *f64) -> () unsafe {
+    ret GL::glMultMatrixd(m);
+}
+fn glMultMatrixf(m: *f32) -> () unsafe {
+    ret GL::glMultMatrixf(m);
 }
 fn glRotated(angle: float, x: float, y: float, z: float) -> () unsafe {
     ret GL::glRotated(angle as f64, x as f64, y as f64, z as f64);
 fn glTranslatef(x: float, y: float, z: float) -> () unsafe {
     ret GL::glTranslatef(x as f32, y as f32, z as f32);
 }
-fn glIsList(list: uint) -> u8 unsafe {
-    ret GL::glIsList(list as u32);
+fn glIsList(list: uint) -> uint unsafe {
+    ret GL::glIsList(list as u32) as uint;
 }
 fn glDeleteLists(list: uint, range: int) -> () unsafe {
     ret GL::glDeleteLists(list as u32, range as i32);
 }
-fn glGenLists(range: int) -> u32 unsafe {
-    ret GL::glGenLists(range as i32);
+fn glGenLists(range: int) -> uint unsafe {
+    ret GL::glGenLists(range as i32) as uint;
 }
 fn glNewList(list: uint, mode: uint) -> () unsafe {
     ret GL::glNewList(list as u32, mode as u32);
     ret GL::glCallList(list as u32);
 }
 fn glCallLists(n: int, type_: uint, lists: *()) -> () unsafe {
-    ret GL::glCallLists(n as i32, type_ as u32, lists as *());
+    ret GL::glCallLists(n as i32, type_ as u32, lists);
 }
 fn glListBase(base: uint) -> () unsafe {
     ret GL::glListBase(base as u32);
 fn glVertex4s(x: int, y: int, z: int, w: int) -> () unsafe {
     ret GL::glVertex4s(x as i16, y as i16, z as i16, w as i16);
 }
-fn glVertex2dv(v: *float) -> () unsafe {
-    ret GL::glVertex2dv(v as *f64);
-}
-fn glVertex2fv(v: *float) -> () unsafe {
-    ret GL::glVertex2fv(v as *f32);
-}
-fn glVertex2iv(v: *int) -> () unsafe {
-    ret GL::glVertex2iv(v as *i32);
-}
-fn glVertex2sv(v: *int) -> () unsafe {
-    ret GL::glVertex2sv(v as *i16);
-}
-fn glVertex3dv(v: *float) -> () unsafe {
-    ret GL::glVertex3dv(v as *f64);
-}
-fn glVertex3fv(v: *float) -> () unsafe {
-    ret GL::glVertex3fv(v as *f32);
-}
-fn glVertex3iv(v: *int) -> () unsafe {
-    ret GL::glVertex3iv(v as *i32);
-}
-fn glVertex3sv(v: *int) -> () unsafe {
-    ret GL::glVertex3sv(v as *i16);
-}
-fn glVertex4dv(v: *float) -> () unsafe {
-    ret GL::glVertex4dv(v as *f64);
-}
-fn glVertex4fv(v: *float) -> () unsafe {
-    ret GL::glVertex4fv(v as *f32);
-}
-fn glVertex4iv(v: *int) -> () unsafe {
-    ret GL::glVertex4iv(v as *i32);
-}
-fn glVertex4sv(v: *int) -> () unsafe {
-    ret GL::glVertex4sv(v as *i16);
+fn glVertex2dv(v: *f64) -> () unsafe {
+    ret GL::glVertex2dv(v);
+}
+fn glVertex2fv(v: *f32) -> () unsafe {
+    ret GL::glVertex2fv(v);
+}
+fn glVertex2iv(v: *i32) -> () unsafe {
+    ret GL::glVertex2iv(v);
+}
+fn glVertex2sv(v: *i16) -> () unsafe {
+    ret GL::glVertex2sv(v);
+}
+fn glVertex3dv(v: *f64) -> () unsafe {
+    ret GL::glVertex3dv(v);
+}
+fn glVertex3fv(v: *f32) -> () unsafe {
+    ret GL::glVertex3fv(v);
+}
+fn glVertex3iv(v: *i32) -> () unsafe {
+    ret GL::glVertex3iv(v);
+}
+fn glVertex3sv(v: *i16) -> () unsafe {
+    ret GL::glVertex3sv(v);
+}
+fn glVertex4dv(v: *f64) -> () unsafe {
+    ret GL::glVertex4dv(v);
+}
+fn glVertex4fv(v: *f32) -> () unsafe {
+    ret GL::glVertex4fv(v);
+}
+fn glVertex4iv(v: *i32) -> () unsafe {
+    ret GL::glVertex4iv(v);
+}
+fn glVertex4sv(v: *i16) -> () unsafe {
+    ret GL::glVertex4sv(v);
 }
 fn glNormal3b(nx: int, ny: int, nz: int) -> () unsafe {
     ret GL::glNormal3b(nx as i8, ny as i8, nz as i8);
 fn glNormal3s(nx: int, ny: int, nz: int) -> () unsafe {
     ret GL::glNormal3s(nx as i16, ny as i16, nz as i16);
 }
-fn glNormal3bv(v: *int) -> () unsafe {
-    ret GL::glNormal3bv(v as *i8);
-}
-fn glNormal3dv(v: *float) -> () unsafe {
-    ret GL::glNormal3dv(v as *f64);
-}
-fn glNormal3fv(v: *float) -> () unsafe {
-    ret GL::glNormal3fv(v as *f32);
-}
-fn glNormal3iv(v: *int) -> () unsafe {
-    ret GL::glNormal3iv(v as *i32);
-}
-fn glNormal3sv(v: *int) -> () unsafe {
-    ret GL::glNormal3sv(v as *i16);
+fn glNormal3bv(v: *i8) -> () unsafe {
+    ret GL::glNormal3bv(v);
+}
+fn glNormal3dv(v: *f64) -> () unsafe {
+    ret GL::glNormal3dv(v);
+}
+fn glNormal3fv(v: *f32) -> () unsafe {
+    ret GL::glNormal3fv(v);
+}
+fn glNormal3iv(v: *i32) -> () unsafe {
+    ret GL::glNormal3iv(v);
+}
+fn glNormal3sv(v: *i16) -> () unsafe {
+    ret GL::glNormal3sv(v);
 }
 fn glIndexd(c: float) -> () unsafe {
     ret GL::glIndexd(c as f64);
 fn glIndexub(c: uint) -> () unsafe {
     ret GL::glIndexub(c as u8);
 }
-fn glIndexfv(c: *float) -> () unsafe {
-    ret GL::glIndexfv(c as *f32);
-}
-fn glIndexiv(c: *int) -> () unsafe {
-    ret GL::glIndexiv(c as *i32);
-}
-fn glIndexsv(c: *int) -> () unsafe {
-    ret GL::glIndexsv(c as *i16);
-}
-fn glIndexubv(c: *uint) -> () unsafe {
-    ret GL::glIndexubv(c as *u8);
+fn glIndexfv(c: *f32) -> () unsafe {
+    ret GL::glIndexfv(c);
+}
+fn glIndexiv(c: *i32) -> () unsafe {
+    ret GL::glIndexiv(c);
+}
+fn glIndexsv(c: *i16) -> () unsafe {
+    ret GL::glIndexsv(c);
+}
+fn glIndexubv(c: str) -> () unsafe {
+    let c_c_str = str::as_c_str(c) { |c_| c_ };
+    ret GL::glIndexubv(c_c_str as *u8);
 }
 fn glColor3d(red: float, green: float, blue: float) -> () unsafe {
     ret GL::glColor3d(red as f64, green as f64, blue as f64);
 fn glColor4us(red: uint, green: uint, blue: uint, alpha: uint) -> () unsafe {
     ret GL::glColor4us(red as u16, green as u16, blue as u16, alpha as u16);
 }
-fn glColor3bv(v: *int) -> () unsafe {
-    ret GL::glColor3bv(v as *i8);
-}
-fn glColor3dv(v: *float) -> () unsafe {
-    ret GL::glColor3dv(v as *f64);
-}
-fn glColor3fv(v: *float) -> () unsafe {
-    ret GL::glColor3fv(v as *f32);
-}
-fn glColor3iv(v: *int) -> () unsafe {
-    ret GL::glColor3iv(v as *i32);
-}
-fn glColor3sv(v: *int) -> () unsafe {
-    ret GL::glColor3sv(v as *i16);
-}
-fn glColor3ubv(v: *uint) -> () unsafe {
-    ret GL::glColor3ubv(v as *u8);
-}
-fn glColor3uiv(v: *uint) -> () unsafe {
-    ret GL::glColor3uiv(v as *u32);
-}
-fn glColor3usv(v: *uint) -> () unsafe {
-    ret GL::glColor3usv(v as *u16);
-}
-fn glColor4bv(v: *int) -> () unsafe {
-    ret GL::glColor4bv(v as *i8);
-}
-fn glColor4dv(v: *float) -> () unsafe {
-    ret GL::glColor4dv(v as *f64);
-}
-fn glColor4fv(v: *float) -> () unsafe {
-    ret GL::glColor4fv(v as *f32);
-}
-fn glColor4iv(v: *int) -> () unsafe {
-    ret GL::glColor4iv(v as *i32);
-}
-fn glColor4sv(v: *int) -> () unsafe {
-    ret GL::glColor4sv(v as *i16);
-}
-fn glColor4ubv(v: *uint) -> () unsafe {
-    ret GL::glColor4ubv(v as *u8);
-}
-fn glColor4uiv(v: *uint) -> () unsafe {
-    ret GL::glColor4uiv(v as *u32);
-}
-fn glColor4usv(v: *uint) -> () unsafe {
-    ret GL::glColor4usv(v as *u16);
+fn glColor3bv(v: *i8) -> () unsafe {
+    ret GL::glColor3bv(v);
+}
+fn glColor3dv(v: *f64) -> () unsafe {
+    ret GL::glColor3dv(v);
+}
+fn glColor3fv(v: *f32) -> () unsafe {
+    ret GL::glColor3fv(v);
+}
+fn glColor3iv(v: *i32) -> () unsafe {
+    ret GL::glColor3iv(v);
+}
+fn glColor3sv(v: *i16) -> () unsafe {
+    ret GL::glColor3sv(v);
+}
+fn glColor3ubv(v: str) -> () unsafe {
+    let v_c_str = str::as_c_str(v) { |v_| v_ };
+    ret GL::glColor3ubv(v_c_str as *u8);
+}
+fn glColor3uiv(v: *u32) -> () unsafe {
+    ret GL::glColor3uiv(v);
+}
+fn glColor3usv(v: *u16) -> () unsafe {
+    ret GL::glColor3usv(v);
+}
+fn glColor4bv(v: *i8) -> () unsafe {
+    ret GL::glColor4bv(v);
+}
+fn glColor4dv(v: *f64) -> () unsafe {
+    ret GL::glColor4dv(v);
+}
+fn glColor4fv(v: *f32) -> () unsafe {
+    ret GL::glColor4fv(v);
+}
+fn glColor4iv(v: *i32) -> () unsafe {
+    ret GL::glColor4iv(v);
+}
+fn glColor4sv(v: *i16) -> () unsafe {
+    ret GL::glColor4sv(v);
+}
+fn glColor4ubv(v: str) -> () unsafe {
+    let v_c_str = str::as_c_str(v) { |v_| v_ };
+    ret GL::glColor4ubv(v_c_str as *u8);
+}
+fn glColor4uiv(v: *u32) -> () unsafe {
+    ret GL::glColor4uiv(v);
+}
+fn glColor4usv(v: *u16) -> () unsafe {
+    ret GL::glColor4usv(v);
 }
 fn glTexCoord1d(s: float) -> () unsafe {
     ret GL::glTexCoord1d(s as f64);
 fn glTexCoord4s(s: int, t: int, r: int, q: int) -> () unsafe {
     ret GL::glTexCoord4s(s as i16, t as i16, r as i16, q as i16);
 }
-fn glTexCoord1dv(v: *float) -> () unsafe {
-    ret GL::glTexCoord1dv(v as *f64);
-}
-fn glTexCoord1fv(v: *float) -> () unsafe {
-    ret GL::glTexCoord1fv(v as *f32);
-}
-fn glTexCoord1iv(v: *int) -> () unsafe {
-    ret GL::glTexCoord1iv(v as *i32);
-}
-fn glTexCoord1sv(v: *int) -> () unsafe {
-    ret GL::glTexCoord1sv(v as *i16);
-}
-fn glTexCoord2dv(v: *float) -> () unsafe {
-    ret GL::glTexCoord2dv(v as *f64);
-}
-fn glTexCoord2fv(v: *float) -> () unsafe {
-    ret GL::glTexCoord2fv(v as *f32);
-}
-fn glTexCoord2iv(v: *int) -> () unsafe {
-    ret GL::glTexCoord2iv(v as *i32);
-}
-fn glTexCoord2sv(v: *int) -> () unsafe {
-    ret GL::glTexCoord2sv(v as *i16);
-}
-fn glTexCoord3dv(v: *float) -> () unsafe {
-    ret GL::glTexCoord3dv(v as *f64);
-}
-fn glTexCoord3fv(v: *float) -> () unsafe {
-    ret GL::glTexCoord3fv(v as *f32);
-}
-fn glTexCoord3iv(v: *int) -> () unsafe {
-    ret GL::glTexCoord3iv(v as *i32);
-}
-fn glTexCoord3sv(v: *int) -> () unsafe {
-    ret GL::glTexCoord3sv(v as *i16);
-}
-fn glTexCoord4dv(v: *float) -> () unsafe {
-    ret GL::glTexCoord4dv(v as *f64);
-}
-fn glTexCoord4fv(v: *float) -> () unsafe {
-    ret GL::glTexCoord4fv(v as *f32);
-}
-fn glTexCoord4iv(v: *int) -> () unsafe {
-    ret GL::glTexCoord4iv(v as *i32);
-}
-fn glTexCoord4sv(v: *int) -> () unsafe {
-    ret GL::glTexCoord4sv(v as *i16);
+fn glTexCoord1dv(v: *f64) -> () unsafe {
+    ret GL::glTexCoord1dv(v);
+}
+fn glTexCoord1fv(v: *f32) -> () unsafe {
+    ret GL::glTexCoord1fv(v);
+}
+fn glTexCoord1iv(v: *i32) -> () unsafe {
+    ret GL::glTexCoord1iv(v);
+}
+fn glTexCoord1sv(v: *i16) -> () unsafe {
+    ret GL::glTexCoord1sv(v);
+}
+fn glTexCoord2dv(v: *f64) -> () unsafe {
+    ret GL::glTexCoord2dv(v);
+}
+fn glTexCoord2fv(v: *f32) -> () unsafe {
+    ret GL::glTexCoord2fv(v);
+}
+fn glTexCoord2iv(v: *i32) -> () unsafe {
+    ret GL::glTexCoord2iv(v);
+}
+fn glTexCoord2sv(v: *i16) -> () unsafe {
+    ret GL::glTexCoord2sv(v);
+}
+fn glTexCoord3dv(v: *f64) -> () unsafe {
+    ret GL::glTexCoord3dv(v);
+}
+fn glTexCoord3fv(v: *f32) -> () unsafe {
+    ret GL::glTexCoord3fv(v);
+}
+fn glTexCoord3iv(v: *i32) -> () unsafe {
+    ret GL::glTexCoord3iv(v);
+}
+fn glTexCoord3sv(v: *i16) -> () unsafe {
+    ret GL::glTexCoord3sv(v);
+}
+fn glTexCoord4dv(v: *f64) -> () unsafe {
+    ret GL::glTexCoord4dv(v);
+}
+fn glTexCoord4fv(v: *f32) -> () unsafe {
+    ret GL::glTexCoord4fv(v);
+}
+fn glTexCoord4iv(v: *i32) -> () unsafe {
+    ret GL::glTexCoord4iv(v);
+}
+fn glTexCoord4sv(v: *i16) -> () unsafe {
+    ret GL::glTexCoord4sv(v);
 }
 fn glRasterPos2d(x: float, y: float) -> () unsafe {
     ret GL::glRasterPos2d(x as f64, y as f64);
 fn glRasterPos4s(x: int, y: int, z: int, w: int) -> () unsafe {
     ret GL::glRasterPos4s(x as i16, y as i16, z as i16, w as i16);
 }
-fn glRasterPos2dv(v: *float) -> () unsafe {
-    ret GL::glRasterPos2dv(v as *f64);
-}
-fn glRasterPos2fv(v: *float) -> () unsafe {
-    ret GL::glRasterPos2fv(v as *f32);
-}
-fn glRasterPos2iv(v: *int) -> () unsafe {
-    ret GL::glRasterPos2iv(v as *i32);
-}
-fn glRasterPos2sv(v: *int) -> () unsafe {
-    ret GL::glRasterPos2sv(v as *i16);
-}
-fn glRasterPos3dv(v: *float) -> () unsafe {
-    ret GL::glRasterPos3dv(v as *f64);
-}
-fn glRasterPos3fv(v: *float) -> () unsafe {
-    ret GL::glRasterPos3fv(v as *f32);
-}
-fn glRasterPos3iv(v: *int) -> () unsafe {
-    ret GL::glRasterPos3iv(v as *i32);
-}
-fn glRasterPos3sv(v: *int) -> () unsafe {
-    ret GL::glRasterPos3sv(v as *i16);
-}
-fn glRasterPos4dv(v: *float) -> () unsafe {
-    ret GL::glRasterPos4dv(v as *f64);
-}
-fn glRasterPos4fv(v: *float) -> () unsafe {
-    ret GL::glRasterPos4fv(v as *f32);
-}
-fn glRasterPos4iv(v: *int) -> () unsafe {
-    ret GL::glRasterPos4iv(v as *i32);
-}
-fn glRasterPos4sv(v: *int) -> () unsafe {
-    ret GL::glRasterPos4sv(v as *i16);
+fn glRasterPos2dv(v: *f64) -> () unsafe {
+    ret GL::glRasterPos2dv(v);
+}
+fn glRasterPos2fv(v: *f32) -> () unsafe {
+    ret GL::glRasterPos2fv(v);
+}
+fn glRasterPos2iv(v: *i32) -> () unsafe {
+    ret GL::glRasterPos2iv(v);
+}
+fn glRasterPos2sv(v: *i16) -> () unsafe {
+    ret GL::glRasterPos2sv(v);
+}
+fn glRasterPos3dv(v: *f64) -> () unsafe {
+    ret GL::glRasterPos3dv(v);
+}
+fn glRasterPos3fv(v: *f32) -> () unsafe {
+    ret GL::glRasterPos3fv(v);
+}
+fn glRasterPos3iv(v: *i32) -> () unsafe {
+    ret GL::glRasterPos3iv(v);
+}
+fn glRasterPos3sv(v: *i16) -> () unsafe {
+    ret GL::glRasterPos3sv(v);
+}
+fn glRasterPos4dv(v: *f64) -> () unsafe {
+    ret GL::glRasterPos4dv(v);
+}
+fn glRasterPos4fv(v: *f32) -> () unsafe {
+    ret GL::glRasterPos4fv(v);
+}
+fn glRasterPos4iv(v: *i32) -> () unsafe {
+    ret GL::glRasterPos4iv(v);
+}
+fn glRasterPos4sv(v: *i16) -> () unsafe {
+    ret GL::glRasterPos4sv(v);
 }
 fn glRectd(x1: float, y1: float, x2: float, y2: float) -> () unsafe {
     ret GL::glRectd(x1 as f64, y1 as f64, x2 as f64, y2 as f64);
 fn glRects(x1: int, y1: int, x2: int, y2: int) -> () unsafe {
     ret GL::glRects(x1 as i16, y1 as i16, x2 as i16, y2 as i16);
 }
-fn glRectdv(v1: *float, v2: *float) -> () unsafe {
-    ret GL::glRectdv(v1 as *f64, v2 as *f64);
-}
-fn glRectfv(v1: *float, v2: *float) -> () unsafe {
-    ret GL::glRectfv(v1 as *f32, v2 as *f32);
-}
-fn glRectiv(v1: *int, v2: *int) -> () unsafe {
-    ret GL::glRectiv(v1 as *i32, v2 as *i32);
-}
-fn glRectsv(v1: *int, v2: *int) -> () unsafe {
-    ret GL::glRectsv(v1 as *i16, v2 as *i16);
+fn glRectdv(v1: *f64, v2: *f64) -> () unsafe {
+    ret GL::glRectdv(v1, v2);
+}
+fn glRectfv(v1: *f32, v2: *f32) -> () unsafe {
+    ret GL::glRectfv(v1, v2);
+}
+fn glRectiv(v1: *i32, v2: *i32) -> () unsafe {
+    ret GL::glRectiv(v1, v2);
+}
+fn glRectsv(v1: *i16, v2: *i16) -> () unsafe {
+    ret GL::glRectsv(v1, v2);
 }
 fn glVertexPointer(size: int, type_: uint, stride: int, ptr: *()) -> () unsafe {
-    ret GL::glVertexPointer(size as i32, type_ as u32, stride as i32, ptr as *());
+    ret GL::glVertexPointer(size as i32, type_ as u32, stride as i32, ptr);
 }
 fn glNormalPointer(type_: uint, stride: int, ptr: *()) -> () unsafe {
-    ret GL::glNormalPointer(type_ as u32, stride as i32, ptr as *());
+    ret GL::glNormalPointer(type_ as u32, stride as i32, ptr);
 }
 fn glColorPointer(size: int, type_: uint, stride: int, ptr: *()) -> () unsafe {
-    ret GL::glColorPointer(size as i32, type_ as u32, stride as i32, ptr as *());
+    ret GL::glColorPointer(size as i32, type_ as u32, stride as i32, ptr);
 }
 fn glIndexPointer(type_: uint, stride: int, ptr: *()) -> () unsafe {
-    ret GL::glIndexPointer(type_ as u32, stride as i32, ptr as *());
+    ret GL::glIndexPointer(type_ as u32, stride as i32, ptr);
 }
 fn glTexCoordPointer(size: int, type_: uint, stride: int, ptr: *()) -> () unsafe {
-    ret GL::glTexCoordPointer(size as i32, type_ as u32, stride as i32, ptr as *());
+    ret GL::glTexCoordPointer(size as i32, type_ as u32, stride as i32, ptr);
 }
 fn glEdgeFlagPointer(stride: int, ptr: *()) -> () unsafe {
-    ret GL::glEdgeFlagPointer(stride as i32, ptr as *());
+    ret GL::glEdgeFlagPointer(stride as i32, ptr);
 }
 fn glGetPointerv(pname: uint, params: *()) -> () unsafe {
-    ret GL::glGetPointerv(pname as u32, params as *());
+    ret GL::glGetPointerv(pname as u32, params);
 }
 fn glArrayElement(i: int) -> () unsafe {
     ret GL::glArrayElement(i as i32);
     ret GL::glDrawArrays(mode as u32, first as i32, count as i32);
 }
 fn glDrawElements(mode: uint, count: int, type_: uint, indices: *()) -> () unsafe {
-    ret GL::glDrawElements(mode as u32, count as i32, type_ as u32, indices as *());
+    ret GL::glDrawElements(mode as u32, count as i32, type_ as u32, indices);
 }
 fn glInterleavedArrays(format: uint, stride: int, pointer: *()) -> () unsafe {
-    ret GL::glInterleavedArrays(format as u32, stride as i32, pointer as *());
+    ret GL::glInterleavedArrays(format as u32, stride as i32, pointer);
 }
 fn glShadeModel(mode: uint) -> () unsafe {
     ret GL::glShadeModel(mode as u32);
 fn glLighti(light: uint, pname: uint, param: int) -> () unsafe {
     ret GL::glLighti(light as u32, pname as u32, param as i32);
 }
-fn glLightfv(light: uint, pname: uint, params: *float) -> () unsafe {
-    ret GL::glLightfv(light as u32, pname as u32, params as *f32);
-}
-fn glLightiv(light: uint, pname: uint, params: *int) -> () unsafe {
-    ret GL::glLightiv(light as u32, pname as u32, params as *i32);
-}
-fn glGetLightfv(light: uint, pname: uint, params: *float) -> () unsafe {
-    ret GL::glGetLightfv(light as u32, pname as u32, params as *f32);
-}
-fn glGetLightiv(light: uint, pname: uint, params: *int) -> () unsafe {
-    ret GL::glGetLightiv(light as u32, pname as u32, params as *i32);
+fn glLightfv(light: uint, pname: uint, params: *f32) -> () unsafe {
+    ret GL::glLightfv(light as u32, pname as u32, params);
+}
+fn glLightiv(light: uint, pname: uint, params: *i32) -> () unsafe {
+    ret GL::glLightiv(light as u32, pname as u32, params);
+}
+fn glGetLightfv(light: uint, pname: uint, params: *f32) -> () unsafe {
+    ret GL::glGetLightfv(light as u32, pname as u32, params);
+}
+fn glGetLightiv(light: uint, pname: uint, params: *i32) -> () unsafe {
+    ret GL::glGetLightiv(light as u32, pname as u32, params);
 }
 fn glLightModelf(pname: uint, param: float) -> () unsafe {
     ret GL::glLightModelf(pname as u32, param as f32);
 fn glLightModeli(pname: uint, param: int) -> () unsafe {
     ret GL::glLightModeli(pname as u32, param as i32);
 }
-fn glLightModelfv(pname: uint, params: *float) -> () unsafe {
-    ret GL::glLightModelfv(pname as u32, params as *f32);
-}
-fn glLightModeliv(pname: uint, params: *int) -> () unsafe {
-    ret GL::glLightModeliv(pname as u32, params as *i32);
+fn glLightModelfv(pname: uint, params: *f32) -> () unsafe {
+    ret GL::glLightModelfv(pname as u32, params);
+}
+fn glLightModeliv(pname: uint, params: *i32) -> () unsafe {
+    ret GL::glLightModeliv(pname as u32, params);
 }
 fn glMaterialf(face: uint, pname: uint, param: float) -> () unsafe {
     ret GL::glMaterialf(face as u32, pname as u32, param as f32);
 fn glMateriali(face: uint, pname: uint, param: int) -> () unsafe {
     ret GL::glMateriali(face as u32, pname as u32, param as i32);
 }
-fn glMaterialfv(face: uint, pname: uint, params: *float) -> () unsafe {
-    ret GL::glMaterialfv(face as u32, pname as u32, params as *f32);
-}
-fn glMaterialiv(face: uint, pname: uint, params: *int) -> () unsafe {
-    ret GL::glMaterialiv(face as u32, pname as u32, params as *i32);
-}
-fn glGetMaterialfv(face: uint, pname: uint, params: *float) -> () unsafe {
-    ret GL::glGetMaterialfv(face as u32, pname as u32, params as *f32);
-}
-fn glGetMaterialiv(face: uint, pname: uint, params: *int) -> () unsafe {
-    ret GL::glGetMaterialiv(face as u32, pname as u32, params as *i32);
+fn glMaterialfv(face: uint, pname: uint, params: *f32) -> () unsafe {
+    ret GL::glMaterialfv(face as u32, pname as u32, params);
+}
+fn glMaterialiv(face: uint, pname: uint, params: *i32) -> () unsafe {
+    ret GL::glMaterialiv(face as u32, pname as u32, params);
+}
+fn glGetMaterialfv(face: uint, pname: uint, params: *f32) -> () unsafe {
+    ret GL::glGetMaterialfv(face as u32, pname as u32, params);
+}
+fn glGetMaterialiv(face: uint, pname: uint, params: *i32) -> () unsafe {
+    ret GL::glGetMaterialiv(face as u32, pname as u32, params);
 }
 fn glColorMaterial(face: uint, mode: uint) -> () unsafe {