Module Glcaml

module Glcaml: sig .. end

GLCaml, an Objective Caml interface for OpenGL versions 1.1, 1.2, 1.3, 1.4, 1.5 and 2.0 plus extensions

The following extensions are supported:

GL_ARB_imaging
GL_ARB_matrix_palette
GL_ARB_multitexture
GL_ARB_vertex_blend
GL_ATI_envmap_bumpmap
GL_ATI_map_object_buffer
GL_ATI_pn_triangles
GL_ATI_separate_stencil
GL_ATI_texture_compression_3dc
GL_ATI_vertex_streams
GL_ATIX_point_sprites
GL_ATIX_texture_env_combine3
GL_ATIX_texture_env_route
GL_ATIX_vertex_shader_output_point_size
GL_EXT_Cg_shader
GL_EXT_depth_bounds_test
GL_EXT_draw_range_elements
GL_EXT_fog_coord
GL_EXT_pixel_buffer_object
GL_EXT_secondary_color
GL_EXT_texture_cube_map
GL_EXT_texture_edge_clamp
GL_EXT_texture_rectangle
GL_EXT_vertex_shader
GL_KTX_buffer_region
GL_NV_fragment_program2
GL_NV_fragment_program_option
GL_NV_vertex_program2_option
GL_NV_vertex_program3

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License version 2, as published by the Free Software Foundation.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU Library General Public License version 2 for more details (enclosed in the file LGPL).

GLCaml is a direct, not particularly type-safe binding to OpenGL. It has the following features:

Inspired by camlgl.sourceforge.net, GLCaml loads the OpenGL library dynamically ("OpenGL32.dll" on windows, "libGL.so.1" on Linux)
OpenGL functions are loaded dynamically and memoized, once loaded, to speed up future calls.
Naming conventions are exactly the same as in the traditional 'C' OpenGL API.
Enumerated constants (Glenums) are in GL_ALL_CAPS format.
Where in C an OR-ed combination of Glenums is passed to a function, in OCaml a list of glenums is passed
Function names have the exact same names in OCaml as in 'C'
Where OpenGL functions require an array for either input or output, a Bigarray of the appropriate type is used.
To this end, types for Bigarrays of bytes, floats, ints, doubles etc have been defined.
set_failwith -> bool -> unit determines whether a failed GL call throws a Failure exception or fails silently.
This binding is wholly automatically generated and contains hundreds of function bindings, the vast majority of which have not been tested. Use at your own risk.

type glpointer

type byte_array = (int, Bigarray.int8_signed_elt, Bigarray.c_layout) Bigarray.Array1.t

type ubyte_array = (int, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t

type short_array = (int, Bigarray.int16_signed_elt, Bigarray.c_layout) Bigarray.Array1.t

type ushort_array = (int, Bigarray.int16_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t

type word_array = (int32, Bigarray.int32_elt, Bigarray.c_layout) Bigarray.Array1.t

type int_array = (int, Bigarray.int_elt, Bigarray.c_layout) Bigarray.Array1.t

type float_array = (float, Bigarray.float32_elt, Bigarray.c_layout) Bigarray.Array1.t

type double_array = (float, Bigarray.float64_elt, Bigarray.c_layout) Bigarray.Array1.t

type byte_matrix = (int, Bigarray.int8_signed_elt, Bigarray.c_layout) Bigarray.Array2.t

type glenum =

`\|`	`GL_CONSTANT_COLOR`
`\|`	`GL_ONE_MINUS_CONSTANT_COLOR`
`\|`	`GL_CONSTANT_ALPHA`
`\|`	`GL_ONE_MINUS_CONSTANT_ALPHA`
`\|`	`GL_BLEND_COLOR`
`\|`	`GL_FUNC_ADD`
`\|`	`GL_MIN`
`\|`	`GL_MAX`
`\|`	`GL_BLEND_EQUATION`
`\|`	`GL_FUNC_SUBTRACT`
`\|`	`GL_FUNC_REVERSE_SUBTRACT`
`\|`	`GL_CONVOLUTION_1D`
`\|`	`GL_CONVOLUTION_2D`
`\|`	`GL_SEPARABLE_2D`
`\|`	`GL_CONVOLUTION_BORDER_MODE`
`\|`	`GL_CONVOLUTION_FILTER_SCALE`
`\|`	`GL_CONVOLUTION_FILTER_BIAS`
`\|`	`GL_REDUCE`
`\|`	`GL_CONVOLUTION_FORMAT`
`\|`	`GL_CONVOLUTION_WIDTH`
`\|`	`GL_CONVOLUTION_HEIGHT`
`\|`	`GL_MAX_CONVOLUTION_WIDTH`
`\|`	`GL_MAX_CONVOLUTION_HEIGHT`
`\|`	`GL_POST_CONVOLUTION_RED_SCALE`
`\|`	`GL_POST_CONVOLUTION_GREEN_SCALE`
`\|`	`GL_POST_CONVOLUTION_BLUE_SCALE`
`\|`	`GL_POST_CONVOLUTION_ALPHA_SCALE`
`\|`	`GL_POST_CONVOLUTION_RED_BIAS`
`\|`	`GL_POST_CONVOLUTION_GREEN_BIAS`
`\|`	`GL_POST_CONVOLUTION_BLUE_BIAS`
`\|`	`GL_POST_CONVOLUTION_ALPHA_BIAS`
`\|`	`GL_HISTOGRAM`
`\|`	`GL_PROXY_HISTOGRAM`
`\|`	`GL_HISTOGRAM_WIDTH`
`\|`	`GL_HISTOGRAM_FORMAT`
`\|`	`GL_HISTOGRAM_RED_SIZE`
`\|`	`GL_HISTOGRAM_GREEN_SIZE`
`\|`	`GL_HISTOGRAM_BLUE_SIZE`
`\|`	`GL_HISTOGRAM_ALPHA_SIZE`
`\|`	`GL_HISTOGRAM_LUMINANCE_SIZE`
`\|`	`GL_HISTOGRAM_SINK`
`\|`	`GL_MINMAX`
`\|`	`GL_MINMAX_FORMAT`
`\|`	`GL_MINMAX_SINK`
`\|`	`GL_TABLE_TOO_LARGE`
`\|`	`GL_COLOR_MATRIX`
`\|`	`GL_COLOR_MATRIX_STACK_DEPTH`
`\|`	`GL_MAX_COLOR_MATRIX_STACK_DEPTH`
`\|`	`GL_POST_COLOR_MATRIX_RED_SCALE`
`\|`	`GL_POST_COLOR_MATRIX_GREEN_SCALE`
`\|`	`GL_POST_COLOR_MATRIX_BLUE_SCALE`
`\|`	`GL_POST_COLOR_MATRIX_ALPHA_SCALE`
`\|`	`GL_POST_COLOR_MATRIX_RED_BIAS`
`\|`	`GL_POST_COLOR_MATRIX_GREEN_BIAS`
`\|`	`GL_POST_COLOR_MATRIX_BLUE_BIAS`
`\|`	`GL_POST_COLOR_MATRIX_ALPHA_BIAS`
`\|`	`GL_COLOR_TABLE`
`\|`	`GL_POST_CONVOLUTION_COLOR_TABLE`
`\|`	`GL_POST_COLOR_MATRIX_COLOR_TABLE`
`\|`	`GL_PROXY_COLOR_TABLE`
`\|`	`GL_PROXY_POST_CONVOLUTION_COLOR_TABLE`
`\|`	`GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE`
`\|`	`GL_COLOR_TABLE_SCALE`
`\|`	`GL_COLOR_TABLE_BIAS`
`\|`	`GL_COLOR_TABLE_FORMAT`
`\|`	`GL_COLOR_TABLE_WIDTH`
`\|`	`GL_COLOR_TABLE_RED_SIZE`
`\|`	`GL_COLOR_TABLE_GREEN_SIZE`
`\|`	`GL_COLOR_TABLE_BLUE_SIZE`
`\|`	`GL_COLOR_TABLE_ALPHA_SIZE`
`\|`	`GL_COLOR_TABLE_LUMINANCE_SIZE`
`\|`	`GL_COLOR_TABLE_INTENSITY_SIZE`
`\|`	`GL_IGNORE_BORDER`
`\|`	`GL_CONSTANT_BORDER`
`\|`	`GL_WRAP_BORDER`
`\|`	`GL_REPLICATE_BORDER`
`\|`	`GL_CONVOLUTION_BORDER_COLOR`
`\|`	`GL_MATRIX_PALETTE_ARB`
`\|`	`GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB`
`\|`	`GL_MAX_PALETTE_MATRICES_ARB`
`\|`	`GL_CURRENT_PALETTE_MATRIX_ARB`
`\|`	`GL_MATRIX_INDEX_ARRAY_ARB`
`\|`	`GL_CURRENT_MATRIX_INDEX_ARB`
`\|`	`GL_MATRIX_INDEX_ARRAY_SIZE_ARB`
`\|`	`GL_MATRIX_INDEX_ARRAY_TYPE_ARB`
`\|`	`GL_MATRIX_INDEX_ARRAY_STRIDE_ARB`
`\|`	`GL_MATRIX_INDEX_ARRAY_POINTER_ARB`
`\|`	`GL_TEXTURE0_ARB`
`\|`	`GL_TEXTURE1_ARB`
`\|`	`GL_TEXTURE2_ARB`
`\|`	`GL_TEXTURE3_ARB`
`\|`	`GL_TEXTURE4_ARB`
`\|`	`GL_TEXTURE5_ARB`
`\|`	`GL_TEXTURE6_ARB`
`\|`	`GL_TEXTURE7_ARB`
`\|`	`GL_TEXTURE8_ARB`
`\|`	`GL_TEXTURE9_ARB`
`\|`	`GL_TEXTURE10_ARB`
`\|`	`GL_TEXTURE11_ARB`
`\|`	`GL_TEXTURE12_ARB`
`\|`	`GL_TEXTURE13_ARB`
`\|`	`GL_TEXTURE14_ARB`
`\|`	`GL_TEXTURE15_ARB`
`\|`	`GL_TEXTURE16_ARB`
`\|`	`GL_TEXTURE17_ARB`
`\|`	`GL_TEXTURE18_ARB`
`\|`	`GL_TEXTURE19_ARB`
`\|`	`GL_TEXTURE20_ARB`
`\|`	`GL_TEXTURE21_ARB`
`\|`	`GL_TEXTURE22_ARB`
`\|`	`GL_TEXTURE23_ARB`
`\|`	`GL_TEXTURE24_ARB`
`\|`	`GL_TEXTURE25_ARB`
`\|`	`GL_TEXTURE26_ARB`
`\|`	`GL_TEXTURE27_ARB`
`\|`	`GL_TEXTURE28_ARB`
`\|`	`GL_TEXTURE29_ARB`
`\|`	`GL_TEXTURE30_ARB`
`\|`	`GL_TEXTURE31_ARB`
`\|`	`GL_ACTIVE_TEXTURE_ARB`
`\|`	`GL_CLIENT_ACTIVE_TEXTURE_ARB`
`\|`	`GL_MAX_TEXTURE_UNITS_ARB`
`\|`	`GL_MAX_VERTEX_UNITS_ARB`
`\|`	`GL_ACTIVE_VERTEX_UNITS_ARB`
`\|`	`GL_WEIGHT_SUM_UNITY_ARB`
`\|`	`GL_VERTEX_BLEND_ARB`
`\|`	`GL_CURRENT_WEIGHT_ARB`
`\|`	`GL_WEIGHT_ARRAY_TYPE_ARB`
`\|`	`GL_WEIGHT_ARRAY_STRIDE_ARB`
`\|`	`GL_WEIGHT_ARRAY_SIZE_ARB`
`\|`	`GL_WEIGHT_ARRAY_POINTER_ARB`
`\|`	`GL_WEIGHT_ARRAY_ARB`
`\|`	`GL_MODELVIEW0_ARB`
`\|`	`GL_MODELVIEW1_ARB`
`\|`	`GL_MODELVIEW2_ARB`
`\|`	`GL_MODELVIEW3_ARB`
`\|`	`GL_MODELVIEW4_ARB`
`\|`	`GL_MODELVIEW5_ARB`
`\|`	`GL_MODELVIEW6_ARB`
`\|`	`GL_MODELVIEW7_ARB`
`\|`	`GL_MODELVIEW8_ARB`
`\|`	`GL_MODELVIEW9_ARB`
`\|`	`GL_MODELVIEW10_ARB`
`\|`	`GL_MODELVIEW11_ARB`
`\|`	`GL_MODELVIEW12_ARB`
`\|`	`GL_MODELVIEW13_ARB`
`\|`	`GL_MODELVIEW14_ARB`
`\|`	`GL_MODELVIEW15_ARB`
`\|`	`GL_MODELVIEW16_ARB`
`\|`	`GL_MODELVIEW17_ARB`
`\|`	`GL_MODELVIEW18_ARB`
`\|`	`GL_MODELVIEW19_ARB`
`\|`	`GL_MODELVIEW20_ARB`
`\|`	`GL_MODELVIEW21_ARB`
`\|`	`GL_MODELVIEW22_ARB`
`\|`	`GL_MODELVIEW23_ARB`
`\|`	`GL_MODELVIEW24_ARB`
`\|`	`GL_MODELVIEW25_ARB`
`\|`	`GL_MODELVIEW26_ARB`
`\|`	`GL_MODELVIEW27_ARB`
`\|`	`GL_MODELVIEW28_ARB`
`\|`	`GL_MODELVIEW29_ARB`
`\|`	`GL_MODELVIEW30_ARB`
`\|`	`GL_MODELVIEW31_ARB`
`\|`	`GL_BUMP_ROT_MATRIX_ATI`
`\|`	`GL_BUMP_ROT_MATRIX_SIZE_ATI`
`\|`	`GL_BUMP_NUM_TEX_UNITS_ATI`
`\|`	`GL_BUMP_TEX_UNITS_ATI`
`\|`	`GL_DUDV_ATI`
`\|`	`GL_DU8DV8_ATI`
`\|`	`GL_BUMP_ENVMAP_ATI`
`\|`	`GL_BUMP_TARGET_ATI`
`\|`	`GL_PN_TRIANGLES_ATI`
`\|`	`GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI`
`\|`	`GL_PN_TRIANGLES_POINT_MODE_ATI`
`\|`	`GL_PN_TRIANGLES_NORMAL_MODE_ATI`
`\|`	`GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI`
`\|`	`GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI`
`\|`	`GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI`
`\|`	`GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI`
`\|`	`GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI`
`\|`	`GL_STENCIL_BACK_FUNC_ATI`
`\|`	`GL_STENCIL_BACK_FAIL_ATI`
`\|`	`GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI`
`\|`	`GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI`
`\|`	`GL_COMPRESSED_RGB_3DC_ATI`
`\|`	`GL_MAX_VERTEX_STREAMS_ATI`
`\|`	`GL_VERTEX_SOURCE_ATI`
`\|`	`GL_VERTEX_STREAM0_ATI`
`\|`	`GL_VERTEX_STREAM1_ATI`
`\|`	`GL_VERTEX_STREAM2_ATI`
`\|`	`GL_VERTEX_STREAM3_ATI`
`\|`	`GL_VERTEX_STREAM4_ATI`
`\|`	`GL_VERTEX_STREAM5_ATI`
`\|`	`GL_VERTEX_STREAM6_ATI`
`\|`	`GL_VERTEX_STREAM7_ATI`
`\|`	`GL_TEXTURE_POINT_MODE_ATIX`
`\|`	`GL_TEXTURE_POINT_ONE_COORD_ATIX`
`\|`	`GL_TEXTURE_POINT_SPRITE_ATIX`
`\|`	`GL_POINT_SPRITE_CULL_MODE_ATIX`
`\|`	`GL_POINT_SPRITE_CULL_CENTER_ATIX`
`\|`	`GL_POINT_SPRITE_CULL_CLIP_ATIX`
`\|`	`GL_MODULATE_ADD_ATIX`
`\|`	`GL_MODULATE_SIGNED_ADD_ATIX`
`\|`	`GL_MODULATE_SUBTRACT_ATIX`
`\|`	`GL_SECONDARY_COLOR_ATIX`
`\|`	`GL_TEXTURE_OUTPUT_RGB_ATIX`
`\|`	`GL_TEXTURE_OUTPUT_ALPHA_ATIX`
`\|`	`GL_OUTPUT_POINT_SIZE_ATIX`
`\|`	`GL_CG_VERTEX_SHADER_EXT`
`\|`	`GL_CG_FRAGMENT_SHADER_EXT`
`\|`	`GL_DEPTH_BOUNDS_TEST_EXT`
`\|`	`GL_DEPTH_BOUNDS_EXT`
`\|`	`GL_FOG_COORDINATE_SOURCE_EXT`
`\|`	`GL_FOG_COORDINATE_EXT`
`\|`	`GL_FRAGMENT_DEPTH_EXT`
`\|`	`GL_CURRENT_FOG_COORDINATE_EXT`
`\|`	`GL_FOG_COORDINATE_ARRAY_TYPE_EXT`
`\|`	`GL_FOG_COORDINATE_ARRAY_STRIDE_EXT`
`\|`	`GL_FOG_COORDINATE_ARRAY_POINTER_EXT`
`\|`	`GL_FOG_COORDINATE_ARRAY_EXT`
`\|`	`GL_PIXEL_PACK_BUFFER_EXT`
`\|`	`GL_PIXEL_UNPACK_BUFFER_EXT`
`\|`	`GL_PIXEL_PACK_BUFFER_BINDING_EXT`
`\|`	`GL_PIXEL_UNPACK_BUFFER_BINDING_EXT`
`\|`	`GL_COLOR_SUM_EXT`
`\|`	`GL_CURRENT_SECONDARY_COLOR_EXT`
`\|`	`GL_SECONDARY_COLOR_ARRAY_SIZE_EXT`
`\|`	`GL_SECONDARY_COLOR_ARRAY_TYPE_EXT`
`\|`	`GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT`
`\|`	`GL_SECONDARY_COLOR_ARRAY_POINTER_EXT`
`\|`	`GL_SECONDARY_COLOR_ARRAY_EXT`
`\|`	`GL_NORMAL_MAP_EXT`
`\|`	`GL_REFLECTION_MAP_EXT`
`\|`	`GL_TEXTURE_CUBE_MAP_EXT`
`\|`	`GL_TEXTURE_BINDING_CUBE_MAP_EXT`
`\|`	`GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT`
`\|`	`GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT`
`\|`	`GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT`
`\|`	`GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT`
`\|`	`GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT`
`\|`	`GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT`
`\|`	`GL_PROXY_TEXTURE_CUBE_MAP_EXT`
`\|`	`GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT`
`\|`	`GL_CLAMP_TO_EDGE_EXT`
`\|`	`GL_TEXTURE_RECTANGLE_EXT`
`\|`	`GL_TEXTURE_BINDING_RECTANGLE_EXT`
`\|`	`GL_PROXY_TEXTURE_RECTANGLE_EXT`
`\|`	`GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT`
`\|`	`GL_VERTEX_SHADER_EXT`
`\|`	`GL_VERTEX_SHADER_BINDING_EXT`
`\|`	`GL_OP_INDEX_EXT`
`\|`	`GL_OP_NEGATE_EXT`
`\|`	`GL_OP_DOT3_EXT`
`\|`	`GL_OP_DOT4_EXT`
`\|`	`GL_OP_MUL_EXT`
`\|`	`GL_OP_ADD_EXT`
`\|`	`GL_OP_MADD_EXT`
`\|`	`GL_OP_FRAC_EXT`
`\|`	`GL_OP_MAX_EXT`
`\|`	`GL_OP_MIN_EXT`
`\|`	`GL_OP_SET_GE_EXT`
`\|`	`GL_OP_SET_LT_EXT`
`\|`	`GL_OP_CLAMP_EXT`
`\|`	`GL_OP_FLOOR_EXT`
`\|`	`GL_OP_ROUND_EXT`
`\|`	`GL_OP_EXP_BASE_2_EXT`
`\|`	`GL_OP_LOG_BASE_2_EXT`
`\|`	`GL_OP_POWER_EXT`
`\|`	`GL_OP_RECIP_EXT`
`\|`	`GL_OP_RECIP_SQRT_EXT`
`\|`	`GL_OP_SUB_EXT`
`\|`	`GL_OP_CROSS_PRODUCT_EXT`
`\|`	`GL_OP_MULTIPLY_MATRIX_EXT`
`\|`	`GL_OP_MOV_EXT`
`\|`	`GL_OUTPUT_VERTEX_EXT`
`\|`	`GL_OUTPUT_COLOR0_EXT`
`\|`	`GL_OUTPUT_COLOR1_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD0_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD1_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD2_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD3_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD4_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD5_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD6_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD7_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD8_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD9_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD10_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD11_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD12_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD13_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD14_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD15_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD16_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD17_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD18_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD19_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD20_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD21_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD22_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD23_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD24_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD25_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD26_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD27_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD28_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD29_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD30_EXT`
`\|`	`GL_OUTPUT_TEXTURE_COORD31_EXT`
`\|`	`GL_OUTPUT_FOG_EXT`
`\|`	`GL_SCALAR_EXT`
`\|`	`GL_VECTOR_EXT`
`\|`	`GL_MATRIX_EXT`
`\|`	`GL_VARIANT_EXT`
`\|`	`GL_INVARIANT_EXT`
`\|`	`GL_LOCAL_CONSTANT_EXT`
`\|`	`GL_LOCAL_EXT`
`\|`	`GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT`
`\|`	`GL_MAX_VERTEX_SHADER_VARIANTS_EXT`
`\|`	`GL_MAX_VERTEX_SHADER_INVARIANTS_EXT`
`\|`	`GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT`
`\|`	`GL_MAX_VERTEX_SHADER_LOCALS_EXT`
`\|`	`GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT`
`\|`	`GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT`
`\|`	`GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT`
`\|`	`GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT`
`\|`	`GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT`
`\|`	`GL_VERTEX_SHADER_INSTRUCTIONS_EXT`
`\|`	`GL_VERTEX_SHADER_VARIANTS_EXT`
`\|`	`GL_VERTEX_SHADER_INVARIANTS_EXT`
`\|`	`GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT`
`\|`	`GL_VERTEX_SHADER_LOCALS_EXT`
`\|`	`GL_VERTEX_SHADER_OPTIMIZED_EXT`
`\|`	`GL_X_EXT`
`\|`	`GL_Y_EXT`
`\|`	`GL_Z_EXT`
`\|`	`GL_W_EXT`
`\|`	`GL_NEGATIVE_X_EXT`
`\|`	`GL_NEGATIVE_Y_EXT`
`\|`	`GL_NEGATIVE_Z_EXT`
`\|`	`GL_NEGATIVE_W_EXT`
`\|`	`GL_ZERO_EXT`
`\|`	`GL_ONE_EXT`
`\|`	`GL_NEGATIVE_ONE_EXT`
`\|`	`GL_NORMALIZED_RANGE_EXT`
`\|`	`GL_FULL_RANGE_EXT`
`\|`	`GL_CURRENT_VERTEX_EXT`
`\|`	`GL_MVP_MATRIX_EXT`
`\|`	`GL_VARIANT_VALUE_EXT`
`\|`	`GL_VARIANT_DATATYPE_EXT`
`\|`	`GL_VARIANT_ARRAY_STRIDE_EXT`
`\|`	`GL_VARIANT_ARRAY_TYPE_EXT`
`\|`	`GL_VARIANT_ARRAY_EXT`
`\|`	`GL_VARIANT_ARRAY_POINTER_EXT`
`\|`	`GL_INVARIANT_VALUE_EXT`
`\|`	`GL_INVARIANT_DATATYPE_EXT`
`\|`	`GL_LOCAL_CONSTANT_VALUE_EXT`
`\|`	`GL_LOCAL_CONSTANT_DATATYPE_EXT`
`\|`	`GL_KTX_FRONT_REGION`
`\|`	`GL_KTX_BACK_REGION`
`\|`	`GL_KTX_Z_REGION`
`\|`	`GL_KTX_STENCIL_REGION`
`\|`	`GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV`
`\|`	`GL_MAX_PROGRAM_CALL_DEPTH_NV`
`\|`	`GL_MAX_PROGRAM_IF_DEPTH_NV`
`\|`	`GL_MAX_PROGRAM_LOOP_DEPTH_NV`
`\|`	`GL_MAX_PROGRAM_LOOP_COUNT_NV`
`\|`	`GL_ACCUM`
`\|`	`GL_LOAD`
`\|`	`GL_RETURN`
`\|`	`GL_MULT`
`\|`	`GL_ADD`
`\|`	`GL_NEVER`
`\|`	`GL_LESS`
`\|`	`GL_EQUAL`
`\|`	`GL_LEQUAL`
`\|`	`GL_GREATER`
`\|`	`GL_NOTEQUAL`
`\|`	`GL_GEQUAL`
`\|`	`GL_ALWAYS`
`\|`	`GL_CURRENT_BIT`
`\|`	`GL_POINT_BIT`
`\|`	`GL_LINE_BIT`
`\|`	`GL_POLYGON_BIT`
`\|`	`GL_POLYGON_STIPPLE_BIT`
`\|`	`GL_PIXEL_MODE_BIT`
`\|`	`GL_LIGHTING_BIT`
`\|`	`GL_FOG_BIT`
`\|`	`GL_DEPTH_BUFFER_BIT`
`\|`	`GL_ACCUM_BUFFER_BIT`
`\|`	`GL_STENCIL_BUFFER_BIT`
`\|`	`GL_VIEWPORT_BIT`
`\|`	`GL_TRANSFORM_BIT`
`\|`	`GL_ENABLE_BIT`
`\|`	`GL_COLOR_BUFFER_BIT`
`\|`	`GL_HINT_BIT`
`\|`	`GL_EVAL_BIT`
`\|`	`GL_LIST_BIT`
`\|`	`GL_TEXTURE_BIT`
`\|`	`GL_SCISSOR_BIT`
`\|`	`GL_ALL_ATTRIB_BITS`
`\|`	`GL_POINTS`
`\|`	`GL_LINES`
`\|`	`GL_LINE_LOOP`
`\|`	`GL_LINE_STRIP`
`\|`	`GL_TRIANGLES`
`\|`	`GL_TRIANGLE_STRIP`
`\|`	`GL_TRIANGLE_FAN`
`\|`	`GL_QUADS`
`\|`	`GL_QUAD_STRIP`
`\|`	`GL_POLYGON`
`\|`	`GL_ZERO`
`\|`	`GL_ONE`
`\|`	`GL_SRC_COLOR`
`\|`	`GL_ONE_MINUS_SRC_COLOR`
`\|`	`GL_SRC_ALPHA`
`\|`	`GL_ONE_MINUS_SRC_ALPHA`
`\|`	`GL_DST_ALPHA`
`\|`	`GL_ONE_MINUS_DST_ALPHA`
`\|`	`GL_DST_COLOR`
`\|`	`GL_ONE_MINUS_DST_COLOR`
`\|`	`GL_SRC_ALPHA_SATURATE`
`\|`	`GL_TRUE`
`\|`	`GL_FALSE`
`\|`	`GL_CLIP_PLANE0`
`\|`	`GL_CLIP_PLANE1`
`\|`	`GL_CLIP_PLANE2`
`\|`	`GL_CLIP_PLANE3`
`\|`	`GL_CLIP_PLANE4`
`\|`	`GL_CLIP_PLANE5`
`\|`	`GL_BYTE`
`\|`	`GL_UNSIGNED_BYTE`
`\|`	`GL_SHORT`
`\|`	`GL_UNSIGNED_SHORT`
`\|`	`GL_INT`
`\|`	`GL_UNSIGNED_INT`
`\|`	`GL_FLOAT`
`\|`	`GL_2_BYTES`
`\|`	`GL_3_BYTES`
`\|`	`GL_4_BYTES`
`\|`	`GL_DOUBLE`
`\|`	`GL_NONE`
`\|`	`GL_FRONT_LEFT`
`\|`	`GL_FRONT_RIGHT`
`\|`	`GL_BACK_LEFT`
`\|`	`GL_BACK_RIGHT`
`\|`	`GL_FRONT`
`\|`	`GL_BACK`
`\|`	`GL_LEFT`
`\|`	`GL_RIGHT`
`\|`	`GL_FRONT_AND_BACK`
`\|`	`GL_AUX0`
`\|`	`GL_AUX1`
`\|`	`GL_AUX2`
`\|`	`GL_AUX3`
`\|`	`GL_NO_ERROR`
`\|`	`GL_INVALID_ENUM`
`\|`	`GL_INVALID_VALUE`
`\|`	`GL_INVALID_OPERATION`
`\|`	`GL_STACK_OVERFLOW`
`\|`	`GL_STACK_UNDERFLOW`
`\|`	`GL_OUT_OF_MEMORY`
`\|`	`GL_2D`
`\|`	`GL_3D`
`\|`	`GL_3D_COLOR`
`\|`	`GL_3D_COLOR_TEXTURE`
`\|`	`GL_4D_COLOR_TEXTURE`
`\|`	`GL_PASS_THROUGH_TOKEN`
`\|`	`GL_POINT_TOKEN`
`\|`	`GL_LINE_TOKEN`
`\|`	`GL_POLYGON_TOKEN`
`\|`	`GL_BITMAP_TOKEN`
`\|`	`GL_DRAW_PIXEL_TOKEN`
`\|`	`GL_COPY_PIXEL_TOKEN`
`\|`	`GL_LINE_RESET_TOKEN`
`\|`	`GL_EXP`
`\|`	`GL_EXP2`
`\|`	`GL_CW`
`\|`	`GL_CCW`
`\|`	`GL_COEFF`
`\|`	`GL_ORDER`
`\|`	`GL_DOMAIN`
`\|`	`GL_CURRENT_COLOR`
`\|`	`GL_CURRENT_INDEX`
`\|`	`GL_CURRENT_NORMAL`
`\|`	`GL_CURRENT_TEXTURE_COORDS`
`\|`	`GL_CURRENT_RASTER_COLOR`
`\|`	`GL_CURRENT_RASTER_INDEX`
`\|`	`GL_CURRENT_RASTER_TEXTURE_COORDS`
`\|`	`GL_CURRENT_RASTER_POSITION`
`\|`	`GL_CURRENT_RASTER_POSITION_VALID`
`\|`	`GL_CURRENT_RASTER_DISTANCE`
`\|`	`GL_POINT_SMOOTH`
`\|`	`GL_POINT_SIZE`
`\|`	`GL_POINT_SIZE_RANGE`
`\|`	`GL_POINT_SIZE_GRANULARITY`
`\|`	`GL_LINE_SMOOTH`
`\|`	`GL_LINE_WIDTH`
`\|`	`GL_LINE_WIDTH_RANGE`
`\|`	`GL_LINE_WIDTH_GRANULARITY`
`\|`	`GL_LINE_STIPPLE`
`\|`	`GL_LINE_STIPPLE_PATTERN`
`\|`	`GL_LINE_STIPPLE_REPEAT`
`\|`	`GL_LIST_MODE`
`\|`	`GL_MAX_LIST_NESTING`
`\|`	`GL_LIST_BASE`
`\|`	`GL_LIST_INDEX`
`\|`	`GL_POLYGON_MODE`
`\|`	`GL_POLYGON_SMOOTH`
`\|`	`GL_POLYGON_STIPPLE`
`\|`	`GL_EDGE_FLAG`
`\|`	`GL_CULL_FACE`
`\|`	`GL_CULL_FACE_MODE`
`\|`	`GL_FRONT_FACE`
`\|`	`GL_LIGHTING`
`\|`	`GL_LIGHT_MODEL_LOCAL_VIEWER`
`\|`	`GL_LIGHT_MODEL_TWO_SIDE`
`\|`	`GL_LIGHT_MODEL_AMBIENT`
`\|`	`GL_SHADE_MODEL`
`\|`	`GL_COLOR_MATERIAL_FACE`
`\|`	`GL_COLOR_MATERIAL_PARAMETER`
`\|`	`GL_COLOR_MATERIAL`
`\|`	`GL_FOG`
`\|`	`GL_FOG_INDEX`
`\|`	`GL_FOG_DENSITY`
`\|`	`GL_FOG_START`
`\|`	`GL_FOG_END`
`\|`	`GL_FOG_MODE`
`\|`	`GL_FOG_COLOR`
`\|`	`GL_DEPTH_RANGE`
`\|`	`GL_DEPTH_TEST`
`\|`	`GL_DEPTH_WRITEMASK`
`\|`	`GL_DEPTH_CLEAR_VALUE`
`\|`	`GL_DEPTH_FUNC`
`\|`	`GL_ACCUM_CLEAR_VALUE`
`\|`	`GL_STENCIL_TEST`
`\|`	`GL_STENCIL_CLEAR_VALUE`
`\|`	`GL_STENCIL_FUNC`
`\|`	`GL_STENCIL_VALUE_MASK`
`\|`	`GL_STENCIL_FAIL`
`\|`	`GL_STENCIL_PASS_DEPTH_FAIL`
`\|`	`GL_STENCIL_PASS_DEPTH_PASS`
`\|`	`GL_STENCIL_REF`
`\|`	`GL_STENCIL_WRITEMASK`
`\|`	`GL_MATRIX_MODE`
`\|`	`GL_NORMALIZE`
`\|`	`GL_VIEWPORT`
`\|`	`GL_MODELVIEW_STACK_DEPTH`
`\|`	`GL_PROJECTION_STACK_DEPTH`
`\|`	`GL_TEXTURE_STACK_DEPTH`
`\|`	`GL_MODELVIEW_MATRIX`
`\|`	`GL_PROJECTION_MATRIX`
`\|`	`GL_TEXTURE_MATRIX`
`\|`	`GL_ATTRIB_STACK_DEPTH`
`\|`	`GL_CLIENT_ATTRIB_STACK_DEPTH`
`\|`	`GL_ALPHA_TEST`
`\|`	`GL_ALPHA_TEST_FUNC`
`\|`	`GL_ALPHA_TEST_REF`
`\|`	`GL_DITHER`
`\|`	`GL_BLEND_DST`
`\|`	`GL_BLEND_SRC`
`\|`	`GL_BLEND`
`\|`	`GL_LOGIC_OP_MODE`
`\|`	`GL_INDEX_LOGIC_OP`
`\|`	`GL_COLOR_LOGIC_OP`
`\|`	`GL_AUX_BUFFERS`
`\|`	`GL_DRAW_BUFFER`
`\|`	`GL_READ_BUFFER`
`\|`	`GL_SCISSOR_BOX`
`\|`	`GL_SCISSOR_TEST`
`\|`	`GL_INDEX_CLEAR_VALUE`
`\|`	`GL_INDEX_WRITEMASK`
`\|`	`GL_COLOR_CLEAR_VALUE`
`\|`	`GL_COLOR_WRITEMASK`
`\|`	`GL_INDEX_MODE`
`\|`	`GL_RGBA_MODE`
`\|`	`GL_DOUBLEBUFFER`
`\|`	`GL_STEREO`
`\|`	`GL_RENDER_MODE`
`\|`	`GL_PERSPECTIVE_CORRECTION_HINT`
`\|`	`GL_POINT_SMOOTH_HINT`
`\|`	`GL_LINE_SMOOTH_HINT`
`\|`	`GL_POLYGON_SMOOTH_HINT`
`\|`	`GL_FOG_HINT`
`\|`	`GL_TEXTURE_GEN_S`
`\|`	`GL_TEXTURE_GEN_T`
`\|`	`GL_TEXTURE_GEN_R`
`\|`	`GL_TEXTURE_GEN_Q`
`\|`	`GL_PIXEL_MAP_I_TO_I`
`\|`	`GL_PIXEL_MAP_S_TO_S`
`\|`	`GL_PIXEL_MAP_I_TO_R`
`\|`	`GL_PIXEL_MAP_I_TO_G`
`\|`	`GL_PIXEL_MAP_I_TO_B`
`\|`	`GL_PIXEL_MAP_I_TO_A`
`\|`	`GL_PIXEL_MAP_R_TO_R`
`\|`	`GL_PIXEL_MAP_G_TO_G`
`\|`	`GL_PIXEL_MAP_B_TO_B`
`\|`	`GL_PIXEL_MAP_A_TO_A`
`\|`	`GL_PIXEL_MAP_I_TO_I_SIZE`
`\|`	`GL_PIXEL_MAP_S_TO_S_SIZE`
`\|`	`GL_PIXEL_MAP_I_TO_R_SIZE`
`\|`	`GL_PIXEL_MAP_I_TO_G_SIZE`
`\|`	`GL_PIXEL_MAP_I_TO_B_SIZE`
`\|`	`GL_PIXEL_MAP_I_TO_A_SIZE`
`\|`	`GL_PIXEL_MAP_R_TO_R_SIZE`
`\|`	`GL_PIXEL_MAP_G_TO_G_SIZE`
`\|`	`GL_PIXEL_MAP_B_TO_B_SIZE`
`\|`	`GL_PIXEL_MAP_A_TO_A_SIZE`
`\|`	`GL_UNPACK_SWAP_BYTES`
`\|`	`GL_UNPACK_LSB_FIRST`
`\|`	`GL_UNPACK_ROW_LENGTH`
`\|`	`GL_UNPACK_SKIP_ROWS`
`\|`	`GL_UNPACK_SKIP_PIXELS`
`\|`	`GL_UNPACK_ALIGNMENT`
`\|`	`GL_PACK_SWAP_BYTES`
`\|`	`GL_PACK_LSB_FIRST`
`\|`	`GL_PACK_ROW_LENGTH`
`\|`	`GL_PACK_SKIP_ROWS`
`\|`	`GL_PACK_SKIP_PIXELS`
`\|`	`GL_PACK_ALIGNMENT`
`\|`	`GL_MAP_COLOR`
`\|`	`GL_MAP_STENCIL`
`\|`	`GL_INDEX_SHIFT`
`\|`	`GL_INDEX_OFFSET`
`\|`	`GL_RED_SCALE`
`\|`	`GL_RED_BIAS`
`\|`	`GL_ZOOM_X`
`\|`	`GL_ZOOM_Y`
`\|`	`GL_GREEN_SCALE`
`\|`	`GL_GREEN_BIAS`
`\|`	`GL_BLUE_SCALE`
`\|`	`GL_BLUE_BIAS`
`\|`	`GL_ALPHA_SCALE`
`\|`	`GL_ALPHA_BIAS`
`\|`	`GL_DEPTH_SCALE`
`\|`	`GL_DEPTH_BIAS`
`\|`	`GL_MAX_EVAL_ORDER`
`\|`	`GL_MAX_LIGHTS`
`\|`	`GL_MAX_CLIP_PLANES`
`\|`	`GL_MAX_TEXTURE_SIZE`
`\|`	`GL_MAX_PIXEL_MAP_TABLE`
`\|`	`GL_MAX_ATTRIB_STACK_DEPTH`
`\|`	`GL_MAX_MODELVIEW_STACK_DEPTH`
`\|`	`GL_MAX_NAME_STACK_DEPTH`
`\|`	`GL_MAX_PROJECTION_STACK_DEPTH`
`\|`	`GL_MAX_TEXTURE_STACK_DEPTH`
`\|`	`GL_MAX_VIEWPORT_DIMS`
`\|`	`GL_MAX_CLIENT_ATTRIB_STACK_DEPTH`
`\|`	`GL_SUBPIXEL_BITS`
`\|`	`GL_INDEX_BITS`
`\|`	`GL_RED_BITS`
`\|`	`GL_GREEN_BITS`
`\|`	`GL_BLUE_BITS`
`\|`	`GL_ALPHA_BITS`
`\|`	`GL_DEPTH_BITS`
`\|`	`GL_STENCIL_BITS`
`\|`	`GL_ACCUM_RED_BITS`
`\|`	`GL_ACCUM_GREEN_BITS`
`\|`	`GL_ACCUM_BLUE_BITS`
`\|`	`GL_ACCUM_ALPHA_BITS`
`\|`	`GL_NAME_STACK_DEPTH`
`\|`	`GL_AUTO_NORMAL`
`\|`	`GL_MAP1_COLOR_4`
`\|`	`GL_MAP1_INDEX`
`\|`	`GL_MAP1_NORMAL`
`\|`	`GL_MAP1_TEXTURE_COORD_1`
`\|`	`GL_MAP1_TEXTURE_COORD_2`
`\|`	`GL_MAP1_TEXTURE_COORD_3`
`\|`	`GL_MAP1_TEXTURE_COORD_4`
`\|`	`GL_MAP1_VERTEX_3`
`\|`	`GL_MAP1_VERTEX_4`
`\|`	`GL_MAP2_COLOR_4`
`\|`	`GL_MAP2_INDEX`
`\|`	`GL_MAP2_NORMAL`
`\|`	`GL_MAP2_TEXTURE_COORD_1`
`\|`	`GL_MAP2_TEXTURE_COORD_2`
`\|`	`GL_MAP2_TEXTURE_COORD_3`
`\|`	`GL_MAP2_TEXTURE_COORD_4`
`\|`	`GL_MAP2_VERTEX_3`
`\|`	`GL_MAP2_VERTEX_4`
`\|`	`GL_MAP1_GRID_DOMAIN`
`\|`	`GL_MAP1_GRID_SEGMENTS`
`\|`	`GL_MAP2_GRID_DOMAIN`
`\|`	`GL_MAP2_GRID_SEGMENTS`
`\|`	`GL_TEXTURE_1D`
`\|`	`GL_TEXTURE_2D`
`\|`	`GL_FEEDBACK_BUFFER_POINTER`
`\|`	`GL_FEEDBACK_BUFFER_SIZE`
`\|`	`GL_FEEDBACK_BUFFER_TYPE`
`\|`	`GL_SELECTION_BUFFER_POINTER`
`\|`	`GL_SELECTION_BUFFER_SIZE`
`\|`	`GL_TEXTURE_WIDTH`
`\|`	`GL_TEXTURE_HEIGHT`
`\|`	`GL_TEXTURE_INTERNAL_FORMAT`
`\|`	`GL_TEXTURE_BORDER_COLOR`
`\|`	`GL_TEXTURE_BORDER`
`\|`	`GL_DONT_CARE`
`\|`	`GL_FASTEST`
`\|`	`GL_NICEST`
`\|`	`GL_LIGHT0`
`\|`	`GL_LIGHT1`
`\|`	`GL_LIGHT2`
`\|`	`GL_LIGHT3`
`\|`	`GL_LIGHT4`
`\|`	`GL_LIGHT5`
`\|`	`GL_LIGHT6`
`\|`	`GL_LIGHT7`
`\|`	`GL_AMBIENT`
`\|`	`GL_DIFFUSE`
`\|`	`GL_SPECULAR`
`\|`	`GL_POSITION`
`\|`	`GL_SPOT_DIRECTION`
`\|`	`GL_SPOT_EXPONENT`
`\|`	`GL_SPOT_CUTOFF`
`\|`	`GL_CONSTANT_ATTENUATION`
`\|`	`GL_LINEAR_ATTENUATION`
`\|`	`GL_QUADRATIC_ATTENUATION`
`\|`	`GL_COMPILE`
`\|`	`GL_COMPILE_AND_EXECUTE`
`\|`	`GL_CLEAR`
`\|`	`GL_AND`
`\|`	`GL_AND_REVERSE`
`\|`	`GL_COPY`
`\|`	`GL_AND_INVERTED`
`\|`	`GL_NOOP`
`\|`	`GL_XOR`
`\|`	`GL_OR`
`\|`	`GL_NOR`
`\|`	`GL_EQUIV`
`\|`	`GL_INVERT`
`\|`	`GL_OR_REVERSE`
`\|`	`GL_COPY_INVERTED`
`\|`	`GL_OR_INVERTED`
`\|`	`GL_NAND`
`\|`	`GL_SET`
`\|`	`GL_EMISSION`
`\|`	`GL_SHININESS`
`\|`	`GL_AMBIENT_AND_DIFFUSE`
`\|`	`GL_COLOR_INDEXES`
`\|`	`GL_MODELVIEW`
`\|`	`GL_PROJECTION`
`\|`	`GL_TEXTURE`
`\|`	`GL_COLOR`
`\|`	`GL_DEPTH`
`\|`	`GL_STENCIL`
`\|`	`GL_COLOR_INDEX`
`\|`	`GL_STENCIL_INDEX`
`\|`	`GL_DEPTH_COMPONENT`
`\|`	`GL_RED`
`\|`	`GL_GREEN`
`\|`	`GL_BLUE`
`\|`	`GL_ALPHA`
`\|`	`GL_RGB`
`\|`	`GL_RGBA`
`\|`	`GL_LUMINANCE`
`\|`	`GL_LUMINANCE_ALPHA`
`\|`	`GL_BITMAP`
`\|`	`GL_POINT`
`\|`	`GL_LINE`
`\|`	`GL_FILL`
`\|`	`GL_RENDER`
`\|`	`GL_FEEDBACK`
`\|`	`GL_SELECT`
`\|`	`GL_FLAT`
`\|`	`GL_SMOOTH`
`\|`	`GL_KEEP`
`\|`	`GL_REPLACE`
`\|`	`GL_INCR`
`\|`	`GL_DECR`
`\|`	`GL_VENDOR`
`\|`	`GL_RENDERER`
`\|`	`GL_VERSION`
`\|`	`GL_EXTENSIONS`
`\|`	`GL_S`
`\|`	`GL_T`
`\|`	`GL_R`
`\|`	`GL_Q`
`\|`	`GL_MODULATE`
`\|`	`GL_DECAL`
`\|`	`GL_TEXTURE_ENV_MODE`
`\|`	`GL_TEXTURE_ENV_COLOR`
`\|`	`GL_TEXTURE_ENV`
`\|`	`GL_EYE_LINEAR`
`\|`	`GL_OBJECT_LINEAR`
`\|`	`GL_SPHERE_MAP`
`\|`	`GL_TEXTURE_GEN_MODE`
`\|`	`GL_OBJECT_PLANE`
`\|`	`GL_EYE_PLANE`
`\|`	`GL_NEAREST`
`\|`	`GL_LINEAR`
`\|`	`GL_NEAREST_MIPMAP_NEAREST`
`\|`	`GL_LINEAR_MIPMAP_NEAREST`
`\|`	`GL_NEAREST_MIPMAP_LINEAR`
`\|`	`GL_LINEAR_MIPMAP_LINEAR`
`\|`	`GL_TEXTURE_MAG_FILTER`
`\|`	`GL_TEXTURE_MIN_FILTER`
`\|`	`GL_TEXTURE_WRAP_S`
`\|`	`GL_TEXTURE_WRAP_T`
`\|`	`GL_CLAMP`
`\|`	`GL_REPEAT`
`\|`	`GL_CLIENT_PIXEL_STORE_BIT`
`\|`	`GL_CLIENT_VERTEX_ARRAY_BIT`
`\|`	`GL_CLIENT_ALL_ATTRIB_BITS`
`\|`	`GL_POLYGON_OFFSET_FACTOR`
`\|`	`GL_POLYGON_OFFSET_UNITS`
`\|`	`GL_POLYGON_OFFSET_POINT`
`\|`	`GL_POLYGON_OFFSET_LINE`
`\|`	`GL_POLYGON_OFFSET_FILL`
`\|`	`GL_ALPHA4`
`\|`	`GL_ALPHA8`
`\|`	`GL_ALPHA12`
`\|`	`GL_ALPHA16`
`\|`	`GL_LUMINANCE4`
`\|`	`GL_LUMINANCE8`
`\|`	`GL_LUMINANCE12`
`\|`	`GL_LUMINANCE16`
`\|`	`GL_LUMINANCE4_ALPHA4`
`\|`	`GL_LUMINANCE6_ALPHA2`
`\|`	`GL_LUMINANCE8_ALPHA8`
`\|`	`GL_LUMINANCE12_ALPHA4`
`\|`	`GL_LUMINANCE12_ALPHA12`
`\|`	`GL_LUMINANCE16_ALPHA16`
`\|`	`GL_INTENSITY`
`\|`	`GL_INTENSITY4`
`\|`	`GL_INTENSITY8`
`\|`	`GL_INTENSITY12`
`\|`	`GL_INTENSITY16`
`\|`	`GL_R3_G3_B2`
`\|`	`GL_RGB4`
`\|`	`GL_RGB5`
`\|`	`GL_RGB8`
`\|`	`GL_RGB10`
`\|`	`GL_RGB12`
`\|`	`GL_RGB16`
`\|`	`GL_RGBA2`
`\|`	`GL_RGBA4`
`\|`	`GL_RGB5_A1`
`\|`	`GL_RGBA8`
`\|`	`GL_RGB10_A2`
`\|`	`GL_RGBA12`
`\|`	`GL_RGBA16`
`\|`	`GL_TEXTURE_RED_SIZE`
`\|`	`GL_TEXTURE_GREEN_SIZE`
`\|`	`GL_TEXTURE_BLUE_SIZE`
`\|`	`GL_TEXTURE_ALPHA_SIZE`
`\|`	`GL_TEXTURE_LUMINANCE_SIZE`
`\|`	`GL_TEXTURE_INTENSITY_SIZE`
`\|`	`GL_PROXY_TEXTURE_1D`
`\|`	`GL_PROXY_TEXTURE_2D`
`\|`	`GL_TEXTURE_PRIORITY`
`\|`	`GL_TEXTURE_RESIDENT`
`\|`	`GL_TEXTURE_BINDING_1D`
`\|`	`GL_TEXTURE_BINDING_2D`
`\|`	`GL_VERTEX_ARRAY`
`\|`	`GL_NORMAL_ARRAY`
`\|`	`GL_COLOR_ARRAY`
`\|`	`GL_INDEX_ARRAY`
`\|`	`GL_TEXTURE_COORD_ARRAY`
`\|`	`GL_EDGE_FLAG_ARRAY`
`\|`	`GL_VERTEX_ARRAY_SIZE`
`\|`	`GL_VERTEX_ARRAY_TYPE`
`\|`	`GL_VERTEX_ARRAY_STRIDE`
`\|`	`GL_NORMAL_ARRAY_TYPE`
`\|`	`GL_NORMAL_ARRAY_STRIDE`
`\|`	`GL_COLOR_ARRAY_SIZE`
`\|`	`GL_COLOR_ARRAY_TYPE`
`\|`	`GL_COLOR_ARRAY_STRIDE`
`\|`	`GL_INDEX_ARRAY_TYPE`
`\|`	`GL_INDEX_ARRAY_STRIDE`
`\|`	`GL_TEXTURE_COORD_ARRAY_SIZE`
`\|`	`GL_TEXTURE_COORD_ARRAY_TYPE`
`\|`	`GL_TEXTURE_COORD_ARRAY_STRIDE`
`\|`	`GL_EDGE_FLAG_ARRAY_STRIDE`
`\|`	`GL_VERTEX_ARRAY_POINTER`
`\|`	`GL_NORMAL_ARRAY_POINTER`
`\|`	`GL_COLOR_ARRAY_POINTER`
`\|`	`GL_INDEX_ARRAY_POINTER`
`\|`	`GL_TEXTURE_COORD_ARRAY_POINTER`
`\|`	`GL_EDGE_FLAG_ARRAY_POINTER`
`\|`	`GL_V2F`
`\|`	`GL_V3F`
`\|`	`GL_C4UB_V2F`
`\|`	`GL_C4UB_V3F`
`\|`	`GL_C3F_V3F`
`\|`	`GL_N3F_V3F`
`\|`	`GL_C4F_N3F_V3F`
`\|`	`GL_T2F_V3F`
`\|`	`GL_T4F_V4F`
`\|`	`GL_T2F_C4UB_V3F`
`\|`	`GL_T2F_C3F_V3F`
`\|`	`GL_T2F_N3F_V3F`
`\|`	`GL_T2F_C4F_N3F_V3F`
`\|`	`GL_T4F_C4F_N3F_V4F`
`\|`	`GL_LOGIC_OP`
`\|`	`GL_TEXTURE_COMPONENTS`
`\|`	`GL_COLOR_INDEX1_EXT`
`\|`	`GL_COLOR_INDEX2_EXT`
`\|`	`GL_COLOR_INDEX4_EXT`
`\|`	`GL_COLOR_INDEX8_EXT`
`\|`	`GL_COLOR_INDEX12_EXT`
`\|`	`GL_COLOR_INDEX16_EXT`
`\|`	`GL_UNSIGNED_BYTE_3_3_2`
`\|`	`GL_UNSIGNED_SHORT_4_4_4_4`
`\|`	`GL_UNSIGNED_SHORT_5_5_5_1`
`\|`	`GL_UNSIGNED_INT_8_8_8_8`
`\|`	`GL_UNSIGNED_INT_10_10_10_2`
`\|`	`GL_RESCALE_NORMAL`
`\|`	`GL_UNSIGNED_BYTE_2_3_3_REV`
`\|`	`GL_UNSIGNED_SHORT_5_6_5`
`\|`	`GL_UNSIGNED_SHORT_5_6_5_REV`
`\|`	`GL_UNSIGNED_SHORT_4_4_4_4_REV`
`\|`	`GL_UNSIGNED_SHORT_1_5_5_5_REV`
`\|`	`GL_UNSIGNED_INT_8_8_8_8_REV`
`\|`	`GL_UNSIGNED_INT_2_10_10_10_REV`
`\|`	`GL_BGR`
`\|`	`GL_BGRA`
`\|`	`GL_MAX_ELEMENTS_VERTICES`
`\|`	`GL_MAX_ELEMENTS_INDICES`
`\|`	`GL_CLAMP_TO_EDGE`
`\|`	`GL_TEXTURE_MIN_LOD`
`\|`	`GL_TEXTURE_MAX_LOD`
`\|`	`GL_TEXTURE_BASE_LEVEL`
`\|`	`GL_TEXTURE_MAX_LEVEL`
`\|`	`GL_LIGHT_MODEL_COLOR_CONTROL`
`\|`	`GL_SINGLE_COLOR`
`\|`	`GL_SEPARATE_SPECULAR_COLOR`
`\|`	`GL_SMOOTH_POINT_SIZE_RANGE`
`\|`	`GL_SMOOTH_POINT_SIZE_GRANULARITY`
`\|`	`GL_SMOOTH_LINE_WIDTH_RANGE`
`\|`	`GL_SMOOTH_LINE_WIDTH_GRANULARITY`
`\|`	`GL_ALIASED_POINT_SIZE_RANGE`
`\|`	`GL_ALIASED_LINE_WIDTH_RANGE`
`\|`	`GL_PACK_SKIP_IMAGES`
`\|`	`GL_PACK_IMAGE_HEIGHT`
`\|`	`GL_UNPACK_SKIP_IMAGES`
`\|`	`GL_UNPACK_IMAGE_HEIGHT`
`\|`	`GL_TEXTURE_3D`
`\|`	`GL_PROXY_TEXTURE_3D`
`\|`	`GL_TEXTURE_DEPTH`
`\|`	`GL_TEXTURE_WRAP_R`
`\|`	`GL_MAX_3D_TEXTURE_SIZE`
`\|`	`GL_TEXTURE_BINDING_3D`
`\|`	`GL_TEXTURE0`
`\|`	`GL_TEXTURE1`
`\|`	`GL_TEXTURE2`
`\|`	`GL_TEXTURE3`
`\|`	`GL_TEXTURE4`
`\|`	`GL_TEXTURE5`
`\|`	`GL_TEXTURE6`
`\|`	`GL_TEXTURE7`
`\|`	`GL_TEXTURE8`
`\|`	`GL_TEXTURE9`
`\|`	`GL_TEXTURE10`
`\|`	`GL_TEXTURE11`
`\|`	`GL_TEXTURE12`
`\|`	`GL_TEXTURE13`
`\|`	`GL_TEXTURE14`
`\|`	`GL_TEXTURE15`
`\|`	`GL_TEXTURE16`
`\|`	`GL_TEXTURE17`
`\|`	`GL_TEXTURE18`
`\|`	`GL_TEXTURE19`
`\|`	`GL_TEXTURE20`
`\|`	`GL_TEXTURE21`
`\|`	`GL_TEXTURE22`
`\|`	`GL_TEXTURE23`
`\|`	`GL_TEXTURE24`
`\|`	`GL_TEXTURE25`
`\|`	`GL_TEXTURE26`
`\|`	`GL_TEXTURE27`
`\|`	`GL_TEXTURE28`
`\|`	`GL_TEXTURE29`
`\|`	`GL_TEXTURE30`
`\|`	`GL_TEXTURE31`
`\|`	`GL_ACTIVE_TEXTURE`
`\|`	`GL_CLIENT_ACTIVE_TEXTURE`
`\|`	`GL_MAX_TEXTURE_UNITS`
`\|`	`GL_NORMAL_MAP`
`\|`	`GL_REFLECTION_MAP`
`\|`	`GL_TEXTURE_CUBE_MAP`
`\|`	`GL_TEXTURE_BINDING_CUBE_MAP`
`\|`	`GL_TEXTURE_CUBE_MAP_POSITIVE_X`
`\|`	`GL_TEXTURE_CUBE_MAP_NEGATIVE_X`
`\|`	`GL_TEXTURE_CUBE_MAP_POSITIVE_Y`
`\|`	`GL_TEXTURE_CUBE_MAP_NEGATIVE_Y`
`\|`	`GL_TEXTURE_CUBE_MAP_POSITIVE_Z`
`\|`	`GL_TEXTURE_CUBE_MAP_NEGATIVE_Z`
`\|`	`GL_PROXY_TEXTURE_CUBE_MAP`
`\|`	`GL_MAX_CUBE_MAP_TEXTURE_SIZE`
`\|`	`GL_COMPRESSED_ALPHA`
`\|`	`GL_COMPRESSED_LUMINANCE`
`\|`	`GL_COMPRESSED_LUMINANCE_ALPHA`
`\|`	`GL_COMPRESSED_INTENSITY`
`\|`	`GL_COMPRESSED_RGB`
`\|`	`GL_COMPRESSED_RGBA`
`\|`	`GL_TEXTURE_COMPRESSION_HINT`
`\|`	`GL_TEXTURE_COMPRESSED_IMAGE_SIZE`
`\|`	`GL_TEXTURE_COMPRESSED`
`\|`	`GL_NUM_COMPRESSED_TEXTURE_FORMATS`
`\|`	`GL_COMPRESSED_TEXTURE_FORMATS`
`\|`	`GL_MULTISAMPLE`
`\|`	`GL_SAMPLE_ALPHA_TO_COVERAGE`
`\|`	`GL_SAMPLE_ALPHA_TO_ONE`
`\|`	`GL_SAMPLE_COVERAGE`
`\|`	`GL_SAMPLE_BUFFERS`
`\|`	`GL_SAMPLES`
`\|`	`GL_SAMPLE_COVERAGE_VALUE`
`\|`	`GL_SAMPLE_COVERAGE_INVERT`
`\|`	`GL_MULTISAMPLE_BIT`
`\|`	`GL_TRANSPOSE_MODELVIEW_MATRIX`
`\|`	`GL_TRANSPOSE_PROJECTION_MATRIX`
`\|`	`GL_TRANSPOSE_TEXTURE_MATRIX`
`\|`	`GL_TRANSPOSE_COLOR_MATRIX`
`\|`	`GL_COMBINE`
`\|`	`GL_COMBINE_RGB`
`\|`	`GL_COMBINE_ALPHA`
`\|`	`GL_SOURCE0_RGB`
`\|`	`GL_SOURCE1_RGB`
`\|`	`GL_SOURCE2_RGB`
`\|`	`GL_SOURCE0_ALPHA`
`\|`	`GL_SOURCE1_ALPHA`
`\|`	`GL_SOURCE2_ALPHA`
`\|`	`GL_OPERAND0_RGB`
`\|`	`GL_OPERAND1_RGB`
`\|`	`GL_OPERAND2_RGB`
`\|`	`GL_OPERAND0_ALPHA`
`\|`	`GL_OPERAND1_ALPHA`
`\|`	`GL_OPERAND2_ALPHA`
`\|`	`GL_RGB_SCALE`
`\|`	`GL_ADD_SIGNED`
`\|`	`GL_INTERPOLATE`
`\|`	`GL_SUBTRACT`
`\|`	`GL_CONSTANT`
`\|`	`GL_PRIMARY_COLOR`
`\|`	`GL_PREVIOUS`
`\|`	`GL_DOT3_RGB`
`\|`	`GL_DOT3_RGBA`
`\|`	`GL_CLAMP_TO_BORDER`
`\|`	`GL_GENERATE_MIPMAP`
`\|`	`GL_GENERATE_MIPMAP_HINT`
`\|`	`GL_DEPTH_COMPONENT16`
`\|`	`GL_DEPTH_COMPONENT24`
`\|`	`GL_DEPTH_COMPONENT32`
`\|`	`GL_TEXTURE_DEPTH_SIZE`
`\|`	`GL_DEPTH_TEXTURE_MODE`
`\|`	`GL_TEXTURE_COMPARE_MODE`
`\|`	`GL_TEXTURE_COMPARE_FUNC`
`\|`	`GL_COMPARE_R_TO_TEXTURE`
`\|`	`GL_FOG_COORDINATE_SOURCE`
`\|`	`GL_FOG_COORDINATE`
`\|`	`GL_FRAGMENT_DEPTH`
`\|`	`GL_CURRENT_FOG_COORDINATE`
`\|`	`GL_FOG_COORDINATE_ARRAY_TYPE`
`\|`	`GL_FOG_COORDINATE_ARRAY_STRIDE`
`\|`	`GL_FOG_COORDINATE_ARRAY_POINTER`
`\|`	`GL_FOG_COORDINATE_ARRAY`
`\|`	`GL_POINT_SIZE_MIN`
`\|`	`GL_POINT_SIZE_MAX`
`\|`	`GL_POINT_FADE_THRESHOLD_SIZE`
`\|`	`GL_POINT_DISTANCE_ATTENUATION`
`\|`	`GL_COLOR_SUM`
`\|`	`GL_CURRENT_SECONDARY_COLOR`
`\|`	`GL_SECONDARY_COLOR_ARRAY_SIZE`
`\|`	`GL_SECONDARY_COLOR_ARRAY_TYPE`
`\|`	`GL_SECONDARY_COLOR_ARRAY_STRIDE`
`\|`	`GL_SECONDARY_COLOR_ARRAY_POINTER`
`\|`	`GL_SECONDARY_COLOR_ARRAY`
`\|`	`GL_BLEND_DST_RGB`
`\|`	`GL_BLEND_SRC_RGB`
`\|`	`GL_BLEND_DST_ALPHA`
`\|`	`GL_BLEND_SRC_ALPHA`
`\|`	`GL_INCR_WRAP`
`\|`	`GL_DECR_WRAP`
`\|`	`GL_TEXTURE_FILTER_CONTROL`
`\|`	`GL_TEXTURE_LOD_BIAS`
`\|`	`GL_MAX_TEXTURE_LOD_BIAS`
`\|`	`GL_MIRRORED_REPEAT`
`\|`	`GL_BUFFER_SIZE`
`\|`	`GL_BUFFER_USAGE`
`\|`	`GL_QUERY_COUNTER_BITS`
`\|`	`GL_CURRENT_QUERY`
`\|`	`GL_QUERY_RESULT`
`\|`	`GL_QUERY_RESULT_AVAILABLE`
`\|`	`GL_ARRAY_BUFFER`
`\|`	`GL_ELEMENT_ARRAY_BUFFER`
`\|`	`GL_ARRAY_BUFFER_BINDING`
`\|`	`GL_ELEMENT_ARRAY_BUFFER_BINDING`
`\|`	`GL_VERTEX_ARRAY_BUFFER_BINDING`
`\|`	`GL_NORMAL_ARRAY_BUFFER_BINDING`
`\|`	`GL_COLOR_ARRAY_BUFFER_BINDING`
`\|`	`GL_INDEX_ARRAY_BUFFER_BINDING`
`\|`	`GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING`
`\|`	`GL_EDGE_FLAG_ARRAY_BUFFER_BINDING`
`\|`	`GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING`
`\|`	`GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING`
`\|`	`GL_WEIGHT_ARRAY_BUFFER_BINDING`
`\|`	`GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING`
`\|`	`GL_READ_ONLY`
`\|`	`GL_WRITE_ONLY`
`\|`	`GL_READ_WRITE`
`\|`	`GL_BUFFER_ACCESS`
`\|`	`GL_BUFFER_MAPPED`
`\|`	`GL_BUFFER_MAP_POINTER`
`\|`	`GL_STREAM_DRAW`
`\|`	`GL_STREAM_READ`
`\|`	`GL_STREAM_COPY`
`\|`	`GL_STATIC_DRAW`
`\|`	`GL_STATIC_READ`
`\|`	`GL_STATIC_COPY`
`\|`	`GL_DYNAMIC_DRAW`
`\|`	`GL_DYNAMIC_READ`
`\|`	`GL_DYNAMIC_COPY`
`\|`	`GL_SAMPLES_PASSED`
`\|`	`GL_FOG_COORD_SRC`
`\|`	`GL_FOG_COORD`
`\|`	`GL_CURRENT_FOG_COORD`
`\|`	`GL_FOG_COORD_ARRAY_TYPE`
`\|`	`GL_FOG_COORD_ARRAY_STRIDE`
`\|`	`GL_FOG_COORD_ARRAY_POINTER`
`\|`	`GL_FOG_COORD_ARRAY`
`\|`	`GL_FOG_COORD_ARRAY_BUFFER_BINDING`
`\|`	`GL_SRC0_RGB`
`\|`	`GL_SRC1_RGB`
`\|`	`GL_SRC2_RGB`
`\|`	`GL_SRC0_ALPHA`
`\|`	`GL_SRC1_ALPHA`
`\|`	`GL_SRC2_ALPHA`
`\|`	`GL_BLEND_EQUATION_RGB`
`\|`	`GL_VERTEX_ATTRIB_ARRAY_ENABLED`
`\|`	`GL_VERTEX_ATTRIB_ARRAY_SIZE`
`\|`	`GL_VERTEX_ATTRIB_ARRAY_STRIDE`
`\|`	`GL_VERTEX_ATTRIB_ARRAY_TYPE`
`\|`	`GL_CURRENT_VERTEX_ATTRIB`
`\|`	`GL_VERTEX_PROGRAM_POINT_SIZE`
`\|`	`GL_VERTEX_PROGRAM_TWO_SIDE`
`\|`	`GL_VERTEX_ATTRIB_ARRAY_POINTER`
`\|`	`GL_STENCIL_BACK_FUNC`
`\|`	`GL_STENCIL_BACK_FAIL`
`\|`	`GL_STENCIL_BACK_PASS_DEPTH_FAIL`
`\|`	`GL_STENCIL_BACK_PASS_DEPTH_PASS`
`\|`	`GL_MAX_DRAW_BUFFERS`
`\|`	`GL_DRAW_BUFFER0`
`\|`	`GL_DRAW_BUFFER1`
`\|`	`GL_DRAW_BUFFER2`
`\|`	`GL_DRAW_BUFFER3`
`\|`	`GL_DRAW_BUFFER4`
`\|`	`GL_DRAW_BUFFER5`
`\|`	`GL_DRAW_BUFFER6`
`\|`	`GL_DRAW_BUFFER7`
`\|`	`GL_DRAW_BUFFER8`
`\|`	`GL_DRAW_BUFFER9`
`\|`	`GL_DRAW_BUFFER10`
`\|`	`GL_DRAW_BUFFER11`
`\|`	`GL_DRAW_BUFFER12`
`\|`	`GL_DRAW_BUFFER13`
`\|`	`GL_DRAW_BUFFER14`
`\|`	`GL_DRAW_BUFFER15`
`\|`	`GL_BLEND_EQUATION_ALPHA`
`\|`	`GL_POINT_SPRITE`
`\|`	`GL_COORD_REPLACE`
`\|`	`GL_MAX_VERTEX_ATTRIBS`
`\|`	`GL_VERTEX_ATTRIB_ARRAY_NORMALIZED`
`\|`	`GL_MAX_TEXTURE_COORDS`
`\|`	`GL_MAX_TEXTURE_IMAGE_UNITS`
`\|`	`GL_FRAGMENT_SHADER`
`\|`	`GL_VERTEX_SHADER`
`\|`	`GL_MAX_FRAGMENT_UNIFORM_COMPONENTS`
`\|`	`GL_MAX_VERTEX_UNIFORM_COMPONENTS`
`\|`	`GL_MAX_VARYING_FLOATS`
`\|`	`GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS`
`\|`	`GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS`
`\|`	`GL_SHADER_TYPE`
`\|`	`GL_FLOAT_VEC2`
`\|`	`GL_FLOAT_VEC3`
`\|`	`GL_FLOAT_VEC4`
`\|`	`GL_INT_VEC2`
`\|`	`GL_INT_VEC3`
`\|`	`GL_INT_VEC4`
`\|`	`GL_BOOL`
`\|`	`GL_BOOL_VEC2`
`\|`	`GL_BOOL_VEC3`
`\|`	`GL_BOOL_VEC4`
`\|`	`GL_FLOAT_MAT2`
`\|`	`GL_FLOAT_MAT3`
`\|`	`GL_FLOAT_MAT4`
`\|`	`GL_SAMPLER_1D`
`\|`	`GL_SAMPLER_2D`
`\|`	`GL_SAMPLER_3D`
`\|`	`GL_SAMPLER_CUBE`
`\|`	`GL_SAMPLER_1D_SHADOW`
`\|`	`GL_SAMPLER_2D_SHADOW`
`\|`	`GL_DELETE_STATUS`
`\|`	`GL_COMPILE_STATUS`
`\|`	`GL_LINK_STATUS`
`\|`	`GL_VALIDATE_STATUS`
`\|`	`GL_INFO_LOG_LENGTH`
`\|`	`GL_ATTACHED_SHADERS`
`\|`	`GL_ACTIVE_UNIFORMS`
`\|`	`GL_ACTIVE_UNIFORM_MAX_LENGTH`
`\|`	`GL_SHADER_SOURCE_LENGTH`
`\|`	`GL_ACTIVE_ATTRIBUTES`
`\|`	`GL_ACTIVE_ATTRIBUTE_MAX_LENGTH`
`\|`	`GL_FRAGMENT_SHADER_DERIVATIVE_HINT`
`\|`	`GL_SHADING_LANGUAGE_VERSION`
`\|`	`GL_CURRENT_PROGRAM`
`\|`	`GL_POINT_SPRITE_COORD_ORIGIN`
`\|`	`GL_LOWER_LEFT`
`\|`	`GL_UPPER_LEFT`
`\|`	`GL_STENCIL_BACK_REF`
`\|`	`GL_STENCIL_BACK_VALUE_MASK`
`\|`	`GL_STENCIL_BACK_WRITEMASK`

val glenum_of_int : int -> glenum

Converts an integer into a glenum

val set_failwith : bool -> unit

When called with true, if an OpenGL function call is not available, a Failure exception is thrown. With false, the call fails silently.

val int_of_glenum : glenum -> int

Converts a glenum to an integer

val glColorTable : glenum ->
       glenum ->
       int -> glenum -> glenum -> glpointer -> unit

val glColorSubTable : glenum ->
       int -> int -> glenum -> glenum -> glpointer -> unit

val glColorTableParameteriv : glenum -> glenum -> int_array -> unit

val glColorTableParameterfv : glenum -> glenum -> float_array -> unit

val glCopyColorSubTable : glenum -> int -> int -> int -> int -> unit

val glCopyColorTable : glenum -> glenum -> int -> int -> int -> unit

val glGetColorTable : glenum -> glenum -> glenum -> glpointer -> unit

val glGetColorTableParameterfv : glenum -> glenum -> float_array -> unit

val glGetColorTableParameteriv : glenum -> glenum -> int_array -> unit

val glHistogram : glenum -> int -> glenum -> bool -> unit

val glResetHistogram : glenum -> unit

val glGetHistogram : glenum ->
       bool -> glenum -> glenum -> glpointer -> unit

val glGetHistogramParameterfv : glenum -> glenum -> float_array -> unit

val glGetHistogramParameteriv : glenum -> glenum -> int_array -> unit

val glMinmax : glenum -> glenum -> bool -> unit

val glResetMinmax : glenum -> unit

val glGetMinmaxParameterfv : glenum -> glenum -> float_array -> unit

val glGetMinmaxParameteriv : glenum -> glenum -> int_array -> unit

val glConvolutionFilter1D : glenum ->
       glenum ->
       int -> glenum -> glenum -> glpointer -> unit

val glConvolutionFilter2D : glenum ->
       glenum ->
       int -> int -> glenum -> glenum -> glpointer -> unit

val glConvolutionParameterf : glenum -> glenum -> float -> unit

val glConvolutionParameterfv : glenum -> glenum -> float_array -> unit

val glConvolutionParameteri : glenum -> glenum -> int -> unit

val glConvolutionParameteriv : glenum -> glenum -> int_array -> unit

val glCopyConvolutionFilter1D : glenum -> glenum -> int -> int -> int -> unit

val glCopyConvolutionFilter2D : glenum -> glenum -> int -> int -> int -> int -> unit

val glGetConvolutionFilter : glenum -> glenum -> glenum -> glpointer -> unit

val glGetConvolutionParameterfv : glenum -> glenum -> float_array -> unit

val glGetConvolutionParameteriv : glenum -> glenum -> int_array -> unit

val glSeparableFilter2D : glenum ->
       glenum ->
       int ->
       int ->
       glenum ->
       glenum -> glpointer -> glpointer -> unit

val glGetSeparableFilter : glenum ->
       glenum ->
       glenum ->
       glpointer -> glpointer -> glpointer -> unit

val glGetMinmax : glenum ->
       bool -> glenum -> glenum -> glpointer -> unit

val glCurrentPaletteMatrixARB : int -> unit

val glMatrixIndexPointerARB : int -> glenum -> int -> glpointer -> unit

val glMatrixIndexubvARB : int -> ubyte_array -> unit

val glMatrixIndexusvARB : int -> ushort_array -> unit

val glMatrixIndexuivARB : int -> int_array -> unit

val glActiveTextureARB : glenum -> unit

val glClientActiveTextureARB : glenum -> unit

val glMultiTexCoord1dARB : glenum -> float -> unit

val glMultiTexCoord1dvARB : glenum -> double_array -> unit

val glMultiTexCoord1fARB : glenum -> float -> unit

val glMultiTexCoord1fvARB : glenum -> float_array -> unit

val glMultiTexCoord1iARB : glenum -> int -> unit

val glMultiTexCoord1ivARB : glenum -> int_array -> unit

val glMultiTexCoord1sARB : glenum -> int -> unit

val glMultiTexCoord1svARB : glenum -> short_array -> unit

val glMultiTexCoord2dARB : glenum -> float -> float -> unit

val glMultiTexCoord2dvARB : glenum -> double_array -> unit

val glMultiTexCoord2fARB : glenum -> float -> float -> unit

val glMultiTexCoord2fvARB : glenum -> float_array -> unit

val glMultiTexCoord2iARB : glenum -> int -> int -> unit

val glMultiTexCoord2ivARB : glenum -> int_array -> unit

val glMultiTexCoord2sARB : glenum -> int -> int -> unit

val glMultiTexCoord2svARB : glenum -> short_array -> unit

val glMultiTexCoord3dARB : glenum -> float -> float -> float -> unit

val glMultiTexCoord3dvARB : glenum -> double_array -> unit

val glMultiTexCoord3fARB : glenum -> float -> float -> float -> unit

val glMultiTexCoord3fvARB : glenum -> float_array -> unit

val glMultiTexCoord3iARB : glenum -> int -> int -> int -> unit

val glMultiTexCoord3ivARB : glenum -> int_array -> unit

val glMultiTexCoord3sARB : glenum -> int -> int -> int -> unit

val glMultiTexCoord3svARB : glenum -> short_array -> unit

val glMultiTexCoord4dARB : glenum -> float -> float -> float -> float -> unit

val glMultiTexCoord4dvARB : glenum -> double_array -> unit

val glMultiTexCoord4fARB : glenum -> float -> float -> float -> float -> unit

val glMultiTexCoord4fvARB : glenum -> float_array -> unit

val glMultiTexCoord4iARB : glenum -> int -> int -> int -> int -> unit

val glMultiTexCoord4ivARB : glenum -> int_array -> unit

val glMultiTexCoord4sARB : glenum -> int -> int -> int -> int -> unit

val glMultiTexCoord4svARB : glenum -> short_array -> unit

val glWeightbvARB : int -> byte_array -> unit

val glWeightsvARB : int -> short_array -> unit

val glWeightivARB : int -> int_array -> unit

val glWeightfvARB : int -> float_array -> unit

val glWeightdvARB : int -> double_array -> unit

val glWeightubvARB : int -> ubyte_array -> unit

val glWeightusvARB : int -> ushort_array -> unit

val glWeightuivARB : int -> int_array -> unit

val glWeightPointerARB : int -> glenum -> int -> glpointer -> unit

val glVertexBlendARB : int -> unit

val glTexBumpParameterivATI : glenum -> int_array -> unit

val glTexBumpParameterfvATI : glenum -> float_array -> unit

val glGetTexBumpParameterivATI : glenum -> int_array -> unit

val glGetTexBumpParameterfvATI : glenum -> float_array -> unit

val glMapObjectBufferATI : int -> glpointer

val glUnmapObjectBufferATI : int -> unit

val glPNTrianglesiATI : glenum -> int -> unit

val glPNTrianglesfATI : glenum -> float -> unit

val glStencilOpSeparateATI : glenum -> glenum -> glenum -> glenum -> unit

val glStencilFuncSeparateATI : glenum -> glenum -> int -> int -> unit

val glClientActiveVertexStreamATI : glenum -> unit

val glVertexBlendEnviATI : glenum -> int -> unit

val glVertexBlendEnvfATI : glenum -> float -> unit

val glVertexStream2sATI : glenum -> int -> int -> unit

val glVertexStream2svATI : glenum -> short_array -> unit

val glVertexStream2iATI : glenum -> int -> int -> unit

val glVertexStream2ivATI : glenum -> int_array -> unit

val glVertexStream2fATI : glenum -> float -> float -> unit

val glVertexStream2fvATI : glenum -> float_array -> unit

val glVertexStream2dATI : glenum -> float -> float -> unit

val glVertexStream2dvATI : glenum -> double_array -> unit

val glVertexStream3sATI : glenum -> int -> int -> int -> unit

val glVertexStream3svATI : glenum -> short_array -> unit

val glVertexStream3iATI : glenum -> int -> int -> int -> unit

val glVertexStream3ivATI : glenum -> int_array -> unit

val glVertexStream3fATI : glenum -> float -> float -> float -> unit

val glVertexStream3fvATI : glenum -> float_array -> unit

val glVertexStream3dATI : glenum -> float -> float -> float -> unit

val glVertexStream3dvATI : glenum -> double_array -> unit

val glVertexStream4sATI : glenum -> int -> int -> int -> int -> unit

val glVertexStream4svATI : glenum -> short_array -> unit

val glVertexStream4iATI : glenum -> int -> int -> int -> int -> unit

val glVertexStream4ivATI : glenum -> int_array -> unit

val glVertexStream4fATI : glenum -> float -> float -> float -> float -> unit

val glVertexStream4fvATI : glenum -> float_array -> unit

val glVertexStream4dATI : glenum -> float -> float -> float -> float -> unit

val glVertexStream4dvATI : glenum -> double_array -> unit

val glNormalStream3bATI : glenum -> int -> int -> int -> unit

val glNormalStream3bvATI : glenum -> byte_array -> unit

val glNormalStream3sATI : glenum -> int -> int -> int -> unit

val glNormalStream3svATI : glenum -> short_array -> unit

val glNormalStream3iATI : glenum -> int -> int -> int -> unit

val glNormalStream3ivATI : glenum -> int_array -> unit

val glNormalStream3fATI : glenum -> float -> float -> float -> unit

val glNormalStream3fvATI : glenum -> float_array -> unit

val glNormalStream3dATI : glenum -> float -> float -> float -> unit

val glNormalStream3dvATI : glenum -> double_array -> unit

val glDepthBoundsEXT : float -> float -> unit

val glDrawRangeElementsEXT : glenum ->
       int -> int -> int -> glenum -> glpointer -> unit

val glFogCoordfEXT : float -> unit

val glFogCoordfvEXT : float_array -> unit

val glFogCoorddEXT : float -> unit

val glFogCoorddvEXT : double_array -> unit

val glFogCoordPointerEXT : glenum -> int -> glpointer -> unit

val glSecondaryColor3bEXT : int -> int -> int -> unit

val glSecondaryColor3bvEXT : byte_array -> unit

val glSecondaryColor3dEXT : float -> float -> float -> unit

val glSecondaryColor3dvEXT : double_array -> unit

val glSecondaryColor3fEXT : float -> float -> float -> unit

val glSecondaryColor3fvEXT : float_array -> unit

val glSecondaryColor3iEXT : int -> int -> int -> unit

val glSecondaryColor3ivEXT : int_array -> unit

val glSecondaryColor3sEXT : int -> int -> int -> unit

val glSecondaryColor3svEXT : short_array -> unit

val glSecondaryColor3ubEXT : int -> int -> int -> unit

val glSecondaryColor3ubvEXT : ubyte_array -> unit

val glSecondaryColor3uiEXT : int -> int -> int -> unit

val glSecondaryColor3uivEXT : int_array -> unit

val glSecondaryColor3usEXT : int -> int -> int -> unit

val glSecondaryColor3usvEXT : ushort_array -> unit

val glSecondaryColorPointerEXT : int -> glenum -> int -> glpointer -> unit

val glBeginVertexShaderEXT : unit -> unit

val glEndVertexShaderEXT : unit -> unit

val glBindVertexShaderEXT : int -> unit

val glGenVertexShadersEXT : int -> int

val glDeleteVertexShaderEXT : int -> unit

val glShaderOp1EXT : glenum -> int -> int -> unit

val glShaderOp2EXT : glenum -> int -> int -> int -> unit

val glShaderOp3EXT : glenum -> int -> int -> int -> int -> unit

val glSwizzleEXT : int ->
       int ->
       glenum -> glenum -> glenum -> glenum -> unit

val glWriteMaskEXT : int ->
       int ->
       glenum -> glenum -> glenum -> glenum -> unit

val glInsertComponentEXT : int -> int -> int -> unit

val glExtractComponentEXT : int -> int -> int -> unit

val glGenSymbolsEXT : glenum -> glenum -> glenum -> int -> int

val glSetInvariantEXT : int -> glenum -> glpointer -> unit

val glSetLocalConstantEXT : int -> glenum -> glpointer -> unit

val glVariantbvEXT : int -> byte_array -> unit

val glVariantsvEXT : int -> short_array -> unit

val glVariantivEXT : int -> int_array -> unit

val glVariantfvEXT : int -> float_array -> unit

val glVariantdvEXT : int -> double_array -> unit

val glVariantubvEXT : int -> ubyte_array -> unit

val glVariantusvEXT : int -> ushort_array -> unit

val glVariantuivEXT : int -> int_array -> unit

val glVariantPointerEXT : int -> glenum -> int -> glpointer -> unit

val glEnableVariantClientStateEXT : int -> unit

val glDisableVariantClientStateEXT : int -> unit

val glBindLightParameterEXT : glenum -> glenum -> int

val glBindMaterialParameterEXT : glenum -> glenum -> int

val glBindTexGenParameterEXT : glenum -> glenum -> glenum -> int

val glBindTextureUnitParameterEXT : glenum -> glenum -> int

val glBindParameterEXT : glenum -> int

val glIsVariantEnabledEXT : int -> glenum -> bool

val glGetVariantBooleanvEXT : int -> glenum -> int_array -> unit

val glGetVariantIntegervEXT : int -> glenum -> int_array -> unit

val glGetVariantFloatvEXT : int -> glenum -> float_array -> unit

val glGetVariantPointervEXT : int -> glenum -> glpointer -> unit

val glGetInvariantBooleanvEXT : int -> glenum -> int_array -> unit

val glGetInvariantIntegervEXT : int -> glenum -> int_array -> unit

val glGetInvariantFloatvEXT : int -> glenum -> float_array -> unit

val glGetLocalConstantBooleanvEXT : int -> glenum -> int_array -> unit

val glGetLocalConstantIntegervEXT : int -> glenum -> int_array -> unit

val glGetLocalConstantFloatvEXT : int -> glenum -> float_array -> unit

val glBufferRegionEnabledEXT : unit -> int

val glNewBufferRegionEXT : glenum -> int

val glDeleteBufferRegionEXT : glenum -> unit

val glReadBufferRegionEXT : int -> int -> int -> int -> int -> unit

val glDrawBufferRegionEXT : int -> int -> int -> int -> int -> int -> int -> unit

val glAccum : glenum -> float -> unit

val glAlphaFunc : glenum -> float -> unit

val glAreTexturesResident : int -> int_array -> int_array -> bool

val glArrayElement : int -> unit

val glBegin : glenum -> unit

val glBindTexture : glenum -> int -> unit

val glBitmap : int -> int -> float -> float -> float -> float -> ubyte_array -> unit

val glBlendFunc : glenum -> glenum -> unit

val glCallList : int -> unit

val glCallLists : int -> glenum -> glpointer -> unit

val glClear : glenum list -> unit

val glClearAccum : float -> float -> float -> float -> unit

val glClearColor : float -> float -> float -> float -> unit

val glClearDepth : float -> unit

val glClearIndex : float -> unit

val glClearStencil : int -> unit

val glClipPlane : glenum -> double_array -> unit

val glColor3b : int -> int -> int -> unit

val glColor3bv : byte_array -> unit

val glColor3d : float -> float -> float -> unit

val glColor3dv : double_array -> unit

val glColor3f : float -> float -> float -> unit

val glColor3fv : float_array -> unit

val glColor3i : int -> int -> int -> unit

val glColor3iv : int_array -> unit

val glColor3s : int -> int -> int -> unit

val glColor3sv : short_array -> unit

val glColor3ub : int -> int -> int -> unit

val glColor3ubv : ubyte_array -> unit

val glColor3ui : int -> int -> int -> unit

val glColor3uiv : int_array -> unit

val glColor3us : int -> int -> int -> unit

val glColor3usv : ushort_array -> unit

val glColor4b : int -> int -> int -> int -> unit

val glColor4bv : byte_array -> unit

val glColor4d : float -> float -> float -> float -> unit

val glColor4dv : double_array -> unit

val glColor4f : float -> float -> float -> float -> unit

val glColor4fv : float_array -> unit

val glColor4i : int -> int -> int -> int -> unit

val glColor4iv : int_array -> unit

val glColor4s : int -> int -> int -> int -> unit

val glColor4sv : short_array -> unit

val glColor4ub : int -> int -> int -> int -> unit

val glColor4ubv : ubyte_array -> unit

val glColor4ui : int -> int -> int -> int -> unit

val glColor4uiv : int_array -> unit

val glColor4us : int -> int -> int -> int -> unit

val glColor4usv : ushort_array -> unit

val glColorMask : bool -> bool -> bool -> bool -> unit

val glColorMaterial : glenum -> glenum -> unit

val glColorPointer : int -> glenum -> int -> glpointer -> unit

val glCopyPixels : int -> int -> int -> int -> glenum -> unit

val glCopyTexImage1D : glenum -> int -> glenum -> int -> int -> int -> int -> unit

val glCopyTexImage2D : glenum ->
       int -> glenum -> int -> int -> int -> int -> int -> unit

val glCopyTexSubImage1D : glenum -> int -> int -> int -> int -> int -> unit

val glCopyTexSubImage2D : glenum -> int -> int -> int -> int -> int -> int -> int -> unit

val glCullFace : glenum -> unit

val glDeleteLists : int -> int -> unit

val glDeleteTextures : int -> int_array -> unit

val glDepthFunc : glenum -> unit

val glDepthMask : bool -> unit

val glDepthRange : float -> float -> unit

val glDisable : glenum -> unit

val glDisableClientState : glenum -> unit

val glDrawArrays : glenum -> int -> int -> unit

val glDrawBuffer : glenum -> unit

val glDrawElements : glenum -> int -> glenum -> glpointer -> unit

val glDrawPixels : int -> int -> glenum -> glenum -> glpointer -> unit

val glEdgeFlag : bool -> unit

val glEdgeFlagPointer : int -> glpointer -> unit

val glEdgeFlagv : int_array -> unit

val glEnable : glenum -> unit

val glEnableClientState : glenum -> unit

val glEnd : unit -> unit

val glEndList : unit -> unit

val glEvalCoord1d : float -> unit

val glEvalCoord1dv : double_array -> unit

val glEvalCoord1f : float -> unit

val glEvalCoord1fv : float_array -> unit

val glEvalCoord2d : float -> float -> unit

val glEvalCoord2dv : double_array -> unit

val glEvalCoord2f : float -> float -> unit

val glEvalCoord2fv : float_array -> unit

val glEvalMesh1 : glenum -> int -> int -> unit

val glEvalMesh2 : glenum -> int -> int -> int -> int -> unit

val glEvalPoint1 : int -> unit

val glEvalPoint2 : int -> int -> unit

val glFeedbackBuffer : int -> glenum -> float_array -> unit

val glFinish : unit -> unit

val glFlush : unit -> unit

val glFogf : glenum -> float -> unit

val glFogfv : glenum -> float_array -> unit

val glFogi : glenum -> int -> unit

val glFogiv : glenum -> int_array -> unit

val glFrontFace : glenum -> unit

val glFrustum : float -> float -> float -> float -> float -> float -> unit

val glGenLists : int -> int

val glGenTextures : int -> int_array -> unit

val glGetBooleanv : glenum -> int_array -> unit

val glGetClipPlane : glenum -> double_array -> unit

val glGetDoublev : glenum -> double_array -> unit

val glGetError : unit -> glenum

val glGetFloatv : glenum -> float_array -> unit

val glGetIntegerv : glenum -> int_array -> unit

val glGetLightfv : glenum -> glenum -> float_array -> unit

val glGetLightiv : glenum -> glenum -> int_array -> unit

val glGetMapdv : glenum -> glenum -> double_array -> unit

val glGetMapfv : glenum -> glenum -> float_array -> unit

val glGetMapiv : glenum -> glenum -> int_array -> unit

val glGetMaterialfv : glenum -> glenum -> float_array -> unit

val glGetMaterialiv : glenum -> glenum -> int_array -> unit

val glGetPixelMapfv : glenum -> float_array -> unit

val glGetPixelMapuiv : glenum -> int_array -> unit

val glGetPixelMapusv : glenum -> ushort_array -> unit

val glGetPointerv : glenum -> glpointer -> unit

val glGetPolygonStipple : ubyte_array -> unit

val glGetString : glenum -> string

val glGetTexEnvfv : glenum -> glenum -> float_array -> unit

val glGetTexEnviv : glenum -> glenum -> int_array -> unit

val glGetTexGendv : glenum -> glenum -> double_array -> unit

val glGetTexGenfv : glenum -> glenum -> float_array -> unit

val glGetTexGeniv : glenum -> glenum -> int_array -> unit

val glGetTexImage : glenum ->
       int -> glenum -> glenum -> glpointer -> unit

val glGetTexLevelParameterfv : glenum -> int -> glenum -> float_array -> unit

val glGetTexLevelParameteriv : glenum -> int -> glenum -> int_array -> unit

val glGetTexParameterfv : glenum -> glenum -> float_array -> unit

val glGetTexParameteriv : glenum -> glenum -> int_array -> unit

val glHint : glenum -> glenum -> unit

val glIndexMask : int -> unit

val glIndexPointer : glenum -> int -> glpointer -> unit

val glIndexd : float -> unit

val glIndexdv : double_array -> unit

val glIndexf : float -> unit

val glIndexfv : float_array -> unit

val glIndexi : int -> unit

val glIndexiv : int_array -> unit

val glIndexs : int -> unit

val glIndexsv : short_array -> unit

val glIndexub : int -> unit

val glIndexubv : ubyte_array -> unit

val glInitNames : unit -> unit

val glInterleavedArrays : glenum -> int -> glpointer -> unit

val glIsEnabled : glenum -> bool

val glIsList : int -> bool

val glIsTexture : int -> bool

val glLightModelf : glenum -> float -> unit

val glLightModelfv : glenum -> float_array -> unit

val glLightModeli : glenum -> int -> unit

val glLightModeliv : glenum -> int_array -> unit

val glLightf : glenum -> glenum -> float -> unit

val glLightfv : glenum -> glenum -> float_array -> unit

val glLighti : glenum -> glenum -> int -> unit

val glLightiv : glenum -> glenum -> int_array -> unit

val glLineStipple : int -> int -> unit

val glLineWidth : float -> unit

val glListBase : int -> unit

val glLoadIdentity : unit -> unit

val glLoadMatrixd : double_array -> unit

val glLoadMatrixf : float_array -> unit

val glLoadName : int -> unit

val glLogicOp : glenum -> unit

val glMap1d : glenum -> float -> float -> int -> int -> double_array -> unit

val glMap1f : glenum -> float -> float -> int -> int -> float_array -> unit

val glMap2d : glenum ->
       float ->
       float ->
       int -> int -> float -> float -> int -> int -> double_array -> unit

val glMap2f : glenum ->
       float ->
       float ->
       int -> int -> float -> float -> int -> int -> float_array -> unit

val glMapGrid1d : int -> float -> float -> unit

val glMapGrid1f : int -> float -> float -> unit

val glMapGrid2d : int -> float -> float -> int -> float -> float -> unit

val glMapGrid2f : int -> float -> float -> int -> float -> float -> unit

val glMaterialf : glenum -> glenum -> float -> unit

val glMaterialfv : glenum -> glenum -> float_array -> unit

val glMateriali : glenum -> glenum -> int -> unit

val glMaterialiv : glenum -> glenum -> int_array -> unit

val glMatrixMode : glenum -> unit

val glMultMatrixd : double_array -> unit

val glMultMatrixf : float_array -> unit

val glNewList : int -> glenum -> unit

val glNormal3b : int -> int -> int -> unit

val glNormal3bv : byte_array -> unit

val glNormal3d : float -> float -> float -> unit

val glNormal3dv : double_array -> unit

val glNormal3f : float -> float -> float -> unit

val glNormal3fv : float_array -> unit

val glNormal3i : int -> int -> int -> unit

val glNormal3iv : int_array -> unit

val glNormal3s : int -> int -> int -> unit

val glNormal3sv : short_array -> unit

val glNormalPointer : glenum -> int -> glpointer -> unit

val glOrtho : float -> float -> float -> float -> float -> float -> unit

val glPassThrough : float -> unit

val glPixelMapfv : glenum -> int -> float_array -> unit

val glPixelMapuiv : glenum -> int -> int_array -> unit

val glPixelMapusv : glenum -> int -> ushort_array -> unit

val glPixelStoref : glenum -> float -> unit

val glPixelStorei : glenum -> int -> unit

val glPixelTransferf : glenum -> float -> unit

val glPixelTransferi : glenum -> int -> unit

val glPixelZoom : float -> float -> unit

val glPointSize : float -> unit

val glPolygonMode : glenum -> glenum -> unit

val glPolygonOffset : float -> float -> unit

val glPolygonStipple : ubyte_array -> unit

val glPopAttrib : unit -> unit

val glPopClientAttrib : unit -> unit

val glPopMatrix : unit -> unit

val glPopName : unit -> unit

val glPrioritizeTextures : int -> int_array -> float_array -> unit

val glPushAttrib : glenum list -> unit

val glPushClientAttrib : glenum list -> unit

val glPushMatrix : unit -> unit

val glPushName : int -> unit

val glRasterPos2d : float -> float -> unit

val glRasterPos2dv : double_array -> unit

val glRasterPos2f : float -> float -> unit

val glRasterPos2fv : float_array -> unit

val glRasterPos2i : int -> int -> unit

val glRasterPos2iv : int_array -> unit

val glRasterPos2s : int -> int -> unit

val glRasterPos2sv : short_array -> unit

val glRasterPos3d : float -> float -> float -> unit

val glRasterPos3dv : double_array -> unit

val glRasterPos3f : float -> float -> float -> unit

val glRasterPos3fv : float_array -> unit

val glRasterPos3i : int -> int -> int -> unit

val glRasterPos3iv : int_array -> unit

val glRasterPos3s : int -> int -> int -> unit

val glRasterPos3sv : short_array -> unit

val glRasterPos4d : float -> float -> float -> float -> unit

val glRasterPos4dv : double_array -> unit

val glRasterPos4f : float -> float -> float -> float -> unit

val glRasterPos4fv : float_array -> unit

val glRasterPos4i : int -> int -> int -> int -> unit

val glRasterPos4iv : int_array -> unit

val glRasterPos4s : int -> int -> int -> int -> unit

val glRasterPos4sv : short_array -> unit

val glReadBuffer : glenum -> unit

val glReadPixels : int ->
       int ->
       int -> int -> glenum -> glenum -> glpointer -> unit

val glRectd : float -> float -> float -> float -> unit

val glRectdv : double_array -> double_array -> unit

val glRectf : float -> float -> float -> float -> unit

val glRectfv : float_array -> float_array -> unit

val glRecti : int -> int -> int -> int -> unit

val glRectiv : int_array -> int_array -> unit

val glRects : int -> int -> int -> int -> unit

val glRectsv : short_array -> short_array -> unit

val glRenderMode : glenum -> int

val glRotated : float -> float -> float -> float -> unit

val glRotatef : float -> float -> float -> float -> unit

val glScaled : float -> float -> float -> unit

val glScalef : float -> float -> float -> unit

val glScissor : int -> int -> int -> int -> unit

val glSelectBuffer : int -> int_array -> unit

val glShadeModel : glenum -> unit

val glStencilFunc : glenum -> int -> int -> unit

val glStencilMask : int -> unit

val glStencilOp : glenum -> glenum -> glenum -> unit

val glTexCoord1d : float -> unit

val glTexCoord1dv : double_array -> unit

val glTexCoord1f : float -> unit

val glTexCoord1fv : float_array -> unit

val glTexCoord1i : int -> unit

val glTexCoord1iv : int_array -> unit

val glTexCoord1s : int -> unit

val glTexCoord1sv : short_array -> unit

val glTexCoord2d : float -> float -> unit

val glTexCoord2dv : double_array -> unit

val glTexCoord2f : float -> float -> unit

val glTexCoord2fv : float_array -> unit

val glTexCoord2i : int -> int -> unit

val glTexCoord2iv : int_array -> unit

val glTexCoord2s : int -> int -> unit

val glTexCoord2sv : short_array -> unit

val glTexCoord3d : float -> float -> float -> unit

val glTexCoord3dv : double_array -> unit

val glTexCoord3f : float -> float -> float -> unit

val glTexCoord3fv : float_array -> unit

val glTexCoord3i : int -> int -> int -> unit

val glTexCoord3iv : int_array -> unit

val glTexCoord3s : int -> int -> int -> unit

val glTexCoord3sv : short_array -> unit

val glTexCoord4d : float -> float -> float -> float -> unit

val glTexCoord4dv : double_array -> unit

val glTexCoord4f : float -> float -> float -> float -> unit

val glTexCoord4fv : float_array -> unit

val glTexCoord4i : int -> int -> int -> int -> unit

val glTexCoord4iv : int_array -> unit

val glTexCoord4s : int -> int -> int -> int -> unit

val glTexCoord4sv : short_array -> unit

val glTexCoordPointer : int -> glenum -> int -> glpointer -> unit

val glTexEnvf : glenum -> glenum -> float -> unit

val glTexEnvfv : glenum -> glenum -> float_array -> unit

val glTexEnvi : glenum -> glenum -> int -> unit

val glTexEnviv : glenum -> glenum -> int_array -> unit

val glTexGend : glenum -> glenum -> float -> unit

val glTexGendv : glenum -> glenum -> double_array -> unit

val glTexGenf : glenum -> glenum -> float -> unit

val glTexGenfv : glenum -> glenum -> float_array -> unit

val glTexGeni : glenum -> glenum -> int -> unit

val glTexGeniv : glenum -> glenum -> int_array -> unit

val glTexImage1D : glenum ->
       int ->
       int ->
       int -> int -> glenum -> glenum -> glpointer -> unit

val glTexImage2D : glenum ->
       int ->
       int ->
       int ->
       int -> int -> glenum -> glenum -> glpointer -> unit

val glTexParameterf : glenum -> glenum -> float -> unit

val glTexParameterfv : glenum -> glenum -> float_array -> unit

val glTexParameteri : glenum -> glenum -> int -> unit

val glTexParameteriv : glenum -> glenum -> int_array -> unit

val glTexSubImage1D : glenum ->
       int ->
       int -> int -> glenum -> glenum -> glpointer -> unit

val glTexSubImage2D : glenum ->
       int ->
       int ->
       int ->
       int -> int -> glenum -> glenum -> glpointer -> unit

val glTranslated : float -> float -> float -> unit

val glTranslatef : float -> float -> float -> unit

val glVertex2d : float -> float -> unit

val glVertex2dv : double_array -> unit

val glVertex2f : float -> float -> unit

val glVertex2fv : float_array -> unit

val glVertex2i : int -> int -> unit

val glVertex2iv : int_array -> unit

val glVertex2s : int -> int -> unit

val glVertex2sv : short_array -> unit

val glVertex3d : float -> float -> float -> unit

val glVertex3dv : double_array -> unit

val glVertex3f : float -> float -> float -> unit

val glVertex3fv : float_array -> unit

val glVertex3i : int -> int -> int -> unit

val glVertex3iv : int_array -> unit

val glVertex3s : int -> int -> int -> unit

val glVertex3sv : short_array -> unit

val glVertex4d : float -> float -> float -> float -> unit

val glVertex4dv : double_array -> unit

val glVertex4f : float -> float -> float -> float -> unit

val glVertex4fv : float_array -> unit

val glVertex4i : int -> int -> int -> int -> unit

val glVertex4iv : int_array -> unit

val glVertex4s : int -> int -> int -> int -> unit

val glVertex4sv : short_array -> unit

val glVertexPointer : int -> glenum -> int -> glpointer -> unit

val glViewport : int -> int -> int -> int -> unit

val glDrawRangeElements : glenum ->
       int -> int -> int -> glenum -> glpointer -> unit

val glTexImage3D : glenum ->
       int ->
       int ->
       int ->
       int ->
       int -> int -> glenum -> glenum -> glpointer -> unit

val glTexSubImage3D : glenum ->
       int ->
       int ->
       int ->
       int ->
       int ->
       int -> int -> glenum -> glenum -> glpointer -> unit

val glCopyTexSubImage3D : glenum -> int -> int -> int -> int -> int -> int -> int -> int -> unit

val glActiveTexture : glenum -> unit

val glClientActiveTexture : glenum -> unit

val glCompressedTexImage1D : glenum ->
       int -> glenum -> int -> int -> int -> glpointer -> unit

val glCompressedTexImage2D : glenum ->
       int -> glenum -> int -> int -> int -> int -> glpointer -> unit

val glCompressedTexImage3D : glenum ->
       int ->
       glenum -> int -> int -> int -> int -> int -> glpointer -> unit

val glCompressedTexSubImage1D : glenum ->
       int -> int -> int -> glenum -> int -> glpointer -> unit

val glCompressedTexSubImage2D : glenum ->
       int ->
       int -> int -> int -> int -> glenum -> int -> glpointer -> unit

val glCompressedTexSubImage3D : glenum ->
       int ->
       int ->
       int ->
       int -> int -> int -> int -> glenum -> int -> glpointer -> unit

val glGetCompressedTexImage : glenum -> int -> glpointer -> unit

val glLoadTransposeMatrixd : float -> unit

val glLoadTransposeMatrixf : float -> unit

val glMultTransposeMatrixd : float -> unit

val glMultTransposeMatrixf : float -> unit

val glMultiTexCoord1d : glenum -> float -> unit

val glMultiTexCoord1dv : glenum -> double_array -> unit

val glMultiTexCoord1f : glenum -> float -> unit

val glMultiTexCoord1fv : glenum -> float_array -> unit

val glMultiTexCoord1i : glenum -> int -> unit

val glMultiTexCoord1iv : glenum -> int_array -> unit

val glMultiTexCoord1s : glenum -> int -> unit

val glMultiTexCoord1sv : glenum -> short_array -> unit

val glMultiTexCoord2d : glenum -> float -> float -> unit

val glMultiTexCoord2dv : glenum -> double_array -> unit

val glMultiTexCoord2f : glenum -> float -> float -> unit

val glMultiTexCoord2fv : glenum -> float_array -> unit

val glMultiTexCoord2i : glenum -> int -> int -> unit

val glMultiTexCoord2iv : glenum -> int_array -> unit

val glMultiTexCoord2s : glenum -> int -> int -> unit

val glMultiTexCoord2sv : glenum -> short_array -> unit

val glMultiTexCoord3d : glenum -> float -> float -> float -> unit

val glMultiTexCoord3dv : glenum -> double_array -> unit

val glMultiTexCoord3f : glenum -> float -> float -> float -> unit

val glMultiTexCoord3fv : glenum -> float_array -> unit

val glMultiTexCoord3i : glenum -> int -> int -> int -> unit

val glMultiTexCoord3iv : glenum -> int_array -> unit

val glMultiTexCoord3s : glenum -> int -> int -> int -> unit

val glMultiTexCoord3sv : glenum -> short_array -> unit

val glMultiTexCoord4d : glenum -> float -> float -> float -> float -> unit

val glMultiTexCoord4dv : glenum -> double_array -> unit

val glMultiTexCoord4f : glenum -> float -> float -> float -> float -> unit

val glMultiTexCoord4fv : glenum -> float_array -> unit

val glMultiTexCoord4i : glenum -> int -> int -> int -> int -> unit

val glMultiTexCoord4iv : glenum -> int_array -> unit

val glMultiTexCoord4s : glenum -> int -> int -> int -> int -> unit

val glMultiTexCoord4sv : glenum -> short_array -> unit

val glSampleCoverage : float -> bool -> unit

val glBlendEquation : glenum -> unit

val glBlendColor : float -> float -> float -> float -> unit

val glFogCoordf : float -> unit

val glFogCoordfv : float_array -> unit

val glFogCoordd : float -> unit

val glFogCoorddv : double_array -> unit

val glFogCoordPointer : glenum -> int -> glpointer -> unit

val glMultiDrawArrays : glenum -> int_array -> int_array -> int -> unit

val glMultiDrawElements : glenum ->
       int_array -> glenum -> glpointer -> int -> unit

val glPointParameterf : glenum -> float -> unit

val glPointParameterfv : glenum -> float_array -> unit

val glSecondaryColor3b : int -> int -> int -> unit

val glSecondaryColor3bv : byte_array -> unit

val glSecondaryColor3d : float -> float -> float -> unit

val glSecondaryColor3dv : double_array -> unit

val glSecondaryColor3f : float -> float -> float -> unit

val glSecondaryColor3fv : float_array -> unit

val glSecondaryColor3i : int -> int -> int -> unit

val glSecondaryColor3iv : int_array -> unit

val glSecondaryColor3s : int -> int -> int -> unit

val glSecondaryColor3sv : short_array -> unit

val glSecondaryColor3ub : int -> int -> int -> unit

val glSecondaryColor3ubv : ubyte_array -> unit

val glSecondaryColor3ui : int -> int -> int -> unit

val glSecondaryColor3uiv : int_array -> unit

val glSecondaryColor3us : int -> int -> int -> unit

val glSecondaryColor3usv : ushort_array -> unit

val glSecondaryColorPointer : int -> glenum -> int -> glpointer -> unit

val glBlendFuncSeparate : glenum -> glenum -> glenum -> glenum -> unit

val glWindowPos2d : float -> float -> unit

val glWindowPos2f : float -> float -> unit

val glWindowPos2i : int -> int -> unit

val glWindowPos2s : int -> int -> unit

val glWindowPos2dv : double_array -> unit

val glWindowPos2fv : float_array -> unit

val glWindowPos2iv : int_array -> unit

val glWindowPos2sv : short_array -> unit

val glWindowPos3d : float -> float -> float -> unit

val glWindowPos3f : float -> float -> float -> unit

val glWindowPos3i : int -> int -> int -> unit

val glWindowPos3s : int -> int -> int -> unit

val glWindowPos3dv : double_array -> unit

val glWindowPos3fv : float_array -> unit

val glWindowPos3iv : int_array -> unit

val glWindowPos3sv : short_array -> unit

val glGenQueries : int -> int_array -> unit

val glDeleteQueries : int -> int_array -> unit

val glIsQuery : int -> bool

val glBeginQuery : glenum -> int -> unit

val glEndQuery : glenum -> unit

val glGetQueryiv : glenum -> glenum -> int_array -> unit

val glGetQueryObjectiv : int -> glenum -> int_array -> unit

val glGetQueryObjectuiv : int -> glenum -> int_array -> unit

val glBindBuffer : glenum -> int -> unit

val glDeleteBuffers : int -> int_array -> unit

val glGenBuffers : int -> int_array -> unit

val glIsBuffer : int -> bool

val glBufferData : glenum -> int -> glpointer -> glenum -> unit

val glBufferSubData : glenum -> int -> int -> glpointer -> unit

val glGetBufferSubData : glenum -> int -> int -> glpointer -> unit

val glMapBuffer : glenum -> glenum -> glpointer

val glUnmapBuffer : glenum -> bool

val glGetBufferParameteriv : glenum -> glenum -> int_array -> unit

val glGetBufferPointerv : glenum -> glenum -> glpointer -> unit

val glBlendEquationSeparate : glenum -> glenum -> unit

val glDrawBuffers : int -> int_array -> unit

val glStencilOpSeparate : glenum -> glenum -> glenum -> glenum -> unit

val glStencilFuncSeparate : glenum -> glenum -> int -> int -> unit

val glStencilMaskSeparate : glenum -> int -> unit

val glAttachShader : int -> int -> unit

val glBindAttribLocation : int -> int -> byte_array -> unit

val glCompileShader : int -> unit

val glCreateProgram : unit -> int

val glCreateShader : glenum -> int

val glDeleteProgram : int -> unit

val glDeleteShader : int -> unit

val glDetachShader : int -> int -> unit

val glDisableVertexAttribArray : int -> unit

val glEnableVertexAttribArray : int -> unit

val glGetActiveAttrib : int ->
       int ->
       int ->
       int_array ->
       int_array -> int_array -> byte_array -> unit

val glGetActiveUniform : int ->
       int ->
       int ->
       int_array ->
       int_array -> int_array -> byte_array -> unit

val glGetAttachedShaders : int -> int -> int_array -> int_array -> unit

val glGetAttribLocation : int -> byte_array -> int

val glGetProgramiv : int -> glenum -> int_array -> unit

val glGetProgramInfoLog : int -> int -> int_array -> byte_array -> unit

val glGetShaderiv : int -> glenum -> int_array -> unit

val glGetShaderInfoLog : int -> int -> int_array -> byte_array -> unit

val glShaderSource : int -> int -> byte_matrix -> int_array -> unit

val glGetUniformLocation : int -> byte_array -> int

val glGetUniformfv : int -> int -> float_array -> unit

val glGetUniformiv : int -> int -> int_array -> unit

val glGetVertexAttribdv : int -> glenum -> double_array -> unit

val glGetVertexAttribfv : int -> glenum -> float_array -> unit

val glGetVertexAttribiv : int -> glenum -> int_array -> unit

val glGetVertexAttribPointerv : int -> glenum -> glpointer -> unit

val glIsProgram : int -> bool

val glIsShader : int -> bool

val glLinkProgram : int -> unit

val glGetShaderSource : int -> int -> int_array -> byte_array -> unit

val glUseProgram : int -> unit

val glUniform1f : int -> float -> unit

val glUniform1fv : int -> int -> float_array -> unit

val glUniform1i : int -> int -> unit

val glUniform1iv : int -> int -> int_array -> unit

val glUniform2f : int -> float -> float -> unit

val glUniform2fv : int -> int -> float_array -> unit

val glUniform2i : int -> int -> int -> unit

val glUniform2iv : int -> int -> int_array -> unit

val glUniform3f : int -> float -> float -> float -> unit

val glUniform3fv : int -> int -> float_array -> unit

val glUniform3i : int -> int -> int -> int -> unit

val glUniform3iv : int -> int -> int_array -> unit

val glUniform4f : int -> float -> float -> float -> float -> unit

val glUniform4fv : int -> int -> float_array -> unit

val glUniform4i : int -> int -> int -> int -> int -> unit

val glUniform4iv : int -> int -> int_array -> unit

val glUniformMatrix2fv : int -> int -> bool -> float_array -> unit

val glUniformMatrix3fv : int -> int -> bool -> float_array -> unit

val glUniformMatrix4fv : int -> int -> bool -> float_array -> unit

val glValidateProgram : int -> unit

val glVertexAttrib1d : int -> float -> unit

val glVertexAttrib1dv : int -> double_array -> unit

val glVertexAttrib1f : int -> float -> unit

val glVertexAttrib1fv : int -> float_array -> unit

val glVertexAttrib1s : int -> int -> unit

val glVertexAttrib1sv : int -> short_array -> unit

val glVertexAttrib2d : int -> float -> float -> unit

val glVertexAttrib2dv : int -> double_array -> unit

val glVertexAttrib2f : int -> float -> float -> unit

val glVertexAttrib2fv : int -> float_array -> unit

val glVertexAttrib2s : int -> int -> int -> unit

val glVertexAttrib2sv : int -> short_array -> unit

val glVertexAttrib3d : int -> float -> float -> float -> unit

val glVertexAttrib3dv : int -> double_array -> unit

val glVertexAttrib3f : int -> float -> float -> float -> unit

val glVertexAttrib3fv : int -> float_array -> unit

val glVertexAttrib3s : int -> int -> int -> int -> unit

val glVertexAttrib3sv : int -> short_array -> unit

val glVertexAttrib4Nbv : int -> byte_array -> unit

val glVertexAttrib4Niv : int -> int_array -> unit

val glVertexAttrib4Nsv : int -> short_array -> unit

val glVertexAttrib4Nub : int -> int -> int -> int -> int -> unit

val glVertexAttrib4Nubv : int -> ubyte_array -> unit

val glVertexAttrib4Nuiv : int -> int_array -> unit

val glVertexAttrib4Nusv : int -> ushort_array -> unit

val glVertexAttrib4bv : int -> byte_array -> unit

val glVertexAttrib4d : int -> float -> float -> float -> float -> unit

val glVertexAttrib4dv : int -> double_array -> unit

val glVertexAttrib4f : int -> float -> float -> float -> float -> unit

val glVertexAttrib4fv : int -> float_array -> unit

val glVertexAttrib4iv : int -> int_array -> unit

val glVertexAttrib4s : int -> int -> int -> int -> int -> unit

val glVertexAttrib4sv : int -> short_array -> unit

val glVertexAttrib4ubv : int -> ubyte_array -> unit

val glVertexAttrib4uiv : int -> int_array -> unit

val glVertexAttrib4usv : int -> ushort_array -> unit

val glVertexAttribPointer : int -> int -> glenum -> bool -> int -> glpointer -> unit