From: Scott Ludwig Date: Wed, 26 Mar 2014 17:06:05 +0000 (-0700) Subject: Merge branch 'master' of https://github.com/ValveSoftware/vogl X-Git-Url: https://git.notmuchmail.org/git?a=commitdiff_plain;h=1bc97f19153f59d0236f4081b2e8564260e6ce70;hp=93a92b59470fbe26110d3740a745ce329fb29f65;p=vogl Merge branch 'master' of https://github.com/ValveSoftware/vogl --- diff --git a/README.md b/README.md index 363e063..668f3ee 100644 --- a/README.md +++ b/README.md @@ -19,6 +19,8 @@ You should now be ready to build in your chroots. Something like any of these: Note that you do _not_ have to use the chroots or mkvogl.sh to build. You could do your own cmake (cmake vogl/src) and go from there. It's up to you to get the dependencies correct though. Look at vogl/bin/chroot_configure.sh to see how the chroots are set up. The source for mkvogl is in vogl/bin/src/mkvogl.cpp - it's just a simple cpp wrapper around cmake. +If you do use the chroots, do not build from within an encrypted home folder, as files in an encrypted home folder will not be visible from within the chroot, causing the build script to fail. + ## Capturing ## vogl/bin/steamlauncher.sh --gameid vogl/vogl_build/bin/glxspheres32 diff --git a/glspec/cpy_inc_files.sh b/glspec/cpy_inc_files.sh deleted file mode 100755 index 14f840c..0000000 --- a/glspec/cpy_inc_files.sh +++ /dev/null @@ -1,3 +0,0 @@ -cp *.inc ../src/voglinc -cp libvogltrace_linker_script.txt ../src/vogltrace - diff --git a/glspec/dbg_final_gl_glx_whitelisted_funcs.txt b/glspec/dbg_final_gl_glx_whitelisted_funcs.txt index 162c057..9be7ab3 100644 --- a/glspec/dbg_final_gl_glx_whitelisted_funcs.txt +++ b/glspec/dbg_final_gl_glx_whitelisted_funcs.txt @@ -184,8 +184,11 @@ glCreateShaderObjectARB glCullFace glCullParameterdvEXT glCullParameterfvEXT +glDebugMessageCallback glDebugMessageCallbackARB +glDebugMessageControl glDebugMessageControlARB +glDebugMessageInsert glDebugMessageInsertARB glDeleteBuffers glDeleteBuffersARB @@ -882,6 +885,8 @@ glNormalP3ui glNormalP3uiv glNormalPointer glNormalPointerEXT +glObjectLabel +glObjectPtrLabel glOrtho glPassThrough glPixelMapfv @@ -907,6 +912,7 @@ glPolygonOffsetEXT glPolygonStipple glPopAttrib glPopClientAttrib +glPopDebugGroup glPopMatrix glPopName glPrimitiveRestartIndex @@ -964,6 +970,7 @@ glProvokingVertex glProvokingVertexEXT glPushAttrib glPushClientAttrib +glPushDebugGroup glPushMatrix glPushName glQueryCounter diff --git a/glspec/dbg_gl_all_funcs.txt b/glspec/dbg_gl_all_funcs.txt index a4c487c..fd60019 100644 --- a/glspec/dbg_gl_all_funcs.txt +++ b/glspec/dbg_gl_all_funcs.txt @@ -5640,12 +5640,12 @@ Name: "DebugMessageCallback", ParamNames: 2, Params: 2, Return: "void", Category Name: "GetDebugMessageLog", ParamNames: 8, Params: 8, Return: "UInt32", Category: "KHR_debug", Version: "4.3", Profile: "", Deprecated: "", Lib: "gl" notlistable: 1 Name: "count", Type: "UInt32", Direction: "in", Semantic: "value", ArraySize: "", Retained: 0 Name: "bufsize", Type: "SizeI", Direction: "in", Semantic: "value", ArraySize: "", Retained: 0 - Name: "sources", Type: "GLenum", Direction: "out", Semantic: "array", ArraySize: "[COMPSIZE(count)]", Retained: 0 - Name: "types", Type: "GLenum", Direction: "out", Semantic: "array", ArraySize: "[COMPSIZE(count)]", Retained: 0 - Name: "ids", Type: "UInt32", Direction: "out", Semantic: "array", ArraySize: "[COMPSIZE(count)]", Retained: 0 - Name: "severities", Type: "GLenum", Direction: "out", Semantic: "array", ArraySize: "[COMPSIZE(count)]", Retained: 0 - Name: "lengths", Type: "SizeI", Direction: "out", Semantic: "array", ArraySize: "[COMPSIZE(count)]", Retained: 0 - Name: "messageLog", Type: "Char", Direction: "out", Semantic: "array", ArraySize: "[COMPSIZE(bufsize)]", Retained: 0 + Name: "sources", Type: "GLenum", Direction: "out", Semantic: "array", ArraySize: "[count]", Retained: 0 + Name: "types", Type: "GLenum", Direction: "out", Semantic: "array", ArraySize: "[count]", Retained: 0 + Name: "ids", Type: "UInt32", Direction: "out", Semantic: "array", ArraySize: "[count]", Retained: 0 + Name: "severities", Type: "GLenum", Direction: "out", Semantic: "array", ArraySize: "[count]", Retained: 0 + Name: "lengths", Type: "SizeI", Direction: "out", Semantic: "array", ArraySize: "[count]", Retained: 0 + Name: "messageLog", Type: "Char", Direction: "out", Semantic: "array", ArraySize: "[bufsize]", Retained: 0 Name: "PushDebugGroup", ParamNames: 4, Params: 4, Return: "void", Category: "KHR_debug", Version: "4.3", Profile: "", Deprecated: "", Lib: "gl" notlistable: 0 Name: "source", Type: "GLenum", Direction: "in", Semantic: "value", ArraySize: "", Retained: 0 diff --git a/glspec/dbg_gl_funcs.txt b/glspec/dbg_gl_funcs.txt index c8775f0..faf63cf 100644 --- a/glspec/dbg_gl_funcs.txt +++ b/glspec/dbg_gl_funcs.txt @@ -5640,12 +5640,12 @@ Name: "DebugMessageCallback", ParamNames: 2, Params: 2, Return: "void", Category Name: "GetDebugMessageLog", ParamNames: 8, Params: 8, Return: "UInt32", Category: "KHR_debug", Version: "4.3", Profile: "", Deprecated: "", Lib: "gl" notlistable: 1 Name: "count", Type: "UInt32", Direction: "in", Semantic: "value", ArraySize: "", Retained: 0 Name: "bufsize", Type: "SizeI", Direction: "in", Semantic: "value", ArraySize: "", Retained: 0 - Name: "sources", Type: "GLenum", Direction: "out", Semantic: "array", ArraySize: "[COMPSIZE(count)]", Retained: 0 - Name: "types", Type: "GLenum", Direction: "out", Semantic: "array", ArraySize: "[COMPSIZE(count)]", Retained: 0 - Name: "ids", Type: "UInt32", Direction: "out", Semantic: "array", ArraySize: "[COMPSIZE(count)]", Retained: 0 - Name: "severities", Type: "GLenum", Direction: "out", Semantic: "array", ArraySize: "[COMPSIZE(count)]", Retained: 0 - Name: "lengths", Type: "SizeI", Direction: "out", Semantic: "array", ArraySize: "[COMPSIZE(count)]", Retained: 0 - Name: "messageLog", Type: "Char", Direction: "out", Semantic: "array", ArraySize: "[COMPSIZE(bufsize)]", Retained: 0 + Name: "sources", Type: "GLenum", Direction: "out", Semantic: "array", ArraySize: "[count]", Retained: 0 + Name: "types", Type: "GLenum", Direction: "out", Semantic: "array", ArraySize: "[count]", Retained: 0 + Name: "ids", Type: "UInt32", Direction: "out", Semantic: "array", ArraySize: "[count]", Retained: 0 + Name: "severities", Type: "GLenum", Direction: "out", Semantic: "array", ArraySize: "[count]", Retained: 0 + Name: "lengths", Type: "SizeI", Direction: "out", Semantic: "array", ArraySize: "[count]", Retained: 0 + Name: "messageLog", Type: "Char", Direction: "out", Semantic: "array", ArraySize: "[bufsize]", Retained: 0 Name: "PushDebugGroup", ParamNames: 4, Params: 4, Return: "void", Category: "KHR_debug", Version: "4.3", Profile: "", Deprecated: "", Lib: "gl" notlistable: 0 Name: "source", Type: "GLenum", Direction: "in", Semantic: "value", ArraySize: "", Retained: 0 diff --git a/glspec/dbg_gl_glx_array_sizes.txt b/glspec/dbg_gl_glx_array_sizes.txt index 3327d90..a76ac9c 100644 --- a/glspec/dbg_gl_glx_array_sizes.txt +++ b/glspec/dbg_gl_glx_array_sizes.txt @@ -9,7 +9,6 @@ [COMPSIZE(attribute)] [COMPSIZE(buf,length)] [COMPSIZE(buffer)] -[COMPSIZE(bufsize)] [COMPSIZE(count)] [COMPSIZE(count,type)] [COMPSIZE(drawcount,stride)] diff --git a/glspec/gl.spec b/glspec/gl.spec index 64c356f..ca6c273 100644 --- a/glspec/gl.spec +++ b/glspec/gl.spec @@ -15495,12 +15495,12 @@ GetDebugMessageLog(count, bufsize, sources, types, ids, severities, lengths, mes return UInt32 param count UInt32 in value param bufsize SizeI in value - param sources GLenum out array [COMPSIZE(count)] - param types GLenum out array [COMPSIZE(count)] - param ids UInt32 out array [COMPSIZE(count)] - param severities GLenum out array [COMPSIZE(count)] - param lengths SizeI out array [COMPSIZE(count)] - param messageLog Char out array [COMPSIZE(bufsize)] + param sources GLenum out array [count] + param types GLenum out array [count] + param ids UInt32 out array [count] + param severities GLenum out array [count] + param lengths SizeI out array [count] + param messageLog Char out array [bufsize] category KHR_debug dlflags notlistable version 4.3 diff --git a/glspec/gl_glx_displaylist_whitelist.txt b/glspec/gl_glx_displaylist_whitelist.txt index c555b9f..034503d 100644 --- a/glspec/gl_glx_displaylist_whitelist.txt +++ b/glspec/gl_glx_displaylist_whitelist.txt @@ -91,3 +91,5 @@ glTextureSubImage[1-2]DEXT glTranslate[f|d] glVertex[2|3|4][f|d|i|s]v? glViewport +glTexGen[i|f|d] +glMaterial[f|i]v? diff --git a/glspec/gl_glx_simple_replay_funcs.txt b/glspec/gl_glx_simple_replay_funcs.txt index 38f311e..bc0f584 100644 --- a/glspec/gl_glx_simple_replay_funcs.txt +++ b/glspec/gl_glx_simple_replay_funcs.txt @@ -648,3 +648,7 @@ glWindowPos3s glWindowPos3sARB glWindowPos3sv glWindowPos3svARB +glPopDebugGroup +glDebugMessageControl +glDebugMessageControlARB +glPushDebugGroup diff --git a/glspec/gl_glx_whitelisted_funcs.txt b/glspec/gl_glx_whitelisted_funcs.txt index 6a63034..4ac6be1 100644 --- a/glspec/gl_glx_whitelisted_funcs.txt +++ b/glspec/gl_glx_whitelisted_funcs.txt @@ -58,7 +58,6 @@ glCreateProgramObjectARB glCreateShader glCreateShaderObjectARB glDebugMessageCallbackARB -glDebugMessageControlARB glDebugMessageInsertARB glDeleteBuffers glDeleteBuffersARB @@ -192,7 +191,6 @@ glGetConvolutionParameterfvEXT glGetConvolutionParameteriv glGetConvolutionParameterivEXT glGetConvolutionParameterxvOES -glGetDebugMessageLog glGetDebugMessageLogAMD glGetDebugMessageLogARB glGetDetailTexFuncSGIS @@ -322,11 +320,9 @@ glGetnUniformivARB glGetnUniformuivARB glGetObjectBufferfvATI glGetObjectBufferivATI -glGetObjectLabel glGetObjectParameterfvARB glGetObjectParameterivAPPLE glGetObjectParameterivARB -glGetObjectPtrLabel glGetOcclusionQueryivNV glGetOcclusionQueryuivNV glGetPathColorGenfvNV @@ -730,3 +726,10 @@ glXSwapIntervalSGI glXUseXFont glXWaitGL glXWaitX +glDebugMessageInsert +glDebugMessageCallback +glObjectLabel +glObjectPtrLabel +glGetObjectLabel +glGetObjectPtrLabel +glGetDebugMessageLog diff --git a/src/build_options.cmake b/src/build_options.cmake index 396a1c9..602e19f 100644 --- a/src/build_options.cmake +++ b/src/build_options.cmake @@ -94,7 +94,7 @@ if ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang") "-Wno-padded" "-Wno-variadic-macros" ) - elseif () + elseif (CLANG_ANALYZE) set(CMAKE_CXX_FLAGS_LIST ${CMAKE_CXX_FLAGS_LIST} "--analyze" "-ferror-limit=0" # Don't ever stop emitting diagnostics diff --git a/src/voglbench/CMakeLists.txt b/src/voglbench/CMakeLists.txt index 52f9e62..5be403d 100644 --- a/src/voglbench/CMakeLists.txt +++ b/src/voglbench/CMakeLists.txt @@ -7,9 +7,9 @@ find_package(X11 REQUIRED) include_directories( ${CMAKE_CURRENT_BINARY_DIR} ${SRC_DIR}/voglcore - ${SRC_DIR}/voglinc + ${CMAKE_BINARY_DIR}/voglinc ${SRC_DIR}/voglcommon - ${SRC_DIR}/libtelemetry + ${SRC_DIR}/libtelemetry ${SRC_DIR}/extlib/loki/include/loki ) @@ -18,6 +18,7 @@ set(SRC_LIST ) add_executable(${PROJECT_NAME} ${SRC_LIST}) +add_dependencies(${PROJECT_NAME} voglgen_make_inc) target_link_libraries(${PROJECT_NAME} ${TELEMETRY_LIBRARY} diff --git a/src/voglbench/voglbench.cpp b/src/voglbench/voglbench.cpp index a7fdad1..92971af 100644 --- a/src/voglbench/voglbench.cpp +++ b/src/voglbench/voglbench.cpp @@ -70,6 +70,7 @@ static command_line_param_desc g_command_line_param_descs[] = { { "width", 1, false, "Replay: Set initial window width (default is 1024)" }, { "height", 1, false, "Replay: Set initial window height (default is 768)" }, + { "msaa", 1, false, "Replay: Set initial window multisamples (default is 0)" }, { "lock_window_dimensions", 0, false, "Replay: Don't automatically change window's dimensions during replay" }, { "endless", 0, false, "Replay: Loop replay endlessly instead of exiting" }, { "force_debug_context", 0, false, "Replay: Force GL debug contexts" }, @@ -397,7 +398,7 @@ static bool tool_replay_mode() // TODO: This will create a window with default attributes, which seems fine for the majority of traces. // Unfortunately, some GL call streams *don't* want an alpha channel, or depth, or stencil etc. in the default framebuffer so this may become a problem. // Also, this design only supports a single window, which is going to be a problem with multiple window traces. - if (!window.open(g_command_line_params.get_value_as_int("width", 0, 1024, 1, 65535), g_command_line_params.get_value_as_int("height", 0, 768, 1, 65535))) + if (!window.open(g_command_line_params.get_value_as_int("width", 0, 1024, 1, 65535), g_command_line_params.get_value_as_int("height", 0, 768, 1, 65535), g_command_line_params.get_value_as_int("msaa", 0, 0, 0, 65535))) { vogl_error_printf("%s: Failed initializing replay window\n", VOGL_FUNCTION_NAME); return false; diff --git a/src/voglcommon/CMakeLists.txt b/src/voglcommon/CMakeLists.txt index 222bf53..960e854 100644 --- a/src/voglcommon/CMakeLists.txt +++ b/src/voglcommon/CMakeLists.txt @@ -6,7 +6,7 @@ include("${SRC_DIR}/build_options.cmake") include_directories( ${SRC_DIR}/extlib/loki/include/loki ${SRC_DIR}/voglcommon - ${SRC_DIR}/voglinc + ${CMAKE_BINARY_DIR}/voglinc ${SRC_DIR}/voglcore ${SRC_DIR}/libtelemetry ${SRC_DIR}/libbacktrace @@ -69,6 +69,7 @@ endif() add_compiler_flag("-fPIC") add_library(${PROJECT_NAME} ${SRC_LIST}) +add_dependencies(${PROJECT_NAME} voglgen_make_inc) target_link_libraries(${PROJECT_NAME} backtrace) build_options_finalize() diff --git a/src/voglcommon/gl_gets.inc b/src/voglcommon/gl_gets.inc index 69a5943..cd7211c 100644 --- a/src/voglcommon/gl_gets.inc +++ b/src/voglcommon/gl_gets.inc @@ -484,6 +484,8 @@ DEFINE_GL_GET(GL_MAX_COLOR_ATTACHMENTS, 0x0030, 0x99) // Not sure about the version of the VAO binding DEFINE_GL_GET(GL_VERTEX_ARRAY_BINDING, 0x0030, 0x99) +DEFINE_GL_INDEXED_GET(GL_BLEND, 0x030, 0x99, GL_MAX_DRAW_BUFFERS) + // Start of version 3.1 - DEFINE_GL_GET(GL_MAX_RECTANGLE_TEXTURE_SIZE, 0x0031, 0x99) DEFINE_GL_GET(GL_MAX_TEXTURE_BUFFER_SIZE, 0x0031, 0x99) diff --git a/src/voglcommon/gl_pname_defs.h b/src/voglcommon/gl_pname_defs.h new file mode 100644 index 0000000..da8fd5c --- /dev/null +++ b/src/voglcommon/gl_pname_defs.h @@ -0,0 +1,3293 @@ +// Originally from apitrace, then heavily modified/fixed +// +// Shorthands for the types +// Note: types MUST me consistent with the vogl_state_type enum +// X = None # To be determined, merely an enum +// B = GLboolean +// I = GLint +// i = GLint64 +// U = GLuint +// E = GLenum +// F = GLfloat +// D = GLdouble +// P = OpaquePointer(Void) +// S = CString +// H = GLhandleARB + +// (functions, type, count, name) # value + +// Important note: functions must be "glGet" or "glGet,glGeti" for vogl_general_context_state::snapshot_state() to retrieve the state via glGet()! + +struct gl_pname_def_t +{ + const char *m_pFuncs; + char m_type; + int m_count; + const char *m_pName; + uint m_gl_enum; +}; + +#ifndef VOGL_DECLARE_PNAME_DEF_TABLE + extern const gl_pname_def_t g_gl_pname_defs[]; +#else + extern const gl_pname_def_t g_gl_pname_defs[] = + { + { "", 'X', 1, "GL_ZERO", 0x0000}, + { "", 'X', 1, "GL_ONE", 0x0001}, + // TODO: These are duplicates + //{ "", 'X', 1, "GL_POINTS", 0x0000}, + //{ "", 'X', 1, "GL_LINES", 0x0001}, + { "", 'X', 1, "GL_LINE_LOOP", 0x0002}, + { "", 'X', 1, "GL_LINE_STRIP", 0x0003}, + { "", 'X', 1, "GL_TRIANGLES", 0x0004}, + { "", 'X', 1, "GL_TRIANGLE_STRIP", 0x0005}, + { "", 'X', 1, "GL_TRIANGLE_FAN", 0x0006}, + { "", 'X', 1, "GL_QUADS", 0x0007}, + { "", 'X', 1, "GL_QUAD_STRIP", 0x0008}, + { "", 'X', 1, "GL_POLYGON", 0x0009}, + { "", 'X', 1, "GL_LINES_ADJACENCY", 0x000A}, + { "", 'X', 1, "GL_LINE_STRIP_ADJACENCY", 0x000B}, + { "", 'X', 1, "GL_TRIANGLES_ADJACENCY", 0x000C}, + { "", 'X', 1, "GL_TRIANGLE_STRIP_ADJACENCY", 0x000D}, + { "", 'X', 1, "GL_PATCHES", 0x000E}, + { "", 'X', 1, "GL_ACCUM", 0x0100}, + { "", 'X', 1, "GL_LOAD", 0x0101}, + { "", 'X', 1, "GL_RETURN", 0x0102}, + { "", 'X', 1, "GL_MULT", 0x0103}, + { "", 'X', 1, "GL_ADD", 0x0104}, + { "", 'X', 1, "GL_NEVER", 0x0200}, + { "", 'X', 1, "GL_LESS", 0x0201}, + { "", 'X', 1, "GL_EQUAL", 0x0202}, + { "", 'X', 1, "GL_LEQUAL", 0x0203}, + { "", 'X', 1, "GL_GREATER", 0x0204}, + { "", 'X', 1, "GL_NOTEQUAL", 0x0205}, + { "", 'X', 1, "GL_GEQUAL", 0x0206}, + { "", 'X', 1, "GL_ALWAYS", 0x0207}, + { "", 'X', 1, "GL_SRC_COLOR", 0x0300}, + { "", 'X', 1, "GL_ONE_MINUS_SRC_COLOR", 0x0301}, + { "", 'X', 1, "GL_SRC_ALPHA", 0x0302}, + { "", 'X', 1, "GL_ONE_MINUS_SRC_ALPHA", 0x0303}, + { "", 'X', 1, "GL_DST_ALPHA", 0x0304}, + { "", 'X', 1, "GL_ONE_MINUS_DST_ALPHA", 0x0305}, + { "", 'X', 1, "GL_DST_COLOR", 0x0306}, + { "", 'X', 1, "GL_ONE_MINUS_DST_COLOR", 0x0307}, + { "", 'X', 1, "GL_SRC_ALPHA_SATURATE", 0x0308}, + { "", 'X', 1, "GL_FRONT_LEFT", 0x0400}, + { "", 'X', 1, "GL_FRONT_RIGHT", 0x0401}, + { "", 'X', 1, "GL_BACK_LEFT", 0x0402}, + { "", 'X', 1, "GL_BACK_RIGHT", 0x0403}, + { "", 'X', 1, "GL_FRONT", 0x0404}, + { "", 'X', 1, "GL_BACK", 0x0405}, + { "", 'X', 1, "GL_LEFT", 0x0406}, + { "", 'X', 1, "GL_RIGHT", 0x0407}, + { "", 'X', 1, "GL_FRONT_AND_BACK", 0x0408}, + { "", 'X', 1, "GL_AUX0", 0x0409}, + { "", 'X', 1, "GL_AUX1", 0x040A}, + { "", 'X', 1, "GL_AUX2", 0x040B}, + { "", 'X', 1, "GL_AUX3", 0x040C}, + { "", 'X', 1, "GL_INVALID_ENUM", 0x0500}, + { "", 'X', 1, "GL_INVALID_VALUE", 0x0501}, + { "", 'X', 1, "GL_INVALID_OPERATION", 0x0502}, + { "", 'X', 1, "GL_STACK_OVERFLOW", 0x0503}, + { "", 'X', 1, "GL_STACK_UNDERFLOW", 0x0504}, + { "", 'X', 1, "GL_OUT_OF_MEMORY", 0x0505}, + { "", 'X', 1, "GL_INVALID_FRAMEBUFFER_OPERATION", 0x0506}, + { "", 'X', 1, "GL_2D", 0x0600}, + { "", 'X', 1, "GL_3D", 0x0601}, + { "", 'X', 1, "GL_3D_COLOR", 0x0602}, + { "", 'X', 1, "GL_3D_COLOR_TEXTURE", 0x0603}, + { "", 'X', 1, "GL_4D_COLOR_TEXTURE", 0x0604}, + { "", 'X', 1, "GL_PASS_THROUGH_TOKEN", 0x0700}, + { "", 'X', 1, "GL_POINT_TOKEN", 0x0701}, + { "", 'X', 1, "GL_LINE_TOKEN", 0x0702}, + { "", 'X', 1, "GL_POLYGON_TOKEN", 0x0703}, + { "", 'X', 1, "GL_BITMAP_TOKEN", 0x0704}, + { "", 'X', 1, "GL_DRAW_PIXEL_TOKEN", 0x0705}, + { "", 'X', 1, "GL_COPY_PIXEL_TOKEN", 0x0706}, + { "", 'X', 1, "GL_LINE_RESET_TOKEN", 0x0707}, + { "", 'X', 1, "GL_EXP", 0x0800}, + { "", 'X', 1, "GL_EXP2", 0x0801}, + { "", 'X', 1, "GL_CW", 0x0900}, + { "", 'X', 1, "GL_CCW", 0x0901}, + { "", 'X', 1, "GL_COEFF", 0x0A00}, + { "", 'X', 1, "GL_ORDER", 0x0A01}, + { "", 'X', 1, "GL_DOMAIN", 0x0A02}, + { "glGet", 'F', 4, "GL_CURRENT_COLOR", 0x0B00}, + { "glGet", 'F', 1, "GL_CURRENT_INDEX", 0x0B01}, + { "glGet", 'F', 3, "GL_CURRENT_NORMAL", 0x0B02}, + { "glGet", 'F', 4, "GL_CURRENT_TEXTURE_COORDS", 0x0B03}, + { "glGet", 'F', 4, "GL_CURRENT_RASTER_COLOR", 0x0B04}, + { "glGet", 'F', 1, "GL_CURRENT_RASTER_INDEX", 0x0B05}, + { "glGet", 'F', 4, "GL_CURRENT_RASTER_TEXTURE_COORDS", 0x0B06}, + { "glGet", 'F', 4, "GL_CURRENT_RASTER_POSITION", 0x0B07}, + { "glGet", 'I', 1, "GL_CURRENT_RASTER_POSITION_VALID", 0x0B08}, + { "glGet", 'F', 1, "GL_CURRENT_RASTER_DISTANCE", 0x0B09}, + { "glGet", 'B', 1, "GL_POINT_SMOOTH", 0x0B10}, + { "glGet", 'F', 1, "GL_POINT_SIZE", 0x0B11}, + { "glGet", 'F', 2, "GL_POINT_SIZE_RANGE", 0x0B12}, + { "glGet", 'F', 1, "GL_POINT_SIZE_GRANULARITY", 0x0B13}, + { "glGet", 'B', 1, "GL_LINE_SMOOTH", 0x0B20}, + { "glGet", 'F', 1, "GL_LINE_WIDTH", 0x0B21}, + { "glGet", 'F', 2, "GL_LINE_WIDTH_RANGE", 0x0B22}, + { "glGet", 'F', 1, "GL_LINE_WIDTH_GRANULARITY", 0x0B23}, + { "glGet", 'B', 1, "GL_LINE_STIPPLE", 0x0B24}, + { "glGet", 'I', 1, "GL_LINE_STIPPLE_PATTERN", 0x0B25}, + { "glGet", 'I', 1, "GL_LINE_STIPPLE_REPEAT", 0x0B26}, + { "glGet", 'E', 1, "GL_LIST_MODE", 0x0B30}, + { "glGet", 'I', 1, "GL_MAX_LIST_NESTING", 0x0B31}, + { "glGet", 'I', 1, "GL_LIST_BASE", 0x0B32}, + { "glGet", 'I', 1, "GL_LIST_INDEX", 0x0B33}, + { "glGet", 'E', 2, "GL_POLYGON_MODE", 0x0B40}, + { "glGet", 'B', 1, "GL_POLYGON_SMOOTH", 0x0B41}, + { "glGet", 'B', 1, "GL_POLYGON_STIPPLE", 0x0B42}, + { "glGet", 'B', 1, "GL_EDGE_FLAG", 0x0B43}, + { "glGet", 'B', 1, "GL_CULL_FACE", 0x0B44}, + { "glGet", 'E', 1, "GL_CULL_FACE_MODE", 0x0B45}, + { "glGet", 'E', 1, "GL_FRONT_FACE", 0x0B46}, + { "glGet", 'B', 1, "GL_LIGHTING", 0x0B50}, + { "glGet", 'B', 1, "GL_LIGHT_MODEL_LOCAL_VIEWER", 0x0B51}, + { "glGet", 'B', 1, "GL_LIGHT_MODEL_TWO_SIDE", 0x0B52}, + { "glGet", 'F', 4, "GL_LIGHT_MODEL_AMBIENT", 0x0B53}, + { "glGet", 'E', 1, "GL_SHADE_MODEL", 0x0B54}, + { "glGet", 'E', 1, "GL_COLOR_MATERIAL_FACE", 0x0B55}, + { "glGet", 'E', 1, "GL_COLOR_MATERIAL_PARAMETER", 0x0B56}, + { "glGet", 'B', 1, "GL_COLOR_MATERIAL", 0x0B57}, + { "glGet", 'B', 1, "GL_FOG", 0x0B60}, + { "glGet", 'I', 1, "GL_FOG_INDEX", 0x0B61}, + { "glGet", 'F', 1, "GL_FOG_DENSITY", 0x0B62}, + { "glGet", 'F', 1, "GL_FOG_START", 0x0B63}, + { "glGet", 'F', 1, "GL_FOG_END", 0x0B64}, + { "glGet", 'E', 1, "GL_FOG_MODE", 0x0B65}, + { "glGet", 'F', 4, "GL_FOG_COLOR", 0x0B66}, + { "glGet", 'D', 2, "GL_DEPTH_RANGE", 0x0B70}, + { "glGet", 'B', 1, "GL_DEPTH_TEST", 0x0B71}, + { "glGet", 'B', 1, "GL_DEPTH_WRITEMASK", 0x0B72}, + { "glGet", 'D', 1, "GL_DEPTH_CLEAR_VALUE", 0x0B73}, + { "glGet", 'E', 1, "GL_DEPTH_FUNC", 0x0B74}, + { "glGet", 'F', 4, "GL_ACCUM_CLEAR_VALUE", 0x0B80}, + { "glGet", 'B', 1, "GL_STENCIL_TEST", 0x0B90}, + { "glGet", 'I', 1, "GL_STENCIL_CLEAR_VALUE", 0x0B91}, + { "glGet", 'E', 1, "GL_STENCIL_FUNC", 0x0B92}, + { "glGet", 'I', 1, "GL_STENCIL_VALUE_MASK", 0x0B93}, + { "glGet", 'E', 1, "GL_STENCIL_FAIL", 0x0B94}, + { "glGet", 'E', 1, "GL_STENCIL_PASS_DEPTH_FAIL", 0x0B95}, + { "glGet", 'E', 1, "GL_STENCIL_PASS_DEPTH_PASS", 0x0B96}, + { "glGet", 'I', 1, "GL_STENCIL_REF", 0x0B97}, + { "glGet", 'I', 1, "GL_STENCIL_WRITEMASK", 0x0B98}, + { "glGet", 'E', 1, "GL_MATRIX_MODE", 0x0BA0}, + { "glGet", 'B', 1, "GL_NORMALIZE", 0x0BA1}, + { "glGet,glGetI", 'I', 4, "GL_VIEWPORT", 0x0BA2}, + { "glGet", 'I', 1, "GL_MODELVIEW_STACK_DEPTH", 0x0BA3}, + { "glGet", 'I', 1, "GL_PROJECTION_STACK_DEPTH", 0x0BA4}, + { "glGet", 'I', 1, "GL_TEXTURE_STACK_DEPTH", 0x0BA5}, + { "glGet", 'F', 16, "GL_MODELVIEW_MATRIX", 0x0BA6}, + { "glGet", 'F', 16, "GL_PROJECTION_MATRIX", 0x0BA7}, + { "glGet", 'F', 16, "GL_TEXTURE_MATRIX", 0x0BA8}, + { "glGet", 'I', 1, "GL_ATTRIB_STACK_DEPTH", 0x0BB0}, + { "glGet", 'I', 1, "GL_CLIENT_ATTRIB_STACK_DEPTH", 0x0BB1}, + { "glGet", 'B', 1, "GL_ALPHA_TEST", 0x0BC0}, + { "glGet", 'E', 1, "GL_ALPHA_TEST_FUNC", 0x0BC1}, + { "glGet", 'F', 1, "GL_ALPHA_TEST_REF", 0x0BC2}, + { "glGet", 'B', 1, "GL_DITHER", 0x0BD0}, + { "glGet", 'E', 1, "GL_BLEND_DST", 0x0BE0}, + { "glGet", 'E', 1, "GL_BLEND_SRC", 0x0BE1}, + { "glGet,glGetI", 'B', 1, "GL_BLEND", 0x0BE2}, + { "glGet", 'E', 1, "GL_LOGIC_OP_MODE", 0x0BF0}, + { "glGet", 'B', 1, "GL_INDEX_LOGIC_OP", 0x0BF1}, + { "glGet", 'B', 1, "GL_COLOR_LOGIC_OP", 0x0BF2}, + { "glGet", 'I', 1, "GL_AUX_BUFFERS", 0x0C00}, + { "glGet", 'E', 1, "GL_DRAW_BUFFER", 0x0C01}, + { "glGet", 'E', 1, "GL_READ_BUFFER", 0x0C02}, + { "glGet", 'I', 4, "GL_SCISSOR_BOX", 0x0C10}, + { "glGet", 'B', 1, "GL_SCISSOR_TEST", 0x0C11}, + { "glGet", 'I', 1, "GL_INDEX_CLEAR_VALUE", 0x0C20}, + { "glGet", 'I', 1, "GL_INDEX_WRITEMASK", 0x0C21}, + { "glGet", 'F', 4, "GL_COLOR_CLEAR_VALUE", 0x0C22}, + { "glGet", 'B', 4, "GL_COLOR_WRITEMASK", 0x0C23}, + { "glGet", 'B', 1, "GL_INDEX_MODE", 0x0C30}, + { "glGet", 'B', 1, "GL_RGBA_MODE", 0x0C31}, + { "glGet", 'B', 1, "GL_DOUBLEBUFFER", 0x0C32}, + { "glGet", 'B', 1, "GL_STEREO", 0x0C33}, + { "glGet", 'E', 1, "GL_RENDER_MODE", 0x0C40}, + { "glGet", 'E', 1, "GL_PERSPECTIVE_CORRECTION_HINT", 0x0C50}, + { "glGet", 'E', 1, "GL_POINT_SMOOTH_HINT", 0x0C51}, + { "glGet", 'E', 1, "GL_LINE_SMOOTH_HINT", 0x0C52}, + { "glGet", 'E', 1, "GL_POLYGON_SMOOTH_HINT", 0x0C53}, + { "glGet", 'E', 1, "GL_FOG_HINT", 0x0C54}, + { "glGet", 'B', 1, "GL_TEXTURE_GEN_S", 0x0C60}, + { "glGet", 'B', 1, "GL_TEXTURE_GEN_T", 0x0C61}, + { "glGet", 'B', 1, "GL_TEXTURE_GEN_R", 0x0C62}, + { "glGet", 'B', 1, "GL_TEXTURE_GEN_Q", 0x0C63}, + { "", 'X', 1, "GL_PIXEL_MAP_I_TO_I", 0x0C70}, + { "", 'X', 1, "GL_PIXEL_MAP_S_TO_S", 0x0C71}, + { "", 'X', 1, "GL_PIXEL_MAP_I_TO_R", 0x0C72}, + { "", 'X', 1, "GL_PIXEL_MAP_I_TO_G", 0x0C73}, + { "", 'X', 1, "GL_PIXEL_MAP_I_TO_B", 0x0C74}, + { "", 'X', 1, "GL_PIXEL_MAP_I_TO_A", 0x0C75}, + { "", 'X', 1, "GL_PIXEL_MAP_R_TO_R", 0x0C76}, + { "", 'X', 1, "GL_PIXEL_MAP_G_TO_G", 0x0C77}, + { "", 'X', 1, "GL_PIXEL_MAP_B_TO_B", 0x0C78}, + { "", 'X', 1, "GL_PIXEL_MAP_A_TO_A", 0x0C79}, + { "glGet", 'I', 1, "GL_PIXEL_MAP_I_TO_I_SIZE", 0x0CB0}, + { "glGet", 'I', 1, "GL_PIXEL_MAP_S_TO_S_SIZE", 0x0CB1}, + { "glGet", 'I', 1, "GL_PIXEL_MAP_I_TO_R_SIZE", 0x0CB2}, + { "glGet", 'I', 1, "GL_PIXEL_MAP_I_TO_G_SIZE", 0x0CB3}, + { "glGet", 'I', 1, "GL_PIXEL_MAP_I_TO_B_SIZE", 0x0CB4}, + { "glGet", 'I', 1, "GL_PIXEL_MAP_I_TO_A_SIZE", 0x0CB5}, + { "glGet", 'I', 1, "GL_PIXEL_MAP_R_TO_R_SIZE", 0x0CB6}, + { "glGet", 'I', 1, "GL_PIXEL_MAP_G_TO_G_SIZE", 0x0CB7}, + { "glGet", 'I', 1, "GL_PIXEL_MAP_B_TO_B_SIZE", 0x0CB8}, + { "glGet", 'I', 1, "GL_PIXEL_MAP_A_TO_A_SIZE", 0x0CB9}, + { "glGet", 'B', 1, "GL_UNPACK_SWAP_BYTES", 0x0CF0}, + { "glGet", 'B', 1, "GL_UNPACK_LSB_FIRST", 0x0CF1}, + { "glGet", 'I', 1, "GL_UNPACK_ROW_LENGTH", 0x0CF2}, + { "glGet", 'I', 1, "GL_UNPACK_SKIP_ROWS", 0x0CF3}, + { "glGet", 'I', 1, "GL_UNPACK_SKIP_PIXELS", 0x0CF4}, + { "glGet", 'I', 1, "GL_UNPACK_ALIGNMENT", 0x0CF5}, + { "glGet", 'B', 1, "GL_PACK_SWAP_BYTES", 0x0D00}, + { "glGet", 'B', 1, "GL_PACK_LSB_FIRST", 0x0D01}, + { "glGet", 'I', 1, "GL_PACK_ROW_LENGTH", 0x0D02}, + { "glGet", 'I', 1, "GL_PACK_SKIP_ROWS", 0x0D03}, + { "glGet", 'I', 1, "GL_PACK_SKIP_PIXELS", 0x0D04}, + { "glGet", 'I', 1, "GL_PACK_ALIGNMENT", 0x0D05}, + { "glGet", 'B', 1, "GL_MAP_COLOR", 0x0D10}, + { "glGet", 'B', 1, "GL_MAP_STENCIL", 0x0D11}, + { "glGet", 'I', 1, "GL_INDEX_SHIFT", 0x0D12}, + { "glGet", 'I', 1, "GL_INDEX_OFFSET", 0x0D13}, + { "glGet", 'F', 1, "GL_RED_SCALE", 0x0D14}, + { "glGet", 'F', 1, "GL_RED_BIAS", 0x0D15}, + { "glGet", 'F', 1, "GL_ZOOM_X", 0x0D16}, + { "glGet", 'F', 1, "GL_ZOOM_Y", 0x0D17}, + { "glGet", 'F', 1, "GL_GREEN_SCALE", 0x0D18}, + { "glGet", 'F', 1, "GL_GREEN_BIAS", 0x0D19}, + { "glGet", 'F', 1, "GL_BLUE_SCALE", 0x0D1A}, + { "glGet", 'F', 1, "GL_BLUE_BIAS", 0x0D1B}, + { "glGet,glGetTexEnv", 'F', 1, "GL_ALPHA_SCALE", 0x0D1C}, + { "glGet", 'F', 1, "GL_ALPHA_BIAS", 0x0D1D}, + { "glGet", 'F', 1, "GL_DEPTH_SCALE", 0x0D1E}, + { "glGet", 'F', 1, "GL_DEPTH_BIAS", 0x0D1F}, + { "glGet", 'I', 1, "GL_MAX_EVAL_ORDER", 0x0D30}, + { "glGet", 'I', 1, "GL_MAX_LIGHTS", 0x0D31}, + { "glGet", 'I', 1, "GL_MAX_CLIP_DISTANCES", 0x0D32}, + { "glGet", 'I', 1, "GL_MAX_TEXTURE_SIZE", 0x0D33}, + { "glGet", 'I', 1, "GL_MAX_PIXEL_MAP_TABLE", 0x0D34}, + { "glGet", 'I', 1, "GL_MAX_ATTRIB_STACK_DEPTH", 0x0D35}, + { "glGet", 'I', 1, "GL_MAX_MODELVIEW_STACK_DEPTH", 0x0D36}, + { "glGet", 'I', 1, "GL_MAX_NAME_STACK_DEPTH", 0x0D37}, + { "glGet", 'I', 1, "GL_MAX_PROJECTION_STACK_DEPTH", 0x0D38}, + { "glGet", 'I', 1, "GL_MAX_TEXTURE_STACK_DEPTH", 0x0D39}, + { "glGet", 'F', 2, "GL_MAX_VIEWPORT_DIMS", 0x0D3A}, + { "glGet", 'I', 1, "GL_MAX_CLIENT_ATTRIB_STACK_DEPTH", 0x0D3B}, + { "glGet", 'I', 1, "GL_SUBPIXEL_BITS", 0x0D50}, + { "glGet", 'I', 1, "GL_INDEX_BITS", 0x0D51}, + { "glGet", 'I', 1, "GL_RED_BITS", 0x0D52}, + { "glGet", 'I', 1, "GL_GREEN_BITS", 0x0D53}, + { "glGet", 'I', 1, "GL_BLUE_BITS", 0x0D54}, + { "glGet", 'I', 1, "GL_ALPHA_BITS", 0x0D55}, + { "glGet", 'I', 1, "GL_DEPTH_BITS", 0x0D56}, + { "glGet", 'I', 1, "GL_STENCIL_BITS", 0x0D57}, + { "glGet", 'I', 1, "GL_ACCUM_RED_BITS", 0x0D58}, + { "glGet", 'I', 1, "GL_ACCUM_GREEN_BITS", 0x0D59}, + { "glGet", 'I', 1, "GL_ACCUM_BLUE_BITS", 0x0D5A}, + { "glGet", 'I', 1, "GL_ACCUM_ALPHA_BITS", 0x0D5B}, + { "glGet", 'I', 1, "GL_NAME_STACK_DEPTH", 0x0D70}, + { "glGet", 'B', 1, "GL_AUTO_NORMAL", 0x0D80}, + { "glGet", 'B', 1, "GL_MAP1_COLOR_4", 0x0D90}, + { "glGet", 'B', 1, "GL_MAP1_INDEX", 0x0D91}, + { "glGet", 'B', 1, "GL_MAP1_NORMAL", 0x0D92}, + { "glGet", 'B', 1, "GL_MAP1_TEXTURE_COORD_1", 0x0D93}, + { "glGet", 'B', 1, "GL_MAP1_TEXTURE_COORD_2", 0x0D94}, + { "glGet", 'B', 1, "GL_MAP1_TEXTURE_COORD_3", 0x0D95}, + { "glGet", 'B', 1, "GL_MAP1_TEXTURE_COORD_4", 0x0D96}, + { "glGet", 'B', 1, "GL_MAP1_VERTEX_3", 0x0D97}, + { "glGet", 'B', 1, "GL_MAP1_VERTEX_4", 0x0D98}, + { "glGet", 'B', 1, "GL_MAP2_COLOR_4", 0x0DB0}, + { "glGet", 'B', 1, "GL_MAP2_INDEX", 0x0DB1}, + { "glGet", 'B', 1, "GL_MAP2_NORMAL", 0x0DB2}, + { "glGet", 'B', 1, "GL_MAP2_TEXTURE_COORD_1", 0x0DB3}, + { "glGet", 'B', 1, "GL_MAP2_TEXTURE_COORD_2", 0x0DB4}, + { "glGet", 'B', 1, "GL_MAP2_TEXTURE_COORD_3", 0x0DB5}, + { "glGet", 'B', 1, "GL_MAP2_TEXTURE_COORD_4", 0x0DB6}, + { "glGet", 'B', 1, "GL_MAP2_VERTEX_3", 0x0DB7}, + { "glGet", 'B', 1, "GL_MAP2_VERTEX_4", 0x0DB8}, + { "glGet", 'F', 2, "GL_MAP1_GRID_DOMAIN", 0x0DD0}, + { "glGet", 'I', 1, "GL_MAP1_GRID_SEGMENTS", 0x0DD1}, + { "glGet", 'F', 4, "GL_MAP2_GRID_DOMAIN", 0x0DD2}, + { "glGet", 'I', 2, "GL_MAP2_GRID_SEGMENTS", 0x0DD3}, + { "glGet", 'B', 1, "GL_TEXTURE_1D", 0x0DE0}, + { "glGet", 'B', 1, "GL_TEXTURE_2D", 0x0DE1}, + { "glGet", 'P', 1, "GL_FEEDBACK_BUFFER_POINTER", 0x0DF0}, + { "glGet", 'I', 1, "GL_FEEDBACK_BUFFER_SIZE", 0x0DF1}, + { "glGet", 'E', 1, "GL_FEEDBACK_BUFFER_TYPE", 0x0DF2}, + { "glGet", 'P', 1, "GL_SELECTION_BUFFER_POINTER", 0x0DF3}, + { "glGet", 'I', 1, "GL_SELECTION_BUFFER_SIZE", 0x0DF4}, + { "glGetTexLevelParameter", 'I', 1, "GL_TEXTURE_WIDTH", 0x1000}, + { "glGetTexLevelParameter", 'I', 1, "GL_TEXTURE_HEIGHT", 0x1001}, + { "glGetTexLevelParameter", 'E', 1, "GL_TEXTURE_INTERNAL_FORMAT", 0x1003}, + { "glGetTexParameter", 'F', 4, "GL_TEXTURE_BORDER_COLOR", 0x1004}, + { "glGetTexLevelParameter", 'I', 1, "GL_TEXTURE_BORDER", 0x1005}, + { "", 'X', 1, "GL_DONT_CARE", 0x1100}, + { "", 'X', 1, "GL_FASTEST", 0x1101}, + { "", 'X', 1, "GL_NICEST", 0x1102}, + { "glGetLight,glGetMaterial", 'F', 4, "GL_AMBIENT", 0x1200}, + { "glGetLight,glGetMaterial", 'F', 4, "GL_DIFFUSE", 0x1201}, + { "glGetLight,glGetMaterial", 'F', 4, "GL_SPECULAR", 0x1202}, + { "glGetLight", 'F', 4, "GL_POSITION", 0x1203}, + { "glGetLight", 'F', 3, "GL_SPOT_DIRECTION", 0x1204}, + { "glGetLight", 'F', 1, "GL_SPOT_EXPONENT", 0x1205}, + { "glGetLight", 'F', 1, "GL_SPOT_CUTOFF", 0x1206}, + { "glGetLight", 'F', 1, "GL_CONSTANT_ATTENUATION", 0x1207}, + { "glGetLight", 'F', 1, "GL_LINEAR_ATTENUATION", 0x1208}, + { "glGetLight", 'F', 1, "GL_QUADRATIC_ATTENUATION", 0x1209}, + { "", 'X', 1, "GL_COMPILE", 0x1300}, + { "", 'X', 1, "GL_COMPILE_AND_EXECUTE", 0x1301}, + { "", 'X', 1, "GL_BYTE", 0x1400}, + { "", 'X', 1, "GL_UNSIGNED_BYTE", 0x1401}, + { "", 'X', 1, "GL_SHORT", 0x1402}, + { "", 'X', 1, "GL_UNSIGNED_SHORT", 0x1403}, + { "", 'X', 1, "GL_INT", 0x1404}, + { "", 'X', 1, "GL_UNSIGNED_INT", 0x1405}, + { "", 'X', 1, "GL_FLOAT", 0x1406}, + { "", 'X', 1, "GL_2_BYTES", 0x1407}, + { "", 'X', 1, "GL_3_BYTES", 0x1408}, + { "", 'X', 1, "GL_4_BYTES", 0x1409}, + { "", 'X', 1, "GL_DOUBLE", 0x140A}, + { "", 'X', 1, "GL_HALF_FLOAT", 0x140B}, + { "", 'X', 1, "GL_FIXED", 0x140C}, + { "", 'X', 1, "GL_INT64_NV", 0x140E}, + { "", 'X', 1, "GL_UNSIGNED_INT64_NV", 0x140F}, + { "", 'X', 1, "GL_CLEAR", 0x1500}, + { "", 'X', 1, "GL_AND", 0x1501}, + { "", 'X', 1, "GL_AND_REVERSE", 0x1502}, + { "", 'X', 1, "GL_COPY", 0x1503}, + { "", 'X', 1, "GL_AND_INVERTED", 0x1504}, + { "", 'X', 1, "GL_NOOP", 0x1505}, + { "", 'X', 1, "GL_XOR", 0x1506}, + { "", 'X', 1, "GL_OR", 0x1507}, + { "", 'X', 1, "GL_NOR", 0x1508}, + { "", 'X', 1, "GL_EQUIV", 0x1509}, + { "", 'X', 1, "GL_INVERT", 0x150A}, + { "", 'X', 1, "GL_OR_REVERSE", 0x150B}, + { "", 'X', 1, "GL_COPY_INVERTED", 0x150C}, + { "", 'X', 1, "GL_OR_INVERTED", 0x150D}, + { "", 'X', 1, "GL_NAND", 0x150E}, + { "", 'X', 1, "GL_SET", 0x150F}, + { "glGetMaterial", 'F', 4, "GL_EMISSION", 0x1600}, + { "glGetMaterial", 'F', 1, "GL_SHININESS", 0x1601}, + { "", 'F', 4, "GL_AMBIENT_AND_DIFFUSE", 0x1602}, + { "glGetMaterial", 'F', 3, "GL_COLOR_INDEXES", 0x1603}, + { "", 'X', 1, "GL_MODELVIEW", 0x1700}, + { "", 'X', 1, "GL_PROJECTION", 0x1701}, + { "", 'X', 1, "GL_TEXTURE", 0x1702}, + { "", 'X', 1, "GL_COLOR", 0x1800}, + { "", 'X', 1, "GL_DEPTH", 0x1801}, + { "", 'X', 1, "GL_STENCIL", 0x1802}, + { "", 'X', 1, "GL_COLOR_INDEX", 0x1900}, + { "", 'X', 1, "GL_STENCIL_INDEX", 0x1901}, + { "", 'X', 1, "GL_DEPTH_COMPONENT", 0x1902}, + { "", 'X', 1, "GL_RED", 0x1903}, + { "", 'X', 1, "GL_GREEN", 0x1904}, + { "", 'X', 1, "GL_BLUE", 0x1905}, + { "", 'X', 1, "GL_ALPHA", 0x1906}, + { "", 'X', 1, "GL_RGB", 0x1907}, + { "", 'X', 1, "GL_RGBA", 0x1908}, + { "", 'X', 1, "GL_LUMINANCE", 0x1909}, + { "", 'X', 1, "GL_LUMINANCE_ALPHA", 0x190A}, + { "_glGet", 'B', 1, "GL_RASTER_POSITION_UNCLIPPED_IBM", 0x19262}, + { "", 'X', 1, "GL_BITMAP", 0x1A00}, + { "", 'X', 1, "GL_PREFER_DOUBLEBUFFER_HINT_PGI", 0x1A1F8}, + { "", 'X', 1, "GL_CONSERVE_MEMORY_HINT_PGI", 0x1A1FD}, + { "", 'X', 1, "GL_RECLAIM_MEMORY_HINT_PGI", 0x1A1FE}, + { "", 'X', 1, "GL_NATIVE_GRAPHICS_HANDLE_PGI", 0x1A202}, + { "", 'X', 1, "GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI", 0x1A203}, + { "", 'X', 1, "GL_NATIVE_GRAPHICS_END_HINT_PGI", 0x1A204}, + { "", 'X', 1, "GL_ALWAYS_FAST_HINT_PGI", 0x1A20C}, + { "", 'X', 1, "GL_ALWAYS_SOFT_HINT_PGI", 0x1A20D}, + { "", 'X', 1, "GL_ALLOW_DRAW_OBJ_HINT_PGI", 0x1A20E}, + { "", 'X', 1, "GL_ALLOW_DRAW_WIN_HINT_PGI", 0x1A20F}, + { "", 'X', 1, "GL_ALLOW_DRAW_FRG_HINT_PGI", 0x1A210}, + { "", 'X', 1, "GL_ALLOW_DRAW_MEM_HINT_PGI", 0x1A211}, + { "", 'X', 1, "GL_STRICT_DEPTHFUNC_HINT_PGI", 0x1A216}, + { "", 'X', 1, "GL_STRICT_LIGHTING_HINT_PGI", 0x1A217}, + { "", 'X', 1, "GL_STRICT_SCISSOR_HINT_PGI", 0x1A218}, + { "", 'X', 1, "GL_FULL_STIPPLE_HINT_PGI", 0x1A219}, + { "", 'X', 1, "GL_CLIP_NEAR_HINT_PGI", 0x1A220}, + { "", 'X', 1, "GL_CLIP_FAR_HINT_PGI", 0x1A221}, + { "", 'X', 1, "GL_WIDE_LINE_HINT_PGI", 0x1A222}, + { "", 'X', 1, "GL_BACK_NORMALS_HINT_PGI", 0x1A223}, + { "", 'X', 1, "GL_VERTEX_DATA_HINT_PGI", 0x1A22A}, + { "", 'X', 1, "GL_VERTEX_CONSISTENT_HINT_PGI", 0x1A22B}, + { "", 'X', 1, "GL_MATERIAL_SIDE_HINT_PGI", 0x1A22C}, + { "", 'X', 1, "GL_MAX_VERTEX_HINT_PGI", 0x1A22D}, + { "", 'X', 1, "GL_POINT", 0x1B00}, + { "", 'X', 1, "GL_LINE", 0x1B01}, + { "", 'X', 1, "GL_FILL", 0x1B02}, + { "", 'X', 1, "GL_RENDER", 0x1C00}, + { "", 'X', 1, "GL_FEEDBACK", 0x1C01}, + { "", 'X', 1, "GL_SELECT", 0x1C02}, + { "", 'X', 1, "GL_FLAT", 0x1D00}, + { "", 'X', 1, "GL_SMOOTH", 0x1D01}, + { "", 'X', 1, "GL_KEEP", 0x1E00}, + { "", 'X', 1, "GL_REPLACE", 0x1E01}, + { "", 'X', 1, "GL_INCR", 0x1E02}, + { "", 'X', 1, "GL_DECR", 0x1E03}, + { "glGet", 'S', 1, "GL_VENDOR", 0x1F00}, + { "glGet", 'S', 1, "GL_RENDERER", 0x1F01}, + { "glGet", 'S', 1, "GL_VERSION", 0x1F02}, + { "glGet", 'S', 1, "GL_EXTENSIONS", 0x1F03}, + { "", 'X', 1, "GL_S", 0x2000}, + { "", 'X', 1, "GL_T", 0x2001}, + { "", 'X', 1, "GL_R", 0x2002}, + { "", 'X', 1, "GL_Q", 0x2003}, + { "", 'X', 1, "GL_MODULATE", 0x2100}, + { "", 'X', 1, "GL_DECAL", 0x2101}, + { "glGetTexEnv", 'E', 1, "GL_TEXTURE_ENV_MODE", 0x2200}, + { "glGetTexEnv", 'F', 4, "GL_TEXTURE_ENV_COLOR", 0x2201}, + { "", 'X', 1, "GL_TEXTURE_ENV", 0x2300}, + { "", 'X', 1, "GL_EYE_LINEAR", 0x2400}, + { "", 'X', 1, "GL_OBJECT_LINEAR", 0x2401}, + { "", 'X', 1, "GL_SPHERE_MAP", 0x2402}, + { "glGetTexGen", 'E', 1, "GL_TEXTURE_GEN_MODE", 0x2500}, + { "glGetTexGen", 'F', 4, "GL_OBJECT_PLANE", 0x2501}, + { "glGetTexGen", 'F', 4, "GL_EYE_PLANE", 0x2502}, + { "", 'X', 1, "GL_NEAREST", 0x2600}, + { "", 'X', 1, "GL_LINEAR", 0x2601}, + { "", 'X', 1, "GL_NEAREST_MIPMAP_NEAREST", 0x2700}, + { "", 'X', 1, "GL_LINEAR_MIPMAP_NEAREST", 0x2701}, + { "", 'X', 1, "GL_NEAREST_MIPMAP_LINEAR", 0x2702}, + { "", 'X', 1, "GL_LINEAR_MIPMAP_LINEAR", 0x2703}, + { "glGetTexParameter", 'E', 1, "GL_TEXTURE_MAG_FILTER", 0x2800}, + { "glGetTexParameter", 'E', 1, "GL_TEXTURE_MIN_FILTER", 0x2801}, + { "glGetTexParameter", 'E', 1, "GL_TEXTURE_WRAP_S", 0x2802}, + { "glGetTexParameter", 'E', 1, "GL_TEXTURE_WRAP_T", 0x2803}, + { "", 'X', 1, "GL_CLAMP", 0x2900}, + { "", 'X', 1, "GL_REPEAT", 0x2901}, + { "glGet", 'F', 1, "GL_POLYGON_OFFSET_UNITS", 0x2A00}, + { "glGet", 'B', 1, "GL_POLYGON_OFFSET_POINT", 0x2A01}, + { "glGet", 'B', 1, "GL_POLYGON_OFFSET_LINE", 0x2A02}, + { "", 'X', 1, "GL_R3_G3_B2", 0x2A10}, + { "", 'X', 1, "GL_V2F", 0x2A20}, + { "", 'X', 1, "GL_V3F", 0x2A21}, + { "", 'X', 1, "GL_C4UB_V2F", 0x2A22}, + { "", 'X', 1, "GL_C4UB_V3F", 0x2A23}, + { "", 'X', 1, "GL_C3F_V3F", 0x2A24}, + { "", 'X', 1, "GL_N3F_V3F", 0x2A25}, + { "", 'X', 1, "GL_C4F_N3F_V3F", 0x2A26}, + { "", 'X', 1, "GL_T2F_V3F", 0x2A27}, + { "", 'X', 1, "GL_T4F_V4F", 0x2A28}, + { "", 'X', 1, "GL_T2F_C4UB_V3F", 0x2A29}, + { "", 'X', 1, "GL_T2F_C3F_V3F", 0x2A2A}, + { "", 'X', 1, "GL_T2F_N3F_V3F", 0x2A2B}, + { "", 'X', 1, "GL_T2F_C4F_N3F_V3F", 0x2A2C}, + { "", 'X', 1, "GL_T4F_C4F_N3F_V4F", 0x2A2D}, + { "glGet", 'B', 1, "GL_CLIP_DISTANCE0", 0x3000}, + { "glGet", 'B', 1, "GL_CLIP_DISTANCE1", 0x3001}, + { "glGet", 'B', 1, "GL_CLIP_DISTANCE2", 0x3002}, + { "glGet", 'B', 1, "GL_CLIP_DISTANCE3", 0x3003}, + { "glGet", 'B', 1, "GL_CLIP_DISTANCE4", 0x3004}, + { "glGet", 'B', 1, "GL_CLIP_DISTANCE5", 0x3005}, + { "glGet", 'B', 1, "GL_CLIP_DISTANCE6", 0x3006}, + { "glGet", 'B', 1, "GL_CLIP_DISTANCE7", 0x3007}, + { "glGet", 'B', 1, "GL_LIGHT0", 0x4000}, + { "glGet", 'B', 1, "GL_LIGHT1", 0x4001}, + { "glGet", 'B', 1, "GL_LIGHT2", 0x4002}, + { "glGet", 'B', 1, "GL_LIGHT3", 0x4003}, + { "glGet", 'B', 1, "GL_LIGHT4", 0x4004}, + { "glGet", 'B', 1, "GL_LIGHT5", 0x4005}, + { "glGet", 'B', 1, "GL_LIGHT6", 0x4006}, + { "glGet", 'B', 1, "GL_LIGHT7", 0x4007}, + { "", 'X', 1, "GL_ABGR_EXT", 0x8000}, + { "", 'X', 1, "GL_CONSTANT_COLOR", 0x8001}, + { "", 'X', 1, "GL_ONE_MINUS_CONSTANT_COLOR", 0x8002}, + { "", 'X', 1, "GL_CONSTANT_ALPHA", 0x8003}, + { "", 'X', 1, "GL_ONE_MINUS_CONSTANT_ALPHA", 0x8004}, + { "glGet", 'F', 4, "GL_BLEND_COLOR", 0x8005}, + { "", 'X', 1, "GL_FUNC_ADD", 0x8006}, + { "", 'X', 1, "GL_MIN", 0x8007}, + { "", 'X', 1, "GL_MAX", 0x8008}, + { "glGet", 'E', 1, "GL_BLEND_EQUATION", 0x8009}, + + { "", 'X', 1, "GL_FUNC_SUBTRACT", 0x800A}, + { "", 'X', 1, "GL_FUNC_REVERSE_SUBTRACT", 0x800B}, + { "", 'X', 1, "GL_CMYK_EXT", 0x800C}, + { "", 'X', 1, "GL_CMYKA_EXT", 0x800D}, + { "glGet", 'I', 1, "GL_PACK_CMYK_HINT_EXT", 0x800E}, + { "glGet", 'I', 1, "GL_UNPACK_CMYK_HINT_EXT", 0x800F}, + { "glGet", 'B', 1, "GL_CONVOLUTION_1D", 0x8010}, + { "glGet", 'B', 1, "GL_CONVOLUTION_2D", 0x8011}, + { "glGet", 'B', 1, "GL_SEPARABLE_2D", 0x8012}, + { "glGetConvolutionParameter", 'E', 1, "GL_CONVOLUTION_BORDER_MODE", 0x8013}, + { "glGetConvolutionParameter", 'F', 4, "GL_CONVOLUTION_FILTER_SCALE", 0x8014}, + { "glGetConvolutionParameter", 'F', 4, "GL_CONVOLUTION_FILTER_BIAS", 0x8015}, + { "", 'X', 1, "GL_REDUCE", 0x8016}, + { "glGetConvolutionParameter", 'E', 1, "GL_CONVOLUTION_FORMAT", 0x8017}, + { "glGetConvolutionParameter", 'I', 1, "GL_CONVOLUTION_WIDTH", 0x8018}, + { "glGetConvolutionParameter", 'I', 1, "GL_CONVOLUTION_HEIGHT", 0x8019}, + { "glGetConvolutionParameter", 'I', 1, "GL_MAX_CONVOLUTION_WIDTH", 0x801A}, + { "glGetConvolutionParameter", 'I', 1, "GL_MAX_CONVOLUTION_HEIGHT", 0x801B}, + { "glGet", 'F', 1, "GL_POST_CONVOLUTION_RED_SCALE", 0x801C}, + { "glGet", 'F', 1, "GL_POST_CONVOLUTION_GREEN_SCALE", 0x801D}, + { "glGet", 'F', 1, "GL_POST_CONVOLUTION_BLUE_SCALE", 0x801E}, + { "glGet", 'F', 1, "GL_POST_CONVOLUTION_ALPHA_SCALE", 0x801F}, + { "glGet", 'F', 1, "GL_POST_CONVOLUTION_RED_BIAS", 0x8020}, + { "glGet", 'F', 1, "GL_POST_CONVOLUTION_GREEN_BIAS", 0x8021}, + { "glGet", 'F', 1, "GL_POST_CONVOLUTION_BLUE_BIAS", 0x8022}, + { "glGet", 'F', 1, "GL_POST_CONVOLUTION_ALPHA_BIAS", 0x8023}, + { "glGet", 'B', 1, "GL_HISTOGRAM", 0x8024}, + { "", 'X', 1, "GL_PROXY_HISTOGRAM", 0x8025}, + { "glGetHistogramParameter", 'I', 1, "GL_HISTOGRAM_WIDTH", 0x8026}, + { "glGetHistogramParameter", 'E', 1, "GL_HISTOGRAM_FORMAT", 0x8027}, + { "glGetHistogramParameter", 'I', 1, "GL_HISTOGRAM_RED_SIZE", 0x8028}, + { "glGetHistogramParameter", 'I', 1, "GL_HISTOGRAM_GREEN_SIZE", 0x8029}, + { "glGetHistogramParameter", 'I', 1, "GL_HISTOGRAM_BLUE_SIZE", 0x802A}, + { "glGetHistogramParameter", 'I', 1, "GL_HISTOGRAM_ALPHA_SIZE", 0x802B}, + { "glGetHistogramParameter", 'I', 1, "GL_HISTOGRAM_LUMINANCE_SIZE", 0x802C}, + { "glGetHistogramParameter", 'B', 1, "GL_HISTOGRAM_SINK", 0x802D}, + { "glGet", 'B', 1, "GL_MINMAX", 0x802E}, + { "glGetMinMaxParameter", 'E', 1, "GL_MINMAX_FORMAT", 0x802F}, + { "glGetMinMaxParameter", 'B', 1, "GL_MINMAX_SINK", 0x8030}, + { "", 'X', 1, "GL_TABLE_TOO_LARGE", 0x8031}, + { "", 'X', 1, "GL_UNSIGNED_BYTE_3_3_2", 0x8032}, + { "", 'X', 1, "GL_UNSIGNED_SHORT_4_4_4_4", 0x8033}, + { "", 'X', 1, "GL_UNSIGNED_SHORT_5_5_5_1", 0x8034}, + { "", 'X', 1, "GL_UNSIGNED_INT_8_8_8_8", 0x8035}, + { "", 'X', 1, "GL_UNSIGNED_INT_10_10_10_2", 0x8036}, + { "glGet", 'B', 1, "GL_POLYGON_OFFSET_FILL", 0x8037}, + { "glGet", 'F', 1, "GL_POLYGON_OFFSET_FACTOR", 0x8038}, + { "glGet", 'F', 1, "GL_POLYGON_OFFSET_BIAS_EXT", 0x8039}, + { "glGet", 'B', 1, "GL_RESCALE_NORMAL", 0x803A}, + { "", 'X', 1, "GL_ALPHA4", 0x803B}, + { "", 'X', 1, "GL_ALPHA8", 0x803C}, + { "", 'X', 1, "GL_ALPHA12", 0x803D}, + { "", 'X', 1, "GL_ALPHA16", 0x803E}, + { "", 'X', 1, "GL_LUMINANCE4", 0x803F}, + { "", 'X', 1, "GL_LUMINANCE8", 0x8040}, + { "", 'X', 1, "GL_LUMINANCE12", 0x8041}, + { "", 'X', 1, "GL_LUMINANCE16", 0x8042}, + { "", 'X', 1, "GL_LUMINANCE4_ALPHA4", 0x8043}, + { "", 'X', 1, "GL_LUMINANCE6_ALPHA2", 0x8044}, + { "", 'X', 1, "GL_LUMINANCE8_ALPHA8", 0x8045}, + { "", 'X', 1, "GL_LUMINANCE12_ALPHA4", 0x8046}, + { "", 'X', 1, "GL_LUMINANCE12_ALPHA12", 0x8047}, + { "", 'X', 1, "GL_LUMINANCE16_ALPHA16", 0x8048}, + { "", 'X', 1, "GL_INTENSITY", 0x8049}, + { "", 'X', 1, "GL_INTENSITY4", 0x804A}, + { "", 'X', 1, "GL_INTENSITY8", 0x804B}, + { "", 'X', 1, "GL_INTENSITY12", 0x804C}, + { "", 'X', 1, "GL_INTENSITY16", 0x804D}, + { "", 'X', 1, "GL_RGB2_EXT", 0x804E}, + { "", 'X', 1, "GL_RGB4", 0x804F}, + { "", 'X', 1, "GL_RGB5", 0x8050}, + { "", 'X', 1, "GL_RGB8", 0x8051}, + { "", 'X', 1, "GL_RGB10", 0x8052}, + { "", 'X', 1, "GL_RGB12", 0x8053}, + { "", 'X', 1, "GL_RGB16", 0x8054}, + { "", 'X', 1, "GL_RGBA2", 0x8055}, + { "", 'X', 1, "GL_RGBA4", 0x8056}, + { "", 'X', 1, "GL_RGB5_A1", 0x8057}, + { "", 'X', 1, "GL_RGBA8", 0x8058}, + { "", 'X', 1, "GL_RGB10_A2", 0x8059}, + { "", 'X', 1, "GL_RGBA12", 0x805A}, + { "", 'X', 1, "GL_RGBA16", 0x805B}, + { "glGetTexLevelParameter", 'I', 1, "GL_TEXTURE_RED_SIZE", 0x805C}, + { "glGetTexLevelParameter", 'I', 1, "GL_TEXTURE_GREEN_SIZE", 0x805D}, + { "glGetTexLevelParameter", 'I', 1, "GL_TEXTURE_BLUE_SIZE", 0x805E}, + { "glGetTexLevelParameter", 'I', 1, "GL_TEXTURE_ALPHA_SIZE", 0x805F}, + { "glGetTexLevelParameter", 'I', 1, "GL_TEXTURE_LUMINANCE_SIZE", 0x8060}, + { "glGetTexLevelParameter", 'I', 1, "GL_TEXTURE_INTENSITY_SIZE", 0x8061}, + { "", 'X', 1, "GL_REPLACE_EXT", 0x8062}, + { "", 'X', 1, "GL_PROXY_TEXTURE_1D", 0x8063}, + { "", 'X', 1, "GL_PROXY_TEXTURE_2D", 0x8064}, + { "", 'X', 1, "GL_TEXTURE_TOO_LARGE_EXT", 0x8065}, + { "glGetTexParameter", 'F', 1, "GL_TEXTURE_PRIORITY", 0x8066}, + { "glGetTexParameter", 'B', 1, "GL_TEXTURE_RESIDENT", 0x8067}, + { "glGet", 'I', 1, "GL_TEXTURE_BINDING_1D", 0x8068}, + { "glGet", 'I', 1, "GL_TEXTURE_BINDING_2D", 0x8069}, + { "glGet", 'I', 1, "GL_TEXTURE_BINDING_3D", 0x806A}, + { "glGet", 'I', 1, "GL_PACK_SKIP_IMAGES", 0x806B}, + { "glGet", 'I', 1, "GL_PACK_IMAGE_HEIGHT", 0x806C}, + { "glGet", 'I', 1, "GL_UNPACK_SKIP_IMAGES", 0x806D}, + { "glGet", 'I', 1, "GL_UNPACK_IMAGE_HEIGHT", 0x806E}, + { "glGet", 'B', 1, "GL_TEXTURE_3D", 0x806F}, + { "", 'X', 1, "GL_PROXY_TEXTURE_3D", 0x8070}, + { "glGetTexLevelParameter", 'I', 1, "GL_TEXTURE_DEPTH", 0x8071}, + { "glGetTexParameter", 'E', 1, "GL_TEXTURE_WRAP_R", 0x8072}, + { "glGet", 'I', 1, "GL_MAX_3D_TEXTURE_SIZE", 0x8073}, + { "glGet", 'B', 1, "GL_VERTEX_ARRAY", 0x8074}, + { "glGet", 'B', 1, "GL_NORMAL_ARRAY", 0x8075}, + { "glGet", 'B', 1, "GL_COLOR_ARRAY", 0x8076}, + { "glGet", 'B', 1, "GL_INDEX_ARRAY", 0x8077}, + { "glGet", 'B', 1, "GL_TEXTURE_COORD_ARRAY", 0x8078}, + { "glGet", 'B', 1, "GL_EDGE_FLAG_ARRAY", 0x8079}, + { "glGet", 'I', 1, "GL_VERTEX_ARRAY_SIZE", 0x807A}, + { "glGet", 'E', 1, "GL_VERTEX_ARRAY_TYPE", 0x807B}, + { "glGet", 'I', 1, "GL_VERTEX_ARRAY_STRIDE", 0x807C}, + { "glGet", 'I', 1, "GL_VERTEX_ARRAY_COUNT_EXT", 0x807D}, + { "glGet", 'E', 1, "GL_NORMAL_ARRAY_TYPE", 0x807E}, + { "glGet", 'I', 1, "GL_NORMAL_ARRAY_STRIDE", 0x807F}, + { "glGet", 'I', 1, "GL_NORMAL_ARRAY_COUNT_EXT", 0x8080}, + { "glGet", 'I', 1, "GL_COLOR_ARRAY_SIZE", 0x8081}, + { "glGet", 'E', 1, "GL_COLOR_ARRAY_TYPE", 0x8082}, + { "glGet", 'I', 1, "GL_COLOR_ARRAY_STRIDE", 0x8083}, + { "glGet", 'I', 1, "GL_COLOR_ARRAY_COUNT_EXT", 0x8084}, + { "glGet", 'E', 1, "GL_INDEX_ARRAY_TYPE", 0x8085}, + { "glGet", 'I', 1, "GL_INDEX_ARRAY_STRIDE", 0x8086}, + { "glGet", 'I', 1, "GL_INDEX_ARRAY_COUNT_EXT", 0x8087}, + { "glGet", 'I', 1, "GL_TEXTURE_COORD_ARRAY_SIZE", 0x8088}, + { "glGet", 'E', 1, "GL_TEXTURE_COORD_ARRAY_TYPE", 0x8089}, + { "glGet", 'I', 1, "GL_TEXTURE_COORD_ARRAY_STRIDE", 0x808A}, + { "glGet", 'I', 1, "GL_TEXTURE_COORD_ARRAY_COUNT_EXT", 0x808B}, + { "glGet", 'I', 1, "GL_EDGE_FLAG_ARRAY_STRIDE", 0x808C}, + { "glGet", 'I', 1, "GL_EDGE_FLAG_ARRAY_COUNT_EXT", 0x808D}, + { "glGet", 'P', 1, "GL_VERTEX_ARRAY_POINTER", 0x808E}, + { "glGet", 'P', 1, "GL_NORMAL_ARRAY_POINTER", 0x808F}, + { "glGet", 'P', 1, "GL_COLOR_ARRAY_POINTER", 0x8090}, + { "glGet", 'P', 1, "GL_INDEX_ARRAY_POINTER", 0x8091}, + { "glGet", 'P', 1, "GL_TEXTURE_COORD_ARRAY_POINTER", 0x8092}, + { "glGet", 'P', 1, "GL_EDGE_FLAG_ARRAY_POINTER", 0x8093}, + { "glGet", 'I', 1, "GL_INTERLACE_SGIX", 0x8094}, + { "", 'X', 1, "GL_DETAIL_TEXTURE_2D_SGIS", 0x8095}, + { "glGet", 'I', 1, "GL_DETAIL_TEXTURE_2D_BINDING_SGIS", 0x8096}, + { "", 'X', 1, "GL_LINEAR_DETAIL_SGIS", 0x8097}, + { "", 'X', 1, "GL_LINEAR_DETAIL_ALPHA_SGIS", 0x8098}, + { "", 'X', 1, "GL_LINEAR_DETAIL_COLOR_SGIS", 0x8099}, + { "", 'X', 1, "GL_DETAIL_TEXTURE_LEVEL_SGIS", 0x809A}, + { "", 'X', 1, "GL_DETAIL_TEXTURE_MODE_SGIS", 0x809B}, + { "", 'X', 1, "GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS", 0x809C}, + { "glGet", 'B', 1, "GL_MULTISAMPLE", 0x809D}, + { "glGet", 'B', 1, "GL_SAMPLE_ALPHA_TO_COVERAGE", 0x809E}, + { "glGet", 'B', 1, "GL_SAMPLE_ALPHA_TO_ONE", 0x809F}, + { "glGet", 'B', 1, "GL_SAMPLE_COVERAGE", 0x80A0}, + { "", 'X', 1, "GL_1PASS_EXT", 0x80A1}, + { "", 'X', 1, "GL_2PASS_0_EXT", 0x80A2}, + { "", 'X', 1, "GL_2PASS_1_EXT", 0x80A3}, + { "", 'X', 1, "GL_4PASS_0_EXT", 0x80A4}, + { "", 'X', 1, "GL_4PASS_1_EXT", 0x80A5}, + { "", 'X', 1, "GL_4PASS_2_EXT", 0x80A6}, + { "", 'X', 1, "GL_4PASS_3_EXT", 0x80A7}, + { "glGet", 'I', 1, "GL_SAMPLE_BUFFERS", 0x80A8}, + { "glGet", 'I', 1, "GL_SAMPLES", 0x80A9}, + { "glGet", 'F', 1, "GL_SAMPLE_COVERAGE_VALUE", 0x80AA}, + { "glGet", 'B', 1, "GL_SAMPLE_COVERAGE_INVERT", 0x80AB}, + { "glGet", 'I', 1, "GL_SAMPLE_PATTERN_EXT", 0x80AC}, + { "", 'X', 1, "GL_LINEAR_SHARPEN_SGIS", 0x80AD}, + { "", 'X', 1, "GL_LINEAR_SHARPEN_ALPHA_SGIS", 0x80AE}, + { "", 'X', 1, "GL_LINEAR_SHARPEN_COLOR_SGIS", 0x80AF}, + { "", 'X', 1, "GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS", 0x80B0}, + { "glGet", 'F', 16, "GL_COLOR_MATRIX", 0x80B1}, + { "glGet", 'I', 1, "GL_COLOR_MATRIX_STACK_DEPTH", 0x80B2}, + { "glGet", 'I', 1, "GL_MAX_COLOR_MATRIX_STACK_DEPTH", 0x80B3}, + { "glGet", 'F', 1, "GL_POST_COLOR_MATRIX_RED_SCALE", 0x80B4}, + { "glGet", 'F', 1, "GL_POST_COLOR_MATRIX_GREEN_SCALE", 0x80B5}, + { "glGet", 'F', 1, "GL_POST_COLOR_MATRIX_BLUE_SCALE", 0x80B6}, + { "glGet", 'F', 1, "GL_POST_COLOR_MATRIX_ALPHA_SCALE", 0x80B7}, + { "glGet", 'F', 1, "GL_POST_COLOR_MATRIX_RED_BIAS", 0x80B8}, + { "glGet", 'F', 1, "GL_POST_COLOR_MATRIX_GREEN_BIAS", 0x80B9}, + { "glGet", 'F', 1, "GL_POST_COLOR_MATRIX_BLUE_BIAS", 0x80BA}, + { "glGet", 'F', 1, "GL_POST_COLOR_MATRIX_ALPHA_BIAS", 0x80BB}, + { "glGet", 'I', 1, "GL_TEXTURE_COLOR_TABLE_SGI", 0x80BC}, + { "", 'X', 1, "GL_PROXY_TEXTURE_COLOR_TABLE_SGI", 0x80BD}, + { "", 'X', 1, "GL_TEXTURE_ENV_BIAS_SGIX", 0x80BE}, + { "glGetTexParameter", 'F', 1, "GL_TEXTURE_COMPARE_FAIL_VALUE_ARB", 0x80BF}, + { "glGet", 'E', 1, "GL_BLEND_DST_RGB", 0x80C8}, + { "glGet", 'E', 1, "GL_BLEND_SRC_RGB", 0x80C9}, + { "glGet", 'E', 1, "GL_BLEND_DST_ALPHA", 0x80CA}, + { "glGet", 'E', 1, "GL_BLEND_SRC_ALPHA", 0x80CB}, + { "", 'X', 1, "GL_422_EXT", 0x80CC}, + { "", 'X', 1, "GL_422_REV_EXT", 0x80CD}, + { "", 'X', 1, "GL_422_AVERAGE_EXT", 0x80CE}, + { "", 'X', 1, "GL_422_REV_AVERAGE_EXT", 0x80CF}, + { "glGet", 'B', 1, "GL_COLOR_TABLE", 0x80D0}, + { "glGet", 'I', 1, "GL_POST_CONVOLUTION_COLOR_TABLE", 0x80D1}, + { "glGet", 'I', 1, "GL_POST_COLOR_MATRIX_COLOR_TABLE", 0x80D2}, + { "", 'X', 1, "GL_PROXY_COLOR_TABLE", 0x80D3}, + { "", 'X', 1, "GL_PROXY_POST_CONVOLUTION_COLOR_TABLE", 0x80D4}, + { "", 'X', 1, "GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE", 0x80D5}, + { "glGetColorTableParameter", 'F', 4, "GL_COLOR_TABLE_SCALE", 0x80D6}, + { "glGetColorTableParameter", 'F', 4, "GL_COLOR_TABLE_BIAS", 0x80D7}, + { "glGetColorTableParameter", 'E', 1, "GL_COLOR_TABLE_FORMAT", 0x80D8}, + { "glGetColorTableParameter", 'I', 1, "GL_COLOR_TABLE_WIDTH", 0x80D9}, + { "glGetColorTableParameter", 'I', 1, "GL_COLOR_TABLE_RED_SIZE", 0x80DA}, + { "glGetColorTableParameter", 'I', 1, "GL_COLOR_TABLE_GREEN_SIZE", 0x80DB}, + { "glGetColorTableParameter", 'I', 1, "GL_COLOR_TABLE_BLUE_SIZE", 0x80DC}, + { "glGetColorTableParameter", 'I', 1, "GL_COLOR_TABLE_ALPHA_SIZE", 0x80DD}, + { "glGetColorTableParameter", 'I', 1, "GL_COLOR_TABLE_LUMINANCE_SIZE", 0x80DE}, + { "glGetColorTableParameter", 'I', 1, "GL_COLOR_TABLE_INTENSITY_SIZE", 0x80DF}, + { "", 'X', 1, "GL_BGR", 0x80E0}, + { "", 'X', 1, "GL_BGRA", 0x80E1}, + { "", 'X', 1, "GL_COLOR_INDEX1_EXT", 0x80E2}, + { "", 'X', 1, "GL_COLOR_INDEX2_EXT", 0x80E3}, + { "", 'X', 1, "GL_COLOR_INDEX4_EXT", 0x80E4}, + { "", 'X', 1, "GL_COLOR_INDEX8_EXT", 0x80E5}, + { "", 'X', 1, "GL_COLOR_INDEX12_EXT", 0x80E6}, + { "", 'X', 1, "GL_COLOR_INDEX16_EXT", 0x80E7}, + { "glGet", 'I', 1, "GL_MAX_ELEMENTS_VERTICES", 0x80E8}, + { "glGet", 'I', 1, "GL_MAX_ELEMENTS_INDICES", 0x80E9}, + { "", 'X', 1, "GL_PHONG_WIN", 0x80EA}, + { "", 'X', 1, "GL_PHONG_HINT_WIN", 0x80EB}, + { "", 'X', 1, "GL_FOG_SPECULAR_TEXTURE_WIN", 0x80EC}, + { "_glGetTexLevelParameter", 'I', 1, "GL_TEXTURE_INDEX_SIZE_EXT", 0x80ED}, + { "glGet", 'E', 1, "GL_CLIP_VOLUME_CLIPPING_HINT_EXT", 0x80F0}, + { "", 'X', 1, "GL_DUAL_ALPHA4_SGIS", 0x8110}, + { "", 'X', 1, "GL_DUAL_ALPHA8_SGIS", 0x8111}, + { "", 'X', 1, "GL_DUAL_ALPHA12_SGIS", 0x8112}, + { "", 'X', 1, "GL_DUAL_ALPHA16_SGIS", 0x8113}, + { "", 'X', 1, "GL_DUAL_LUMINANCE4_SGIS", 0x8114}, + { "", 'X', 1, "GL_DUAL_LUMINANCE8_SGIS", 0x8115}, + { "", 'X', 1, "GL_DUAL_LUMINANCE12_SGIS", 0x8116}, + { "", 'X', 1, "GL_DUAL_LUMINANCE16_SGIS", 0x8117}, + { "", 'X', 1, "GL_DUAL_INTENSITY4_SGIS", 0x8118}, + { "", 'X', 1, "GL_DUAL_INTENSITY8_SGIS", 0x8119}, + { "", 'X', 1, "GL_DUAL_INTENSITY12_SGIS", 0x811A}, + { "", 'X', 1, "GL_DUAL_INTENSITY16_SGIS", 0x811B}, + { "", 'X', 1, "GL_DUAL_LUMINANCE_ALPHA4_SGIS", 0x811C}, + { "", 'X', 1, "GL_DUAL_LUMINANCE_ALPHA8_SGIS", 0x811D}, + { "", 'X', 1, "GL_QUAD_ALPHA4_SGIS", 0x811E}, + { "", 'X', 1, "GL_QUAD_ALPHA8_SGIS", 0x811F}, + { "", 'X', 1, "GL_QUAD_LUMINANCE4_SGIS", 0x8120}, + { "", 'X', 1, "GL_QUAD_LUMINANCE8_SGIS", 0x8121}, + { "", 'X', 1, "GL_QUAD_INTENSITY4_SGIS", 0x8122}, + { "", 'X', 1, "GL_QUAD_INTENSITY8_SGIS", 0x8123}, + { "", 'X', 1, "GL_DUAL_TEXTURE_SELECT_SGIS", 0x8124}, + { "", 'X', 1, "GL_QUAD_TEXTURE_SELECT_SGIS", 0x8125}, + { "glGet", 'F', 1, "GL_POINT_SIZE_MIN", 0x8126}, + { "glGet", 'F', 1, "GL_POINT_SIZE_MAX", 0x8127}, + { "glGet", 'F', 1, "GL_POINT_FADE_THRESHOLD_SIZE", 0x8128}, + { "glGet", 'F', 3, "GL_POINT_DISTANCE_ATTENUATION", 0x8129}, + { "", 'X', 1, "GL_FOG_FUNC_SGIS", 0x812A}, + { "glGet", 'I', 1, "GL_FOG_FUNC_POINTS_SGIS", 0x812B}, + { "glGet", 'I', 1, "GL_MAX_FOG_FUNC_POINTS_SGIS", 0x812C}, + { "", 'X', 1, "GL_CLAMP_TO_BORDER", 0x812D}, + { "", 'X', 1, "GL_TEXTURE_MULTI_BUFFER_HINT_SGIX", 0x812E}, + { "", 'X', 1, "GL_CLAMP_TO_EDGE", 0x812F}, + { "glGet", 'I', 1, "GL_PACK_SKIP_VOLUMES_SGIS", 0x8130}, + { "glGet", 'I', 1, "GL_PACK_IMAGE_DEPTH_SGIS", 0x8131}, + { "glGet", 'I', 1, "GL_UNPACK_SKIP_VOLUMES_SGIS", 0x8132}, + { "glGet", 'I', 1, "GL_UNPACK_IMAGE_DEPTH_SGIS", 0x8133}, + { "glGet", 'I', 1, "GL_TEXTURE_4D_SGIS", 0x8134}, + { "", 'X', 1, "GL_PROXY_TEXTURE_4D_SGIS", 0x8135}, + { "", 'X', 1, "GL_TEXTURE_4DSIZE_SGIS", 0x8136}, + { "", 'X', 1, "GL_TEXTURE_WRAP_Q_SGIS", 0x8137}, + { "glGet", 'I', 1, "GL_MAX_4D_TEXTURE_SIZE_SGIS", 0x8138}, + { "glGet", 'I', 1, "GL_PIXEL_TEX_GEN_SGIX", 0x8139}, + { "glGetTexParameter", 'F', 1, "GL_TEXTURE_MIN_LOD", 0x813A}, + { "glGetTexParameter", 'F', 1, "GL_TEXTURE_MAX_LOD", 0x813B}, + { "glGetTexParameter", 'I', 1, "GL_TEXTURE_BASE_LEVEL", 0x813C}, + { "glGetTexParameter", 'I', 1, "GL_TEXTURE_MAX_LEVEL", 0x813D}, + { "glGet", 'I', 1, "GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX", 0x813E}, + { "glGet", 'I', 1, "GL_PIXEL_TILE_CACHE_INCREMENT_SGIX", 0x813F}, + { "glGet", 'I', 1, "GL_PIXEL_TILE_WIDTH_SGIX", 0x8140}, + { "glGet", 'I', 1, "GL_PIXEL_TILE_HEIGHT_SGIX", 0x8141}, + { "glGet", 'I', 1, "GL_PIXEL_TILE_GRID_WIDTH_SGIX", 0x8142}, + { "glGet", 'I', 1, "GL_PIXEL_TILE_GRID_HEIGHT_SGIX", 0x8143}, + { "glGet", 'I', 1, "GL_PIXEL_TILE_GRID_DEPTH_SGIX", 0x8144}, + { "glGet", 'I', 1, "GL_PIXEL_TILE_CACHE_SIZE_SGIX", 0x8145}, + { "", 'X', 1, "GL_FILTER4_SGIS", 0x8146}, + { "", 'X', 1, "GL_TEXTURE_FILTER4_SIZE_SGIS", 0x8147}, + { "glGet", 'I', 1, "GL_SPRITE_SGIX", 0x8148}, + { "glGet", 'I', 1, "GL_SPRITE_MODE_SGIX", 0x8149}, + { "glGet", 'F', 3, "GL_SPRITE_AXIS_SGIX", 0x814A}, + { "glGet", 'F', 3, "GL_SPRITE_TRANSLATION_SGIX", 0x814B}, + { "", 'X', 1, "GL_SPRITE_AXIAL_SGIX", 0x814C}, + { "", 'X', 1, "GL_SPRITE_OBJECT_ALIGNED_SGIX", 0x814D}, + { "", 'X', 1, "GL_SPRITE_EYE_ALIGNED_SGIX", 0x814E}, + { "glGet", 'I', 1, "GL_TEXTURE_4D_BINDING_SGIS", 0x814F}, + { "", 'X', 1, "GL_IGNORE_BORDER_HP", 0x8150}, + { "", 'X', 1, "GL_CONSTANT_BORDER", 0x8151}, + { "", 'X', 1, "GL_REPLICATE_BORDER", 0x8153}, + { "glGetConvolutionParameter", 'F', 4, "GL_CONVOLUTION_BORDER_COLOR", 0x8154}, + { "", 'X', 1, "GL_IMAGE_SCALE_X_HP", 0x8155}, + { "", 'X', 1, "GL_IMAGE_SCALE_Y_HP", 0x8156}, + { "", 'X', 1, "GL_IMAGE_TRANSLATE_X_HP", 0x8157}, + { "", 'X', 1, "GL_IMAGE_TRANSLATE_Y_HP", 0x8158}, + { "", 'X', 1, "GL_IMAGE_ROTATE_ANGLE_HP", 0x8159}, + { "", 'X', 1, "GL_IMAGE_ROTATE_ORIGIN_X_HP", 0x815A}, + { "", 'X', 1, "GL_IMAGE_ROTATE_ORIGIN_Y_HP", 0x815B}, + { "", 'X', 1, "GL_IMAGE_MAG_FILTER_HP", 0x815C}, + { "", 'X', 1, "GL_IMAGE_MIN_FILTER_HP", 0x815D}, + { "", 'X', 1, "GL_IMAGE_CUBIC_WEIGHT_HP", 0x815E}, + { "", 'X', 1, "GL_CUBIC_HP", 0x815F}, + { "", 'X', 1, "GL_AVERAGE_HP", 0x8160}, + { "", 'X', 1, "GL_IMAGE_TRANSFORM_2D_HP", 0x8161}, + { "", 'X', 1, "GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP", 0x8162}, + { "", 'X', 1, "GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP", 0x8163}, + { "_glGet", 'B', 1, "GL_OCCLUSION_TEST_HP", 0x8165}, + { "_glGet", 'B', 1, "GL_OCCLUSION_TEST_RESULT_HP", 0x8166}, + { "", 'X', 1, "GL_TEXTURE_LIGHTING_MODE_HP", 0x8167}, + { "", 'X', 1, "GL_TEXTURE_POST_SPECULAR_HP", 0x8168}, + { "", 'X', 1, "GL_TEXTURE_PRE_SPECULAR_HP", 0x8169}, + { "", 'X', 1, "GL_LINEAR_CLIPMAP_LINEAR_SGIX", 0x8170}, + { "glGetTexParameter", 'I', 2, "GL_TEXTURE_CLIPMAP_CENTER_SGIX", 0x8171}, + { "glGetTexParameter", 'F', 1, "GL_TEXTURE_CLIPMAP_FRAME_SGIX", 0x8172}, + { "glGetTexParameter", 'I', 2, "GL_TEXTURE_CLIPMAP_OFFSET_SGIX", 0x8173}, + { "glGetTexParameter", 'I', 3, "GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX", 0x8174}, + { "", 'X', 1, "GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX", 0x8175}, + { "", 'I', 1, "GL_TEXTURE_CLIPMAP_DEPTH_SGIX", 0x8176}, + { "glGet", 'I', 1, "GL_MAX_CLIPMAP_DEPTH_SGIX", 0x8177}, + { "glGet", 'I', 1, "GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX", 0x8178}, + { "glGetTexParameter", 'F', 1, "GL_POST_TEXTURE_FILTER_BIAS_SGIX", 0x8179}, + { "glGetTexParameter", 'F', 1, "GL_POST_TEXTURE_FILTER_SCALE_SGIX", 0x817A}, + { "glGet", 'F', 2, "GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX", 0x817B}, + { "glGet", 'F', 2, "GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX", 0x817C}, + { "glGet", 'I', 1, "GL_REFERENCE_PLANE_SGIX", 0x817D}, + { "glGet", 'F', 4, "GL_REFERENCE_PLANE_EQUATION_SGIX", 0x817E}, + { "glGet", 'I', 1, "GL_IR_INSTRUMENT1_SGIX", 0x817F}, + { "", 'X', 1, "GL_INSTRUMENT_BUFFER_POINTER_SGIX", 0x8180}, + { "glGet", 'I', 1, "GL_INSTRUMENT_MEASUREMENTS_SGIX", 0x8181}, + { "", 'X', 1, "GL_LIST_PRIORITY_SGIX", 0x8182}, + { "glGet", 'I', 1, "GL_CALLIGRAPHIC_FRAGMENT_SGIX", 0x8183}, + { "", 'X', 1, "GL_PIXEL_TEX_GEN_Q_CEILING_SGIX", 0x8184}, + { "", 'X', 1, "GL_PIXEL_TEX_GEN_Q_ROUND_SGIX", 0x8185}, + { "", 'X', 1, "GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX", 0x8186}, + { "", 'X', 1, "GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX", 0x8187}, + { "", 'X', 1, "GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX", 0x8188}, + { "", 'X', 1, "GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX", 0x8189}, + { "", 'X', 1, "GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX", 0x818A}, + { "glGet", 'I', 1, "GL_FRAMEZOOM_SGIX", 0x818B}, + { "glGet", 'I', 1, "GL_FRAMEZOOM_FACTOR_SGIX", 0x818C}, + { "glGet", 'I', 1, "GL_MAX_FRAMEZOOM_FACTOR_SGIX", 0x818D}, + { "glGetTexParameter", 'F', 1, "GL_TEXTURE_LOD_BIAS_S_SGIX", 0x818E}, + { "glGetTexParameter", 'F', 1, "GL_TEXTURE_LOD_BIAS_T_SGIX", 0x818F}, + { "glGetTexParameter", 'F', 1, "GL_TEXTURE_LOD_BIAS_R_SGIX", 0x8190}, + { "glGetTexParameter", 'B', 1, "GL_GENERATE_MIPMAP", 0x8191}, + { "glGet", 'E', 1, "GL_GENERATE_MIPMAP_HINT", 0x8192}, + { "", 'X', 1, "GL_GEOMETRY_DEFORMATION_SGIX", 0x8194}, + { "", 'X', 1, "GL_TEXTURE_DEFORMATION_SGIX", 0x8195}, + { "glGet", 'I', 1, "GL_DEFORMATIONS_MASK_SGIX", 0x8196}, + { "", 'X', 1, "GL_MAX_DEFORMATION_ORDER_SGIX", 0x8197}, + { "glGet", 'I', 1, "GL_FOG_OFFSET_SGIX", 0x8198}, + { "glGet", 'F', 4, "GL_FOG_OFFSET_VALUE_SGIX", 0x8199}, + { "glGetTexParameter", 'B', 1, "GL_TEXTURE_COMPARE_SGIX", 0x819A}, + { "glGetTexParameter", 'E', 1, "GL_TEXTURE_COMPARE_OPERATOR_SGIX", 0x819B}, + { "", 'X', 1, "GL_TEXTURE_LEQUAL_R_SGIX", 0x819C}, + { "", 'X', 1, "GL_TEXTURE_GEQUAL_R_SGIX", 0x819D}, + { "", 'X', 1, "GL_DEPTH_COMPONENT16", 0x81A5}, + { "", 'X', 1, "GL_DEPTH_COMPONENT24", 0x81A6}, + { "", 'X', 1, "GL_DEPTH_COMPONENT32", 0x81A7}, + { "glGet", 'I', 1, "GL_ARRAY_ELEMENT_LOCK_FIRST_EXT", 0x81A8}, + { "glGet", 'I', 1, "GL_ARRAY_ELEMENT_LOCK_COUNT_EXT", 0x81A9}, + { "glGet", 'B', 1, "GL_CULL_VERTEX_EXT", 0x81AA}, + { "glGet", 'F', 4, "GL_CULL_VERTEX_EYE_POSITION_EXT", 0x81AB}, + { "glGet", 'F', 4, "GL_CULL_VERTEX_OBJECT_POSITION_EXT", 0x81AC}, + { "", 'X', 1, "GL_IUI_V2F_EXT", 0x81AD}, + { "", 'X', 1, "GL_IUI_V3F_EXT", 0x81AE}, + { "", 'X', 1, "GL_IUI_N3F_V2F_EXT", 0x81AF}, + { "", 'X', 1, "GL_IUI_N3F_V3F_EXT", 0x81B0}, + { "", 'X', 1, "GL_T2F_IUI_V2F_EXT", 0x81B1}, + { "", 'X', 1, "GL_T2F_IUI_V3F_EXT", 0x81B2}, + { "", 'X', 1, "GL_T2F_IUI_N3F_V2F_EXT", 0x81B3}, + { "", 'X', 1, "GL_T2F_IUI_N3F_V3F_EXT", 0x81B4}, + { "", 'X', 1, "GL_INDEX_TEST_EXT", 0x81B5}, + { "", 'X', 1, "GL_INDEX_TEST_FUNC_EXT", 0x81B6}, + { "", 'X', 1, "GL_INDEX_TEST_REF_EXT", 0x81B7}, + { "", 'X', 1, "GL_INDEX_MATERIAL_EXT", 0x81B8}, + { "", 'X', 1, "GL_INDEX_MATERIAL_PARAMETER_EXT", 0x81B9}, + { "", 'X', 1, "GL_INDEX_MATERIAL_FACE_EXT", 0x81BA}, + { "", 'X', 1, "GL_YCRCB_422_SGIX", 0x81BB}, + { "", 'X', 1, "GL_YCRCB_444_SGIX", 0x81BC}, + { "", 'X', 1, "GL_WRAP_BORDER_SUN", 0x81D4}, + { "", 'X', 1, "GL_UNPACK_CONSTANT_DATA_SUNX", 0x81D5}, + { "", 'X', 1, "GL_TEXTURE_CONSTANT_DATA_SUNX", 0x81D6}, + { "", 'X', 1, "GL_TRIANGLE_LIST_SUN", 0x81D7}, + { "", 'X', 1, "GL_REPLACEMENT_CODE_SUN", 0x81D8}, + { "", 'X', 1, "GL_GLOBAL_ALPHA_SUN", 0x81D9}, + { "", 'X', 1, "GL_GLOBAL_ALPHA_FACTOR_SUN", 0x81DA}, + { "glGet", 'B', 4, "GL_TEXTURE_COLOR_WRITEMASK_SGIS", 0x81EF}, + { "", 'X', 1, "GL_EYE_DISTANCE_TO_POINT_SGIS", 0x81F0}, + { "", 'X', 1, "GL_OBJECT_DISTANCE_TO_POINT_SGIS", 0x81F1}, + { "", 'X', 1, "GL_EYE_DISTANCE_TO_LINE_SGIS", 0x81F2}, + { "", 'X', 1, "GL_OBJECT_DISTANCE_TO_LINE_SGIS", 0x81F3}, + { "", 'X', 1, "GL_EYE_POINT_SGIS", 0x81F4}, + { "", 'X', 1, "GL_OBJECT_POINT_SGIS", 0x81F5}, + { "", 'X', 1, "GL_EYE_LINE_SGIS", 0x81F6}, + { "", 'X', 1, "GL_OBJECT_LINE_SGIS", 0x81F7}, + { "glGet", 'E', 1, "GL_LIGHT_MODEL_COLOR_CONTROL", 0x81F8}, + { "", 'X', 1, "GL_SINGLE_COLOR", 0x81F9}, + { "", 'X', 1, "GL_SEPARATE_SPECULAR_COLOR", 0x81FA}, + { "", 'X', 1, "GL_SHARED_TEXTURE_PALETTE_EXT", 0x81FB}, + { "", 'X', 1, "GL_FOG_SCALE_SGIX", 0x81FC}, + { "", 'X', 1, "GL_FOG_SCALE_VALUE_SGIX", 0x81FD}, + { "", 'X', 1, "GL_TEXT_FRAGMENT_SHADER_ATI", 0x8200}, + { "glGetFramebufferAttachmentParameter", 'E', 1, "GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING", 0x8210}, + { "glGetFramebufferAttachmentParameter", 'E', 1, "GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE", 0x8211}, + { "glGetFramebufferAttachmentParameter", 'I', 1, "GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE", 0x8212}, + { "glGetFramebufferAttachmentParameter", 'I', 1, "GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE", 0x8213}, + { "glGetFramebufferAttachmentParameter", 'I', 1, "GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE", 0x8214}, + { "glGetFramebufferAttachmentParameter", 'I', 1, "GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE", 0x8215}, + { "glGetFramebufferAttachmentParameter", 'I', 1, "GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE", 0x8216}, + { "glGetFramebufferAttachmentParameter", 'I', 1, "GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE", 0x8217}, + { "", 'X', 1, "GL_FRAMEBUFFER_DEFAULT", 0x8218}, + { "", 'X', 1, "GL_FRAMEBUFFER_UNDEFINED", 0x8219}, + { "", 'X', 1, "GL_DEPTH_STENCIL_ATTACHMENT", 0x821A}, + { "glGet", 'I', 1, "GL_MAJOR_VERSION", 0x821B}, + { "glGet", 'I', 1, "GL_MINOR_VERSION", 0x821C}, + { "glGet", 'I', 1, "GL_NUM_EXTENSIONS", 0x821D}, + { "glGet", 'I', 1, "GL_CONTEXT_FLAGS", 0x821E}, + { "", 'X', 1, "GL_INDEX", 0x8222}, + { "", 'X', 1, "GL_COMPRESSED_RED", 0x8225}, + { "", 'X', 1, "GL_COMPRESSED_RG", 0x8226}, + { "", 'X', 1, "GL_RG", 0x8227}, + { "", 'X', 1, "GL_RG_INTEGER", 0x8228}, + { "", 'X', 1, "GL_R8", 0x8229}, + { "", 'X', 1, "GL_R16", 0x822A}, + { "", 'X', 1, "GL_RG8", 0x822B}, + { "", 'X', 1, "GL_RG16", 0x822C}, + { "", 'X', 1, "GL_R16F", 0x822D}, + { "", 'X', 1, "GL_R32F", 0x822E}, + { "", 'X', 1, "GL_RG16F", 0x822F}, + { "", 'X', 1, "GL_RG32F", 0x8230}, + { "", 'X', 1, "GL_R8I", 0x8231}, + { "", 'X', 1, "GL_R8UI", 0x8232}, + { "", 'X', 1, "GL_R16I", 0x8233}, + { "", 'X', 1, "GL_R16UI", 0x8234}, + { "", 'X', 1, "GL_R32I", 0x8235}, + { "", 'X', 1, "GL_R32UI", 0x8236}, + { "", 'X', 1, "GL_RG8I", 0x8237}, + { "", 'X', 1, "GL_RG8UI", 0x8238}, + { "", 'X', 1, "GL_RG16I", 0x8239}, + { "", 'X', 1, "GL_RG16UI", 0x823A}, + { "", 'X', 1, "GL_RG32I", 0x823B}, + { "", 'X', 1, "GL_RG32UI", 0x823C}, + { "", 'X', 1, "GL_SYNC_CL_EVENT_ARB", 0x8240}, + { "", 'X', 1, "GL_SYNC_CL_EVENT_COMPLETE_ARB", 0x8241}, + { "glGet", 'B', 1, "GL_DEBUG_OUTPUT_SYNCHRONOUS", 0x8242}, + { "glGet", 'I', 1, "GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH", 0x8243}, + { "glGet", 'P', 1, "GL_DEBUG_CALLBACK_FUNCTION", 0x8244}, + { "glGet", 'P', 1, "GL_DEBUG_CALLBACK_USER_PARAM", 0x8245}, + { "", 'X', 1, "GL_DEBUG_SOURCE_API", 0x8246}, + { "", 'X', 1, "GL_DEBUG_SOURCE_WINDOW_SYSTEM", 0x8247}, + { "", 'X', 1, "GL_DEBUG_SOURCE_SHADER_COMPILER", 0x8248}, + { "", 'X', 1, "GL_DEBUG_SOURCE_THIRD_PARTY", 0x8249}, + { "", 'X', 1, "GL_DEBUG_SOURCE_APPLICATION", 0x824A}, + { "", 'X', 1, "GL_DEBUG_SOURCE_OTHER", 0x824B}, + { "", 'X', 1, "GL_DEBUG_TYPE_ERROR", 0x824C}, + { "", 'X', 1, "GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR", 0x824D}, + { "", 'X', 1, "GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR", 0x824E}, + { "", 'X', 1, "GL_DEBUG_TYPE_PORTABILITY", 0x824F}, + { "", 'X', 1, "GL_DEBUG_TYPE_PERFORMANCE", 0x8250}, + { "", 'X', 1, "GL_DEBUG_TYPE_OTHER", 0x8251}, + { "", 'X', 1, "GL_LOSE_CONTEXT_ON_RESET_ARB", 0x8252}, + { "", 'X', 1, "GL_GUILTY_CONTEXT_RESET_ARB", 0x8253}, + { "", 'X', 1, "GL_INNOCENT_CONTEXT_RESET_ARB", 0x8254}, + { "", 'X', 1, "GL_UNKNOWN_CONTEXT_RESET_ARB", 0x8255}, + { "glGet", 'E', 1, "GL_RESET_NOTIFICATION_STRATEGY_ARB", 0x8256}, + { "", 'X', 1, "GL_PROGRAM_BINARY_RETRIEVABLE_HINT", 0x8257}, + { "", 'X', 1, "GL_PROGRAM_SEPARABLE", 0x8258}, + { "glGet", 'I', 1, "GL_ACTIVE_PROGRAM", 0x8259}, + { "glGet", 'U', 1, "GL_PROGRAM_PIPELINE_BINDING", 0x825A}, + { "glGet", 'I', 1, "GL_MAX_VIEWPORTS", 0x825B}, + { "glGet", 'I', 1, "GL_VIEWPORT_SUBPIXEL_BITS", 0x825C}, + { "glGet", 'F', 2, "GL_VIEWPORT_BOUNDS_RANGE", 0x825D}, + { "glGet", 'E', 1, "GL_LAYER_PROVOKING_VERTEX", 0x825E}, + { "glGet", 'E', 1, "GL_VIEWPORT_INDEX_PROVOKING_VERTEX", 0x825F}, + { "", 'X', 1, "GL_UNDEFINED_VERTEX", 0x8260}, + { "", 'X', 1, "GL_NO_RESET_NOTIFICATION_ARB", 0x8261}, + { "glGet", 'I', 1, "GL_MAX_COMPUTE_SHARED_MEMORY_SIZE", 0x8262}, + { "glGet", 'I', 1, "GL_MAX_COMPUTE_UNIFORM_COMPONENTS", 0x8263}, + { "glGet", 'I', 1, "GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS", 0x8264}, + { "glGet", 'I', 1, "GL_MAX_COMPUTE_ATOMIC_COUNTERS", 0x8265}, + { "glGet", 'I', 1, "GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS", 0x8266}, + { "", 'X', 1, "GL_COMPUTE_LOCAL_WORK_SIZE", 0x8267}, + { "", 'X', 1, "GL_DEBUG_TYPE_MARKER", 0x8268}, + { "", 'X', 1, "GL_DEBUG_TYPE_PUSH_GROUP", 0x8269}, + { "", 'X', 1, "GL_DEBUG_TYPE_POP_GROUP", 0x826A}, + { "", 'X', 1, "GL_DEBUG_SEVERITY_NOTIFICATION", 0x826B}, + { "glGet", 'I', 1, "GL_MAX_DEBUG_GROUP_STACK_DEPTH", 0x826C}, + { "glGet", 'I', 1, "GL_DEBUG_GROUP_STACK_DEPTH", 0x826D}, + { "glGet", 'I', 1, "GL_MAX_UNIFORM_LOCATIONS", 0x826E}, + { "", 'I', 1, "GL_INTERNALFORMAT_SUPPORTED", 0x826F}, + { "", 'I', 1, "GL_INTERNALFORMAT_PREFERRED", 0x8270}, + { "", 'I', 1, "GL_INTERNALFORMAT_RED_SIZE", 0x8271}, + { "", 'I', 1, "GL_INTERNALFORMAT_GREEN_SIZE", 0x8272}, + { "", 'I', 1, "GL_INTERNALFORMAT_BLUE_SIZE", 0x8273}, + { "", 'I', 1, "GL_INTERNALFORMAT_ALPHA_SIZE", 0x8274}, + { "", 'I', 1, "GL_INTERNALFORMAT_DEPTH_SIZE", 0x8275}, + { "", 'I', 1, "GL_INTERNALFORMAT_STENCIL_SIZE", 0x8276}, + { "", 'I', 1, "GL_INTERNALFORMAT_SHARED_SIZE", 0x8277}, + { "", 'E', 1, "GL_INTERNALFORMAT_RED_TYPE", 0x8278}, + { "", 'E', 1, "GL_INTERNALFORMAT_GREEN_TYPE", 0x8279}, + { "", 'E', 1, "GL_INTERNALFORMAT_BLUE_TYPE", 0x827A}, + { "", 'E', 1, "GL_INTERNALFORMAT_ALPHA_TYPE", 0x827B}, + { "", 'E', 1, "GL_INTERNALFORMAT_DEPTH_TYPE", 0x827C}, + { "", 'E', 1, "GL_INTERNALFORMAT_STENCIL_TYPE", 0x827D}, + { "", 'I', 1, "GL_MAX_WIDTH", 0x827E}, + { "", 'I', 1, "GL_MAX_HEIGHT", 0x827F}, + { "", 'I', 1, "GL_MAX_DEPTH", 0x8280}, + { "", 'I', 1, "GL_MAX_LAYERS", 0x8281}, + { "", 'I', 1, "GL_MAX_COMBINED_DIMENSIONS", 0x8282}, + { "", 'X', 1, "GL_COLOR_COMPONENTS", 0x8283}, + { "", 'X', 1, "GL_DEPTH_COMPONENTS", 0x8284}, + { "", 'X', 1, "GL_STENCIL_COMPONENTS", 0x8285}, + { "", 'X', 1, "GL_COLOR_RENDERABLE", 0x8286}, + { "", 'X', 1, "GL_DEPTH_RENDERABLE", 0x8287}, + { "", 'X', 1, "GL_STENCIL_RENDERABLE", 0x8288}, + { "", 'X', 1, "GL_FRAMEBUFFER_RENDERABLE", 0x8289}, + { "", 'X', 1, "GL_FRAMEBUFFER_RENDERABLE_LAYERED", 0x828A}, + { "", 'X', 1, "GL_FRAMEBUFFER_BLEND", 0x828B}, + { "", 'X', 1, "GL_READ_PIXELS", 0x828C}, + { "", 'X', 1, "GL_READ_PIXELS_FORMAT", 0x828D}, + { "", 'X', 1, "GL_READ_PIXELS_TYPE", 0x828E}, + { "", 'X', 1, "GL_TEXTURE_IMAGE_FORMAT", 0x828F}, + { "", 'X', 1, "GL_TEXTURE_IMAGE_TYPE", 0x8290}, + { "", 'X', 1, "GL_GET_TEXTURE_IMAGE_FORMAT", 0x8291}, + { "", 'X', 1, "GL_GET_TEXTURE_IMAGE_TYPE", 0x8292}, + { "", 'X', 1, "GL_MIPMAP", 0x8293}, + { "", 'X', 1, "GL_MANUAL_GENERATE_MIPMAP", 0x8294}, + { "", 'X', 1, "GL_AUTO_GENERATE_MIPMAP", 0x8295}, + { "", 'X', 1, "GL_COLOR_ENCODING", 0x8296}, + { "", 'X', 1, "GL_SRGB_READ", 0x8297}, + { "", 'X', 1, "GL_SRGB_WRITE", 0x8298}, + { "", 'X', 1, "GL_SRGB_DECODE_ARB", 0x8299}, + { "", 'X', 1, "GL_FILTER", 0x829A}, + { "", 'X', 1, "GL_VERTEX_TEXTURE", 0x829B}, + { "", 'X', 1, "GL_TESS_CONTROL_TEXTURE", 0x829C}, + { "", 'X', 1, "GL_TESS_EVALUATION_TEXTURE", 0x829D}, + { "", 'X', 1, "GL_GEOMETRY_TEXTURE", 0x829E}, + { "", 'X', 1, "GL_FRAGMENT_TEXTURE", 0x829F}, + { "", 'X', 1, "GL_COMPUTE_TEXTURE", 0x82A0}, + { "", 'X', 1, "GL_TEXTURE_SHADOW", 0x82A1}, + { "", 'X', 1, "GL_TEXTURE_GATHER", 0x82A2}, + { "", 'X', 1, "GL_TEXTURE_GATHER_SHADOW", 0x82A3}, + { "", 'X', 1, "GL_SHADER_IMAGE_LOAD", 0x82A4}, + { "", 'X', 1, "GL_SHADER_IMAGE_STORE", 0x82A5}, + { "", 'X', 1, "GL_SHADER_IMAGE_ATOMIC", 0x82A6}, + { "", 'X', 1, "GL_IMAGE_TEXEL_SIZE", 0x82A7}, + { "", 'X', 1, "GL_IMAGE_COMPATIBILITY_CLASS", 0x82A8}, + { "", 'X', 1, "GL_IMAGE_PIXEL_FORMAT", 0x82A9}, + { "", 'X', 1, "GL_IMAGE_PIXEL_TYPE", 0x82AA}, + { "", 'X', 1, "GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST", 0x82AC}, + { "", 'X', 1, "GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST", 0x82AD}, + { "", 'X', 1, "GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE", 0x82AE}, + { "", 'X', 1, "GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE", 0x82AF}, + { "", 'X', 1, "GL_TEXTURE_COMPRESSED_BLOCK_WIDTH", 0x82B1}, + { "", 'X', 1, "GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT", 0x82B2}, + { "", 'X', 1, "GL_TEXTURE_COMPRESSED_BLOCK_SIZE", 0x82B3}, + { "", 'X', 1, "GL_CLEAR_BUFFER", 0x82B4}, + { "", 'X', 1, "GL_TEXTURE_VIEW", 0x82B5}, + { "", 'X', 1, "GL_VIEW_COMPATIBILITY_CLASS", 0x82B6}, + { "", 'X', 1, "GL_FULL_SUPPORT", 0x82B7}, + { "", 'X', 1, "GL_CAVEAT_SUPPORT", 0x82B8}, + { "", 'X', 1, "GL_IMAGE_CLASS_4_X_32", 0x82B9}, + { "", 'X', 1, "GL_IMAGE_CLASS_2_X_32", 0x82BA}, + { "", 'X', 1, "GL_IMAGE_CLASS_1_X_32", 0x82BB}, + { "", 'X', 1, "GL_IMAGE_CLASS_4_X_16", 0x82BC}, + { "", 'X', 1, "GL_IMAGE_CLASS_2_X_16", 0x82BD}, + { "", 'X', 1, "GL_IMAGE_CLASS_1_X_16", 0x82BE}, + { "", 'X', 1, "GL_IMAGE_CLASS_4_X_8", 0x82BF}, + { "", 'X', 1, "GL_IMAGE_CLASS_2_X_8", 0x82C0}, + { "", 'X', 1, "GL_IMAGE_CLASS_1_X_8", 0x82C1}, + { "", 'X', 1, "GL_IMAGE_CLASS_11_11_10", 0x82C2}, + { "", 'X', 1, "GL_IMAGE_CLASS_10_10_10_2", 0x82C3}, + { "", 'X', 1, "GL_VIEW_CLASS_128_BITS", 0x82C4}, + { "", 'X', 1, "GL_VIEW_CLASS_96_BITS", 0x82C5}, + { "", 'X', 1, "GL_VIEW_CLASS_64_BITS", 0x82C6}, + { "", 'X', 1, "GL_VIEW_CLASS_48_BITS", 0x82C7}, + { "", 'X', 1, "GL_VIEW_CLASS_32_BITS", 0x82C8}, + { "", 'X', 1, "GL_VIEW_CLASS_24_BITS", 0x82C9}, + { "", 'X', 1, "GL_VIEW_CLASS_16_BITS", 0x82CA}, + { "", 'X', 1, "GL_VIEW_CLASS_8_BITS", 0x82CB}, + { "", 'X', 1, "GL_VIEW_CLASS_S3TC_DXT1_RGB", 0x82CC}, + { "", 'X', 1, "GL_VIEW_CLASS_S3TC_DXT1_RGBA", 0x82CD}, + { "", 'X', 1, "GL_VIEW_CLASS_S3TC_DXT3_RGBA", 0x82CE}, + { "", 'X', 1, "GL_VIEW_CLASS_S3TC_DXT5_RGBA", 0x82CF}, + { "", 'X', 1, "GL_VIEW_CLASS_RGTC1_RED", 0x82D0}, + { "", 'X', 1, "GL_VIEW_CLASS_RGTC2_RG", 0x82D1}, + { "", 'X', 1, "GL_VIEW_CLASS_BPTC_UNORM", 0x82D2}, + { "", 'X', 1, "GL_VIEW_CLASS_BPTC_FLOAT", 0x82D3}, + { "glGet", 'I', 1, "GL_VERTEX_ATTRIB_BINDING", 0x82D4}, + { "glGet", 'I', 1, "GL_VERTEX_ATTRIB_RELATIVE_OFFSET", 0x82D5}, + { "glGetI", 'I', 1, "GL_VERTEX_BINDING_DIVISOR", 0x82D6}, + { "glGetI", 'I', 1, "GL_VERTEX_BINDING_OFFSET", 0x82D7}, + { "glGetI", 'I', 1, "GL_VERTEX_BINDING_STRIDE", 0x82D8}, + { "glGet", 'I', 1, "GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET", 0x82D9}, + { "glGet", 'I', 1, "GL_MAX_VERTEX_ATTRIB_BINDINGS", 0x82DA}, + { "glGetTexParameter", 'I', 1, "GL_TEXTURE_VIEW_MIN_LEVEL", 0x82DB}, + { "glGetTexParameter", 'I', 1, "GL_TEXTURE_VIEW_NUM_LEVELS", 0x82DC}, + { "glGetTexParameter", 'I', 1, "GL_TEXTURE_VIEW_MIN_LAYER", 0x82DD}, + { "glGetTexParameter", 'I', 1, "GL_TEXTURE_VIEW_NUM_LAYERS", 0x82DE}, + { "glGetTexParameter", 'I', 1, "GL_TEXTURE_IMMUTABLE_LEVELS", 0x82DF}, + { "", 'X', 1, "GL_BUFFER", 0x82E0}, + { "", 'X', 1, "GL_SHADER", 0x82E1}, + { "", 'X', 1, "GL_PROGRAM", 0x82E2}, + { "", 'X', 1, "GL_QUERY", 0x82E3}, + { "", 'X', 1, "GL_PROGRAM_PIPELINE", 0x82E4}, + { "", 'X', 1, "GL_SAMPLER", 0x82E6}, + { "", 'X', 1, "GL_DISPLAY_LIST", 0x82E7}, + { "glGet", 'I', 1, "GL_MAX_LABEL_LENGTH", 0x82E8}, + { "", 'X', 1, "GL_NUM_SHADING_LANGUAGE_VERSIONS", 0x82E9}, + { "", 'X', 1, "GL_DEPTH_PASS_INSTRUMENT_SGIX", 0x8310}, + { "", 'X', 1, "GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX", 0x8311}, + { "", 'X', 1, "GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX", 0x8312}, + { "glGet", 'I', 1, "GL_CONVOLUTION_HINT_SGIX", 0x8316}, + { "", 'X', 1, "GL_YCRCB_SGIX", 0x8318}, + { "", 'X', 1, "GL_YCRCBA_SGIX", 0x8319}, + { "", 'X', 1, "GL_ALPHA_MIN_SGIX", 0x8320}, + { "", 'X', 1, "GL_ALPHA_MAX_SGIX", 0x8321}, + { "", 'X', 1, "GL_SCALEBIAS_HINT_SGIX", 0x8322}, + { "", 'X', 1, "GL_ASYNC_MARKER_SGIX", 0x8329}, + { "glGet", 'I', 1, "GL_PIXEL_TEX_GEN_MODE_SGIX", 0x832B}, + { "", 'X', 1, "GL_ASYNC_HISTOGRAM_SGIX", 0x832C}, + { "", 'X', 1, "GL_MAX_ASYNC_HISTOGRAM_SGIX", 0x832D}, + { "", 'X', 1, "GL_PIXEL_TRANSFORM_2D_EXT", 0x8330}, + { "", 'X', 1, "GL_PIXEL_MAG_FILTER_EXT", 0x8331}, + { "", 'X', 1, "GL_PIXEL_MIN_FILTER_EXT", 0x8332}, + { "", 'X', 1, "GL_PIXEL_CUBIC_WEIGHT_EXT", 0x8333}, + { "", 'X', 1, "GL_CUBIC_EXT", 0x8334}, + { "", 'X', 1, "GL_AVERAGE_EXT", 0x8335}, + { "", 'X', 1, "GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT", 0x8336}, + { "", 'X', 1, "GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT", 0x8337}, + { "", 'X', 1, "GL_PIXEL_TRANSFORM_2D_MATRIX_EXT", 0x8338}, + { "", 'X', 1, "GL_FRAGMENT_MATERIAL_EXT", 0x8349}, + { "", 'X', 1, "GL_FRAGMENT_NORMAL_EXT", 0x834A}, + { "", 'X', 1, "GL_FRAGMENT_COLOR_EXT", 0x834C}, + { "", 'X', 1, "GL_ATTENUATION_EXT", 0x834D}, + { "", 'X', 1, "GL_SHADOW_ATTENUATION_EXT", 0x834E}, + { "glGet", 'I', 1, "GL_TEXTURE_APPLICATION_MODE_EXT", 0x834F}, + { "glGet", 'I', 1, "GL_TEXTURE_LIGHT_EXT", 0x8350}, + { "glGet", 'I', 1, "GL_TEXTURE_MATERIAL_FACE_EXT", 0x8351}, + { "glGet", 'I', 1, "GL_TEXTURE_MATERIAL_PARAMETER_EXT", 0x8352}, + { "glGet", 'I', 1, "GL_PIXEL_TEXTURE_SGIS", 0x8353}, + { "glGet", 'I', 1, "GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS", 0x8354}, + { "glGet", 'I', 1, "GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS", 0x8355}, + { "glGet", 'I', 1, "GL_PIXEL_GROUP_COLOR_SGIS", 0x8356}, + { "", 'X', 1, "GL_ASYNC_TEX_IMAGE_SGIX", 0x835C}, + { "", 'X', 1, "GL_ASYNC_DRAW_PIXELS_SGIX", 0x835D}, + { "", 'X', 1, "GL_ASYNC_READ_PIXELS_SGIX", 0x835E}, + { "", 'X', 1, "GL_MAX_ASYNC_TEX_IMAGE_SGIX", 0x835F}, + { "", 'X', 1, "GL_MAX_ASYNC_DRAW_PIXELS_SGIX", 0x8360}, + { "", 'X', 1, "GL_MAX_ASYNC_READ_PIXELS_SGIX", 0x8361}, + { "", 'X', 1, "GL_UNSIGNED_BYTE_2_3_3_REV", 0x8362}, + { "", 'X', 1, "GL_UNSIGNED_SHORT_5_6_5", 0x8363}, + { "", 'X', 1, "GL_UNSIGNED_SHORT_5_6_5_REV", 0x8364}, + { "", 'X', 1, "GL_UNSIGNED_SHORT_4_4_4_4_REV", 0x8365}, + { "", 'X', 1, "GL_UNSIGNED_SHORT_1_5_5_5_REV", 0x8366}, + { "", 'X', 1, "GL_UNSIGNED_INT_8_8_8_8_REV", 0x8367}, + { "", 'X', 1, "GL_UNSIGNED_INT_2_10_10_10_REV", 0x8368}, + { "glGetTexParameter", 'F', 1, "GL_TEXTURE_MAX_CLAMP_S_SGIX", 0x8369}, + { "glGetTexParameter", 'F', 1, "GL_TEXTURE_MAX_CLAMP_T_SGIX", 0x836A}, + { "glGetTexParameter", 'F', 1, "GL_TEXTURE_MAX_CLAMP_R_SGIX", 0x836B}, + { "", 'X', 1, "GL_MIRRORED_REPEAT", 0x8370}, + { "", 'X', 1, "GL_RGB_S3TC", 0x83A0}, + { "", 'X', 1, "GL_RGB4_S3TC", 0x83A1}, + { "", 'X', 1, "GL_RGBA_S3TC", 0x83A2}, + { "", 'X', 1, "GL_RGBA4_S3TC", 0x83A3}, + { "", 'X', 1, "GL_VERTEX_PRECLIP_SGIX", 0x83EE}, + { "", 'X', 1, "GL_VERTEX_PRECLIP_HINT_SGIX", 0x83EF}, + { "", 'X', 1, "GL_COMPRESSED_RGB_S3TC_DXT1_EXT", 0x83F0}, + { "", 'X', 1, "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT", 0x83F1}, + { "", 'X', 1, "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT", 0x83F2}, + { "", 'X', 1, "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT", 0x83F3}, + { "", 'X', 1, "GL_PARALLEL_ARRAYS_INTEL", 0x83F4}, + { "", 'X', 1, "GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL", 0x83F5}, + { "", 'X', 1, "GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL", 0x83F6}, + { "", 'X', 1, "GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL", 0x83F7}, + { "", 'X', 1, "GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL", 0x83F8}, + { "glGet", 'I', 1, "GL_FRAGMENT_LIGHTING_SGIX", 0x8400}, + { "glGet", 'I', 1, "GL_FRAGMENT_COLOR_MATERIAL_SGIX", 0x8401}, + { "glGet", 'I', 1, "GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX", 0x8402}, + { "glGet", 'I', 1, "GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX", 0x8403}, + { "glGet", 'I', 1, "GL_MAX_FRAGMENT_LIGHTS_SGIX", 0x8404}, + { "glGet", 'I', 1, "GL_MAX_ACTIVE_LIGHTS_SGIX", 0x8405}, + { "glGet", 'I', 1, "GL_CURRENT_RASTER_NORMAL_SGIX", 0x8406}, + { "glGet", 'I', 1, "GL_LIGHT_ENV_MODE_SGIX", 0x8407}, + { "glGet", 'I', 1, "GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX", 0x8408}, + { "glGet", 'I', 1, "GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX", 0x8409}, + { "glGet", 'F', 4, "GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX", 0x840A}, + { "glGet", 'I', 1, "GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX", 0x840B}, + { "glGet", 'I', 1, "GL_FRAGMENT_LIGHT0_SGIX", 0x840C}, + { "", 'X', 1, "GL_FRAGMENT_LIGHT1_SGIX", 0x840D}, + { "", 'X', 1, "GL_FRAGMENT_LIGHT2_SGIX", 0x840E}, + { "", 'X', 1, "GL_FRAGMENT_LIGHT3_SGIX", 0x840F}, + { "", 'X', 1, "GL_FRAGMENT_LIGHT4_SGIX", 0x8410}, + { "", 'X', 1, "GL_FRAGMENT_LIGHT5_SGIX", 0x8411}, + { "", 'X', 1, "GL_FRAGMENT_LIGHT6_SGIX", 0x8412}, + { "", 'X', 1, "GL_FRAGMENT_LIGHT7_SGIX", 0x8413}, + { "", 'X', 1, "GL_PACK_RESAMPLE_SGIX", 0x842C}, + { "", 'X', 1, "GL_UNPACK_RESAMPLE_SGIX", 0x842D}, + { "", 'X', 1, "GL_RESAMPLE_REPLICATE_SGIX", 0x842E}, + { "", 'X', 1, "GL_RESAMPLE_ZERO_FILL_SGIX", 0x842F}, + { "", 'X', 1, "GL_RESAMPLE_DECIMATE_SGIX", 0x8430}, + { "", 'X', 1, "GL_TANGENT_ARRAY_EXT", 0x8439}, + { "", 'X', 1, "GL_BINORMAL_ARRAY_EXT", 0x843A}, + { "", 'X', 1, "GL_CURRENT_TANGENT_EXT", 0x843B}, + { "", 'X', 1, "GL_CURRENT_BINORMAL_EXT", 0x843C}, + { "glGet", 'E', 1, "GL_TANGENT_ARRAY_TYPE_EXT", 0x843E}, + { "", 'X', 1, "GL_TANGENT_ARRAY_STRIDE_EXT", 0x843F}, + { "glGet", 'E', 1, "GL_BINORMAL_ARRAY_TYPE_EXT", 0x8440}, + { "", 'X', 1, "GL_BINORMAL_ARRAY_STRIDE_EXT", 0x8441}, + { "glGet", 'P', 1, "GL_TANGENT_ARRAY_POINTER_EXT", 0x8442}, + { "glGet", 'P', 1, "GL_BINORMAL_ARRAY_POINTER_EXT", 0x8443}, + { "", 'X', 1, "GL_MAP1_TANGENT_EXT", 0x8444}, + { "", 'X', 1, "GL_MAP2_TANGENT_EXT", 0x8445}, + { "", 'X', 1, "GL_MAP1_BINORMAL_EXT", 0x8446}, + { "", 'X', 1, "GL_MAP2_BINORMAL_EXT", 0x8447}, + { "", 'X', 1, "GL_NEAREST_CLIPMAP_NEAREST_SGIX", 0x844D}, + { "", 'X', 1, "GL_NEAREST_CLIPMAP_LINEAR_SGIX", 0x844E}, + { "", 'X', 1, "GL_LINEAR_CLIPMAP_NEAREST_SGIX", 0x844F}, + { "glGet", 'E', 1, "GL_FOG_COORD_SRC", 0x8450}, + { "", 'X', 1, "GL_FOG_COORD", 0x8451}, + { "", 'X', 1, "GL_FRAGMENT_DEPTH", 0x8452}, + { "glGet", 'F', 1, "GL_CURRENT_FOG_COORD", 0x8453}, + { "glGet", 'E', 1, "GL_FOG_COORD_ARRAY_TYPE", 0x8454}, + { "glGet", 'I', 1, "GL_FOG_COORD_ARRAY_STRIDE", 0x8455}, + { "glGet", 'P', 1, "GL_FOG_COORD_ARRAY_POINTER", 0x8456}, + { "glGet", 'B', 1, "GL_FOG_COORD_ARRAY", 0x8457}, + { "glGet", 'B', 1, "GL_COLOR_SUM", 0x8458}, + { "glGet", 'F', 4, "GL_CURRENT_SECONDARY_COLOR", 0x8459}, + { "glGet", 'I', 1, "GL_SECONDARY_COLOR_ARRAY_SIZE", 0x845A}, + { "glGet", 'E', 1, "GL_SECONDARY_COLOR_ARRAY_TYPE", 0x845B}, + { "glGet", 'I', 1, "GL_SECONDARY_COLOR_ARRAY_STRIDE", 0x845C}, + { "glGet", 'P', 1, "GL_SECONDARY_COLOR_ARRAY_POINTER", 0x845D}, + { "glGet", 'B', 1, "GL_SECONDARY_COLOR_ARRAY", 0x845E}, + { "glGet", 'F', 4, "GL_CURRENT_RASTER_SECONDARY_COLOR", 0x845F}, + { "glGet", 'F', 2, "GL_ALIASED_POINT_SIZE_RANGE", 0x846D}, + { "glGet", 'F', 2, "GL_ALIASED_LINE_WIDTH_RANGE", 0x846E}, + { "", 'X', 1, "GL_SCREEN_COORDINATES_REND", 0x8490}, + { "", 'X', 1, "GL_INVERTED_SCREEN_W_REND", 0x8491}, + { "", 'X', 1, "GL_TEXTURE0", 0x84C0}, + { "", 'X', 1, "GL_TEXTURE1", 0x84C1}, + { "", 'X', 1, "GL_TEXTURE2", 0x84C2}, + { "", 'X', 1, "GL_TEXTURE3", 0x84C3}, + { "", 'X', 1, "GL_TEXTURE4", 0x84C4}, + { "", 'X', 1, "GL_TEXTURE5", 0x84C5}, + { "", 'X', 1, "GL_TEXTURE6", 0x84C6}, + { "", 'X', 1, "GL_TEXTURE7", 0x84C7}, + { "", 'X', 1, "GL_TEXTURE8", 0x84C8}, + { "", 'X', 1, "GL_TEXTURE9", 0x84C9}, + { "", 'X', 1, "GL_TEXTURE10", 0x84CA}, + { "", 'X', 1, "GL_TEXTURE11", 0x84CB}, + { "", 'X', 1, "GL_TEXTURE12", 0x84CC}, + { "", 'X', 1, "GL_TEXTURE13", 0x84CD}, + { "", 'X', 1, "GL_TEXTURE14", 0x84CE}, + { "", 'X', 1, "GL_TEXTURE15", 0x84CF}, + { "", 'X', 1, "GL_TEXTURE16", 0x84D0}, + { "", 'X', 1, "GL_TEXTURE17", 0x84D1}, + { "", 'X', 1, "GL_TEXTURE18", 0x84D2}, + { "", 'X', 1, "GL_TEXTURE19", 0x84D3}, + { "", 'X', 1, "GL_TEXTURE20", 0x84D4}, + { "", 'X', 1, "GL_TEXTURE21", 0x84D5}, + { "", 'X', 1, "GL_TEXTURE22", 0x84D6}, + { "", 'X', 1, "GL_TEXTURE23", 0x84D7}, + { "", 'X', 1, "GL_TEXTURE24", 0x84D8}, + { "", 'X', 1, "GL_TEXTURE25", 0x84D9}, + { "", 'X', 1, "GL_TEXTURE26", 0x84DA}, + { "", 'X', 1, "GL_TEXTURE27", 0x84DB}, + { "", 'X', 1, "GL_TEXTURE28", 0x84DC}, + { "", 'X', 1, "GL_TEXTURE29", 0x84DD}, + { "", 'X', 1, "GL_TEXTURE30", 0x84DE}, + { "", 'X', 1, "GL_TEXTURE31", 0x84DF}, + { "glGet", 'E', 1, "GL_ACTIVE_TEXTURE", 0x84E0}, + { "glGet", 'E', 1, "GL_CLIENT_ACTIVE_TEXTURE", 0x84E1}, + { "glGet", 'I', 1, "GL_MAX_TEXTURE_UNITS", 0x84E2}, + { "glGet", 'F', 16, "GL_TRANSPOSE_MODELVIEW_MATRIX", 0x84E3}, + { "glGet", 'F', 16, "GL_TRANSPOSE_PROJECTION_MATRIX", 0x84E4}, + { "glGet", 'F', 16, "GL_TRANSPOSE_TEXTURE_MATRIX", 0x84E5}, + { "glGet", 'F', 16, "GL_TRANSPOSE_COLOR_MATRIX", 0x84E6}, + { "", 'X', 1, "GL_SUBTRACT", 0x84E7}, + { "glGet", 'I', 1, "GL_MAX_RENDERBUFFER_SIZE", 0x84E8}, + { "", 'X', 1, "GL_COMPRESSED_ALPHA", 0x84E9}, + { "", 'X', 1, "GL_COMPRESSED_LUMINANCE", 0x84EA}, + { "", 'X', 1, "GL_COMPRESSED_LUMINANCE_ALPHA", 0x84EB}, + { "", 'X', 1, "GL_COMPRESSED_INTENSITY", 0x84EC}, + { "", 'X', 1, "GL_COMPRESSED_RGB", 0x84ED}, + { "", 'X', 1, "GL_COMPRESSED_RGBA", 0x84EE}, + { "glGet", 'E', 1, "GL_TEXTURE_COMPRESSION_HINT", 0x84EF}, + { "glGetActiveUniformBlock", 'B', 1, "GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER", 0x84F0}, + { "glGetActiveUniformBlock", 'B', 1, "GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER", 0x84F1}, + { "", 'X', 1, "GL_ALL_COMPLETED_NV", 0x84F2}, + { "", 'X', 1, "GL_FENCE_STATUS_NV", 0x84F3}, + { "", 'X', 1, "GL_FENCE_CONDITION_NV", 0x84F4}, + { "_glGet", 'B', 1, "GL_TEXTURE_RECTANGLE", 0x84F5}, + { "glGet", 'I', 1, "GL_TEXTURE_BINDING_RECTANGLE", 0x84F6}, + { "", 'X', 1, "GL_PROXY_TEXTURE_RECTANGLE", 0x84F7}, + { "glGet", 'I', 1, "GL_MAX_RECTANGLE_TEXTURE_SIZE", 0x84F8}, + { "", 'X', 1, "GL_DEPTH_STENCIL", 0x84F9}, + { "", 'X', 1, "GL_UNSIGNED_INT_24_8", 0x84FA}, + { "glGet", 'F', 1, "GL_MAX_TEXTURE_LOD_BIAS", 0x84FD}, + { "glGetTexParameter", 'F', 1, "GL_TEXTURE_MAX_ANISOTROPY_EXT", 0x84FE}, + { "glGet", 'F', 1, "GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT", 0x84FF}, + { "", 'X', 1, "GL_TEXTURE_FILTER_CONTROL", 0x8500}, + { "glGetTexParameter,glGetTexEnv", 'F', 1, "GL_TEXTURE_LOD_BIAS", 0x8501}, + { "", 'X', 1, "GL_MODELVIEW1_STACK_DEPTH_EXT", 0x8502}, + { "", 'X', 1, "GL_COMBINE4_NV", 0x8503}, + { "glGet", 'F', 1, "GL_MAX_SHININESS_NV", 0x8504}, + { "glGet", 'F', 1, "GL_MAX_SPOT_EXPONENT_NV", 0x8505}, + { "", 'X', 1, "GL_MODELVIEW1_MATRIX_EXT", 0x8506}, + { "", 'X', 1, "GL_INCR_WRAP", 0x8507}, + { "", 'X', 1, "GL_DECR_WRAP", 0x8508}, + { "", 'X', 1, "GL_VERTEX_WEIGHTING_EXT", 0x8509}, + { "", 'X', 1, "GL_MODELVIEW1_ARB", 0x850A}, + { "", 'X', 1, "GL_CURRENT_VERTEX_WEIGHT_EXT", 0x850B}, + { "", 'X', 1, "GL_VERTEX_WEIGHT_ARRAY_EXT", 0x850C}, + { "", 'X', 1, "GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT", 0x850D}, + { "glGet", 'E', 1, "GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT", 0x850E}, + { "", 'X', 1, "GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT", 0x850F}, + { "", 'X', 1, "GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT", 0x8510}, + { "", 'X', 1, "GL_NORMAL_MAP", 0x8511}, + { "", 'X', 1, "GL_REFLECTION_MAP", 0x8512}, + { "glGet", 'B', 1, "GL_TEXTURE_CUBE_MAP", 0x8513}, + { "glGet", 'I', 1, "GL_TEXTURE_BINDING_CUBE_MAP", 0x8514}, + { "", 'X', 1, "GL_TEXTURE_CUBE_MAP_POSITIVE_X", 0x8515}, + { "", 'X', 1, "GL_TEXTURE_CUBE_MAP_NEGATIVE_X", 0x8516}, + { "", 'X', 1, "GL_TEXTURE_CUBE_MAP_POSITIVE_Y", 0x8517}, + { "", 'X', 1, "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y", 0x8518}, + { "", 'X', 1, "GL_TEXTURE_CUBE_MAP_POSITIVE_Z", 0x8519}, + { "", 'X', 1, "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z", 0x851A}, + { "", 'X', 1, "GL_PROXY_TEXTURE_CUBE_MAP", 0x851B}, + { "glGet", 'I', 1, "GL_MAX_CUBE_MAP_TEXTURE_SIZE", 0x851C}, + { "_glGet", 'B', 1, "GL_VERTEX_ARRAY_RANGE_NV", 0x851D}, + { "_glGet", 'I', 1, "GL_VERTEX_ARRAY_RANGE_LENGTH_NV", 0x851E}, + { "_glGet", 'B', 1, "GL_VERTEX_ARRAY_RANGE_VALID_NV", 0x851F}, + { "_glGet", 'I', 1, "GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV", 0x8520}, + { "_glGet", 'P', 1, "GL_VERTEX_ARRAY_RANGE_POINTER_NV", 0x8521}, + { "", 'X', 1, "GL_REGISTER_COMBINERS_NV", 0x8522}, + { "", 'X', 1, "GL_VARIABLE_A_NV", 0x8523}, + { "", 'X', 1, "GL_VARIABLE_B_NV", 0x8524}, + { "", 'X', 1, "GL_VARIABLE_C_NV", 0x8525}, + { "", 'X', 1, "GL_VARIABLE_D_NV", 0x8526}, + { "", 'X', 1, "GL_VARIABLE_E_NV", 0x8527}, + { "", 'X', 1, "GL_VARIABLE_F_NV", 0x8528}, + { "", 'X', 1, "GL_VARIABLE_G_NV", 0x8529}, + { "glGet", 'F', 4, "GL_CONSTANT_COLOR0_NV", 0x852A}, + { "glGet", 'F', 4, "GL_CONSTANT_COLOR1_NV", 0x852B}, + { "", 'X', 1, "GL_PRIMARY_COLOR_NV", 0x852C}, + { "", 'X', 1, "GL_SECONDARY_COLOR_NV", 0x852D}, + { "", 'X', 1, "GL_SPARE0_NV", 0x852E}, + { "", 'X', 1, "GL_SPARE1_NV", 0x852F}, + { "", 'X', 1, "GL_DISCARD_NV", 0x8530}, + { "", 'X', 1, "GL_E_TIMES_F_NV", 0x8531}, + { "", 'X', 1, "GL_SPARE0_PLUS_SECONDARY_COLOR_NV", 0x8532}, + { "", 'X', 1, "GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV", 0x8533}, + { "glGet", 'E', 1, "GL_MULTISAMPLE_FILTER_HINT_NV", 0x8534}, + { "", 'X', 1, "GL_PER_STAGE_CONSTANTS_NV", 0x8535}, + { "", 'X', 1, "GL_UNSIGNED_IDENTITY_NV", 0x8536}, + { "", 'X', 1, "GL_UNSIGNED_INVERT_NV", 0x8537}, + { "", 'X', 1, "GL_EXPAND_NORMAL_NV", 0x8538}, + { "", 'X', 1, "GL_EXPAND_NEGATE_NV", 0x8539}, + { "", 'X', 1, "GL_HALF_BIAS_NORMAL_NV", 0x853A}, + { "", 'X', 1, "GL_HALF_BIAS_NEGATE_NV", 0x853B}, + { "", 'X', 1, "GL_SIGNED_IDENTITY_NV", 0x853C}, + { "", 'X', 1, "GL_SIGNED_NEGATE_NV", 0x853D}, + { "", 'X', 1, "GL_SCALE_BY_TWO_NV", 0x853E}, + { "", 'X', 1, "GL_SCALE_BY_FOUR_NV", 0x853F}, + { "", 'X', 1, "GL_SCALE_BY_ONE_HALF_NV", 0x8540}, + { "", 'X', 1, "GL_BIAS_BY_NEGATIVE_ONE_HALF_NV", 0x8541}, + { "", 'X', 1, "GL_COMBINER_INPUT_NV", 0x8542}, + { "", 'X', 1, "GL_COMBINER_MAPPING_NV", 0x8543}, + { "", 'X', 1, "GL_COMBINER_COMPONENT_USAGE_NV", 0x8544}, + { "", 'X', 1, "GL_COMBINER_AB_DOT_PRODUCT_NV", 0x8545}, + { "", 'X', 1, "GL_COMBINER_CD_DOT_PRODUCT_NV", 0x8546}, + { "", 'X', 1, "GL_COMBINER_MUX_SUM_NV", 0x8547}, + { "", 'X', 1, "GL_COMBINER_SCALE_NV", 0x8548}, + { "", 'X', 1, "GL_COMBINER_BIAS_NV", 0x8549}, + { "", 'X', 1, "GL_COMBINER_AB_OUTPUT_NV", 0x854A}, + { "", 'X', 1, "GL_COMBINER_CD_OUTPUT_NV", 0x854B}, + { "", 'X', 1, "GL_COMBINER_SUM_OUTPUT_NV", 0x854C}, + { "glGet", 'I', 1, "GL_MAX_GENERAL_COMBINERS_NV", 0x854D}, + { "glGet", 'I', 1, "GL_NUM_GENERAL_COMBINERS_NV", 0x854E}, + { "glGet", 'B', 1, "GL_COLOR_SUM_CLAMP_NV", 0x854F}, + { "", 'X', 1, "GL_COMBINER0_NV", 0x8550}, + { "", 'X', 1, "GL_COMBINER1_NV", 0x8551}, + { "", 'X', 1, "GL_COMBINER2_NV", 0x8552}, + { "", 'X', 1, "GL_COMBINER3_NV", 0x8553}, + { "", 'X', 1, "GL_COMBINER4_NV", 0x8554}, + { "", 'X', 1, "GL_COMBINER5_NV", 0x8555}, + { "", 'X', 1, "GL_COMBINER6_NV", 0x8556}, + { "", 'X', 1, "GL_COMBINER7_NV", 0x8557}, + { "", 'X', 1, "GL_PRIMITIVE_RESTART_NV", 0x8558}, + { "", 'X', 1, "GL_PRIMITIVE_RESTART_INDEX_NV", 0x8559}, + { "glGet", 'E', 1, "GL_FOG_DISTANCE_MODE_NV", 0x855A}, + { "", 'X', 1, "GL_EYE_RADIAL_NV", 0x855B}, + { "", 'X', 1, "GL_EYE_PLANE_ABSOLUTE_NV", 0x855C}, + { "", 'X', 1, "GL_EMBOSS_LIGHT_NV", 0x855D}, + { "", 'X', 1, "GL_EMBOSS_CONSTANT_NV", 0x855E}, + { "", 'X', 1, "GL_EMBOSS_MAP_NV", 0x855F}, + { "", 'X', 1, "GL_RED_MIN_CLAMP_INGR", 0x8560}, + { "", 'X', 1, "GL_GREEN_MIN_CLAMP_INGR", 0x8561}, + { "", 'X', 1, "GL_BLUE_MIN_CLAMP_INGR", 0x8562}, + { "", 'X', 1, "GL_ALPHA_MIN_CLAMP_INGR", 0x8563}, + { "", 'X', 1, "GL_RED_MAX_CLAMP_INGR", 0x8564}, + { "", 'X', 1, "GL_GREEN_MAX_CLAMP_INGR", 0x8565}, + { "", 'X', 1, "GL_BLUE_MAX_CLAMP_INGR", 0x8566}, + { "", 'X', 1, "GL_ALPHA_MAX_CLAMP_INGR", 0x8567}, + { "", 'X', 1, "GL_INTERLACE_READ_INGR", 0x8568}, + { "", 'X', 1, "GL_COMBINE", 0x8570}, + { "glGetTexEnv", 'E', 1, "GL_COMBINE_RGB", 0x8571}, + { "glGetTexEnv", 'E', 1, "GL_COMBINE_ALPHA", 0x8572}, + { "glGetTexEnv", 'F', 1, "GL_RGB_SCALE", 0x8573}, + { "", 'X', 1, "GL_ADD_SIGNED", 0x8574}, + { "", 'X', 1, "GL_INTERPOLATE", 0x8575}, + { "", 'X', 1, "GL_CONSTANT", 0x8576}, + { "", 'X', 1, "GL_PRIMARY_COLOR", 0x8577}, + { "", 'X', 1, "GL_PREVIOUS", 0x8578}, + { "glGetTexEnv", 'E', 1, "GL_SRC0_RGB", 0x8580}, + { "glGetTexEnv", 'E', 1, "GL_SRC1_RGB", 0x8581}, + { "glGetTexEnv", 'E', 1, "GL_SRC2_RGB", 0x8582}, + { "glGetTexEnv", 'E', 1, "GL_SOURCE3_RGB_NV", 0x8583}, + { "glGetTexEnv", 'E', 1, "GL_SRC0_ALPHA", 0x8588}, + { "glGetTexEnv", 'E', 1, "GL_SRC1_ALPHA", 0x8589}, + { "glGetTexEnv", 'E', 1, "GL_SRC2_ALPHA", 0x858A}, + { "glGetTexEnv", 'E', 1, "GL_SOURCE3_ALPHA_NV", 0x858B}, + { "glGetTexEnv", 'E', 1, "GL_OPERAND0_RGB", 0x8590}, + { "glGetTexEnv", 'E', 1, "GL_OPERAND1_RGB", 0x8591}, + { "glGetTexEnv", 'E', 1, "GL_OPERAND2_RGB", 0x8592}, + { "glGetTexEnv", 'E', 1, "GL_OPERAND3_RGB_NV", 0x8593}, + { "glGetTexEnv", 'E', 1, "GL_OPERAND0_ALPHA", 0x8598}, + { "glGetTexEnv", 'E', 1, "GL_OPERAND1_ALPHA", 0x8599}, + { "glGetTexEnv", 'E', 1, "GL_OPERAND2_ALPHA", 0x859A}, + { "glGetTexEnv", 'E', 1, "GL_OPERAND3_ALPHA_NV", 0x859B}, + { "", 'X', 1, "GL_PACK_SUBSAMPLE_RATE_SGIX", 0x85A0}, + { "", 'X', 1, "GL_UNPACK_SUBSAMPLE_RATE_SGIX", 0x85A1}, + { "", 'X', 1, "GL_PIXEL_SUBSAMPLE_4444_SGIX", 0x85A2}, + { "", 'X', 1, "GL_PIXEL_SUBSAMPLE_2424_SGIX", 0x85A3}, + { "", 'X', 1, "GL_PIXEL_SUBSAMPLE_4242_SGIX", 0x85A4}, + { "", 'X', 1, "GL_PERTURB_EXT", 0x85AE}, + { "", 'X', 1, "GL_TEXTURE_NORMAL_EXT", 0x85AF}, + { "", 'X', 1, "GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE", 0x85B0}, + { "", 'X', 1, "GL_TRANSFORM_HINT_APPLE", 0x85B1}, + { "", 'X', 1, "GL_UNPACK_CLIENT_STORAGE_APPLE", 0x85B2}, + { "", 'X', 1, "GL_BUFFER_OBJECT_APPLE", 0x85B3}, + { "", 'X', 1, "GL_STORAGE_CLIENT_APPLE", 0x85B4}, + { "glGet", 'I', 1, "GL_VERTEX_ARRAY_BINDING", 0x85B5}, + { "glGetTexParameter", 'X', 1, "GL_TEXTURE_RANGE_LENGTH_APPLE", 0x85B7}, + { "", 'P', 1, "GL_TEXTURE_RANGE_POINTER_APPLE", 0x85B8}, + { "", 'X', 1, "GL_YCBCR_422_APPLE", 0x85B9}, + { "", 'X', 1, "GL_UNSIGNED_SHORT_8_8_MESA", 0x85BA}, + { "", 'X', 1, "GL_UNSIGNED_SHORT_8_8_REV_MESA", 0x85BB}, + { "glGetTexParameter", 'E', 1, "GL_TEXTURE_STORAGE_HINT_APPLE", 0x85BC}, + { "", 'X', 1, "GL_STORAGE_PRIVATE_APPLE", 0x85BD}, + { "", 'X', 1, "GL_STORAGE_CACHED_APPLE", 0x85BE}, + { "", 'X', 1, "GL_STORAGE_SHARED_APPLE", 0x85BF}, + { "", 'X', 1, "GL_REPLACEMENT_CODE_ARRAY_SUN", 0x85C0}, + { "glGet", 'E', 1, "GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN", 0x85C1}, + { "", 'X', 1, "GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN", 0x85C2}, + { "", 'X', 1, "GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN", 0x85C3}, + { "", 'X', 1, "GL_R1UI_V3F_SUN", 0x85C4}, + { "", 'X', 1, "GL_R1UI_C4UB_V3F_SUN", 0x85C5}, + { "", 'X', 1, "GL_R1UI_C3F_V3F_SUN", 0x85C6}, + { "", 'X', 1, "GL_R1UI_N3F_V3F_SUN", 0x85C7}, + { "", 'X', 1, "GL_R1UI_C4F_N3F_V3F_SUN", 0x85C8}, + { "", 'X', 1, "GL_R1UI_T2F_V3F_SUN", 0x85C9}, + { "", 'X', 1, "GL_R1UI_T2F_N3F_V3F_SUN", 0x85CA}, + { "", 'X', 1, "GL_R1UI_T2F_C4F_N3F_V3F_SUN", 0x85CB}, + { "", 'X', 1, "GL_SLICE_ACCUM_SUN", 0x85CC}, + { "", 'X', 1, "GL_QUAD_MESH_SUN", 0x8614}, + { "", 'X', 1, "GL_TRIANGLE_MESH_SUN", 0x8615}, + { "glGet", 'B', 1, "GL_VERTEX_PROGRAM_ARB", 0x8620}, + { "", 'X', 1, "GL_VERTEX_STATE_PROGRAM_NV", 0x8621}, + { "glGetVertexAttrib", 'B', 1, "GL_VERTEX_ATTRIB_ARRAY_ENABLED", 0x8622}, + { "glGetVertexAttrib", 'I', 1, "GL_VERTEX_ATTRIB_ARRAY_SIZE", 0x8623}, + { "glGetVertexAttrib", 'I', 1, "GL_VERTEX_ATTRIB_ARRAY_STRIDE", 0x8624}, + { "glGetVertexAttrib", 'E', 1, "GL_VERTEX_ATTRIB_ARRAY_TYPE", 0x8625}, + { "glGetVertexAttrib", 'D', 4, "GL_CURRENT_VERTEX_ATTRIB", 0x8626}, + { "glGetProgramARB", 'I', 1, "GL_PROGRAM_LENGTH_ARB", 0x8627}, + { "", 'S', 1, "GL_PROGRAM_STRING_ARB", 0x8628}, + { "", 'X', 1, "GL_MODELVIEW_PROJECTION_NV", 0x8629}, + { "", 'X', 1, "GL_IDENTITY_NV", 0x862A}, + { "", 'X', 1, "GL_INVERSE_NV", 0x862B}, + { "", 'X', 1, "GL_TRANSPOSE_NV", 0x862C}, + { "", 'X', 1, "GL_INVERSE_TRANSPOSE_NV", 0x862D}, + { "glGet", 'I', 1, "GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB", 0x862E}, + { "glGet", 'I', 1, "GL_MAX_PROGRAM_MATRICES_ARB", 0x862F}, + { "", 'X', 1, "GL_MATRIX0_NV", 0x8630}, + { "", 'X', 1, "GL_MATRIX1_NV", 0x8631}, + { "", 'X', 1, "GL_MATRIX2_NV", 0x8632}, + { "", 'X', 1, "GL_MATRIX3_NV", 0x8633}, + { "", 'X', 1, "GL_MATRIX4_NV", 0x8634}, + { "", 'X', 1, "GL_MATRIX5_NV", 0x8635}, + { "", 'X', 1, "GL_MATRIX6_NV", 0x8636}, + { "", 'X', 1, "GL_MATRIX7_NV", 0x8637}, + { "glGet", 'I', 1, "GL_CURRENT_MATRIX_STACK_DEPTH_ARB", 0x8640}, + { "glGet", 'F', 16, "GL_CURRENT_MATRIX_ARB", 0x8641}, + { "glGet", 'B', 1, "GL_PROGRAM_POINT_SIZE", 0x8642}, + { "glGet", 'B', 1, "GL_VERTEX_PROGRAM_TWO_SIDE", 0x8643}, + { "", 'X', 1, "GL_PROGRAM_PARAMETER_NV", 0x8644}, + { "glGetVertexAttrib", 'P', 1, "GL_VERTEX_ATTRIB_ARRAY_POINTER", 0x8645}, + { "glGetProgramNV", 'I', 1, "GL_PROGRAM_TARGET_NV", 0x8646}, + { "glGetProgramNV", 'B', 1, "GL_PROGRAM_RESIDENT_NV", 0x8647}, + { "", 'X', 1, "GL_TRACK_MATRIX_NV", 0x8648}, + { "", 'X', 1, "GL_TRACK_MATRIX_TRANSFORM_NV", 0x8649}, + { "glGet", 'I', 1, "GL_VERTEX_PROGRAM_BINDING_NV", 0x864A}, + { "glGet", 'I', 1, "GL_PROGRAM_ERROR_POSITION_ARB", 0x864B}, + { "", 'X', 1, "GL_OFFSET_TEXTURE_RECTANGLE_NV", 0x864C}, + { "", 'X', 1, "GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV", 0x864D}, + { "", 'X', 1, "GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV", 0x864E}, + { "glGet", 'B', 1, "GL_DEPTH_CLAMP", 0x864F}, + { "_glGet", 'B', 1, "GL_VERTEX_ATTRIB_ARRAY0_NV", 0x8650}, + { "_glGet", 'B', 1, "GL_VERTEX_ATTRIB_ARRAY1_NV", 0x8651}, + { "_glGet", 'B', 1, "GL_VERTEX_ATTRIB_ARRAY2_NV", 0x8652}, + { "_glGet", 'B', 1, "GL_VERTEX_ATTRIB_ARRAY3_NV", 0x8653}, + { "_glGet", 'B', 1, "GL_VERTEX_ATTRIB_ARRAY4_NV", 0x8654}, + { "_glGet", 'B', 1, "GL_VERTEX_ATTRIB_ARRAY5_NV", 0x8655}, + { "_glGet", 'B', 1, "GL_VERTEX_ATTRIB_ARRAY6_NV", 0x8656}, + { "_glGet", 'B', 1, "GL_VERTEX_ATTRIB_ARRAY7_NV", 0x8657}, + { "_glGet", 'B', 1, "GL_VERTEX_ATTRIB_ARRAY8_NV", 0x8658}, + { "_glGet", 'B', 1, "GL_VERTEX_ATTRIB_ARRAY9_NV", 0x8659}, + { "_glGet", 'B', 1, "GL_VERTEX_ATTRIB_ARRAY10_NV", 0x865A}, + { "_glGet", 'B', 1, "GL_VERTEX_ATTRIB_ARRAY11_NV", 0x865B}, + { "_glGet", 'B', 1, "GL_VERTEX_ATTRIB_ARRAY12_NV", 0x865C}, + { "_glGet", 'B', 1, "GL_VERTEX_ATTRIB_ARRAY13_NV", 0x865D}, + { "_glGet", 'B', 1, "GL_VERTEX_ATTRIB_ARRAY14_NV", 0x865E}, + { "_glGet", 'B', 1, "GL_VERTEX_ATTRIB_ARRAY15_NV", 0x865F}, + { "", 'X', 1, "GL_MAP1_VERTEX_ATTRIB0_4_NV", 0x8660}, + { "", 'X', 1, "GL_MAP1_VERTEX_ATTRIB1_4_NV", 0x8661}, + { "", 'X', 1, "GL_MAP1_VERTEX_ATTRIB2_4_NV", 0x8662}, + { "", 'X', 1, "GL_MAP1_VERTEX_ATTRIB3_4_NV", 0x8663}, + { "", 'X', 1, "GL_MAP1_VERTEX_ATTRIB4_4_NV", 0x8664}, + { "", 'X', 1, "GL_MAP1_VERTEX_ATTRIB5_4_NV", 0x8665}, + { "", 'X', 1, "GL_MAP1_VERTEX_ATTRIB6_4_NV", 0x8666}, + { "", 'X', 1, "GL_MAP1_VERTEX_ATTRIB7_4_NV", 0x8667}, + { "", 'X', 1, "GL_MAP1_VERTEX_ATTRIB8_4_NV", 0x8668}, + { "", 'X', 1, "GL_MAP1_VERTEX_ATTRIB9_4_NV", 0x8669}, + { "", 'X', 1, "GL_MAP1_VERTEX_ATTRIB10_4_NV", 0x866A}, + { "", 'X', 1, "GL_MAP1_VERTEX_ATTRIB11_4_NV", 0x866B}, + { "", 'X', 1, "GL_MAP1_VERTEX_ATTRIB12_4_NV", 0x866C}, + { "", 'X', 1, "GL_MAP1_VERTEX_ATTRIB13_4_NV", 0x866D}, + { "", 'X', 1, "GL_MAP1_VERTEX_ATTRIB14_4_NV", 0x866E}, + { "", 'X', 1, "GL_MAP1_VERTEX_ATTRIB15_4_NV", 0x866F}, + { "", 'X', 1, "GL_MAP2_VERTEX_ATTRIB0_4_NV", 0x8670}, + { "", 'X', 1, "GL_MAP2_VERTEX_ATTRIB1_4_NV", 0x8671}, + { "", 'X', 1, "GL_MAP2_VERTEX_ATTRIB2_4_NV", 0x8672}, + { "", 'X', 1, "GL_MAP2_VERTEX_ATTRIB3_4_NV", 0x8673}, + { "", 'X', 1, "GL_MAP2_VERTEX_ATTRIB4_4_NV", 0x8674}, + { "", 'X', 1, "GL_MAP2_VERTEX_ATTRIB5_4_NV", 0x8675}, + { "", 'X', 1, "GL_MAP2_VERTEX_ATTRIB6_4_NV", 0x8676}, + { "glGetProgramARB", 'I', 1, "GL_PROGRAM_BINDING_ARB", 0x8677}, + { "", 'X', 1, "GL_MAP2_VERTEX_ATTRIB8_4_NV", 0x8678}, + { "", 'X', 1, "GL_MAP2_VERTEX_ATTRIB9_4_NV", 0x8679}, + { "", 'X', 1, "GL_MAP2_VERTEX_ATTRIB10_4_NV", 0x867A}, + { "", 'X', 1, "GL_MAP2_VERTEX_ATTRIB11_4_NV", 0x867B}, + { "", 'X', 1, "GL_MAP2_VERTEX_ATTRIB12_4_NV", 0x867C}, + { "", 'X', 1, "GL_MAP2_VERTEX_ATTRIB13_4_NV", 0x867D}, + { "", 'X', 1, "GL_MAP2_VERTEX_ATTRIB14_4_NV", 0x867E}, + { "", 'X', 1, "GL_MAP2_VERTEX_ATTRIB15_4_NV", 0x867F}, + { "glGetTexLevelParameter", 'I', 1, "GL_TEXTURE_COMPRESSED_IMAGE_SIZE", 0x86A0}, + { "glGetTexLevelParameter", 'B', 1, "GL_TEXTURE_COMPRESSED", 0x86A1}, + { "glGet", 'I', 1, "GL_NUM_COMPRESSED_TEXTURE_FORMATS", 0x86A2}, + //{ "glGet", 'E', '_glGetInteger{ GL_NUM_COMPRESSED_TEXTURE_FORMATS)', "GL_COMPRESSED_TEXTURE_FORMATS", 0x86A3}, + { "glGet", 'I', 1, "GL_MAX_VERTEX_UNITS_ARB", 0x86A4}, + { "glGet", 'I', 1, "GL_ACTIVE_VERTEX_UNITS_ARB", 0x86A5}, + { "glGet", 'B', 1, "GL_WEIGHT_SUM_UNITY_ARB", 0x86A6}, + { "glGet", 'B', 1, "GL_VERTEX_BLEND_ARB", 0x86A7}, + { "glGet", 'F', 1, "GL_CURRENT_WEIGHT_ARB", 0x86A8}, + { "glGet", 'E', 1, "GL_WEIGHT_ARRAY_TYPE_ARB", 0x86A9}, + { "glGet", 'I', 1, "GL_WEIGHT_ARRAY_STRIDE_ARB", 0x86AA}, + { "glGet", 'I', 1, "GL_WEIGHT_ARRAY_SIZE_ARB", 0x86AB}, + { "glGet", 'P', 1, "GL_WEIGHT_ARRAY_POINTER_ARB", 0x86AC}, + { "glGet", 'B', 1, "GL_WEIGHT_ARRAY_ARB", 0x86AD}, + { "", 'X', 1, "GL_DOT3_RGB", 0x86AE}, + { "", 'X', 1, "GL_DOT3_RGBA", 0x86AF}, + { "", 'X', 1, "GL_COMPRESSED_RGB_FXT1_3DFX", 0x86B0}, + { "", 'X', 1, "GL_COMPRESSED_RGBA_FXT1_3DFX", 0x86B1}, + { "", 'X', 1, "GL_MULTISAMPLE_3DFX", 0x86B2}, + { "", 'X', 1, "GL_SAMPLE_BUFFERS_3DFX", 0x86B3}, + { "", 'X', 1, "GL_SAMPLES_3DFX", 0x86B4}, + { "", 'X', 1, "GL_EVAL_2D_NV", 0x86C0}, + { "", 'X', 1, "GL_EVAL_TRIANGULAR_2D_NV", 0x86C1}, + { "", 'X', 1, "GL_MAP_TESSELLATION_NV", 0x86C2}, + { "", 'X', 1, "GL_MAP_ATTRIB_U_ORDER_NV", 0x86C3}, + { "", 'X', 1, "GL_MAP_ATTRIB_V_ORDER_NV", 0x86C4}, + { "", 'X', 1, "GL_EVAL_FRACTIONAL_TESSELLATION_NV", 0x86C5}, + { "", 'X', 1, "GL_EVAL_VERTEX_ATTRIB0_NV", 0x86C6}, + { "", 'X', 1, "GL_EVAL_VERTEX_ATTRIB1_NV", 0x86C7}, + { "", 'X', 1, "GL_EVAL_VERTEX_ATTRIB2_NV", 0x86C8}, + { "", 'X', 1, "GL_EVAL_VERTEX_ATTRIB3_NV", 0x86C9}, + { "", 'X', 1, "GL_EVAL_VERTEX_ATTRIB4_NV", 0x86CA}, + { "", 'X', 1, "GL_EVAL_VERTEX_ATTRIB5_NV", 0x86CB}, + { "", 'X', 1, "GL_EVAL_VERTEX_ATTRIB6_NV", 0x86CC}, + { "", 'X', 1, "GL_EVAL_VERTEX_ATTRIB7_NV", 0x86CD}, + { "", 'X', 1, "GL_EVAL_VERTEX_ATTRIB8_NV", 0x86CE}, + { "", 'X', 1, "GL_EVAL_VERTEX_ATTRIB9_NV", 0x86CF}, + { "", 'X', 1, "GL_EVAL_VERTEX_ATTRIB10_NV", 0x86D0}, + { "", 'X', 1, "GL_EVAL_VERTEX_ATTRIB11_NV", 0x86D1}, + { "", 'X', 1, "GL_EVAL_VERTEX_ATTRIB12_NV", 0x86D2}, + { "", 'X', 1, "GL_EVAL_VERTEX_ATTRIB13_NV", 0x86D3}, + { "", 'X', 1, "GL_EVAL_VERTEX_ATTRIB14_NV", 0x86D4}, + { "", 'X', 1, "GL_EVAL_VERTEX_ATTRIB15_NV", 0x86D5}, + { "", 'X', 1, "GL_MAX_MAP_TESSELLATION_NV", 0x86D6}, + { "", 'X', 1, "GL_MAX_RATIONAL_EVAL_ORDER_NV", 0x86D7}, + { "", 'X', 1, "GL_MAX_PROGRAM_PATCH_ATTRIBS_NV", 0x86D8}, + { "glGetTexEnv", 'E', 1, "GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV", 0x86D9}, + { "", 'X', 1, "GL_UNSIGNED_INT_S8_S8_8_8_NV", 0x86DA}, + { "", 'X', 1, "GL_UNSIGNED_INT_8_8_S8_S8_REV_NV", 0x86DB}, + { "", 'X', 1, "GL_DSDT_MAG_INTENSITY_NV", 0x86DC}, + { "", 'X', 1, "GL_SHADER_CONSISTENT_NV", 0x86DD}, + { "", 'X', 1, "GL_TEXTURE_SHADER_NV", 0x86DE}, + { "glGetTexEnv", 'E', 1, "GL_SHADER_OPERATION_NV", 0x86DF}, + { "glGetTexEnv", 'E', 4, "GL_CULL_MODES_NV", 0x86E0}, + { "glGetTexEnv", 'F', 4, "GL_OFFSET_TEXTURE_MATRIX_NV", 0x86E1}, + { "glGetTexEnv", 'F', 1, "GL_OFFSET_TEXTURE_SCALE_NV", 0x86E2}, + { "glGetTexEnv", 'F', 1, "GL_OFFSET_TEXTURE_BIAS_NV", 0x86E3}, + { "glGetTexEnv", 'E', 1, "GL_PREVIOUS_TEXTURE_INPUT_NV", 0x86E4}, + { "glGetTexEnv", 'F', 3, "GL_CONST_EYE_NV", 0x86E5}, + { "", 'X', 1, "GL_PASS_THROUGH_NV", 0x86E6}, + { "", 'X', 1, "GL_CULL_FRAGMENT_NV", 0x86E7}, + { "", 'X', 1, "GL_OFFSET_TEXTURE_2D_NV", 0x86E8}, + { "", 'X', 1, "GL_DEPENDENT_AR_TEXTURE_2D_NV", 0x86E9}, + { "", 'X', 1, "GL_DEPENDENT_GB_TEXTURE_2D_NV", 0x86EA}, + { "", 'X', 1, "GL_SURFACE_STATE_NV", 0x86EB}, + { "", 'X', 1, "GL_DOT_PRODUCT_NV", 0x86EC}, + { "", 'X', 1, "GL_DOT_PRODUCT_DEPTH_REPLACE_NV", 0x86ED}, + { "", 'X', 1, "GL_DOT_PRODUCT_TEXTURE_2D_NV", 0x86EE}, + { "", 'X', 1, "GL_DOT_PRODUCT_TEXTURE_3D_NV", 0x86EF}, + { "", 'X', 1, "GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV", 0x86F0}, + { "", 'X', 1, "GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV", 0x86F1}, + { "", 'X', 1, "GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV", 0x86F2}, + { "", 'X', 1, "GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV", 0x86F3}, + { "", 'X', 1, "GL_HILO_NV", 0x86F4}, + { "", 'X', 1, "GL_DSDT_NV", 0x86F5}, + { "", 'X', 1, "GL_DSDT_MAG_NV", 0x86F6}, + { "", 'X', 1, "GL_DSDT_MAG_VIB_NV", 0x86F7}, + { "", 'X', 1, "GL_HILO16_NV", 0x86F8}, + { "", 'X', 1, "GL_SIGNED_HILO_NV", 0x86F9}, + { "", 'X', 1, "GL_SIGNED_HILO16_NV", 0x86FA}, + { "", 'X', 1, "GL_SIGNED_RGBA_NV", 0x86FB}, + { "", 'X', 1, "GL_SIGNED_RGBA8_NV", 0x86FC}, + { "", 'X', 1, "GL_SURFACE_REGISTERED_NV", 0x86FD}, + { "", 'X', 1, "GL_SIGNED_RGB_NV", 0x86FE}, + + { "", 'X', 1, "GL_SIGNED_RGB8_NV", 0x86FF}, + { "", 'X', 1, "GL_SURFACE_MAPPED_NV", 0x8700}, + { "", 'X', 1, "GL_SIGNED_LUMINANCE_NV", 0x8701}, + { "", 'X', 1, "GL_SIGNED_LUMINANCE8_NV", 0x8702}, + { "", 'X', 1, "GL_SIGNED_LUMINANCE_ALPHA_NV", 0x8703}, + { "", 'X', 1, "GL_SIGNED_LUMINANCE8_ALPHA8_NV", 0x8704}, + { "", 'X', 1, "GL_SIGNED_ALPHA_NV", 0x8705}, + { "", 'X', 1, "GL_SIGNED_ALPHA8_NV", 0x8706}, + { "", 'X', 1, "GL_SIGNED_INTENSITY_NV", 0x8707}, + { "", 'X', 1, "GL_SIGNED_INTENSITY8_NV", 0x8708}, + { "", 'X', 1, "GL_DSDT8_NV", 0x8709}, + { "", 'X', 1, "GL_DSDT8_MAG8_NV", 0x870A}, + { "", 'X', 1, "GL_DSDT8_MAG8_INTENSITY8_NV", 0x870B}, + { "", 'X', 1, "GL_SIGNED_RGB_UNSIGNED_ALPHA_NV", 0x870C}, + { "", 'X', 1, "GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV", 0x870D}, + { "", 'X', 1, "GL_HI_SCALE_NV", 0x870E}, + { "", 'X', 1, "GL_LO_SCALE_NV", 0x870F}, + { "", 'X', 1, "GL_DS_SCALE_NV", 0x8710}, + { "", 'X', 1, "GL_DT_SCALE_NV", 0x8711}, + { "", 'X', 1, "GL_MAGNITUDE_SCALE_NV", 0x8712}, + { "", 'X', 1, "GL_VIBRANCE_SCALE_NV", 0x8713}, + { "", 'X', 1, "GL_HI_BIAS_NV", 0x8714}, + { "", 'X', 1, "GL_LO_BIAS_NV", 0x8715}, + { "", 'X', 1, "GL_DS_BIAS_NV", 0x8716}, + { "", 'X', 1, "GL_DT_BIAS_NV", 0x8717}, + { "", 'X', 1, "GL_MAGNITUDE_BIAS_NV", 0x8718}, + { "", 'X', 1, "GL_VIBRANCE_BIAS_NV", 0x8719}, + { "", 'X', 1, "GL_TEXTURE_BORDER_VALUES_NV", 0x871A}, + { "", 'X', 1, "GL_TEXTURE_HI_SIZE_NV", 0x871B}, + { "", 'X', 1, "GL_TEXTURE_LO_SIZE_NV", 0x871C}, + { "", 'X', 1, "GL_TEXTURE_DS_SIZE_NV", 0x871D}, + { "", 'X', 1, "GL_TEXTURE_DT_SIZE_NV", 0x871E}, + { "", 'X', 1, "GL_TEXTURE_MAG_SIZE_NV", 0x871F}, + { "_glGet", 'F', 16, "GL_MODELVIEW2_ARB", 0x8722}, + { "_glGet", 'F', 16, "GL_MODELVIEW3_ARB", 0x8723}, + { "_glGet", 'F', 16, "GL_MODELVIEW4_ARB", 0x8724}, + { "_glGet", 'F', 16, "GL_MODELVIEW5_ARB", 0x8725}, + { "_glGet", 'F', 16, "GL_MODELVIEW6_ARB", 0x8726}, + { "_glGet", 'F', 16, "GL_MODELVIEW7_ARB", 0x8727}, + { "_glGet", 'F', 16, "GL_MODELVIEW8_ARB", 0x8728}, + { "_glGet", 'F', 16, "GL_MODELVIEW9_ARB", 0x8729}, + { "_glGet", 'F', 16, "GL_MODELVIEW10_ARB", 0x872A}, + { "_glGet", 'F', 16, "GL_MODELVIEW11_ARB", 0x872B}, + { "_glGet", 'F', 16, "GL_MODELVIEW12_ARB", 0x872C}, + { "_glGet", 'F', 16, "GL_MODELVIEW13_ARB", 0x872D}, + { "_glGet", 'F', 16, "GL_MODELVIEW14_ARB", 0x872E}, + { "_glGet", 'F', 16, "GL_MODELVIEW15_ARB", 0x872F}, + { "_glGet", 'F', 16, "GL_MODELVIEW16_ARB", 0x8730}, + { "_glGet", 'F', 16, "GL_MODELVIEW17_ARB", 0x8731}, + { "_glGet", 'F', 16, "GL_MODELVIEW18_ARB", 0x8732}, + { "_glGet", 'F', 16, "GL_MODELVIEW19_ARB", 0x8733}, + { "_glGet", 'F', 16, "GL_MODELVIEW20_ARB", 0x8734}, + { "_glGet", 'F', 16, "GL_MODELVIEW21_ARB", 0x8735}, + { "_glGet", 'F', 16, "GL_MODELVIEW22_ARB", 0x8736}, + { "_glGet", 'F', 16, "GL_MODELVIEW23_ARB", 0x8737}, + { "_glGet", 'F', 16, "GL_MODELVIEW24_ARB", 0x8738}, + { "_glGet", 'F', 16, "GL_MODELVIEW25_ARB", 0x8739}, + { "_glGet", 'F', 16, "GL_MODELVIEW26_ARB", 0x873A}, + { "_glGet", 'F', 16, "GL_MODELVIEW27_ARB", 0x873B}, + { "_glGet", 'F', 16, "GL_MODELVIEW28_ARB", 0x873C}, + { "_glGet", 'F', 16, "GL_MODELVIEW29_ARB", 0x873D}, + { "_glGet", 'F', 16, "GL_MODELVIEW30_ARB", 0x873E}, + { "_glGet", 'F', 16, "GL_MODELVIEW31_ARB", 0x873F}, + { "", 'X', 1, "GL_DOT3_RGB_EXT", 0x8740}, + { "", 'X', 1, "GL_DOT3_RGBA_EXT", 0x8741}, + { "", 'X', 1, "GL_MIRROR_CLAMP_ATI", 0x8742}, + { "", 'X', 1, "GL_MIRROR_CLAMP_TO_EDGE_ATI", 0x8743}, + { "", 'X', 1, "GL_MODULATE_ADD_ATI", 0x8744}, + { "", 'X', 1, "GL_MODULATE_SIGNED_ADD_ATI", 0x8745}, + { "", 'X', 1, "GL_MODULATE_SUBTRACT_ATI", 0x8746}, + { "", 'X', 1, "GL_YCBCR_MESA", 0x8757}, + { "glGet", 'B', 1, "GL_PACK_INVERT_MESA", 0x8758}, + { "", 'X', 1, "GL_TEXTURE_1D_STACK_MESAX", 0x8759}, + { "", 'X', 1, "GL_TEXTURE_2D_STACK_MESAX", 0x875A}, + { "", 'X', 1, "GL_PROXY_TEXTURE_1D_STACK_MESAX", 0x875B}, + { "", 'X', 1, "GL_PROXY_TEXTURE_2D_STACK_MESAX", 0x875C}, + { "", 'X', 1, "GL_TEXTURE_1D_STACK_BINDING_MESAX", 0x875D}, + { "", 'X', 1, "GL_TEXTURE_2D_STACK_BINDING_MESAX", 0x875E}, + { "", 'X', 1, "GL_STATIC_ATI", 0x8760}, + { "", 'X', 1, "GL_DYNAMIC_ATI", 0x8761}, + { "", 'X', 1, "GL_PRESERVE_ATI", 0x8762}, + { "", 'X', 1, "GL_DISCARD_ATI", 0x8763}, + { "glGetBufferParameter", 'I', 1, "GL_BUFFER_SIZE", 0x8764}, + { "glGetBufferParameter", 'E', 1, "GL_BUFFER_USAGE", 0x8765}, + { "", 'X', 1, "GL_ARRAY_OBJECT_BUFFER_ATI", 0x8766}, + { "", 'X', 1, "GL_ARRAY_OBJECT_OFFSET_ATI", 0x8767}, + { "", 'X', 1, "GL_ELEMENT_ARRAY_ATI", 0x8768}, + { "glGet", 'E', 1, "GL_ELEMENT_ARRAY_TYPE_ATI", 0x8769}, + { "", 'X', 1, "GL_ELEMENT_ARRAY_POINTER_ATI", 0x876A}, + { "", 'X', 1, "GL_MAX_VERTEX_STREAMS_ATI", 0x876B}, + { "", 'X', 1, "GL_VERTEX_STREAM0_ATI", 0x876C}, + { "", 'X', 1, "GL_VERTEX_STREAM1_ATI", 0x876D}, + { "", 'X', 1, "GL_VERTEX_STREAM2_ATI", 0x876E}, + { "", 'X', 1, "GL_VERTEX_STREAM3_ATI", 0x876F}, + { "", 'X', 1, "GL_VERTEX_STREAM4_ATI", 0x8770}, + { "", 'X', 1, "GL_VERTEX_STREAM5_ATI", 0x8771}, + { "", 'X', 1, "GL_VERTEX_STREAM6_ATI", 0x8772}, + { "", 'X', 1, "GL_VERTEX_STREAM7_ATI", 0x8773}, + { "", 'X', 1, "GL_VERTEX_SOURCE_ATI", 0x8774}, + { "", 'X', 1, "GL_BUMP_ROT_MATRIX_ATI", 0x8775}, + { "", 'X', 1, "GL_BUMP_ROT_MATRIX_SIZE_ATI", 0x8776}, + { "", 'X', 1, "GL_BUMP_NUM_TEX_UNITS_ATI", 0x8777}, + { "", 'X', 1, "GL_BUMP_TEX_UNITS_ATI", 0x8778}, + { "", 'X', 1, "GL_DUDV_ATI", 0x8779}, + { "", 'X', 1, "GL_DU8DV8_ATI", 0x877A}, + { "", 'X', 1, "GL_BUMP_ENVMAP_ATI", 0x877B}, + { "glGetTexEnv", 'E', 1, "GL_BUMP_TARGET_ATI", 0x877C}, + { "", 'X', 1, "GL_VERTEX_SHADER_EXT", 0x8780}, + { "glGet", 'I', 1, "GL_VERTEX_SHADER_BINDING_EXT", 0x8781}, + { "", 'X', 1, "GL_OP_INDEX_EXT", 0x8782}, + { "", 'X', 1, "GL_OP_NEGATE_EXT", 0x8783}, + { "", 'X', 1, "GL_OP_DOT3_EXT", 0x8784}, + { "", 'X', 1, "GL_OP_DOT4_EXT", 0x8785}, + { "", 'X', 1, "GL_OP_MUL_EXT", 0x8786}, + { "", 'X', 1, "GL_OP_ADD_EXT", 0x8787}, + { "", 'X', 1, "GL_OP_MADD_EXT", 0x8788}, + { "", 'X', 1, "GL_OP_FRAC_EXT", 0x8789}, + { "", 'X', 1, "GL_OP_MAX_EXT", 0x878A}, + { "", 'X', 1, "GL_OP_MIN_EXT", 0x878B}, + { "", 'X', 1, "GL_OP_SET_GE_EXT", 0x878C}, + { "", 'X', 1, "GL_OP_SET_LT_EXT", 0x878D}, + { "", 'X', 1, "GL_OP_CLAMP_EXT", 0x878E}, + { "", 'X', 1, "GL_OP_FLOOR_EXT", 0x878F}, + { "", 'X', 1, "GL_OP_ROUND_EXT", 0x8790}, + { "", 'X', 1, "GL_OP_EXP_BASE_2_EXT", 0x8791}, + { "", 'X', 1, "GL_OP_LOG_BASE_2_EXT", 0x8792}, + { "", 'X', 1, "GL_OP_POWER_EXT", 0x8793}, + + { "", 'X', 1, "GL_OP_RECIP_EXT", 0x8794}, + { "", 'X', 1, "GL_OP_RECIP_SQRT_EXT", 0x8795}, + { "", 'X', 1, "GL_OP_SUB_EXT", 0x8796}, + { "", 'X', 1, "GL_OP_CROSS_PRODUCT_EXT", 0x8797}, + { "", 'X', 1, "GL_OP_MULTIPLY_MATRIX_EXT", 0x8798}, + { "", 'X', 1, "GL_OP_MOV_EXT", 0x8799}, + { "", 'X', 1, "GL_OUTPUT_VERTEX_EXT", 0x879A}, + { "", 'X', 1, "GL_OUTPUT_COLOR0_EXT", 0x879B}, + { "", 'X', 1, "GL_OUTPUT_COLOR1_EXT", 0x879C}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD0_EXT", 0x879D}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD1_EXT", 0x879E}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD2_EXT", 0x879F}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD3_EXT", 0x87A0}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD4_EXT", 0x87A1}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD5_EXT", 0x87A2}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD6_EXT", 0x87A3}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD7_EXT", 0x87A4}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD8_EXT", 0x87A5}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD9_EXT", 0x87A6}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD10_EXT", 0x87A7}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD11_EXT", 0x87A8}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD12_EXT", 0x87A9}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD13_EXT", 0x87AA}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD14_EXT", 0x87AB}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD15_EXT", 0x87AC}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD16_EXT", 0x87AD}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD17_EXT", 0x87AE}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD18_EXT", 0x87AF}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD19_EXT", 0x87B0}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD20_EXT", 0x87B1}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD21_EXT", 0x87B2}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD22_EXT", 0x87B3}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD23_EXT", 0x87B4}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD24_EXT", 0x87B5}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD25_EXT", 0x87B6}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD26_EXT", 0x87B7}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD27_EXT", 0x87B8}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD28_EXT", 0x87B9}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD29_EXT", 0x87BA}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD30_EXT", 0x87BB}, + { "", 'X', 1, "GL_OUTPUT_TEXTURE_COORD31_EXT", 0x87BC}, + { "", 'X', 1, "GL_OUTPUT_FOG_EXT", 0x87BD}, + { "", 'X', 1, "GL_SCALAR_EXT", 0x87BE}, + { "", 'X', 1, "GL_VECTOR_EXT", 0x87BF}, + { "", 'X', 1, "GL_MATRIX_EXT", 0x87C0}, + { "", 'X', 1, "GL_VARIANT_EXT", 0x87C1}, + { "", 'X', 1, "GL_INVARIANT_EXT", 0x87C2}, + { "", 'X', 1, "GL_LOCAL_CONSTANT_EXT", 0x87C3}, + { "", 'X', 1, "GL_LOCAL_EXT", 0x87C4}, + { "", 'X', 1, "GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT", 0x87C5}, + { "", 'X', 1, "GL_MAX_VERTEX_SHADER_VARIANTS_EXT", 0x87C6}, + { "", 'X', 1, "GL_MAX_VERTEX_SHADER_INVARIANTS_EXT", 0x87C7}, + { "", 'X', 1, "GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT", 0x87C8}, + { "", 'X', 1, "GL_MAX_VERTEX_SHADER_LOCALS_EXT", 0x87C9}, + { "", 'X', 1, "GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT", 0x87CA}, + { "", 'X', 1, "GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT", 0x87CB}, + { "", 'X', 1, "GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT", 0x87CC}, + { "", 'X', 1, "GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT", 0x87CD}, + { "", 'X', 1, "GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT", 0x87CE}, + { "", 'X', 1, "GL_VERTEX_SHADER_INSTRUCTIONS_EXT", 0x87CF}, + { "", 'X', 1, "GL_VERTEX_SHADER_VARIANTS_EXT", 0x87D0}, + { "", 'X', 1, "GL_VERTEX_SHADER_INVARIANTS_EXT", 0x87D1}, + { "", 'X', 1, "GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT", 0x87D2}, + + { "", 'X', 1, "GL_VERTEX_SHADER_LOCALS_EXT", 0x87D3}, + { "", 'X', 1, "GL_VERTEX_SHADER_OPTIMIZED_EXT", 0x87D4}, + { "", 'X', 1, "GL_X_EXT", 0x87D5}, + { "", 'X', 1, "GL_Y_EXT", 0x87D6}, + { "", 'X', 1, "GL_Z_EXT", 0x87D7}, + { "", 'X', 1, "GL_W_EXT", 0x87D8}, + { "", 'X', 1, "GL_NEGATIVE_X_EXT", 0x87D9}, + { "", 'X', 1, "GL_NEGATIVE_Y_EXT", 0x87DA}, + { "", 'X', 1, "GL_NEGATIVE_Z_EXT", 0x87DB}, + { "", 'X', 1, "GL_NEGATIVE_W_EXT", 0x87DC}, + { "", 'X', 1, "GL_ZERO_EXT", 0x87DD}, + { "", 'X', 1, "GL_ONE_EXT", 0x87DE}, + { "", 'X', 1, "GL_NEGATIVE_ONE_EXT", 0x87DF}, + { "", 'X', 1, "GL_NORMALIZED_RANGE_EXT", 0x87E0}, + { "", 'X', 1, "GL_FULL_RANGE_EXT", 0x87E1}, + { "", 'X', 1, "GL_CURRENT_VERTEX_EXT", 0x87E2}, + { "", 'X', 1, "GL_MVP_MATRIX_EXT", 0x87E3}, + { "", 'X', 1, "GL_VARIANT_VALUE_EXT", 0x87E4}, + { "", 'X', 1, "GL_VARIANT_DATATYPE_EXT", 0x87E5}, + { "", 'X', 1, "GL_VARIANT_ARRAY_STRIDE_EXT", 0x87E6}, + { "glGet", 'E', 1, "GL_VARIANT_ARRAY_TYPE_EXT", 0x87E7}, + + { "", 'X', 1, "GL_VARIANT_ARRAY_EXT", 0x87E8}, + { "", 'X', 1, "GL_VARIANT_ARRAY_POINTER_EXT", 0x87E9}, + { "", 'X', 1, "GL_INVARIANT_VALUE_EXT", 0x87EA}, + { "", 'X', 1, "GL_INVARIANT_DATATYPE_EXT", 0x87EB}, + { "", 'X', 1, "GL_LOCAL_CONSTANT_VALUE_EXT", 0x87EC}, + { "", 'X', 1, "GL_LOCAL_CONSTANT_DATATYPE_EXT", 0x87ED}, + { "", 'X', 1, "GL_PN_TRIANGLES_ATI", 0x87F0}, + { "", 'X', 1, "GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI", 0x87F1}, + { "", 'X', 1, "GL_PN_TRIANGLES_POINT_MODE_ATI", 0x87F2}, + { "", 'X', 1, "GL_PN_TRIANGLES_NORMAL_MODE_ATI", 0x87F3}, + { "", 'X', 1, "GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI", 0x87F4}, + { "", 'X', 1, "GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI", 0x87F5}, + { "", 'X', 1, "GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI", 0x87F6}, + { "", 'X', 1, "GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI", 0x87F7}, + { "", 'X', 1, "GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI", 0x87F8}, + { "", 'X', 1, "GL_VBO_FREE_MEMORY_ATI", 0x87FB}, + { "", 'I', 4, "GL_TEXTURE_FREE_MEMORY_ATI", 0x87FC}, + { "", 'X', 1, "GL_RENDERBUFFER_FREE_MEMORY_ATI", 0x87FD}, + { "glGet", 'I', 1, "GL_NUM_PROGRAM_BINARY_FORMATS", 0x87FE}, + //{ "glGet", 'E', "_glGetInteger{ GL_NUM_PROGRAM_BINARY_FORMATS)", "GL_PROGRAM_BINARY_FORMATS", 0x87FF}, + { "glGet", 'E', 1, "GL_STENCIL_BACK_FUNC", 0x8800}, + { "glGet", 'E', 1, "GL_STENCIL_BACK_FAIL", 0x8801}, + { "glGet", 'E', 1, "GL_STENCIL_BACK_PASS_DEPTH_FAIL", 0x8802}, + { "glGet", 'E', 1, "GL_STENCIL_BACK_PASS_DEPTH_PASS", 0x8803}, + { "glGet", 'B', 1, "GL_FRAGMENT_PROGRAM_ARB", 0x8804}, + + { "glGetProgramARB", 'I', 1, "GL_PROGRAM_ALU_INSTRUCTIONS_ARB", 0x8805}, + { "glGetProgramARB", 'I', 1, "GL_PROGRAM_TEX_INSTRUCTIONS_ARB", 0x8806}, + { "glGetProgramARB", 'I', 1, "GL_PROGRAM_TEX_INDIRECTIONS_ARB", 0x8807}, + { "glGetProgramARB", 'I', 1, "GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB", 0x8808}, + { "glGetProgramARB", 'I', 1, "GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB", 0x8809}, + { "glGetProgramARB", 'I', 1, "GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB", 0x880A}, + { "glGetProgramARB", 'I', 1, "GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB", 0x880B}, + { "glGetProgramARB", 'I', 1, "GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB", 0x880C}, + { "glGetProgramARB", 'I', 1, "GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB", 0x880D}, + { "glGetProgramARB", 'I', 1, "GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB", 0x880E}, + { "glGetProgramARB", 'I', 1, "GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB", 0x880F}, + { "glGetProgramARB", 'I', 1, "GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB", 0x8810}, + { "", 'X', 1, "GL_RGBA32F", 0x8814}, + { "", 'X', 1, "GL_RGB32F", 0x8815}, + { "", 'X', 1, "GL_ALPHA32F_ARB", 0x8816}, + { "", 'X', 1, "GL_INTENSITY32F_ARB", 0x8817}, + + { "", 'X', 1, "GL_LUMINANCE32F_ARB", 0x8818}, + { "", 'X', 1, "GL_LUMINANCE_ALPHA32F_ARB", 0x8819}, + { "", 'X', 1, "GL_RGBA16F", 0x881A}, + { "", 'X', 1, "GL_RGB16F", 0x881B}, + { "", 'X', 1, "GL_ALPHA16F_ARB", 0x881C}, + { "", 'X', 1, "GL_INTENSITY16F_ARB", 0x881D}, + { "", 'X', 1, "GL_LUMINANCE16F_ARB", 0x881E}, + { "", 'X', 1, "GL_LUMINANCE_ALPHA16F_ARB", 0x881F}, + { "glGet", 'B', 1, "GL_RGBA_FLOAT_MODE_ARB", 0x8820}, + { "glGet", 'I', 1, "GL_MAX_DRAW_BUFFERS", 0x8824}, + { "glGet", 'E', 1, "GL_DRAW_BUFFER0", 0x8825}, + { "glGet", 'E', 1, "GL_DRAW_BUFFER1", 0x8826}, + { "glGet", 'E', 1, "GL_DRAW_BUFFER2", 0x8827}, + { "glGet", 'E', 1, "GL_DRAW_BUFFER3", 0x8828}, + { "glGet", 'E', 1, "GL_DRAW_BUFFER4", 0x8829}, + { "glGet", 'E', 1, "GL_DRAW_BUFFER5", 0x882A}, + { "glGet", 'E', 1, "GL_DRAW_BUFFER6", 0x882B}, + { "glGet", 'E', 1, "GL_DRAW_BUFFER7", 0x882C}, + { "glGet", 'E', 1, "GL_DRAW_BUFFER8", 0x882D}, + { "glGet", 'E', 1, "GL_DRAW_BUFFER9", 0x882E}, + { "glGet", 'E', 1, "GL_DRAW_BUFFER10", 0x882F}, + { "glGet", 'E', 1, "GL_DRAW_BUFFER11", 0x8830}, + { "glGet", 'E', 1, "GL_DRAW_BUFFER12", 0x8831}, + { "glGet", 'E', 1, "GL_DRAW_BUFFER13", 0x8832}, + { "glGet", 'E', 1, "GL_DRAW_BUFFER14", 0x8833}, + { "glGet", 'E', 1, "GL_DRAW_BUFFER15", 0x8834}, + { "", 'X', 1, "GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI", 0x8835}, + { "glGet", 'E', 1, "GL_BLEND_EQUATION_ALPHA", 0x883D}, + { "glGet", 'B', 1, "GL_MATRIX_PALETTE_ARB", 0x8840}, + { "glGet", 'I', 1, "GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB", 0x8841}, + { "glGet", 'I', 1, "GL_MAX_PALETTE_MATRICES_ARB", 0x8842}, + { "glGet", 'I', 1, "GL_CURRENT_PALETTE_MATRIX_ARB", 0x8843}, + { "glGet", 'B', 1, "GL_MATRIX_INDEX_ARRAY_ARB", 0x8844}, + { "glGet", 'I', 1, "GL_CURRENT_MATRIX_INDEX_ARB", 0x8845}, + { "glGet", 'I', 1, "GL_MATRIX_INDEX_ARRAY_SIZE_ARB", 0x8846}, + { "glGet", 'E', 1, "GL_MATRIX_INDEX_ARRAY_TYPE_ARB", 0x8847}, + { "glGet", 'I', 1, "GL_MATRIX_INDEX_ARRAY_STRIDE_ARB", 0x8848}, + { "glGet", 'P', 1, "GL_MATRIX_INDEX_ARRAY_POINTER_ARB", 0x8849}, + { "glGetTexLevelParameter", 'I', 1, "GL_TEXTURE_DEPTH_SIZE", 0x884A}, + { "glGetTexParameter", 'E', 1, "GL_DEPTH_TEXTURE_MODE", 0x884B}, + { "glGetTexParameter", 'E', 1, "GL_TEXTURE_COMPARE_MODE", 0x884C}, + { "glGetTexParameter", 'E', 1, "GL_TEXTURE_COMPARE_FUNC", 0x884D}, + { "", 'X', 1, "GL_COMPARE_REF_TO_TEXTURE", 0x884E}, + { "glGet", 'B', 1, "GL_TEXTURE_CUBE_MAP_SEAMLESS", 0x884F}, + { "", 'X', 1, "GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV", 0x8850}, + { "", 'X', 1, "GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV", 0x8851}, + { "", 'X', 1, "GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV", 0x8852}, + { "", 'X', 1, "GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV", 0x8853}, + { "", 'X', 1, "GL_OFFSET_HILO_TEXTURE_2D_NV", 0x8854}, + { "", 'X', 1, "GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV", 0x8855}, + { "", 'X', 1, "GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV", 0x8856}, + { "", 'X', 1, "GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV", 0x8857}, + { "", 'X', 1, "GL_DEPENDENT_HILO_TEXTURE_2D_NV", 0x8858}, + { "", 'X', 1, "GL_DEPENDENT_RGB_TEXTURE_3D_NV", 0x8859}, + { "", 'X', 1, "GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV", 0x885A}, + { "", 'X', 1, "GL_DOT_PRODUCT_PASS_THROUGH_NV", 0x885B}, + { "", 'X', 1, "GL_DOT_PRODUCT_TEXTURE_1D_NV", 0x885C}, + { "", 'X', 1, "GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV", 0x885D}, + { "", 'X', 1, "GL_HILO8_NV", 0x885E}, + { "", 'X', 1, "GL_SIGNED_HILO8_NV", 0x885F}, + { "", 'X', 1, "GL_FORCE_BLUE_TO_ONE_NV", 0x8860}, + { "glGet", 'B', 1, "GL_POINT_SPRITE", 0x8861}, + + { "glGetTexEnv", 'B', 1, "GL_COORD_REPLACE", 0x8862}, + { "glGet", 'E', 1, "GL_POINT_SPRITE_R_MODE_NV", 0x8863}, + { "glGetQuery", 'I', 1, "GL_QUERY_COUNTER_BITS", 0x8864}, + { "glGetQuery", 'I', 1, "GL_CURRENT_QUERY", 0x8865}, + { "glGetQueryObject", 'I', 1, "GL_QUERY_RESULT", 0x8866}, + { "glGetQueryObject", 'B', 1, "GL_QUERY_RESULT_AVAILABLE", 0x8867}, + { "", 'X', 1, "GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV", 0x8868}, + { "glGet", 'I', 1, "GL_MAX_VERTEX_ATTRIBS", 0x8869}, + { "glGetVertexAttrib", 'B', 1, "GL_VERTEX_ATTRIB_ARRAY_NORMALIZED", 0x886A}, + { "", 'X', 1, "GL_MAX_TESS_CONTROL_INPUT_COMPONENTS", 0x886C}, + { "", 'X', 1, "GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS", 0x886D}, + { "", 'X', 1, "GL_DEPTH_STENCIL_TO_RGBA_NV", 0x886E}, + { "", 'X', 1, "GL_DEPTH_STENCIL_TO_BGRA_NV", 0x886F}, + { "", 'X', 1, "GL_FRAGMENT_PROGRAM_NV", 0x8870}, + { "glGet", 'I', 1, "GL_MAX_TEXTURE_COORDS", 0x8871}, + { "glGet", 'I', 1, "GL_MAX_TEXTURE_IMAGE_UNITS", 0x8872}, + { "glGet", 'I', 1, "GL_FRAGMENT_PROGRAM_BINDING_NV", 0x8873}, + { "glGet", 'S', 1, "GL_PROGRAM_ERROR_STRING_ARB", 0x8874}, + { "", 'X', 1, "GL_PROGRAM_FORMAT_ASCII_ARB", 0x8875}, + { "glGetProgramARB", 'E', 1, "GL_PROGRAM_FORMAT_ARB", 0x8876}, + { "", 'X', 1, "GL_WRITE_PIXEL_DATA_RANGE_NV", 0x8878}, + { "", 'X', 1, "GL_READ_PIXEL_DATA_RANGE_NV", 0x8879}, + { "", 'X', 1, "GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV", 0x887A}, + { "", 'X', 1, "GL_READ_PIXEL_DATA_RANGE_LENGTH_NV", 0x887B}, + { "", 'X', 1, "GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV", 0x887C}, + { "", 'X', 1, "GL_READ_PIXEL_DATA_RANGE_POINTER_NV", 0x887D}, + { "", 'X', 1, "GL_GEOMETRY_SHADER_INVOCATIONS", 0x887F}, + { "", 'X', 1, "GL_FLOAT_R_NV", 0x8880}, + { "", 'X', 1, "GL_FLOAT_RG_NV", 0x8881}, + { "", 'X', 1, "GL_FLOAT_RGB_NV", 0x8882}, + { "", 'X', 1, "GL_FLOAT_RGBA_NV", 0x8883}, + { "", 'X', 1, "GL_FLOAT_R16_NV", 0x8884}, + { "", 'X', 1, "GL_FLOAT_R32_NV", 0x8885}, + { "", 'X', 1, "GL_FLOAT_RG16_NV", 0x8886}, + { "", 'X', 1, "GL_FLOAT_RG32_NV", 0x8887}, + { "", 'X', 1, "GL_FLOAT_RGB16_NV", 0x8888}, + { "", 'X', 1, "GL_FLOAT_RGB32_NV", 0x8889}, + { "", 'X', 1, "GL_FLOAT_RGBA16_NV", 0x888A}, + { "", 'X', 1, "GL_FLOAT_RGBA32_NV", 0x888B}, + { "", 'X', 1, "GL_TEXTURE_FLOAT_COMPONENTS_NV", 0x888C}, + { "", 'X', 1, "GL_FLOAT_CLEAR_COLOR_VALUE_NV", 0x888D}, + { "", 'X', 1, "GL_FLOAT_RGBA_MODE_NV", 0x888E}, + { "glGetTexParameter", 'E', 1, "GL_TEXTURE_UNSIGNED_REMAP_MODE_NV", 0x888F}, + { "glGet", 'B', 1, "GL_DEPTH_BOUNDS_TEST_EXT", 0x8890}, + { "glGet", 'F', 2, "GL_DEPTH_BOUNDS_EXT", 0x8891}, + { "", 'X', 1, "GL_ARRAY_BUFFER", 0x8892}, + { "", 'X', 1, "GL_ELEMENT_ARRAY_BUFFER", 0x8893}, + { "glGet", 'I', 1, "GL_ARRAY_BUFFER_BINDING", 0x8894}, + { "glGet", 'I', 1, "GL_ELEMENT_ARRAY_BUFFER_BINDING", 0x8895}, + { "glGet", 'I', 1, "GL_VERTEX_ARRAY_BUFFER_BINDING", 0x8896}, + { "glGet", 'I', 1, "GL_NORMAL_ARRAY_BUFFER_BINDING", 0x8897}, + { "glGet", 'I', 1, "GL_COLOR_ARRAY_BUFFER_BINDING", 0x8898}, + { "glGet", 'I', 1, "GL_INDEX_ARRAY_BUFFER_BINDING", 0x8899}, + { "glGet", 'I', 1, "GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING", 0x889A}, + { "glGet", 'I', 1, "GL_EDGE_FLAG_ARRAY_BUFFER_BINDING", 0x889B}, + { "glGet", 'I', 1, "GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING", 0x889C}, + { "glGet", 'I', 1, "GL_FOG_COORD_ARRAY_BUFFER_BINDING", 0x889D}, + { "glGet", 'I', 1, "GL_WEIGHT_ARRAY_BUFFER_BINDING", 0x889E}, + { "glGetVertexAttrib", 'I', 1, "GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING", 0x889F}, + { "glGetProgramARB", 'I', 1, "GL_PROGRAM_INSTRUCTIONS_ARB", 0x88A0}, + { "glGetProgramARB", 'I', 1, "GL_MAX_PROGRAM_INSTRUCTIONS_ARB", 0x88A1}, + { "glGetProgramARB", 'I', 1, "GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB", 0x88A2}, + { "glGetProgramARB", 'I', 1, "GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB", 0x88A3}, + { "glGetProgramARB", 'I', 1, "GL_PROGRAM_TEMPORARIES_ARB", 0x88A4}, + { "glGetProgramARB", 'I', 1, "GL_MAX_PROGRAM_TEMPORARIES_ARB", 0x88A5}, + { "glGetProgramARB", 'I', 1, "GL_PROGRAM_NATIVE_TEMPORARIES_ARB", 0x88A6}, + { "glGetProgramARB", 'I', 1, "GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB", 0x88A7}, + { "glGetProgramARB", 'I', 1, "GL_PROGRAM_PARAMETERS_ARB", 0x88A8}, + { "glGetProgramARB", 'I', 1, "GL_MAX_PROGRAM_PARAMETERS_ARB", 0x88A9}, + { "glGetProgramARB", 'I', 1, "GL_PROGRAM_NATIVE_PARAMETERS_ARB", 0x88AA}, + { "glGetProgramARB", 'I', 1, "GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB", 0x88AB}, + { "glGetProgramARB", 'I', 1, "GL_PROGRAM_ATTRIBS_ARB", 0x88AC}, + { "glGetProgramARB", 'I', 1, "GL_MAX_PROGRAM_ATTRIBS_ARB", 0x88AD}, + { "glGetProgramARB", 'I', 1, "GL_PROGRAM_NATIVE_ATTRIBS_ARB", 0x88AE}, + { "glGetProgramARB", 'I', 1, "GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB", 0x88AF}, + { "glGetProgramARB", 'I', 1, "GL_PROGRAM_ADDRESS_REGISTERS_ARB", 0x88B0}, + { "glGetProgramARB", 'I', 1, "GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB", 0x88B1}, + { "glGetProgramARB", 'I', 1, "GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB", 0x88B2}, + { "glGetProgramARB", 'I', 1, "GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB", 0x88B3}, + { "glGetProgramARB", 'I', 1, "GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB", 0x88B4}, + { "glGetProgramARB", 'I', 1, "GL_MAX_PROGRAM_ENV_PARAMETERS_ARB", 0x88B5}, + { "glGetProgramARB", 'B', 1, "GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB", 0x88B6}, + { "glGet", 'F', 16, "GL_TRANSPOSE_CURRENT_MATRIX_ARB", 0x88B7}, + { "", 'X', 1, "GL_READ_ONLY", 0x88B8}, + { "", 'X', 1, "GL_WRITE_ONLY", 0x88B9}, + { "", 'X', 1, "GL_READ_WRITE", 0x88BA}, + { "glGetBufferParameter", 'E', 1, "GL_BUFFER_ACCESS", 0x88BB}, + { "glGetBufferParameter", 'B', 1, "GL_BUFFER_MAPPED", 0x88BC}, + { "glGetBufferParameter", 'P', 1, "GL_BUFFER_MAP_POINTER", 0x88BD}, + { "", 'X', 1, "GL_WRITE_DISCARD_NV", 0x88BE}, + { "", 'X', 1, "GL_TIME_ELAPSED", 0x88BF}, + { "", 'X', 1, "GL_MATRIX0_ARB", 0x88C0}, + { "", 'X', 1, "GL_MATRIX1_ARB", 0x88C1}, + { "", 'X', 1, "GL_MATRIX2_ARB", 0x88C2}, + { "", 'X', 1, "GL_MATRIX3_ARB", 0x88C3}, + { "", 'X', 1, "GL_MATRIX4_ARB", 0x88C4}, + { "", 'X', 1, "GL_MATRIX5_ARB", 0x88C5}, + { "", 'X', 1, "GL_MATRIX6_ARB", 0x88C6}, + { "", 'X', 1, "GL_MATRIX7_ARB", 0x88C7}, + { "", 'X', 1, "GL_MATRIX8_ARB", 0x88C8}, + { "", 'X', 1, "GL_MATRIX9_ARB", 0x88C9}, + { "", 'X', 1, "GL_MATRIX10_ARB", 0x88CA}, + { "", 'X', 1, "GL_MATRIX11_ARB", 0x88CB}, + { "", 'X', 1, "GL_MATRIX12_ARB", 0x88CC}, + { "", 'X', 1, "GL_MATRIX13_ARB", 0x88CD}, + { "", 'X', 1, "GL_MATRIX14_ARB", 0x88CE}, + { "", 'X', 1, "GL_MATRIX15_ARB", 0x88CF}, + { "", 'X', 1, "GL_MATRIX16_ARB", 0x88D0}, + { "", 'X', 1, "GL_MATRIX17_ARB", 0x88D1}, + { "", 'X', 1, "GL_MATRIX18_ARB", 0x88D2}, + { "", 'X', 1, "GL_MATRIX19_ARB", 0x88D3}, + { "", 'X', 1, "GL_MATRIX20_ARB", 0x88D4}, + { "", 'X', 1, "GL_MATRIX21_ARB", 0x88D5}, + { "", 'X', 1, "GL_MATRIX22_ARB", 0x88D6}, + { "", 'X', 1, "GL_MATRIX23_ARB", 0x88D7}, + { "", 'X', 1, "GL_MATRIX24_ARB", 0x88D8}, + { "", 'X', 1, "GL_MATRIX25_ARB", 0x88D9}, + { "", 'X', 1, "GL_MATRIX26_ARB", 0x88DA}, + { "", 'X', 1, "GL_MATRIX27_ARB", 0x88DB}, + { "", 'X', 1, "GL_MATRIX28_ARB", 0x88DC}, + { "", 'X', 1, "GL_MATRIX29_ARB", 0x88DD}, + { "", 'X', 1, "GL_MATRIX30_ARB", 0x88DE}, + { "", 'X', 1, "GL_MATRIX31_ARB", 0x88DF}, + { "", 'X', 1, "GL_STREAM_DRAW", 0x88E0}, + { "", 'X', 1, "GL_STREAM_READ", 0x88E1}, + { "", 'X', 1, "GL_STREAM_COPY", 0x88E2}, + { "", 'X', 1, "GL_STATIC_DRAW", 0x88E4}, + { "", 'X', 1, "GL_STATIC_READ", 0x88E5}, + { "", 'X', 1, "GL_STATIC_COPY", 0x88E6}, + { "", 'X', 1, "GL_DYNAMIC_DRAW", 0x88E8}, + { "", 'X', 1, "GL_DYNAMIC_READ", 0x88E9}, + { "", 'X', 1, "GL_DYNAMIC_COPY", 0x88EA}, + { "", 'X', 1, "GL_PIXEL_PACK_BUFFER", 0x88EB}, + { "", 'X', 1, "GL_PIXEL_UNPACK_BUFFER", 0x88EC}, + { "glGet", 'I', 1, "GL_PIXEL_PACK_BUFFER_BINDING", 0x88ED}, + { "glGet", 'I', 1, "GL_PIXEL_UNPACK_BUFFER_BINDING", 0x88EF}, + { "", 'X', 1, "GL_DEPTH24_STENCIL8", 0x88F0}, + { "glGetTexLevelParameter", 'I', 1, "GL_TEXTURE_STENCIL_SIZE", 0x88F1}, + { "", 'X', 1, "GL_STENCIL_TAG_BITS_EXT", 0x88F2}, + { "", 'X', 1, "GL_STENCIL_CLEAR_TAG_VALUE_EXT", 0x88F3}, + { "glGetProgramARB", 'I', 1, "GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV", 0x88F4}, + { "glGetProgramARB", 'I', 1, "GL_MAX_PROGRAM_CALL_DEPTH_NV", 0x88F5}, + { "glGetProgramARB", 'I', 1, "GL_MAX_PROGRAM_IF_DEPTH_NV", 0x88F6}, + { "glGetProgramARB", 'I', 1, "GL_MAX_PROGRAM_LOOP_DEPTH_NV", 0x88F7}, + { "glGetProgramARB", 'I', 1, "GL_MAX_PROGRAM_LOOP_COUNT_NV", 0x88F8}, + { "", 'X', 1, "GL_SRC1_COLOR", 0x88F9}, + { "", 'X', 1, "GL_ONE_MINUS_SRC1_COLOR", 0x88FA}, + { "", 'X', 1, "GL_ONE_MINUS_SRC1_ALPHA", 0x88FB}, + { "glGet", 'I', 1, "GL_MAX_DUAL_SOURCE_DRAW_BUFFERS", 0x88FC}, + { "glGetVertexAttrib", 'I', 1, "GL_VERTEX_ATTRIB_ARRAY_INTEGER", 0x88FD}, + { "glGetVertexAttrib", 'I', 1, "GL_VERTEX_ATTRIB_ARRAY_DIVISOR", 0x88FE}, + { "glGet", 'I', 1, "GL_MAX_ARRAY_TEXTURE_LAYERS", 0x88FF}, + { "glGet", 'F', 1, "GL_MIN_PROGRAM_TEXEL_OFFSET", 0x8904}, + { "glGet", 'F', 1, "GL_MAX_PROGRAM_TEXEL_OFFSET", 0x8905}, + { "", 'X', 1, "GL_PROGRAM_ATTRIB_COMPONENTS_NV", 0x8906}, + { "", 'X', 1, "GL_PROGRAM_RESULT_COMPONENTS_NV", 0x8907}, + { "", 'X', 1, "GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV", 0x8908}, + { "", 'X', 1, "GL_MAX_PROGRAM_RESULT_COMPONENTS_NV", 0x8909}, + { "glGet", 'B', 1, "GL_STENCIL_TEST_TWO_SIDE_EXT", 0x8910}, + { "glGet", 'E', 1, "GL_ACTIVE_STENCIL_FACE_EXT", 0x8911}, + { "", 'X', 1, "GL_MIRROR_CLAMP_TO_BORDER_EXT", 0x8912}, + { "", 'X', 1, "GL_SAMPLES_PASSED", 0x8914}, + { "", 'X', 1, "GL_GEOMETRY_VERTICES_OUT", 0x8916}, + { "", 'X', 1, "GL_GEOMETRY_INPUT_TYPE", 0x8917}, + { "", 'X', 1, "GL_GEOMETRY_OUTPUT_TYPE", 0x8918}, + { "glGet", 'I', 1, "GL_SAMPLER_BINDING", 0x8919}, + { "glGet", 'B', 1, "GL_CLAMP_VERTEX_COLOR", 0x891A}, + { "glGet", 'B', 1, "GL_CLAMP_FRAGMENT_COLOR", 0x891B}, + { "glGet", 'B', 1, "GL_CLAMP_READ_COLOR", 0x891C}, + { "", 'X', 1, "GL_FIXED_ONLY", 0x891D}, + { "", 'X', 1, "GL_TESS_CONTROL_PROGRAM_NV", 0x891E}, + { "", 'X', 1, "GL_TESS_EVALUATION_PROGRAM_NV", 0x891F}, + { "", 'X', 1, "GL_FRAGMENT_SHADER_ATI", 0x8920}, + { "", 'X', 1, "GL_REG_0_ATI", 0x8921}, + { "", 'X', 1, "GL_REG_1_ATI", 0x8922}, + { "", 'X', 1, "GL_REG_2_ATI", 0x8923}, + { "", 'X', 1, "GL_REG_3_ATI", 0x8924}, + { "", 'X', 1, "GL_REG_4_ATI", 0x8925}, + { "", 'X', 1, "GL_REG_5_ATI", 0x8926}, + { "", 'X', 1, "GL_REG_6_ATI", 0x8927}, + { "", 'X', 1, "GL_REG_7_ATI", 0x8928}, + { "", 'X', 1, "GL_REG_8_ATI", 0x8929}, + { "", 'X', 1, "GL_REG_9_ATI", 0x892A}, + { "", 'X', 1, "GL_REG_10_ATI", 0x892B}, + { "", 'X', 1, "GL_REG_11_ATI", 0x892C}, + { "", 'X', 1, "GL_REG_12_ATI", 0x892D}, + { "", 'X', 1, "GL_REG_13_ATI", 0x892E}, + { "", 'X', 1, "GL_REG_14_ATI", 0x892F}, + { "", 'X', 1, "GL_REG_15_ATI", 0x8930}, + { "", 'X', 1, "GL_REG_16_ATI", 0x8931}, + { "", 'X', 1, "GL_REG_17_ATI", 0x8932}, + { "", 'X', 1, "GL_REG_18_ATI", 0x8933}, + { "", 'X', 1, "GL_REG_19_ATI", 0x8934}, + { "", 'X', 1, "GL_REG_20_ATI", 0x8935}, + { "", 'X', 1, "GL_REG_21_ATI", 0x8936}, + { "", 'X', 1, "GL_REG_22_ATI", 0x8937}, + { "", 'X', 1, "GL_REG_23_ATI", 0x8938}, + { "", 'X', 1, "GL_REG_24_ATI", 0x8939}, + { "", 'X', 1, "GL_REG_25_ATI", 0x893A}, + { "", 'X', 1, "GL_REG_26_ATI", 0x893B}, + { "", 'X', 1, "GL_REG_27_ATI", 0x893C}, + { "", 'X', 1, "GL_REG_28_ATI", 0x893D}, + { "", 'X', 1, "GL_REG_29_ATI", 0x893E}, + { "", 'X', 1, "GL_REG_30_ATI", 0x893F}, + { "", 'X', 1, "GL_REG_31_ATI", 0x8940}, + { "", 'X', 1, "GL_CON_0_ATI", 0x8941}, + { "", 'X', 1, "GL_CON_1_ATI", 0x8942}, + { "", 'X', 1, "GL_CON_2_ATI", 0x8943}, + { "", 'X', 1, "GL_CON_3_ATI", 0x8944}, + { "", 'X', 1, "GL_CON_4_ATI", 0x8945}, + { "", 'X', 1, "GL_CON_5_ATI", 0x8946}, + { "", 'X', 1, "GL_CON_6_ATI", 0x8947}, + { "", 'X', 1, "GL_CON_7_ATI", 0x8948}, + { "", 'X', 1, "GL_CON_8_ATI", 0x8949}, + { "", 'X', 1, "GL_CON_9_ATI", 0x894A}, + { "", 'X', 1, "GL_CON_10_ATI", 0x894B}, + { "", 'X', 1, "GL_CON_11_ATI", 0x894C}, + { "", 'X', 1, "GL_CON_12_ATI", 0x894D}, + { "", 'X', 1, "GL_CON_13_ATI", 0x894E}, + { "", 'X', 1, "GL_CON_14_ATI", 0x894F}, + { "", 'X', 1, "GL_CON_15_ATI", 0x8950}, + { "", 'X', 1, "GL_CON_16_ATI", 0x8951}, + { "", 'X', 1, "GL_CON_17_ATI", 0x8952}, + { "", 'X', 1, "GL_CON_18_ATI", 0x8953}, + { "", 'X', 1, "GL_CON_19_ATI", 0x8954}, + { "", 'X', 1, "GL_CON_20_ATI", 0x8955}, + { "", 'X', 1, "GL_CON_21_ATI", 0x8956}, + { "", 'X', 1, "GL_CON_22_ATI", 0x8957}, + { "", 'X', 1, "GL_CON_23_ATI", 0x8958}, + { "", 'X', 1, "GL_CON_24_ATI", 0x8959}, + { "", 'X', 1, "GL_CON_25_ATI", 0x895A}, + { "", 'X', 1, "GL_CON_26_ATI", 0x895B}, + { "", 'X', 1, "GL_CON_27_ATI", 0x895C}, + { "", 'X', 1, "GL_CON_28_ATI", 0x895D}, + { "", 'X', 1, "GL_CON_29_ATI", 0x895E}, + { "", 'X', 1, "GL_CON_30_ATI", 0x895F}, + { "", 'X', 1, "GL_CON_31_ATI", 0x8960}, + { "", 'X', 1, "GL_MOV_ATI", 0x8961}, + { "", 'X', 1, "GL_ADD_ATI", 0x8963}, + { "", 'X', 1, "GL_MUL_ATI", 0x8964}, + { "", 'X', 1, "GL_SUB_ATI", 0x8965}, + { "", 'X', 1, "GL_DOT3_ATI", 0x8966}, + { "", 'X', 1, "GL_DOT4_ATI", 0x8967}, + { "", 'X', 1, "GL_MAD_ATI", 0x8968}, + { "", 'X', 1, "GL_LERP_ATI", 0x8969}, + { "", 'X', 1, "GL_CND_ATI", 0x896A}, + { "", 'X', 1, "GL_CND0_ATI", 0x896B}, + { "", 'X', 1, "GL_DOT2_ADD_ATI", 0x896C}, + { "", 'X', 1, "GL_SECONDARY_INTERPOLATOR_ATI", 0x896D}, + { "", 'X', 1, "GL_NUM_FRAGMENT_REGISTERS_ATI", 0x896E}, + { "", 'X', 1, "GL_NUM_FRAGMENT_CONSTANTS_ATI", 0x896F}, + { "", 'X', 1, "GL_NUM_PASSES_ATI", 0x8970}, + { "", 'X', 1, "GL_NUM_INSTRUCTIONS_PER_PASS_ATI", 0x8971}, + { "", 'X', 1, "GL_NUM_INSTRUCTIONS_TOTAL_ATI", 0x8972}, + { "", 'X', 1, "GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI", 0x8973}, + { "", 'X', 1, "GL_NUM_LOOPBACK_COMPONENTS_ATI", 0x8974}, + { "", 'X', 1, "GL_COLOR_ALPHA_PAIRING_ATI", 0x8975}, + { "", 'X', 1, "GL_SWIZZLE_STR_ATI", 0x8976}, + { "", 'X', 1, "GL_SWIZZLE_STQ_ATI", 0x8977}, + { "", 'X', 1, "GL_SWIZZLE_STR_DR_ATI", 0x8978}, + { "", 'X', 1, "GL_SWIZZLE_STQ_DQ_ATI", 0x8979}, + { "", 'X', 1, "GL_SWIZZLE_STRQ_ATI", 0x897A}, + { "", 'X', 1, "GL_SWIZZLE_STRQ_DQ_ATI", 0x897B}, + { "", 'X', 1, "GL_INTERLACE_OML", 0x8980}, + { "", 'X', 1, "GL_INTERLACE_READ_OML", 0x8981}, + { "", 'X', 1, "GL_FORMAT_SUBSAMPLE_24_24_OML", 0x8982}, + { "", 'X', 1, "GL_FORMAT_SUBSAMPLE_244_244_OML", 0x8983}, + { "", 'X', 1, "GL_PACK_RESAMPLE_OML", 0x8984}, + { "", 'X', 1, "GL_UNPACK_RESAMPLE_OML", 0x8985}, + { "", 'X', 1, "GL_RESAMPLE_REPLICATE_OML", 0x8986}, + { "", 'X', 1, "GL_RESAMPLE_ZERO_FILL_OML", 0x8987}, + { "", 'X', 1, "GL_RESAMPLE_AVERAGE_OML", 0x8988}, + { "", 'X', 1, "GL_RESAMPLE_DECIMATE_OML", 0x8989}, + { "", 'X', 1, "GL_POINT_SIZE_ARRAY_TYPE_OES", 0x898A}, + { "", 'X', 1, "GL_POINT_SIZE_ARRAY_STRIDE_OES", 0x898B}, + { "", 'X', 1, "GL_POINT_SIZE_ARRAY_POINTER_OES", 0x898C}, + { "", 'X', 1, "GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES", 0x898D}, + { "", 'X', 1, "GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES", 0x898E}, + { "", 'X', 1, "GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES", 0x898F}, + { "", 'X', 1, "GL_VERTEX_ATTRIB_MAP1_APPLE", 0x8A00}, + { "", 'X', 1, "GL_VERTEX_ATTRIB_MAP2_APPLE", 0x8A01}, + { "", 'X', 1, "GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE", 0x8A02}, + { "", 'X', 1, "GL_VERTEX_ATTRIB_MAP1_COEFF_APPLE", 0x8A03}, + { "", 'X', 1, "GL_VERTEX_ATTRIB_MAP1_ORDER_APPLE", 0x8A04}, + { "", 'X', 1, "GL_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE", 0x8A05}, + { "", 'X', 1, "GL_VERTEX_ATTRIB_MAP2_SIZE_APPLE", 0x8A06}, + { "", 'X', 1, "GL_VERTEX_ATTRIB_MAP2_COEFF_APPLE", 0x8A07}, + { "", 'X', 1, "GL_VERTEX_ATTRIB_MAP2_ORDER_APPLE", 0x8A08}, + { "", 'X', 1, "GL_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE", 0x8A09}, + { "", 'X', 1, "GL_DRAW_PIXELS_APPLE", 0x8A0A}, + { "", 'X', 1, "GL_FENCE_APPLE", 0x8A0B}, + { "", 'X', 1, "GL_ELEMENT_ARRAY_APPLE", 0x8A0C}, + { "glGet", 'E', 1, "GL_ELEMENT_ARRAY_TYPE_APPLE", 0x8A0D}, + { "", 'X', 1, "GL_ELEMENT_ARRAY_POINTER_APPLE", 0x8A0E}, + { "", 'X', 1, "GL_COLOR_FLOAT_APPLE", 0x8A0F}, + { "", 'X', 1, "GL_UNIFORM_BUFFER", 0x8A11}, + { "", 'X', 1, "GL_BUFFER_SERIALIZED_MODIFY_APPLE", 0x8A12}, + { "", 'X', 1, "GL_BUFFER_FLUSHING_UNMAP_APPLE", 0x8A13}, + { "", 'X', 1, "GL_AUX_DEPTH_STENCIL_APPLE", 0x8A14}, + { "", 'X', 1, "GL_PACK_ROW_BYTES_APPLE", 0x8A15}, + { "", 'X', 1, "GL_UNPACK_ROW_BYTES_APPLE", 0x8A16}, + { "", 'X', 1, "GL_RELEASED_APPLE", 0x8A19}, + { "", 'X', 1, "GL_VOLATILE_APPLE", 0x8A1A}, + { "", 'X', 1, "GL_RETAINED_APPLE", 0x8A1B}, + { "", 'X', 1, "GL_UNDEFINED_APPLE", 0x8A1C}, + { "", 'X', 1, "GL_PURGEABLE_APPLE", 0x8A1D}, + { "", 'X', 1, "GL_RGB_422_APPLE", 0x8A1F}, + { "glGet,glGetI", 'I', 1, "GL_UNIFORM_BUFFER_BINDING", 0x8A28}, + { "glGetI", 'i', 1, "GL_UNIFORM_BUFFER_START", 0x8A29}, + { "glGetI", 'i', 1, "GL_UNIFORM_BUFFER_SIZE", 0x8A2A}, + { "glGet", 'I', 1, "GL_MAX_VERTEX_UNIFORM_BLOCKS", 0x8A2B}, + { "glGet", 'I', 1, "GL_MAX_GEOMETRY_UNIFORM_BLOCKS", 0x8A2C}, + { "glGet", 'I', 1, "GL_MAX_FRAGMENT_UNIFORM_BLOCKS", 0x8A2D}, + { "glGet", 'I', 1, "GL_MAX_COMBINED_UNIFORM_BLOCKS", 0x8A2E}, + { "glGet", 'I', 1, "GL_MAX_UNIFORM_BUFFER_BINDINGS", 0x8A2F}, + { "glGet", 'I', 1, "GL_MAX_UNIFORM_BLOCK_SIZE", 0x8A30}, + { "glGet", 'I', 1, "GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS", 0x8A31}, + { "glGet", 'I', 1, "GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS", 0x8A32}, + { "glGet", 'I', 1, "GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS", 0x8A33}, + { "glGet", 'I', 1, "GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT", 0x8A34}, + { "glGetProgram", 'I', 1, "GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH", 0x8A35}, + { "glGetProgram", 'I', 1, "GL_ACTIVE_UNIFORM_BLOCKS", 0x8A36}, + { "glGetActiveUniforms", 'E', 1, "GL_UNIFORM_TYPE", 0x8A37}, + { "glGetActiveUniforms", 'I', 1, "GL_UNIFORM_SIZE", 0x8A38}, + { "glGetActiveUniforms", 'I', 1, "GL_UNIFORM_NAME_LENGTH", 0x8A39}, + { "glGetActiveUniforms", 'I', 1, "GL_UNIFORM_BLOCK_INDEX", 0x8A3A}, + { "glGetActiveUniforms", 'I', 1, "GL_UNIFORM_OFFSET", 0x8A3B}, + { "glGetActiveUniforms", 'I', 1, "GL_UNIFORM_ARRAY_STRIDE", 0x8A3C}, + { "glGetActiveUniforms", 'I', 1, "GL_UNIFORM_MATRIX_STRIDE", 0x8A3D}, + { "glGetActiveUniforms", 'B', 1, "GL_UNIFORM_IS_ROW_MAJOR", 0x8A3E}, + { "glGetActiveUniformBlock", 'I', 1, "GL_UNIFORM_BLOCK_BINDING", 0x8A3F}, + { "glGetActiveUniformBlock", 'I', 1, "GL_UNIFORM_BLOCK_DATA_SIZE", 0x8A40}, + { "glGetActiveUniformBlock", 'I', 1, "GL_UNIFORM_BLOCK_NAME_LENGTH", 0x8A41}, + { "glGetActiveUniformBlock", 'I', 1, "GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS", 0x8A42}, + { "glGetActiveUniformBlock", 'I', 1, "GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES", 0x8A43}, + { "glGetActiveUniformBlock", 'B', 1, "GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER", 0x8A44}, + { "glGetActiveUniformBlock", 'B', 1, "GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER", 0x8A45}, + { "glGetActiveUniformBlock", 'B', 1, "GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER", 0x8A46}, + { "glGetTexParameter", 'E', 1, "GL_TEXTURE_SRGB_DECODE_EXT", 0x8A48}, + { "", 'X', 1, "GL_DECODE_EXT", 0x8A49}, + { "", 'X', 1, "GL_SKIP_DECODE_EXT", 0x8A4A}, + { "glGetProgramPipeline", 'I', 1, "GL_FRAGMENT_SHADER", 0x8B30}, + { "glGetProgramPipeline", 'I', 1, "GL_VERTEX_SHADER", 0x8B31}, + { "", 'H', 1, "GL_PROGRAM_OBJECT_ARB", 0x8B40}, + { "", 'X', 1, "GL_SHADER_OBJECT_ARB", 0x8B48}, + { "glGet", 'I', 1, "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS", 0x8B49}, + { "glGet", 'I', 1, "GL_MAX_VERTEX_UNIFORM_COMPONENTS", 0x8B4A}, + { "glGet", 'I', 1, "GL_MAX_VARYING_COMPONENTS", 0x8B4B}, + { "glGet", 'I', 1, "GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS", 0x8B4C}, + { "glGet", 'I', 1, "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS", 0x8B4D}, + { "", 'E', 1, "GL_OBJECT_TYPE_ARB", 0x8B4E}, + { "glGetShader", 'E', 1, "GL_SHADER_TYPE", 0x8B4F}, + { "", 'X', 1, "GL_FLOAT_VEC2", 0x8B50}, + { "", 'X', 1, "GL_FLOAT_VEC3", 0x8B51}, + { "", 'X', 1, "GL_FLOAT_VEC4", 0x8B52}, + { "", 'X', 1, "GL_INT_VEC2", 0x8B53}, + { "", 'X', 1, "GL_INT_VEC3", 0x8B54}, + { "", 'X', 1, "GL_INT_VEC4", 0x8B55}, + { "", 'X', 1, "GL_BOOL", 0x8B56}, + { "", 'X', 1, "GL_BOOL_VEC2", 0x8B57}, + { "", 'X', 1, "GL_BOOL_VEC3", 0x8B58}, + { "", 'X', 1, "GL_BOOL_VEC4", 0x8B59}, + { "", 'X', 1, "GL_FLOAT_MAT2", 0x8B5A}, + { "", 'X', 1, "GL_FLOAT_MAT3", 0x8B5B}, + { "", 'X', 1, "GL_FLOAT_MAT4", 0x8B5C}, + { "", 'X', 1, "GL_SAMPLER_1D", 0x8B5D}, + { "", 'X', 1, "GL_SAMPLER_2D", 0x8B5E}, + { "", 'X', 1, "GL_SAMPLER_3D", 0x8B5F}, + { "", 'X', 1, "GL_SAMPLER_CUBE", 0x8B60}, + { "", 'X', 1, "GL_SAMPLER_1D_SHADOW", 0x8B61}, + { "", 'X', 1, "GL_SAMPLER_2D_SHADOW", 0x8B62}, + { "", 'X', 1, "GL_SAMPLER_2D_RECT", 0x8B63}, + { "", 'X', 1, "GL_SAMPLER_2D_RECT_SHADOW", 0x8B64}, + { "", 'X', 1, "GL_FLOAT_MAT2x3", 0x8B65}, + { "", 'X', 1, "GL_FLOAT_MAT2x4", 0x8B66}, + { "", 'X', 1, "GL_FLOAT_MAT3x2", 0x8B67}, + { "", 'X', 1, "GL_FLOAT_MAT3x4", 0x8B68}, + { "", 'X', 1, "GL_FLOAT_MAT4x2", 0x8B69}, + { "", 'X', 1, "GL_FLOAT_MAT4x3", 0x8B6A}, + { "glGetShader,glGetProgram", 'B', 1, "GL_DELETE_STATUS", 0x8B80}, + { "glGetShader,glGetProgram", 'B', 1, "GL_COMPILE_STATUS", 0x8B81}, + { "glGetShader,glGetProgram", 'B', 1, "GL_LINK_STATUS", 0x8B82}, + { "glGetShader,glGetProgram", 'B', 1, "GL_VALIDATE_STATUS", 0x8B83}, + { "glGetShader,glGetProgram", 'I', 1, "GL_INFO_LOG_LENGTH", 0x8B84}, + { "glGetProgram", 'I', 1, "GL_ATTACHED_SHADERS", 0x8B85}, + { "glGetProgram", 'I', 1, "GL_ACTIVE_UNIFORMS", 0x8B86}, + { "glGetProgram", 'I', 1, "GL_ACTIVE_UNIFORM_MAX_LENGTH", 0x8B87}, + { "glGetShader", 'I', 1, "GL_SHADER_SOURCE_LENGTH", 0x8B88}, + { "glGetProgram", 'I', 1, "GL_ACTIVE_ATTRIBUTES", 0x8B89}, + { "glGetProgram", 'I', 1, "GL_ACTIVE_ATTRIBUTE_MAX_LENGTH", 0x8B8A}, + { "glGet", 'E', 1, "GL_FRAGMENT_SHADER_DERIVATIVE_HINT", 0x8B8B}, + { "glGet", 'S', 1, "GL_SHADING_LANGUAGE_VERSION", 0x8B8C}, + { "glGet", 'U', 1, "GL_CURRENT_PROGRAM", 0x8B8D}, + { "", 'X', 1, "GL_PALETTE4_RGB8_OES", 0x8B90}, + { "", 'X', 1, "GL_PALETTE4_RGBA8_OES", 0x8B91}, + { "", 'X', 1, "GL_PALETTE4_R5_G6_B5_OES", 0x8B92}, + { "", 'X', 1, "GL_PALETTE4_RGBA4_OES", 0x8B93}, + { "", 'X', 1, "GL_PALETTE4_RGB5_A1_OES", 0x8B94}, + { "", 'X', 1, "GL_PALETTE8_RGB8_OES", 0x8B95}, + { "", 'X', 1, "GL_PALETTE8_RGBA8_OES", 0x8B96}, + { "", 'X', 1, "GL_PALETTE8_R5_G6_B5_OES", 0x8B97}, + { "", 'X', 1, "GL_PALETTE8_RGBA4_OES", 0x8B98}, + { "", 'X', 1, "GL_PALETTE8_RGB5_A1_OES", 0x8B99}, + { "glGet", 'E', 1, "GL_IMPLEMENTATION_COLOR_READ_TYPE", 0x8B9A}, + { "glGet", 'E', 1, "GL_IMPLEMENTATION_COLOR_READ_FORMAT", 0x8B9B}, + { "", 'X', 1, "GL_POINT_SIZE_ARRAY_OES", 0x8B9C}, + { "glGetTexParameter", 'I', 4, "GL_TEXTURE_CROP_RECT_OES", 0x8B9D}, + { "", 'X', 1, "GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES", 0x8B9E}, + { "", 'X', 1, "GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES", 0x8B9F}, + { "", 'X', 1, "GL_COUNTER_TYPE_AMD", 0x8BC0}, + { "", 'X', 1, "GL_COUNTER_RANGE_AMD", 0x8BC1}, + { "", 'X', 1, "GL_UNSIGNED_INT64_AMD", 0x8BC2}, + { "", 'X', 1, "GL_PERCENTAGE_AMD", 0x8BC3}, + { "", 'X', 1, "GL_PERFMON_RESULT_AVAILABLE_AMD", 0x8BC4}, + { "", 'X', 1, "GL_PERFMON_RESULT_SIZE_AMD", 0x8BC5}, + { "", 'X', 1, "GL_PERFMON_RESULT_AMD", 0x8BC6}, + { "glGetTexLevelParameter", 'E', 1, "GL_TEXTURE_RED_TYPE", 0x8C10}, + { "glGetTexLevelParameter", 'E', 1, "GL_TEXTURE_GREEN_TYPE", 0x8C11}, + { "glGetTexLevelParameter", 'E', 1, "GL_TEXTURE_BLUE_TYPE", 0x8C12}, + { "glGetTexLevelParameter", 'E', 1, "GL_TEXTURE_ALPHA_TYPE", 0x8C13}, + { "glGetTexLevelParameter", 'E', 1, "GL_TEXTURE_LUMINANCE_TYPE", 0x8C14}, + { "glGetTexLevelParameter", 'E', 1, "GL_TEXTURE_INTENSITY_TYPE", 0x8C15}, + { "glGetTexLevelParameter", 'E', 1, "GL_TEXTURE_DEPTH_TYPE", 0x8C16}, + { "", 'X', 1, "GL_UNSIGNED_NORMALIZED", 0x8C17}, + { "", 'X', 1, "GL_TEXTURE_1D_ARRAY", 0x8C18}, + { "", 'X', 1, "GL_PROXY_TEXTURE_1D_ARRAY", 0x8C19}, + { "", 'X', 1, "GL_TEXTURE_2D_ARRAY", 0x8C1A}, + { "", 'X', 1, "GL_PROXY_TEXTURE_2D_ARRAY", 0x8C1B}, + { "glGet", 'I', 1, "GL_TEXTURE_BINDING_1D_ARRAY", 0x8C1C}, + { "glGet", 'I', 1, "GL_TEXTURE_BINDING_2D_ARRAY", 0x8C1D}, + { "", 'X', 1, "GL_GEOMETRY_PROGRAM_NV", 0x8C26}, + { "", 'X', 1, "GL_MAX_PROGRAM_OUTPUT_VERTICES_NV", 0x8C27}, + { "", 'X', 1, "GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV", 0x8C28}, + { "glGet", 'I', 1, "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS", 0x8C29}, + { "glGet", 'I', 1, "GL_TEXTURE_BUFFER", 0x8C2A}, + { "glGet", 'I', 1, "GL_MAX_TEXTURE_BUFFER_SIZE", 0x8C2B}, + { "glGet", 'I', 1, "GL_TEXTURE_BINDING_BUFFER", 0x8C2C}, + { "glGet", 'I', 1, "GL_TEXTURE_BUFFER_DATA_STORE_BINDING", 0x8C2D}, + { "glGet", 'E', 1, "GL_TEXTURE_BUFFER_FORMAT", 0x8C2E}, + { "", 'X', 1, "GL_ANY_SAMPLES_PASSED", 0x8C2F}, + { "glGet", 'B', 1, "GL_SAMPLE_SHADING", 0x8C36}, + { "glGet", 'F', 1, "GL_MIN_SAMPLE_SHADING_VALUE", 0x8C37}, + { "", 'X', 1, "GL_R11F_G11F_B10F", 0x8C3A}, + { "", 'X', 1, "GL_UNSIGNED_INT_10F_11F_11F_REV", 0x8C3B}, + { "", 'X', 1, "GL_RGBA_SIGNED_COMPONENTS_EXT", 0x8C3C}, + { "", 'X', 1, "GL_RGB9_E5", 0x8C3D}, + { "", 'X', 1, "GL_UNSIGNED_INT_5_9_9_9_REV", 0x8C3E}, + { "", 'I', 1, "GL_TEXTURE_SHARED_SIZE", 0x8C3F}, + { "", 'X', 1, "GL_SRGB", 0x8C40}, + { "", 'X', 1, "GL_SRGB8", 0x8C41}, + { "", 'X', 1, "GL_SRGB_ALPHA", 0x8C42}, + { "", 'X', 1, "GL_SRGB8_ALPHA8", 0x8C43}, + { "", 'X', 1, "GL_SLUMINANCE_ALPHA", 0x8C44}, + { "", 'X', 1, "GL_SLUMINANCE8_ALPHA8", 0x8C45}, + { "", 'X', 1, "GL_SLUMINANCE", 0x8C46}, + { "", 'X', 1, "GL_SLUMINANCE8", 0x8C47}, + { "", 'X', 1, "GL_COMPRESSED_SRGB", 0x8C48}, + { "", 'X', 1, "GL_COMPRESSED_SRGB_ALPHA", 0x8C49}, + { "", 'X', 1, "GL_COMPRESSED_SLUMINANCE", 0x8C4A}, + { "", 'X', 1, "GL_COMPRESSED_SLUMINANCE_ALPHA", 0x8C4B}, + { "", 'X', 1, "GL_COMPRESSED_SRGB_S3TC_DXT1_EXT", 0x8C4C}, + { "", 'X', 1, "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT", 0x8C4D}, + { "", 'X', 1, "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT", 0x8C4E}, + { "", 'X', 1, "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT", 0x8C4F}, + { "", 'X', 1, "GL_COMPRESSED_LUMINANCE_LATC1_EXT", 0x8C70}, + { "", 'X', 1, "GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT", 0x8C71}, + { "", 'X', 1, "GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT", 0x8C72}, + { "", 'X', 1, "GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT", 0x8C73}, + { "", 'X', 1, "GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV", 0x8C74}, + { "", 'X', 1, "GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV", 0x8C75}, + { "", 'X', 1, "GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH", 0x8C76}, + { "", 'X', 1, "GL_BACK_PRIMARY_COLOR_NV", 0x8C77}, + { "", 'X', 1, "GL_BACK_SECONDARY_COLOR_NV", 0x8C78}, + { "", 'X', 1, "GL_TEXTURE_COORD_NV", 0x8C79}, + { "", 'X', 1, "GL_CLIP_DISTANCE_NV", 0x8C7A}, + { "", 'X', 1, "GL_VERTEX_ID_NV", 0x8C7B}, + { "", 'X', 1, "GL_PRIMITIVE_ID_NV", 0x8C7C}, + { "", 'X', 1, "GL_GENERIC_ATTRIB_NV", 0x8C7D}, + { "", 'X', 1, "GL_TRANSFORM_FEEDBACK_ATTRIBS_NV", 0x8C7E}, + { "", 'X', 1, "GL_TRANSFORM_FEEDBACK_BUFFER_MODE", 0x8C7F}, + { "", 'X', 1, "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS", 0x8C80}, + { "", 'X', 1, "GL_ACTIVE_VARYINGS_NV", 0x8C81}, + { "", 'X', 1, "GL_ACTIVE_VARYING_MAX_LENGTH_NV", 0x8C82}, + { "", 'X', 1, "GL_TRANSFORM_FEEDBACK_VARYINGS", 0x8C83}, + { "glGetI", 'I', 1, "GL_TRANSFORM_FEEDBACK_BUFFER_START", 0x8C84}, + { "glGetI", 'I', 1, "GL_TRANSFORM_FEEDBACK_BUFFER_SIZE", 0x8C85}, + { "", 'X', 1, "GL_TRANSFORM_FEEDBACK_RECORD_NV", 0x8C86}, + { "", 'X', 1, "GL_PRIMITIVES_GENERATED", 0x8C87}, + { "", 'X', 1, "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN", 0x8C88}, + { "glGet", 'B', 1, "GL_RASTERIZER_DISCARD", 0x8C89}, + { "", 'X', 1, "GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS", 0x8C8A}, + { "", 'X', 1, "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS", 0x8C8B}, + { "", 'X', 1, "GL_INTERLEAVED_ATTRIBS", 0x8C8C}, + { "", 'X', 1, "GL_SEPARATE_ATTRIBS", 0x8C8D}, + { "glGet", 'X', 1, "GL_TRANSFORM_FEEDBACK_BUFFER", 0x8C8E}, + { "glGet,glGetI", 'I', 1, "GL_TRANSFORM_FEEDBACK_BUFFER_BINDING", 0x8C8F}, + { "", 'X', 1, "GL_ATC_RGB_AMD", 0x8C92}, + { "", 'X', 1, "GL_ATC_RGBA_EXPLICIT_ALPHA_AMD", 0x8C93}, + { "glGet", 'E', 1, "GL_POINT_SPRITE_COORD_ORIGIN", 0x8CA0}, + { "", 'X', 1, "GL_LOWER_LEFT", 0x8CA1}, + { "", 'X', 1, "GL_UPPER_LEFT", 0x8CA2}, + { "glGet", 'I', 1, "GL_STENCIL_BACK_REF", 0x8CA3}, + { "glGet", 'U', 1, "GL_STENCIL_BACK_VALUE_MASK", 0x8CA4}, + { "glGet", 'U', 1, "GL_STENCIL_BACK_WRITEMASK", 0x8CA5}, + { "glGet", 'I', 1, "GL_DRAW_FRAMEBUFFER_BINDING", 0x8CA6}, + { "glGet", 'I', 1, "GL_RENDERBUFFER_BINDING", 0x8CA7}, + { "", 'I', 1, "GL_READ_FRAMEBUFFER", 0x8CA8}, + { "", 'I', 1, "GL_DRAW_FRAMEBUFFER", 0x8CA9}, + { "glGet", 'I', 1, "GL_READ_FRAMEBUFFER_BINDING", 0x8CAA}, + { "glGetRenderbufferParameter", 'I', 1, "GL_RENDERBUFFER_SAMPLES", 0x8CAB}, + { "", 'X', 1, "GL_DEPTH_COMPONENT32F", 0x8CAC}, + { "", 'X', 1, "GL_DEPTH32F_STENCIL8", 0x8CAD}, + { "glGetFramebufferAttachmentParameter", 'E', 1, "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE", 0x8CD0}, + { "glGetFramebufferAttachmentParameter", 'I', 1, "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME", 0x8CD1}, + { "glGetFramebufferAttachmentParameter", 'I', 1, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL", 0x8CD2}, + { "glGetFramebufferAttachmentParameter", 'E', 1, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE", 0x8CD3}, + { "glGetFramebufferAttachmentParameter", 'I', 1, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER", 0x8CD4}, + { "", 'X', 1, "GL_FRAMEBUFFER_COMPLETE", 0x8CD5}, + { "", 'X', 1, "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT", 0x8CD6}, + { "", 'X', 1, "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT", 0x8CD7}, + { "", 'X', 1, "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT", 0x8CD9}, + { "", 'X', 1, "GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT", 0x8CDA}, + { "", 'X', 1, "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER", 0x8CDB}, + { "", 'X', 1, "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER", 0x8CDC}, + { "", 'X', 1, "GL_FRAMEBUFFER_UNSUPPORTED", 0x8CDD}, + { "glGet", 'I', 1, "GL_MAX_COLOR_ATTACHMENTS", 0x8CDF}, + { "", 'X', 1, "GL_COLOR_ATTACHMENT0", 0x8CE0}, + { "", 'X', 1, "GL_COLOR_ATTACHMENT1", 0x8CE1}, + { "", 'X', 1, "GL_COLOR_ATTACHMENT2", 0x8CE2}, + { "", 'X', 1, "GL_COLOR_ATTACHMENT3", 0x8CE3}, + { "", 'X', 1, "GL_COLOR_ATTACHMENT4", 0x8CE4}, + { "", 'X', 1, "GL_COLOR_ATTACHMENT5", 0x8CE5}, + { "", 'X', 1, "GL_COLOR_ATTACHMENT6", 0x8CE6}, + { "", 'X', 1, "GL_COLOR_ATTACHMENT7", 0x8CE7}, + { "", 'X', 1, "GL_COLOR_ATTACHMENT8", 0x8CE8}, + { "", 'X', 1, "GL_COLOR_ATTACHMENT9", 0x8CE9}, + { "", 'X', 1, "GL_COLOR_ATTACHMENT10", 0x8CEA}, + { "", 'X', 1, "GL_COLOR_ATTACHMENT11", 0x8CEB}, + { "", 'X', 1, "GL_COLOR_ATTACHMENT12", 0x8CEC}, + { "", 'X', 1, "GL_COLOR_ATTACHMENT13", 0x8CED}, + { "", 'X', 1, "GL_COLOR_ATTACHMENT14", 0x8CEE}, + { "", 'X', 1, "GL_COLOR_ATTACHMENT15", 0x8CEF}, + { "", 'X', 1, "GL_DEPTH_ATTACHMENT", 0x8D00}, + { "", 'X', 1, "GL_STENCIL_ATTACHMENT", 0x8D20}, + { "", 'X', 1, "GL_FRAMEBUFFER", 0x8D40}, + { "", 'X', 1, "GL_RENDERBUFFER", 0x8D41}, + { "glGetRenderbufferParameter", 'I', 1, "GL_RENDERBUFFER_WIDTH", 0x8D42}, + { "glGetRenderbufferParameter", 'I', 1, "GL_RENDERBUFFER_HEIGHT", 0x8D43}, + { "glGetRenderbufferParameter", 'I', 1, "GL_RENDERBUFFER_INTERNAL_FORMAT", 0x8D44}, + { "", 'X', 1, "GL_STENCIL_INDEX1", 0x8D46}, + { "", 'X', 1, "GL_STENCIL_INDEX4", 0x8D47}, + { "", 'X', 1, "GL_STENCIL_INDEX8", 0x8D48}, + { "", 'X', 1, "GL_STENCIL_INDEX16", 0x8D49}, + { "glGetRenderbufferParameter", 'I', 1, "GL_RENDERBUFFER_RED_SIZE", 0x8D50}, + { "glGetRenderbufferParameter", 'I', 1, "GL_RENDERBUFFER_GREEN_SIZE", 0x8D51}, + { "glGetRenderbufferParameter", 'I', 1, "GL_RENDERBUFFER_BLUE_SIZE", 0x8D52}, + { "glGetRenderbufferParameter", 'I', 1, "GL_RENDERBUFFER_ALPHA_SIZE", 0x8D53}, + { "glGetRenderbufferParameter", 'I', 1, "GL_RENDERBUFFER_DEPTH_SIZE", 0x8D54}, + { "glGetRenderbufferParameter", 'I', 1, "GL_RENDERBUFFER_STENCIL_SIZE", 0x8D55}, + { "", 'X', 1, "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE", 0x8D56}, + { "glGet", 'I', 1, "GL_MAX_SAMPLES", 0x8D57}, + { "", 'X', 1, "GL_TEXTURE_GEN_STR_OES", 0x8D60}, + { "", 'X', 1, "GL_HALF_FLOAT_OES", 0x8D61}, + { "", 'X', 1, "GL_RGB565_OES", 0x8D62}, + { "", 'X', 1, "GL_ETC1_RGB8_OES", 0x8D64}, + { "", 'X', 1, "GL_TEXTURE_EXTERNAL_OES", 0x8D65}, + { "", 'X', 1, "GL_SAMPLER_EXTERNAL_OES", 0x8D66}, + { "", 'X', 1, "GL_TEXTURE_BINDING_EXTERNAL_OES", 0x8D67}, + { "", 'X', 1, "GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES", 0x8D68}, + { "", 'B', 1, "GL_PRIMITIVE_RESTART_FIXED_INDEX", 0x8D69}, + { "", 'X', 1, "GL_ANY_SAMPLES_PASSED_CONSERVATIVE", 0x8D6A}, + { "glGet", 'I', 1, "GL_MAX_ELEMENT_INDEX", 0x8D6B}, + { "", 'X', 1, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT", 0x8D6C}, + { "", 'X', 1, "GL_RGBA32UI", 0x8D70}, + { "", 'X', 1, "GL_RGB32UI", 0x8D71}, + { "", 'X', 1, "GL_ALPHA32UI_EXT", 0x8D72}, + { "", 'X', 1, "GL_INTENSITY32UI_EXT", 0x8D73}, + { "", 'X', 1, "GL_LUMINANCE32UI_EXT", 0x8D74}, + { "", 'X', 1, "GL_LUMINANCE_ALPHA32UI_EXT", 0x8D75}, + { "", 'X', 1, "GL_RGBA16UI", 0x8D76}, + { "", 'X', 1, "GL_RGB16UI", 0x8D77}, + { "", 'X', 1, "GL_ALPHA16UI_EXT", 0x8D78}, + { "", 'X', 1, "GL_INTENSITY16UI_EXT", 0x8D79}, + { "", 'X', 1, "GL_LUMINANCE16UI_EXT", 0x8D7A}, + { "", 'X', 1, "GL_LUMINANCE_ALPHA16UI_EXT", 0x8D7B}, + { "", 'X', 1, "GL_RGBA8UI", 0x8D7C}, + { "", 'X', 1, "GL_RGB8UI", 0x8D7D}, + { "", 'X', 1, "GL_ALPHA8UI_EXT", 0x8D7E}, + { "", 'X', 1, "GL_INTENSITY8UI_EXT", 0x8D7F}, + { "", 'X', 1, "GL_LUMINANCE8UI_EXT", 0x8D80}, + { "", 'X', 1, "GL_LUMINANCE_ALPHA8UI_EXT", 0x8D81}, + { "", 'X', 1, "GL_RGBA32I", 0x8D82}, + { "", 'X', 1, "GL_RGB32I", 0x8D83}, + { "", 'X', 1, "GL_ALPHA32I_EXT", 0x8D84}, + { "", 'X', 1, "GL_INTENSITY32I_EXT", 0x8D85}, + { "", 'X', 1, "GL_LUMINANCE32I_EXT", 0x8D86}, + { "", 'X', 1, "GL_LUMINANCE_ALPHA32I_EXT", 0x8D87}, + { "", 'X', 1, "GL_RGBA16I", 0x8D88}, + { "", 'X', 1, "GL_RGB16I", 0x8D89}, + { "", 'X', 1, "GL_ALPHA16I_EXT", 0x8D8A}, + { "", 'X', 1, "GL_INTENSITY16I_EXT", 0x8D8B}, + { "", 'X', 1, "GL_LUMINANCE16I_EXT", 0x8D8C}, + { "", 'X', 1, "GL_LUMINANCE_ALPHA16I_EXT", 0x8D8D}, + { "", 'X', 1, "GL_RGBA8I", 0x8D8E}, + { "", 'X', 1, "GL_RGB8I", 0x8D8F}, + { "", 'X', 1, "GL_ALPHA8I_EXT", 0x8D90}, + { "", 'X', 1, "GL_INTENSITY8I_EXT", 0x8D91}, + { "", 'X', 1, "GL_LUMINANCE8I_EXT", 0x8D92}, + { "", 'X', 1, "GL_LUMINANCE_ALPHA8I_EXT", 0x8D93}, + { "", 'X', 1, "GL_RED_INTEGER", 0x8D94}, + { "", 'X', 1, "GL_GREEN_INTEGER", 0x8D95}, + { "", 'X', 1, "GL_BLUE_INTEGER", 0x8D96}, + { "", 'X', 1, "GL_ALPHA_INTEGER", 0x8D97}, + { "", 'X', 1, "GL_RGB_INTEGER", 0x8D98}, + { "", 'X', 1, "GL_RGBA_INTEGER", 0x8D99}, + { "", 'X', 1, "GL_BGR_INTEGER", 0x8D9A}, + { "", 'X', 1, "GL_BGRA_INTEGER", 0x8D9B}, + { "", 'X', 1, "GL_LUMINANCE_INTEGER_EXT", 0x8D9C}, + { "", 'X', 1, "GL_LUMINANCE_ALPHA_INTEGER_EXT", 0x8D9D}, + { "glGet", 'B', 1, "GL_RGBA_INTEGER_MODE_EXT", 0x8D9E}, + { "", 'X', 1, "GL_INT_2_10_10_10_REV", 0x8D9F}, + { "", 'X', 1, "GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV", 0x8DA0}, + { "", 'X', 1, "GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV", 0x8DA1}, + { "", 'X', 1, "GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV", 0x8DA2}, + { "", 'X', 1, "GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV", 0x8DA3}, + { "", 'X', 1, "GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV", 0x8DA4}, + { "", 'X', 1, "GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV", 0x8DA5}, + { "", 'X', 1, "GL_MAX_PROGRAM_GENERIC_RESULTS_NV", 0x8DA6}, + { "glGetFramebufferAttachmentParameter", 'B', 1, "GL_FRAMEBUFFER_ATTACHMENT_LAYERED", 0x8DA7}, + { "", 'X', 1, "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS", 0x8DA8}, + { "", 'X', 1, "GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB", 0x8DA9}, + { "", 'X', 1, "GL_LAYER_NV", 0x8DAA}, + { "", 'X', 1, "GL_DEPTH_COMPONENT32F_NV", 0x8DAB}, + { "", 'X', 1, "GL_DEPTH32F_STENCIL8_NV", 0x8DAC}, + { "", 'X', 1, "GL_FLOAT_32_UNSIGNED_INT_24_8_REV", 0x8DAD}, + { "", 'X', 1, "GL_SHADER_INCLUDE_ARB", 0x8DAE}, + { "", 'X', 1, "GL_DEPTH_BUFFER_FLOAT_MODE_NV", 0x8DAF}, + { "glGet", 'B', 1, "GL_FRAMEBUFFER_SRGB", 0x8DB9}, + { "glGet", 'B', 1, "GL_FRAMEBUFFER_SRGB_CAPABLE_EXT", 0x8DBA}, + { "", 'X', 1, "GL_COMPRESSED_RED_RGTC1", 0x8DBB}, + { "", 'X', 1, "GL_COMPRESSED_SIGNED_RED_RGTC1", 0x8DBC}, + { "", 'X', 1, "GL_COMPRESSED_RG_RGTC2", 0x8DBD}, + { "", 'X', 1, "GL_COMPRESSED_SIGNED_RG_RGTC2", 0x8DBE}, + { "", 'X', 1, "GL_SAMPLER_1D_ARRAY", 0x8DC0}, + { "", 'X', 1, "GL_SAMPLER_2D_ARRAY", 0x8DC1}, + { "", 'X', 1, "GL_SAMPLER_BUFFER", 0x8DC2}, + { "", 'X', 1, "GL_SAMPLER_1D_ARRAY_SHADOW", 0x8DC3}, + { "", 'X', 1, "GL_SAMPLER_2D_ARRAY_SHADOW", 0x8DC4}, + { "", 'X', 1, "GL_SAMPLER_CUBE_SHADOW", 0x8DC5}, + { "", 'X', 1, "GL_UNSIGNED_INT_VEC2", 0x8DC6}, + { "", 'X', 1, "GL_UNSIGNED_INT_VEC3", 0x8DC7}, + { "", 'X', 1, "GL_UNSIGNED_INT_VEC4", 0x8DC8}, + { "", 'X', 1, "GL_INT_SAMPLER_1D", 0x8DC9}, + { "", 'X', 1, "GL_INT_SAMPLER_2D", 0x8DCA}, + { "", 'X', 1, "GL_INT_SAMPLER_3D", 0x8DCB}, + { "", 'X', 1, "GL_INT_SAMPLER_CUBE", 0x8DCC}, + { "", 'X', 1, "GL_INT_SAMPLER_2D_RECT", 0x8DCD}, + { "", 'X', 1, "GL_INT_SAMPLER_1D_ARRAY", 0x8DCE}, + { "", 'X', 1, "GL_INT_SAMPLER_2D_ARRAY", 0x8DCF}, + { "", 'X', 1, "GL_INT_SAMPLER_BUFFER", 0x8DD0}, + { "", 'X', 1, "GL_UNSIGNED_INT_SAMPLER_1D", 0x8DD1}, + { "", 'X', 1, "GL_UNSIGNED_INT_SAMPLER_2D", 0x8DD2}, + { "", 'X', 1, "GL_UNSIGNED_INT_SAMPLER_3D", 0x8DD3}, + { "", 'X', 1, "GL_UNSIGNED_INT_SAMPLER_CUBE", 0x8DD4}, + { "", 'X', 1, "GL_UNSIGNED_INT_SAMPLER_2D_RECT", 0x8DD5}, + { "", 'X', 1, "GL_UNSIGNED_INT_SAMPLER_1D_ARRAY", 0x8DD6}, + { "", 'X', 1, "GL_UNSIGNED_INT_SAMPLER_2D_ARRAY", 0x8DD7}, + { "", 'X', 1, "GL_UNSIGNED_INT_SAMPLER_BUFFER", 0x8DD8}, + { "glGetProgramPipeline", 'I', 1, "GL_GEOMETRY_SHADER", 0x8DD9}, + { "glGetProgram", 'I', 1, "GL_GEOMETRY_VERTICES_OUT_ARB", 0x8DDA}, + { "glGetProgram", 'E', 1, "GL_GEOMETRY_INPUT_TYPE_ARB", 0x8DDB}, + { "glGetProgram", 'E', 1, "GL_GEOMETRY_OUTPUT_TYPE_ARB", 0x8DDC}, + { "glGet", 'I', 1, "GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB", 0x8DDD}, + { "glGet", 'I', 1, "GL_MAX_VERTEX_VARYING_COMPONENTS_ARB", 0x8DDE}, + { "glGet", 'I', 1, "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS", 0x8DDF}, + { "glGet", 'I', 1, "GL_MAX_GEOMETRY_OUTPUT_VERTICES", 0x8DE0}, + { "glGet", 'I', 1, "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS", 0x8DE1}, + { "", 'X', 1, "GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT", 0x8DE2}, + { "", 'X', 1, "GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT", 0x8DE3}, + { "", 'X', 1, "GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT", 0x8DE4}, + { "", 'X', 1, "GL_ACTIVE_SUBROUTINES", 0x8DE5}, + { "", 'X', 1, "GL_ACTIVE_SUBROUTINE_UNIFORMS", 0x8DE6}, + { "glGet", 'I', 1, "GL_MAX_SUBROUTINES", 0x8DE7}, + { "glGet", 'I', 1, "GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS", 0x8DE8}, + { "glGetNamedString", 'X', 1, "GL_NAMED_STRING_LENGTH_ARB", 0x8DE9}, + { "glGetNamedString", 'E', 1, "GL_NAMED_STRING_TYPE_ARB", 0x8DEA}, + { "glGet", 'I', 1, "GL_MAX_BINDABLE_UNIFORM_SIZE_EXT", 0x8DED}, + { "", 'X', 1, "GL_UNIFORM_BUFFER_EXT", 0x8DEE}, + { "glGet", 'I', 1, "GL_UNIFORM_BUFFER_BINDING_EXT", 0x8DEF}, + { "", 'X', 1, "GL_LOW_FLOAT", 0x8DF0}, + { "", 'X', 1, "GL_MEDIUM_FLOAT", 0x8DF1}, + { "", 'X', 1, "GL_HIGH_FLOAT", 0x8DF2}, + { "", 'X', 1, "GL_LOW_INT", 0x8DF3}, + { "", 'X', 1, "GL_MEDIUM_INT", 0x8DF4}, + { "", 'X', 1, "GL_HIGH_INT", 0x8DF5}, + { "glGet", 'I', 1, "GL_NUM_SHADER_BINARY_FORMATS", 0x8DF9}, + { "glGet", 'B', 1, "GL_SHADER_COMPILER", 0x8DFA}, + { "glGet", 'I', 1, "GL_MAX_VERTEX_UNIFORM_VECTORS", 0x8DFB}, + { "glGet", 'I', 1, "GL_MAX_VARYING_VECTORS", 0x8DFC}, + { "glGet", 'I', 1, "GL_MAX_FRAGMENT_UNIFORM_VECTORS", 0x8DFD}, + { "", 'X', 1, "GL_RENDERBUFFER_COLOR_SAMPLES_NV", 0x8E10}, + { "", 'X', 1, "GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV", 0x8E11}, + { "", 'X', 1, "GL_MULTISAMPLE_COVERAGE_MODES_NV", 0x8E12}, + { "", 'X', 1, "GL_QUERY_WAIT", 0x8E13}, + { "", 'X', 1, "GL_QUERY_NO_WAIT", 0x8E14}, + { "", 'X', 1, "GL_QUERY_BY_REGION_WAIT", 0x8E15}, + { "", 'X', 1, "GL_QUERY_BY_REGION_NO_WAIT", 0x8E16}, + { "glGet", 'I', 1, "GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS", 0x8E1E}, + { "glGet", 'I', 1, "GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS", 0x8E1F}, + { "", 'X', 1, "GL_COLOR_SAMPLES_NV", 0x8E20}, + { "", 'X', 1, "GL_TRANSFORM_FEEDBACK", 0x8E22}, + { "glGet", 'B', 1, "GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED", 0x8E23}, + { "glGet", 'B', 1, "GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE", 0x8E24}, + { "glGet", 'I', 1, "GL_TRANSFORM_FEEDBACK_BINDING", 0x8E25}, + { "", 'X', 1, "GL_FRAME_NV", 0x8E26}, + { "", 'X', 1, "GL_FIELDS_NV", 0x8E27}, + { "glGet", 'i', 1, "GL_TIMESTAMP", 0x8E28}, + { "", 'X', 1, "GL_NUM_FILL_STREAMS_NV", 0x8E29}, + { "", 'X', 1, "GL_PRESENT_TIME_NV", 0x8E2A}, + { "", 'X', 1, "GL_PRESENT_DURATION_NV", 0x8E2B}, + { "", 'X', 1, "GL_PROGRAM_MATRIX_EXT", 0x8E2D}, + { "", 'X', 1, "GL_TRANSPOSE_PROGRAM_MATRIX_EXT", 0x8E2E}, + { "", 'X', 1, "GL_PROGRAM_MATRIX_STACK_DEPTH_EXT", 0x8E2F}, + { "glGetTexParameter", 'E', 1, "GL_TEXTURE_SWIZZLE_R", 0x8E42}, + { "glGetTexParameter", 'E', 1, "GL_TEXTURE_SWIZZLE_G", 0x8E43}, + { "glGetTexParameter", 'E', 1, "GL_TEXTURE_SWIZZLE_B", 0x8E44}, + { "glGetTexParameter", 'E', 1, "GL_TEXTURE_SWIZZLE_A", 0x8E45}, + { "glGetTexParameter", 'E', 4, "GL_TEXTURE_SWIZZLE_RGBA", 0x8E46}, + { "", 'X', 1, "GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS", 0x8E47}, + { "", 'X', 1, "GL_ACTIVE_SUBROUTINE_MAX_LENGTH", 0x8E48}, + { "", 'X', 1, "GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH", 0x8E49}, + { "", 'X', 1, "GL_NUM_COMPATIBLE_SUBROUTINES", 0x8E4A}, + { "", 'X', 1, "GL_COMPATIBLE_SUBROUTINES", 0x8E4B}, + { "glGet", 'B', 1, "GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION", 0x8E4C}, + { "", 'X', 1, "GL_FIRST_VERTEX_CONVENTION", 0x8E4D}, + { "", 'X', 1, "GL_LAST_VERTEX_CONVENTION", 0x8E4E}, + { "glGet", 'E', 1, "GL_PROVOKING_VERTEX", 0x8E4F}, + { "glGetMultisample", 'I', 1, "GL_SAMPLE_POSITION", 0x8E50}, + { "glGet", 'B', 1, "GL_SAMPLE_MASK", 0x8E51}, + { "glGet", 'I', 1, "GL_SAMPLE_MASK_VALUE", 0x8E52}, + { "", 'X', 1, "GL_TEXTURE_BINDING_RENDERBUFFER_NV", 0x8E53}, + { "glGet", 'I', 1, "GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV", 0x8E54}, + { "", 'X', 1, "GL_TEXTURE_RENDERBUFFER_NV", 0x8E55}, + { "", 'X', 1, "GL_SAMPLER_RENDERBUFFER_NV", 0x8E56}, + { "", 'X', 1, "GL_INT_SAMPLER_RENDERBUFFER_NV", 0x8E57}, + { "", 'X', 1, "GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV", 0x8E58}, + { "glGet", 'I', 1, "GL_MAX_SAMPLE_MASK_WORDS", 0x8E59}, + { "", 'X', 1, "GL_MAX_GEOMETRY_SHADER_INVOCATIONS", 0x8E5A}, + { "", 'X', 1, "GL_MIN_FRAGMENT_INTERPOLATION_OFFSET", 0x8E5B}, + { "", 'X', 1, "GL_MAX_FRAGMENT_INTERPOLATION_OFFSET", 0x8E5C}, + { "", 'X', 1, "GL_FRAGMENT_INTERPOLATION_OFFSET_BITS", 0x8E5D}, + { "", 'X', 1, "GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET", 0x8E5E}, + { "", 'X', 1, "GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET", 0x8E5F}, + { "glGet", 'I', 1, "GL_MAX_TRANSFORM_FEEDBACK_BUFFERS", 0x8E70}, + { "glGet", 'I', 1, "GL_MAX_VERTEX_STREAMS", 0x8E71}, + { "glGet", 'I', 1, "GL_PATCH_VERTICES", 0x8E72}, + { "glGet", 'F', 2, "GL_PATCH_DEFAULT_INNER_LEVEL", 0x8E73}, + { "glGet", 'F', 4, "GL_PATCH_DEFAULT_OUTER_LEVEL", 0x8E74}, + { "glGet", 'X', 1, "GL_TESS_CONTROL_OUTPUT_VERTICES", 0x8E75}, + { "glGet", 'E', 1, "GL_TESS_GEN_MODE", 0x8E76}, + { "glGet", 'E', 1, "GL_TESS_GEN_SPACING", 0x8E77}, + { "glGet", 'E', 1, "GL_TESS_GEN_VERTEX_ORDER", 0x8E78}, + { "glGet", 'E', 1, "GL_TESS_GEN_POINT_MODE", 0x8E79}, + { "", 'X', 1, "GL_ISOLINES", 0x8E7A}, + { "", 'X', 1, "GL_FRACTIONAL_ODD", 0x8E7B}, + { "", 'X', 1, "GL_FRACTIONAL_EVEN", 0x8E7C}, + { "glGet", 'I', 1, "GL_MAX_PATCH_VERTICES", 0x8E7D}, + { "glGet", 'I', 1, "GL_MAX_TESS_GEN_LEVEL", 0x8E7E}, + { "glGet", 'I', 1, "GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS", 0x8E7F}, + { "glGet", 'I', 1, "GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS", 0x8E80}, + { "glGet", 'I', 1, "GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS", 0x8E81}, + { "glGet", 'I', 1, "GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS", 0x8E82}, + { "glGet", 'I', 1, "GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS", 0x8E83}, + { "glGet", 'I', 1, "GL_MAX_TESS_PATCH_COMPONENTS", 0x8E84}, + { "glGet", 'I', 1, "GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS", 0x8E85}, + { "glGet", 'I', 1, "GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS", 0x8E86}, + { "glGetProgramPipeline", 'I', 1, "GL_TESS_EVALUATION_SHADER", 0x8E87}, + { "glGetProgramPipeline", 'I', 1, "GL_TESS_CONTROL_SHADER", 0x8E88}, + { "glGet", 'I', 1, "GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS", 0x8E89}, + { "glGet", 'I', 1, "GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS", 0x8E8A}, + { "", 'X', 1, "GL_COMPRESSED_RGBA_BPTC_UNORM_ARB", 0x8E8C}, + { "", 'X', 1, "GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB", 0x8E8D}, + { "", 'X', 1, "GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB", 0x8E8E}, + { "", 'X', 1, "GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB", 0x8E8F}, + { "", 'X', 1, "GL_BUFFER_GPU_ADDRESS_NV", 0x8F1D}, + { "", 'X', 1, "GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV", 0x8F1E}, + { "", 'X', 1, "GL_ELEMENT_ARRAY_UNIFIED_NV", 0x8F1F}, + { "", 'X', 1, "GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV", 0x8F20}, + { "", 'X', 1, "GL_VERTEX_ARRAY_ADDRESS_NV", 0x8F21}, + { "", 'X', 1, "GL_NORMAL_ARRAY_ADDRESS_NV", 0x8F22}, + { "", 'X', 1, "GL_COLOR_ARRAY_ADDRESS_NV", 0x8F23}, + { "", 'X', 1, "GL_INDEX_ARRAY_ADDRESS_NV", 0x8F24}, + { "", 'X', 1, "GL_TEXTURE_COORD_ARRAY_ADDRESS_NV", 0x8F25}, + { "", 'X', 1, "GL_EDGE_FLAG_ARRAY_ADDRESS_NV", 0x8F26}, + { "", 'X', 1, "GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV", 0x8F27}, + { "", 'X', 1, "GL_FOG_COORD_ARRAY_ADDRESS_NV", 0x8F28}, + { "", 'X', 1, "GL_ELEMENT_ARRAY_ADDRESS_NV", 0x8F29}, + { "", 'X', 1, "GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV", 0x8F2A}, + { "", 'X', 1, "GL_VERTEX_ARRAY_LENGTH_NV", 0x8F2B}, + { "", 'X', 1, "GL_NORMAL_ARRAY_LENGTH_NV", 0x8F2C}, + { "", 'X', 1, "GL_COLOR_ARRAY_LENGTH_NV", 0x8F2D}, + { "", 'X', 1, "GL_INDEX_ARRAY_LENGTH_NV", 0x8F2E}, + { "", 'X', 1, "GL_TEXTURE_COORD_ARRAY_LENGTH_NV", 0x8F2F}, + { "", 'X', 1, "GL_EDGE_FLAG_ARRAY_LENGTH_NV", 0x8F30}, + { "", 'X', 1, "GL_SECONDARY_COLOR_ARRAY_LENGTH_NV", 0x8F31}, + { "", 'X', 1, "GL_FOG_COORD_ARRAY_LENGTH_NV", 0x8F32}, + { "", 'X', 1, "GL_ELEMENT_ARRAY_LENGTH_NV", 0x8F33}, + { "", 'X', 1, "GL_GPU_ADDRESS_NV", 0x8F34}, + { "", 'X', 1, "GL_MAX_SHADER_BUFFER_ADDRESS_NV", 0x8F35}, + { "glGet", 'I', 1, "GL_COPY_READ_BUFFER", 0x8F36}, + { "glGet", 'I', 1, "GL_COPY_WRITE_BUFFER", 0x8F37}, + { "", 'X', 1, "GL_MAX_IMAGE_UNITS", 0x8F38}, + { "", 'X', 1, "GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS", 0x8F39}, + { "", 'X', 1, "GL_IMAGE_BINDING_NAME", 0x8F3A}, + { "", 'X', 1, "GL_IMAGE_BINDING_LEVEL", 0x8F3B}, + { "", 'X', 1, "GL_IMAGE_BINDING_LAYERED", 0x8F3C}, + { "", 'X', 1, "GL_IMAGE_BINDING_LAYER", 0x8F3D}, + { "", 'X', 1, "GL_IMAGE_BINDING_ACCESS", 0x8F3E}, + { "", 'X', 1, "GL_DRAW_INDIRECT_BUFFER", 0x8F3F}, + { "", 'X', 1, "GL_DRAW_INDIRECT_UNIFIED_NV", 0x8F40}, + { "", 'X', 1, "GL_DRAW_INDIRECT_ADDRESS_NV", 0x8F41}, + { "", 'X', 1, "GL_DRAW_INDIRECT_LENGTH_NV", 0x8F42}, + { "glGet", 'I', 1, "GL_DRAW_INDIRECT_BUFFER_BINDING", 0x8F43}, + { "", 'X', 1, "GL_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV", 0x8F44}, + { "", 'X', 1, "GL_MAX_PROGRAM_SUBROUTINE_NUM_NV", 0x8F45}, + { "", 'X', 1, "GL_DOUBLE_MAT2", 0x8F46}, + { "", 'X', 1, "GL_DOUBLE_MAT3", 0x8F47}, + { "", 'X', 1, "GL_DOUBLE_MAT4", 0x8F48}, + { "", 'X', 1, "GL_DOUBLE_MAT2x3", 0x8F49}, + { "", 'X', 1, "GL_DOUBLE_MAT2x4", 0x8F4A}, + { "", 'X', 1, "GL_DOUBLE_MAT3x2", 0x8F4B}, + { "", 'X', 1, "GL_DOUBLE_MAT3x4", 0x8F4C}, + { "", 'X', 1, "GL_DOUBLE_MAT4x2", 0x8F4D}, + { "", 'X', 1, "GL_DOUBLE_MAT4x3", 0x8F4E}, + { "", 'X', 1, "GL_MALI_SHADER_BINARY_ARM", 0x8F60}, + { "", 'X', 1, "GL_RED_SNORM", 0x8F90}, + { "", 'X', 1, "GL_RG_SNORM", 0x8F91}, + { "", 'X', 1, "GL_RGB_SNORM", 0x8F92}, + { "", 'X', 1, "GL_RGBA_SNORM", 0x8F93}, + { "", 'X', 1, "GL_R8_SNORM", 0x8F94}, + { "", 'X', 1, "GL_RG8_SNORM", 0x8F95}, + { "", 'X', 1, "GL_RGB8_SNORM", 0x8F96}, + { "", 'X', 1, "GL_RGBA8_SNORM", 0x8F97}, + { "", 'X', 1, "GL_R16_SNORM", 0x8F98}, + { "", 'X', 1, "GL_RG16_SNORM", 0x8F99}, + { "", 'X', 1, "GL_RGB16_SNORM", 0x8F9A}, + { "", 'X', 1, "GL_RGBA16_SNORM", 0x8F9B}, + { "", 'X', 1, "GL_SIGNED_NORMALIZED", 0x8F9C}, + { "glGet", 'B', 1, "GL_PRIMITIVE_RESTART", 0x8F9D}, + { "glGet", 'I', 1, "GL_PRIMITIVE_RESTART_INDEX", 0x8F9E}, + { "", 'X', 1, "GL_PERFMON_GLOBAL_MODE_QCOM", 0x8FA0}, + { "", 'X', 1, "GL_SHADER_BINARY_VIV", 0x8FC4}, + { "", 'X', 1, "GL_INT8_NV", 0x8FE0}, + { "", 'X', 1, "GL_INT8_VEC2_NV", 0x8FE1}, + { "", 'X', 1, "GL_INT8_VEC3_NV", 0x8FE2}, + { "", 'X', 1, "GL_INT8_VEC4_NV", 0x8FE3}, + { "", 'X', 1, "GL_INT16_NV", 0x8FE4}, + { "", 'X', 1, "GL_INT16_VEC2_NV", 0x8FE5}, + { "", 'X', 1, "GL_INT16_VEC3_NV", 0x8FE6}, + { "", 'X', 1, "GL_INT16_VEC4_NV", 0x8FE7}, + { "", 'X', 1, "GL_INT64_VEC2_NV", 0x8FE9}, + { "", 'X', 1, "GL_INT64_VEC3_NV", 0x8FEA}, + { "", 'X', 1, "GL_INT64_VEC4_NV", 0x8FEB}, + { "", 'X', 1, "GL_UNSIGNED_INT8_NV", 0x8FEC}, + { "", 'X', 1, "GL_UNSIGNED_INT8_VEC2_NV", 0x8FED}, + { "", 'X', 1, "GL_UNSIGNED_INT8_VEC3_NV", 0x8FEE}, + { "", 'X', 1, "GL_UNSIGNED_INT8_VEC4_NV", 0x8FEF}, + { "", 'X', 1, "GL_UNSIGNED_INT16_NV", 0x8FF0}, + { "", 'X', 1, "GL_UNSIGNED_INT16_VEC2_NV", 0x8FF1}, + { "", 'X', 1, "GL_UNSIGNED_INT16_VEC3_NV", 0x8FF2}, + { "", 'X', 1, "GL_UNSIGNED_INT16_VEC4_NV", 0x8FF3}, + { "", 'X', 1, "GL_UNSIGNED_INT64_VEC2_NV", 0x8FF5}, + { "", 'X', 1, "GL_UNSIGNED_INT64_VEC3_NV", 0x8FF6}, + { "", 'X', 1, "GL_UNSIGNED_INT64_VEC4_NV", 0x8FF7}, + { "", 'X', 1, "GL_FLOAT16_NV", 0x8FF8}, + { "", 'X', 1, "GL_FLOAT16_VEC2_NV", 0x8FF9}, + { "", 'X', 1, "GL_FLOAT16_VEC3_NV", 0x8FFA}, + { "", 'X', 1, "GL_FLOAT16_VEC4_NV", 0x8FFB}, + { "", 'X', 1, "GL_DOUBLE_VEC2", 0x8FFC}, + { "", 'X', 1, "GL_DOUBLE_VEC3", 0x8FFD}, + { "", 'X', 1, "GL_DOUBLE_VEC4", 0x8FFE}, + { "", 'X', 1, "GL_SAMPLER_BUFFER_AMD", 0x9001}, + { "", 'X', 1, "GL_INT_SAMPLER_BUFFER_AMD", 0x9002}, + { "", 'X', 1, "GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD", 0x9003}, + { "", 'X', 1, "GL_TESSELLATION_MODE_AMD", 0x9004}, + { "", 'X', 1, "GL_TESSELLATION_FACTOR_AMD", 0x9005}, + { "", 'X', 1, "GL_DISCRETE_AMD", 0x9006}, + { "", 'X', 1, "GL_CONTINUOUS_AMD", 0x9007}, + { "_glGet", 'B', 1, "GL_TEXTURE_CUBE_MAP_ARRAY", 0x9009}, + { "glGet", 'I', 1, "GL_TEXTURE_BINDING_CUBE_MAP_ARRAY", 0x900A}, + { "", 'X', 1, "GL_PROXY_TEXTURE_CUBE_MAP_ARRAY", 0x900B}, + { "", 'X', 1, "GL_SAMPLER_CUBE_MAP_ARRAY", 0x900C}, + { "", 'X', 1, "GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW", 0x900D}, + { "", 'X', 1, "GL_INT_SAMPLER_CUBE_MAP_ARRAY", 0x900E}, + { "", 'X', 1, "GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY", 0x900F}, + { "", 'X', 1, "GL_ALPHA_SNORM", 0x9010}, + { "", 'X', 1, "GL_LUMINANCE_SNORM", 0x9011}, + { "", 'X', 1, "GL_LUMINANCE_ALPHA_SNORM", 0x9012}, + { "", 'X', 1, "GL_INTENSITY_SNORM", 0x9013}, + { "", 'X', 1, "GL_ALPHA8_SNORM", 0x9014}, + { "", 'X', 1, "GL_LUMINANCE8_SNORM", 0x9015}, + { "", 'X', 1, "GL_LUMINANCE8_ALPHA8_SNORM", 0x9016}, + { "", 'X', 1, "GL_INTENSITY8_SNORM", 0x9017}, + { "", 'X', 1, "GL_ALPHA16_SNORM", 0x9018}, + { "", 'X', 1, "GL_LUMINANCE16_SNORM", 0x9019}, + { "", 'X', 1, "GL_LUMINANCE16_ALPHA16_SNORM", 0x901A}, + { "", 'X', 1, "GL_INTENSITY16_SNORM", 0x901B}, + { "", 'X', 1, "GL_FACTOR_MIN_AMD", 0x901C}, + { "", 'X', 1, "GL_FACTOR_MAX_AMD", 0x901D}, + { "", 'B', 1, "GL_DEPTH_CLAMP_NEAR_AMD", 0x901E}, + { "", 'B', 1, "GL_DEPTH_CLAMP_FAR_AMD", 0x901F}, + { "", 'X', 1, "GL_VIDEO_BUFFER_NV", 0x9020}, + { "glGet", 'I', 1, "GL_VIDEO_BUFFER_BINDING_NV", 0x9021}, + { "", 'X', 1, "GL_FIELD_UPPER_NV", 0x9022}, + { "", 'X', 1, "GL_FIELD_LOWER_NV", 0x9023}, + { "", 'X', 1, "GL_NUM_VIDEO_CAPTURE_STREAMS_NV", 0x9024}, + { "", 'X', 1, "GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV", 0x9025}, + { "", 'X', 1, "GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV", 0x9026}, + { "", 'X', 1, "GL_LAST_VIDEO_CAPTURE_STATUS_NV", 0x9027}, + { "", 'X', 1, "GL_VIDEO_BUFFER_PITCH_NV", 0x9028}, + { "", 'X', 1, "GL_VIDEO_COLOR_CONVERSION_MATRIX_NV", 0x9029}, + { "", 'X', 1, "GL_VIDEO_COLOR_CONVERSION_MAX_NV", 0x902A}, + { "", 'X', 1, "GL_VIDEO_COLOR_CONVERSION_MIN_NV", 0x902B}, + { "", 'X', 1, "GL_VIDEO_COLOR_CONVERSION_OFFSET_NV", 0x902C}, + { "", 'X', 1, "GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV", 0x902D}, + { "", 'X', 1, "GL_PARTIAL_SUCCESS_NV", 0x902E}, + { "", 'X', 1, "GL_SUCCESS_NV", 0x902F}, + { "", 'X', 1, "GL_FAILURE_NV", 0x9030}, + { "", 'X', 1, "GL_YCBYCR8_422_NV", 0x9031}, + { "", 'X', 1, "GL_YCBAYCR8A_4224_NV", 0x9032}, + { "", 'X', 1, "GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV", 0x9033}, + { "", 'X', 1, "GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV", 0x9034}, + { "", 'X', 1, "GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV", 0x9035}, + { "", 'X', 1, "GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV", 0x9036}, + { "", 'X', 1, "GL_Z4Y12Z4CB12Z4CR12_444_NV", 0x9037}, + { "", 'X', 1, "GL_VIDEO_CAPTURE_FRAME_WIDTH_NV", 0x9038}, + { "", 'X', 1, "GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV", 0x9039}, + { "", 'X', 1, "GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV", 0x903A}, + { "", 'X', 1, "GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV", 0x903B}, + { "", 'X', 1, "GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV", 0x903C}, + { "", 'X', 1, "GL_TEXTURE_COVERAGE_SAMPLES_NV", 0x9045}, + { "", 'X', 1, "GL_TEXTURE_COLOR_SAMPLES_NV", 0x9046}, + { "glGet", 'I', 1, "GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX", 0x9047}, + { "glGet", 'I', 1, "GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX", 0x9048}, + { "glGet", 'I', 1, "GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX", 0x9049}, + { "glGet", 'I', 1, "GL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX", 0x904A}, + { "glGet", 'I', 1, "GL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX", 0x904B}, + { "", 'X', 1, "GL_IMAGE_1D", 0x904C}, + { "", 'X', 1, "GL_IMAGE_2D", 0x904D}, + { "", 'X', 1, "GL_IMAGE_3D", 0x904E}, + { "", 'X', 1, "GL_IMAGE_2D_RECT", 0x904F}, + { "", 'X', 1, "GL_IMAGE_CUBE", 0x9050}, + { "", 'X', 1, "GL_IMAGE_BUFFER", 0x9051}, + { "", 'X', 1, "GL_IMAGE_1D_ARRAY", 0x9052}, + { "", 'X', 1, "GL_IMAGE_2D_ARRAY", 0x9053}, + { "", 'X', 1, "GL_IMAGE_CUBE_MAP_ARRAY", 0x9054}, + { "", 'X', 1, "GL_IMAGE_2D_MULTISAMPLE", 0x9055}, + { "", 'X', 1, "GL_IMAGE_2D_MULTISAMPLE_ARRAY", 0x9056}, + { "", 'X', 1, "GL_INT_IMAGE_1D", 0x9057}, + { "", 'X', 1, "GL_INT_IMAGE_2D", 0x9058}, + { "", 'X', 1, "GL_INT_IMAGE_3D", 0x9059}, + { "", 'X', 1, "GL_INT_IMAGE_2D_RECT", 0x905A}, + { "", 'X', 1, "GL_INT_IMAGE_CUBE", 0x905B}, + { "", 'X', 1, "GL_INT_IMAGE_BUFFER", 0x905C}, + { "", 'X', 1, "GL_INT_IMAGE_1D_ARRAY", 0x905D}, + { "", 'X', 1, "GL_INT_IMAGE_2D_ARRAY", 0x905E}, + { "", 'X', 1, "GL_INT_IMAGE_CUBE_MAP_ARRAY", 0x905F}, + { "", 'X', 1, "GL_INT_IMAGE_2D_MULTISAMPLE", 0x9060}, + { "", 'X', 1, "GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY", 0x9061}, + { "", 'X', 1, "GL_UNSIGNED_INT_IMAGE_1D", 0x9062}, + { "", 'X', 1, "GL_UNSIGNED_INT_IMAGE_2D", 0x9063}, + { "", 'X', 1, "GL_UNSIGNED_INT_IMAGE_3D", 0x9064}, + { "", 'X', 1, "GL_UNSIGNED_INT_IMAGE_2D_RECT", 0x9065}, + { "", 'X', 1, "GL_UNSIGNED_INT_IMAGE_CUBE", 0x9066}, + { "", 'X', 1, "GL_UNSIGNED_INT_IMAGE_BUFFER", 0x9067}, + { "", 'X', 1, "GL_UNSIGNED_INT_IMAGE_1D_ARRAY", 0x9068}, + { "", 'X', 1, "GL_UNSIGNED_INT_IMAGE_2D_ARRAY", 0x9069}, + { "", 'X', 1, "GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY", 0x906A}, + { "", 'X', 1, "GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE", 0x906B}, + { "", 'X', 1, "GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY", 0x906C}, + { "", 'X', 1, "GL_MAX_IMAGE_SAMPLES", 0x906D}, + { "", 'X', 1, "GL_IMAGE_BINDING_FORMAT", 0x906E}, + { "", 'X', 1, "GL_RGB10_A2UI", 0x906F}, + { "", 'X', 1, "GL_PATH_FORMAT_SVG_NV", 0x9070}, + { "", 'X', 1, "GL_PATH_FORMAT_PS_NV", 0x9071}, + { "", 'X', 1, "GL_STANDARD_FONT_NAME_NV", 0x9072}, + { "", 'X', 1, "GL_SYSTEM_FONT_NAME_NV", 0x9073}, + { "", 'X', 1, "GL_FILE_NAME_NV", 0x9074}, + { "", 'X', 1, "GL_PATH_STROKE_WIDTH_NV", 0x9075}, + { "", 'X', 1, "GL_PATH_END_CAPS_NV", 0x9076}, + { "", 'X', 1, "GL_PATH_INITIAL_END_CAP_NV", 0x9077}, + { "", 'X', 1, "GL_PATH_TERMINAL_END_CAP_NV", 0x9078}, + { "", 'X', 1, "GL_PATH_JOIN_STYLE_NV", 0x9079}, + { "", 'X', 1, "GL_PATH_MITER_LIMIT_NV", 0x907A}, + { "", 'X', 1, "GL_PATH_DASH_CAPS_NV", 0x907B}, + { "", 'X', 1, "GL_PATH_INITIAL_DASH_CAP_NV", 0x907C}, + { "", 'X', 1, "GL_PATH_TERMINAL_DASH_CAP_NV", 0x907D}, + { "", 'X', 1, "GL_PATH_DASH_OFFSET_NV", 0x907E}, + { "", 'X', 1, "GL_PATH_CLIENT_LENGTH_NV", 0x907F}, + { "", 'X', 1, "GL_PATH_FILL_MODE_NV", 0x9080}, + { "", 'X', 1, "GL_PATH_FILL_MASK_NV", 0x9081}, + { "", 'X', 1, "GL_PATH_FILL_COVER_MODE_NV", 0x9082}, + { "", 'X', 1, "GL_PATH_STROKE_COVER_MODE_NV", 0x9083}, + { "", 'X', 1, "GL_PATH_STROKE_MASK_NV", 0x9084}, + { "", 'X', 1, "GL_PATH_SAMPLE_QUALITY_NV", 0x9085}, + { "", 'X', 1, "GL_PATH_STROKE_BOUND_NV", 0x9086}, + { "", 'X', 1, "GL_PATH_STROKE_OVERSAMPLE_COUNT_NV", 0x9087}, + { "", 'X', 1, "GL_COUNT_UP_NV", 0x9088}, + { "", 'X', 1, "GL_COUNT_DOWN_NV", 0x9089}, + { "", 'X', 1, "GL_PATH_OBJECT_BOUNDING_BOX_NV", 0x908A}, + { "", 'X', 1, "GL_CONVEX_HULL_NV", 0x908B}, + { "", 'X', 1, "GL_MULTI_HULLS_NV", 0x908C}, + { "", 'X', 1, "GL_BOUNDING_BOX_NV", 0x908D}, + { "", 'X', 1, "GL_TRANSLATE_X_NV", 0x908E}, + { "", 'X', 1, "GL_TRANSLATE_Y_NV", 0x908F}, + { "", 'X', 1, "GL_TRANSLATE_2D_NV", 0x9090}, + { "", 'X', 1, "GL_TRANSLATE_3D_NV", 0x9091}, + { "", 'X', 1, "GL_AFFINE_2D_NV", 0x9092}, + { "", 'X', 1, "GL_PROJECTIVE_2D_NV", 0x9093}, + { "", 'X', 1, "GL_AFFINE_3D_NV", 0x9094}, + { "", 'X', 1, "GL_PROJECTIVE_3D_NV", 0x9095}, + { "", 'X', 1, "GL_TRANSPOSE_AFFINE_2D_NV", 0x9096}, + { "", 'X', 1, "GL_TRANSPOSE_PROJECTIVE_2D_NV", 0x9097}, + { "", 'X', 1, "GL_TRANSPOSE_AFFINE_3D_NV", 0x9098}, + { "", 'X', 1, "GL_TRANSPOSE_PROJECTIVE_3D_NV", 0x9099}, + { "", 'X', 1, "GL_UTF8_NV", 0x909A}, + { "", 'X', 1, "GL_UTF16_NV", 0x909B}, + { "", 'X', 1, "GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV", 0x909C}, + { "", 'X', 1, "GL_PATH_COMMAND_COUNT_NV", 0x909D}, + { "", 'X', 1, "GL_PATH_COORD_COUNT_NV", 0x909E}, + { "", 'X', 1, "GL_PATH_DASH_ARRAY_COUNT_NV", 0x909F}, + { "", 'X', 1, "GL_PATH_COMPUTED_LENGTH_NV", 0x90A0}, + { "", 'X', 1, "GL_PATH_FILL_BOUNDING_BOX_NV", 0x90A1}, + { "", 'X', 1, "GL_PATH_STROKE_BOUNDING_BOX_NV", 0x90A2}, + { "", 'X', 1, "GL_SQUARE_NV", 0x90A3}, + { "", 'X', 1, "GL_ROUND_NV", 0x90A4}, + { "", 'X', 1, "GL_TRIANGULAR_NV", 0x90A5}, + { "", 'X', 1, "GL_BEVEL_NV", 0x90A6}, + { "", 'X', 1, "GL_MITER_REVERT_NV", 0x90A7}, + { "", 'X', 1, "GL_MITER_TRUNCATE_NV", 0x90A8}, + { "", 'X', 1, "GL_SKIP_MISSING_GLYPH_NV", 0x90A9}, + { "", 'X', 1, "GL_USE_MISSING_GLYPH_NV", 0x90AA}, + { "", 'X', 1, "GL_PATH_ERROR_POSITION_NV", 0x90AB}, + { "", 'X', 1, "GL_PATH_FOG_GEN_MODE_NV", 0x90AC}, + { "", 'X', 1, "GL_ACCUM_ADJACENT_PAIRS_NV", 0x90AD}, + { "", 'X', 1, "GL_ADJACENT_PAIRS_NV", 0x90AE}, + { "", 'X', 1, "GL_FIRST_TO_REST_NV", 0x90AF}, + { "", 'X', 1, "GL_PATH_GEN_MODE_NV", 0x90B0}, + { "", 'X', 1, "GL_PATH_GEN_COEFF_NV", 0x90B1}, + { "", 'X', 1, "GL_PATH_GEN_COLOR_FORMAT_NV", 0x90B2}, + { "", 'X', 1, "GL_PATH_GEN_COMPONENTS_NV", 0x90B3}, + { "", 'X', 1, "GL_PATH_DASH_OFFSET_RESET_NV", 0x90B4}, + { "", 'X', 1, "GL_MOVE_TO_RESETS_NV", 0x90B5}, + { "", 'X', 1, "GL_MOVE_TO_CONTINUES_NV", 0x90B6}, + { "", 'X', 1, "GL_PATH_STENCIL_FUNC_NV", 0x90B7}, + { "", 'X', 1, "GL_PATH_STENCIL_REF_NV", 0x90B8}, + { "", 'X', 1, "GL_PATH_STENCIL_VALUE_MASK_NV", 0x90B9}, + { "", 'X', 1, "GL_SCALED_RESOLVE_FASTEST_EXT", 0x90BA}, + { "", 'X', 1, "GL_SCALED_RESOLVE_NICEST_EXT", 0x90BB}, + { "glGet", 'I', 1, "GL_MIN_MAP_BUFFER_ALIGNMENT", 0x90BC}, + { "", 'X', 1, "GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV", 0x90BD}, + { "", 'X', 1, "GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV", 0x90BE}, + { "", 'X', 1, "GL_PATH_COVER_DEPTH_FUNC_NV", 0x90BF}, + { "", 'X', 1, "GL_IMAGE_FORMAT_COMPATIBILITY_TYPE", 0x90C7}, + { "", 'X', 1, "GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE", 0x90C8}, + { "", 'X', 1, "GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS", 0x90C9}, + { "", 'X', 1, "GL_MAX_VERTEX_IMAGE_UNIFORMS", 0x90CA}, + { "", 'X', 1, "GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS", 0x90CB}, + { "", 'X', 1, "GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS", 0x90CC}, + { "", 'X', 1, "GL_MAX_GEOMETRY_IMAGE_UNIFORMS", 0x90CD}, + { "", 'X', 1, "GL_MAX_FRAGMENT_IMAGE_UNIFORMS", 0x90CE}, + { "", 'X', 1, "GL_MAX_COMBINED_IMAGE_UNIFORMS", 0x90CF}, + { "glGet", 'I', 1, "GL_SHADER_STORAGE_BUFFER", 0x90D2}, + { "glGet,glGetI", 'U', 1, "GL_SHADER_STORAGE_BUFFER_BINDING", 0x90D3}, + { "glGetI", 'I', 1, "GL_SHADER_STORAGE_BUFFER_START", 0x90D4}, + { "glGetI", 'I', 1, "GL_SHADER_STORAGE_BUFFER_SIZE", 0x90D5}, + { "glGet", 'I', 1, "GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS", 0x90D6}, + { "glGet", 'I', 1, "GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS", 0x90D7}, + { "glGet", 'I', 1, "GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS", 0x90D8}, + { "glGet", 'I', 1, "GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS", 0x90D9}, + { "glGet", 'I', 1, "GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS", 0x90DA}, + { "glGet", 'I', 1, "GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS", 0x90DB}, + { "glGet", 'I', 1, "GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS", 0x90DC}, + { "glGet", 'I', 1, "GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS", 0x90DD}, + { "glGet", 'I', 1, "GL_MAX_SHADER_STORAGE_BLOCK_SIZE", 0x90DE}, + { "glGet", 'I', 1, "GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT", 0x90DF}, + { "", 'X', 1, "GL_SYNC_X11_FENCE_EXT", 0x90E1}, + { "glGetTexParameter", 'E', 1, "GL_DEPTH_STENCIL_TEXTURE_MODE", 0x90EA}, + { "glGet", 'I', 1, "GL_MAX_COMPUTE_LOCAL_INVOCATIONS", 0x90EB}, + { "", 'X', 1, "GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER", 0x90EC}, + { "", 'X', 1, "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER", 0x90ED}, + { "", 'X', 1, "GL_DISPATCH_INDIRECT_BUFFER", 0x90EE}, + { "glGet", 'I', 1, "GL_DISPATCH_INDIRECT_BUFFER_BINDING", 0x90EF}, + { "", 'X', 1, "GL_TEXTURE_2D_MULTISAMPLE", 0x9100}, + { "", 'X', 1, "GL_PROXY_TEXTURE_2D_MULTISAMPLE", 0x9101}, + { "", 'X', 1, "GL_TEXTURE_2D_MULTISAMPLE_ARRAY", 0x9102}, + { "", 'X', 1, "GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY", 0x9103}, + { "glGet", 'I', 1, "GL_TEXTURE_BINDING_2D_MULTISAMPLE", 0x9104}, + { "glGet", 'I', 1, "GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY", 0x9105}, + { "glGetTexLevelParameter", 'I', 1, "GL_TEXTURE_SAMPLES", 0x9106}, + { "glGetTexLevelParameter", 'B', 1, "GL_TEXTURE_FIXED_SAMPLE_LOCATIONS", 0x9107}, + { "", 'X', 1, "GL_SAMPLER_2D_MULTISAMPLE", 0x9108}, + { "", 'X', 1, "GL_INT_SAMPLER_2D_MULTISAMPLE", 0x9109}, + { "", 'X', 1, "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE", 0x910A}, + { "", 'X', 1, "GL_SAMPLER_2D_MULTISAMPLE_ARRAY", 0x910B}, + { "", 'X', 1, "GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY", 0x910C}, + { "", 'X', 1, "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY", 0x910D}, + { "glGet", 'I', 1, "GL_MAX_COLOR_TEXTURE_SAMPLES", 0x910E}, + { "glGet", 'I', 1, "GL_MAX_DEPTH_TEXTURE_SAMPLES", 0x910F}, + { "glGet", 'I', 1, "GL_MAX_INTEGER_SAMPLES", 0x9110}, + { "glGet", 'i', 1, "GL_MAX_SERVER_WAIT_TIMEOUT", 0x9111}, + { "glGetSync", 'E', 1, "GL_OBJECT_TYPE", 0x9112}, + { "glGetSync", 'E', 1, "GL_SYNC_CONDITION", 0x9113}, + { "glGetSync", 'E', 1, "GL_SYNC_STATUS", 0x9114}, + { "glGetSync", 'U', 1, "GL_SYNC_FLAGS", 0x9115}, + { "", 'X', 1, "GL_SYNC_FENCE", 0x9116}, + { "", 'X', 1, "GL_SYNC_GPU_COMMANDS_COMPLETE", 0x9117}, + { "", 'X', 1, "GL_UNSIGNALED", 0x9118}, + { "", 'X', 1, "GL_SIGNALED", 0x9119}, + { "", 'X', 1, "GL_ALREADY_SIGNALED", 0x911A}, + { "", 'X', 1, "GL_TIMEOUT_EXPIRED", 0x911B}, + { "", 'X', 1, "GL_CONDITION_SATISFIED", 0x911C}, + { "", 'X', 1, "GL_WAIT_FAILED", 0x911D}, + { "glGetBufferParameter", 'I', 1, "GL_BUFFER_ACCESS_FLAGS", 0x911F}, + { "glGetBufferParameter", 'I', 1, "GL_BUFFER_MAP_LENGTH", 0x9120}, + { "glGetBufferParameter", 'I', 1, "GL_BUFFER_MAP_OFFSET", 0x9121}, + { "glGet", 'I', 1, "GL_MAX_VERTEX_OUTPUT_COMPONENTS", 0x9122}, + { "glGet", 'I', 1, "GL_MAX_GEOMETRY_INPUT_COMPONENTS", 0x9123}, + { "glGet", 'I', 1, "GL_MAX_GEOMETRY_OUTPUT_COMPONENTS", 0x9124}, + { "glGet", 'I', 1, "GL_MAX_FRAGMENT_INPUT_COMPONENTS", 0x9125}, + { "glGet", 'I', 1, "GL_CONTEXT_PROFILE_MASK", 0x9126}, + { "", 'X', 1, "GL_UNPACK_COMPRESSED_BLOCK_WIDTH", 0x9127}, + { "", 'X', 1, "GL_UNPACK_COMPRESSED_BLOCK_HEIGHT", 0x9128}, + { "", 'X', 1, "GL_UNPACK_COMPRESSED_BLOCK_DEPTH", 0x9129}, + { "", 'X', 1, "GL_UNPACK_COMPRESSED_BLOCK_SIZE", 0x912A}, + { "", 'X', 1, "GL_PACK_COMPRESSED_BLOCK_WIDTH", 0x912B}, + { "", 'X', 1, "GL_PACK_COMPRESSED_BLOCK_HEIGHT", 0x912C}, + { "", 'X', 1, "GL_PACK_COMPRESSED_BLOCK_DEPTH", 0x912D}, + { "", 'X', 1, "GL_PACK_COMPRESSED_BLOCK_SIZE", 0x912E}, + { "", 'I', 1, "GL_TEXTURE_IMMUTABLE_FORMAT", 0x912F}, + { "", 'X', 1, "GL_SGX_PROGRAM_BINARY_IMG", 0x9130}, + { "", 'X', 1, "GL_RENDERBUFFER_SAMPLES_IMG", 0x9133}, + { "", 'X', 1, "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG", 0x9134}, + { "", 'X', 1, "GL_MAX_SAMPLES_IMG", 0x9135}, + { "", 'X', 1, "GL_TEXTURE_SAMPLES_IMG", 0x9136}, + { "glGet", 'I', 1, "GL_MAX_DEBUG_MESSAGE_LENGTH", 0x9143}, + { "glGet", 'I', 1, "GL_MAX_DEBUG_LOGGED_MESSAGES", 0x9144}, + { "glGet", 'I', 1, "GL_DEBUG_LOGGED_MESSAGES", 0x9145}, + { "", 'X', 1, "GL_DEBUG_SEVERITY_HIGH", 0x9146}, + { "", 'X', 1, "GL_DEBUG_SEVERITY_MEDIUM", 0x9147}, + { "", 'X', 1, "GL_DEBUG_SEVERITY_LOW", 0x9148}, + { "", 'X', 1, "GL_DEBUG_CATEGORY_API_ERROR_AMD", 0x9149}, + { "", 'X', 1, "GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD", 0x914A}, + { "", 'X', 1, "GL_DEBUG_CATEGORY_DEPRECATION_AMD", 0x914B}, + { "", 'X', 1, "GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD", 0x914C}, + { "", 'X', 1, "GL_DEBUG_CATEGORY_PERFORMANCE_AMD", 0x914D}, + { "", 'X', 1, "GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD", 0x914E}, + { "", 'X', 1, "GL_DEBUG_CATEGORY_APPLICATION_AMD", 0x914F}, + { "", 'X', 1, "GL_DEBUG_CATEGORY_OTHER_AMD", 0x9150}, + { "", 'X', 1, "GL_BUFFER_OBJECT_EXT", 0x9151}, + { "", 'X', 1, "GL_PERFORMANCE_MONITOR_AMD", 0x9152}, + { "", 'X', 1, "GL_QUERY_OBJECT_EXT", 0x9153}, + { "", 'X', 1, "GL_VERTEX_ARRAY_OBJECT_EXT", 0x9154}, + { "", 'X', 1, "GL_SAMPLER_OBJECT_AMD", 0x9155}, + { "", 'X', 1, "GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD", 0x9160}, + { "", 'X', 1, "GL_QUERY_BUFFER_AMD", 0x9192}, + { "", 'X', 1, "GL_QUERY_BUFFER_BINDING_AMD", 0x9193}, + { "", 'X', 1, "GL_QUERY_RESULT_NO_WAIT_AMD", 0x9194}, + { "glGetTexLevelParameter", 'I', 1, "GL_TEXTURE_BUFFER_OFFSET", 0x919D}, + { "glGetTexLevelParameter", 'I', 1, "GL_TEXTURE_BUFFER_SIZE", 0x919E}, + { "glGet", 'I', 1, "GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT", 0x919F}, + { "", 'X', 1, "GL_COMPUTE_SHADER", 0x91B9}, + { "glGet", 'I', 1, "GL_MAX_COMPUTE_UNIFORM_BLOCKS", 0x91BB}, + { "glGet", 'I', 1, "GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS", 0x91BC}, + { "glGet", 'I', 1, "GL_MAX_COMPUTE_IMAGE_UNIFORMS", 0x91BD}, + { "glGetI", 'I', 3, "GL_MAX_COMPUTE_WORK_GROUP_COUNT", 0x91BE}, + { "glGetI", 'I', 3, "GL_MAX_COMPUTE_WORK_GROUP_SIZE", 0x91BF}, + { "", 'X', 1, "GL_SHADER_BINARY_DMP", 0x9250}, + { "", 'X', 1, "GL_COMPRESSED_R11_EAC", 0x9270}, + { "", 'X', 1, "GL_COMPRESSED_SIGNED_R11_EAC", 0x9271}, + { "", 'X', 1, "GL_COMPRESSED_RG11_EAC", 0x9272}, + { "", 'X', 1, "GL_COMPRESSED_SIGNED_RG11_EAC", 0x9273}, + { "", 'X', 1, "GL_COMPRESSED_RGB8_ETC2", 0x9274}, + { "", 'X', 1, "GL_COMPRESSED_SRGB8_ETC2", 0x9275}, + { "", 'X', 1, "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2", 0x9276}, + { "", 'X', 1, "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2", 0x9277}, + { "", 'X', 1, "GL_COMPRESSED_RGBA8_ETC2_EAC", 0x9278}, + { "", 'X', 1, "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC", 0x9279}, + { "", 'X', 1, "GL_ATOMIC_COUNTER_BUFFER", 0x92C0}, + { "", 'X', 1, "GL_ATOMIC_COUNTER_BUFFER_BINDING", 0x92C1}, + { "", 'X', 1, "GL_ATOMIC_COUNTER_BUFFER_START", 0x92C2}, + { "", 'X', 1, "GL_ATOMIC_COUNTER_BUFFER_SIZE", 0x92C3}, + { "", 'X', 1, "GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE", 0x92C4}, + { "", 'X', 1, "GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS", 0x92C5}, + { "", 'X', 1, "GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES", 0x92C6}, + { "", 'X', 1, "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER", 0x92C7}, + { "", 'X', 1, "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER", 0x92C8}, + { "", 'X', 1, "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER", 0x92C9}, + { "", 'X', 1, "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER", 0x92CA}, + { "", 'X', 1, "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER", 0x92CB}, + { "", 'X', 1, "GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS", 0x92CC}, + { "", 'X', 1, "GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS", 0x92CD}, + { "", 'X', 1, "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS", 0x92CE}, + { "", 'X', 1, "GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS", 0x92CF}, + { "", 'X', 1, "GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS", 0x92D0}, + { "glGet", 'I', 1, "GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS", 0x92D1}, + { "glGet", 'I', 1, "GL_MAX_VERTEX_ATOMIC_COUNTERS", 0x92D2}, + { "glGet", 'I', 1, "GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS", 0x92D3}, + { "glGet", 'I', 1, "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS", 0x92D4}, + { "glGet", 'I', 1, "GL_MAX_GEOMETRY_ATOMIC_COUNTERS", 0x92D5}, + { "glGet", 'I', 1, "GL_MAX_FRAGMENT_ATOMIC_COUNTERS", 0x92D6}, + { "glGet", 'I', 1, "GL_MAX_COMBINED_ATOMIC_COUNTERS", 0x92D7}, + { "glGet", 'I', 1, "GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE", 0x92D8}, + { "", 'X', 1, "GL_ACTIVE_ATOMIC_COUNTER_BUFFERS", 0x92D9}, + { "", 'X', 1, "GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX", 0x92DA}, + { "", 'X', 1, "GL_UNSIGNED_INT_ATOMIC_COUNTER", 0x92DB}, + { "", 'X', 1, "GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS", 0x92DC}, + { "glGet", 'B', 1, "GL_DEBUG_OUTPUT", 0x92E0}, + { "", 'X', 1, "GL_UNIFORM", 0x92E1}, + { "", 'X', 1, "GL_UNIFORM_BLOCK", 0x92E2}, + { "", 'X', 1, "GL_PROGRAM_INPUT", 0x92E3}, + { "", 'X', 1, "GL_PROGRAM_OUTPUT", 0x92E4}, + { "", 'X', 1, "GL_BUFFER_VARIABLE", 0x92E5}, + { "", 'X', 1, "GL_SHADER_STORAGE_BLOCK", 0x92E6}, + { "", 'X', 1, "GL_IS_PER_PATCH", 0x92E7}, + { "", 'X', 1, "GL_VERTEX_SUBROUTINE", 0x92E8}, + { "", 'X', 1, "GL_TESS_CONTROL_SUBROUTINE", 0x92E9}, + { "", 'X', 1, "GL_TESS_EVALUATION_SUBROUTINE", 0x92EA}, + { "", 'X', 1, "GL_GEOMETRY_SUBROUTINE", 0x92EB}, + { "", 'X', 1, "GL_FRAGMENT_SUBROUTINE", 0x92EC}, + { "", 'X', 1, "GL_COMPUTE_SUBROUTINE", 0x92ED}, + { "", 'X', 1, "GL_VERTEX_SUBROUTINE_UNIFORM", 0x92EE}, + { "", 'X', 1, "GL_TESS_CONTROL_SUBROUTINE_UNIFORM", 0x92EF}, + { "", 'X', 1, "GL_TESS_EVALUATION_SUBROUTINE_UNIFORM", 0x92F0}, + { "", 'X', 1, "GL_GEOMETRY_SUBROUTINE_UNIFORM", 0x92F1}, + { "", 'X', 1, "GL_FRAGMENT_SUBROUTINE_UNIFORM", 0x92F2}, + { "", 'X', 1, "GL_COMPUTE_SUBROUTINE_UNIFORM", 0x92F3}, + { "", 'X', 1, "GL_TRANSFORM_FEEDBACK_VARYING", 0x92F4}, + { "", 'X', 1, "GL_ACTIVE_RESOURCES", 0x92F5}, + { "", 'X', 1, "GL_MAX_NAME_LENGTH", 0x92F6}, + { "", 'X', 1, "GL_MAX_NUM_ACTIVE_VARIABLES", 0x92F7}, + { "", 'X', 1, "GL_MAX_NUM_COMPATIBLE_SUBROUTINES", 0x92F8}, + { "", 'X', 1, "GL_NAME_LENGTH", 0x92F9}, + { "", 'X', 1, "GL_TYPE", 0x92FA}, + { "", 'X', 1, "GL_ARRAY_SIZE", 0x92FB}, + { "", 'X', 1, "GL_OFFSET", 0x92FC}, + { "", 'X', 1, "GL_BLOCK_INDEX", 0x92FD}, + { "", 'X', 1, "GL_ARRAY_STRIDE", 0x92FE}, + { "", 'X', 1, "GL_MATRIX_STRIDE", 0x92FF}, + { "", 'X', 1, "GL_IS_ROW_MAJOR", 0x9300}, + { "", 'X', 1, "GL_ATOMIC_COUNTER_BUFFER_INDEX", 0x9301}, + { "", 'X', 1, "GL_BUFFER_BINDING", 0x9302}, + { "", 'X', 1, "GL_BUFFER_DATA_SIZE", 0x9303}, + { "", 'X', 1, "GL_NUM_ACTIVE_VARIABLES", 0x9304}, + { "", 'X', 1, "GL_ACTIVE_VARIABLES", 0x9305}, + { "", 'X', 1, "GL_REFERENCED_BY_VERTEX_SHADER", 0x9306}, + { "", 'X', 1, "GL_REFERENCED_BY_TESS_CONTROL_SHADER", 0x9307}, + { "", 'X', 1, "GL_REFERENCED_BY_TESS_EVALUATION_SHADER", 0x9308}, + { "", 'X', 1, "GL_REFERENCED_BY_GEOMETRY_SHADER", 0x9309}, + { "", 'X', 1, "GL_REFERENCED_BY_FRAGMENT_SHADER", 0x930A}, + { "", 'X', 1, "GL_REFERENCED_BY_COMPUTE_SHADER", 0x930B}, + { "", 'X', 1, "GL_TOP_LEVEL_ARRAY_SIZE", 0x930C}, + { "", 'X', 1, "GL_TOP_LEVEL_ARRAY_STRIDE", 0x930D}, + { "", 'X', 1, "GL_LOCATION", 0x930E}, + { "", 'X', 1, "GL_LOCATION_INDEX", 0x930F}, + { "glGet", 'I', 1, "GL_FRAMEBUFFER_DEFAULT_WIDTH", 0x9310}, + { "glGet", 'I', 1, "GL_FRAMEBUFFER_DEFAULT_HEIGHT", 0x9311}, + { "glGet", 'I', 1, "GL_FRAMEBUFFER_DEFAULT_LAYERS", 0x9312}, + { "glGet", 'I', 1, "GL_FRAMEBUFFER_DEFAULT_SAMPLES", 0x9313}, + { "glGet", 'B', 1, "GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS", 0x9314}, + { "glGet", 'I', 1, "GL_MAX_FRAMEBUFFER_WIDTH", 0x9315}, + { "glGet", 'I', 1, "GL_MAX_FRAMEBUFFER_HEIGHT", 0x9316}, + { "glGet", 'I', 1, "GL_MAX_FRAMEBUFFER_LAYERS", 0x9317}, + { "glGet", 'I', 1, "GL_MAX_FRAMEBUFFER_SAMPLES", 0x9318}, + { "", 'X', 1, "GL_NUM_SAMPLE_COUNTS", 0x9380}, + { "", 'X', 1, "GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE", 0x93A0}, + { "", 'X', 1, "GL_TEXTURE_USAGE_ANGLE", 0x93A2}, + { "", 'X', 1, "GL_FRAMEBUFFER_ATTACHMENT_ANGLE", 0x93A3}, + { "", 'X', 1, "GL_PACK_REVERSE_ROW_ORDER_ANGLE", 0x93A4}, + { "", 'X', 1, "GL_COMPRESSED_RGBA_ASTC_4x4_KHR", 0x93B0}, + { "", 'X', 1, "GL_COMPRESSED_RGBA_ASTC_5x4_KHR", 0x93B1}, + { "", 'X', 1, "GL_COMPRESSED_RGBA_ASTC_5x5_KHR", 0x93B2}, + { "", 'X', 1, "GL_COMPRESSED_RGBA_ASTC_6x5_KHR", 0x93B3}, + { "", 'X', 1, "GL_COMPRESSED_RGBA_ASTC_6x6_KHR", 0x93B4}, + { "", 'X', 1, "GL_COMPRESSED_RGBA_ASTC_8x5_KHR", 0x93B5}, + { "", 'X', 1, "GL_COMPRESSED_RGBA_ASTC_8x6_KHR", 0x93B6}, + { "", 'X', 1, "GL_COMPRESSED_RGBA_ASTC_8x8_KHR", 0x93B7}, + { "", 'X', 1, "GL_COMPRESSED_RGBA_ASTC_10x5_KHR", 0x93B8}, + { "", 'X', 1, "GL_COMPRESSED_RGBA_ASTC_10x6_KHR", 0x93B9}, + { "", 'X', 1, "GL_COMPRESSED_RGBA_ASTC_10x8_KHR", 0x93BA}, + { "", 'X', 1, "GL_COMPRESSED_RGBA_ASTC_10x10_KHR", 0x93BB}, + { "", 'X', 1, "GL_COMPRESSED_RGBA_ASTC_12x10_KHR", 0x93BC}, + { "", 'X', 1, "GL_COMPRESSED_RGBA_ASTC_12x12_KHR", 0x93BD}, + { "", 'X', 1, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR", 0x93D0}, + { "", 'X', 1, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR", 0x93D1}, + { "", 'X', 1, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR", 0x93D2}, + { "", 'X', 1, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR", 0x93D3}, + { "", 'X', 1, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR", 0x93D4}, + { "", 'X', 1, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR", 0x93D5}, + { "", 'X', 1, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR", 0x93D6}, + { "", 'X', 1, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR", 0x93D7}, + { "", 'X', 1, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR", 0x93D8}, + { "", 'X', 1, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR", 0x93D9}, + { "", 'X', 1, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR", 0x93DA}, + { "", 'X', 1, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR", 0x93DB}, + { "", 'X', 1, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR", 0x93DC}, + { "", 'X', 1, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR", 0x93DD}, + { "", 'X', 1, "GL_RESTART_PATH_NV", 0xF0}, + { "", 'X', 1, "GL_DUP_FIRST_CUBIC_CURVE_TO_NV", 0xF2}, + { "", 'X', 1, "GL_DUP_LAST_CUBIC_CURVE_TO_NV", 0xF4}, + { "", 'X', 1, "GL_RECT_NV", 0xF6}, + { "", 'X', 1, "GL_CIRCULAR_CCW_ARC_TO_NV", 0xF8}, + { "", 'X', 1, "GL_CIRCULAR_CW_ARC_TO_NV", 0xFA}, + { "", 'X', 1, "GL_CIRCULAR_TANGENT_ARC_TO_NV", 0xFC}, + { "", 'X', 1, "GL_ARC_TO_NV", 0xFE}, + { "", 'X', 1, "GL_INVALID_INDEX", 0xFFFFFFFFu}, + + // Special pnames, count is fetched from other GL state. + { "glGet", 'I', 0, "GL_PROGRAM_BINARY_FORMATS", 0x87FF }, // actual # is dependent on GL_NUM_PROGRAM_BINARY_FORMATS + { "glGet", 'I', 0, "GL_COMPRESSED_TEXTURE_FORMATS", 0x86A3 } // actual # is dependent on GL_NUM_COMPRESSED_TEXTURE_FORMATS + }; + + #define GL_PNAME_DEFS_ARRAY_SIZE (sizeof(g_gl_pname_defs) / sizeof(g_gl_pname_defs[0])) +#endif + diff --git a/src/voglcommon/vogl_general_context_state.cpp b/src/voglcommon/vogl_general_context_state.cpp index d2d25a4..95ceaee 100644 --- a/src/voglcommon/vogl_general_context_state.cpp +++ b/src/voglcommon/vogl_general_context_state.cpp @@ -28,7 +28,7 @@ #include "vogl_general_context_state.h" #include "vogl_console.h" -#include "gl_pname_defs.inc" +#include "gl_pname_defs.h" // TODO: Indexed versions of glGet's // TODO: Add GL4 types @@ -333,10 +333,13 @@ bool vogl_general_context_state::restore_buffer_binding(GLenum binding_enum, GLe VOGL_FUNC_TRACER uint buffer = 0; - if (get(binding_enum, 0, &buffer)) + if (get(binding_enum, 0, &buffer, 1, false)) { buffer = static_cast(remapper.remap_handle(VOGL_NAMESPACE_BUFFERS, buffer)); + GL_ENTRYPOINT(glBindBuffer)(set_enum, 0); + VOGL_CHECK_GL_ERROR; + GL_ENTRYPOINT(glBindBuffer)(set_enum, buffer); VOGL_CHECK_GL_ERROR; @@ -355,9 +358,9 @@ bool vogl_general_context_state::restore_buffer_binding_range(GLenum binding_enu uint64_t start, size = 0; uint buffer = 0; - if (get(binding_enum, index, &buffer, indexed_variant) && - get(start_enum, index, &start, indexed_variant) && - get(size_enum, index, &size, indexed_variant)) + if (get(binding_enum, index, &buffer, 1, indexed_variant) && + get(start_enum, index, &start, 1, indexed_variant) && + get(size_enum, index, &size, 1, indexed_variant)) { if (buffer) { @@ -1836,8 +1839,6 @@ bool vogl_general_context_state::restore(const vogl_context_info &context_info, ADD_PROCESSED_STATE(GL_ELEMENT_ARRAY_BUFFER_BINDING, 0); // restore transform feedback targets - restore_buffer_binding(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, GL_TRANSFORM_FEEDBACK_BUFFER, remapper); - ADD_PROCESSED_STATE(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, 0); for (uint i = 0; i < context_info.get_max_transform_feedback_separate_attribs(); i++) { restore_buffer_binding_range(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, GL_TRANSFORM_FEEDBACK_BUFFER_START, GL_TRANSFORM_FEEDBACK_BUFFER_SIZE, GL_TRANSFORM_FEEDBACK_BUFFER, i, true, remapper); @@ -1846,9 +1847,10 @@ bool vogl_general_context_state::restore(const vogl_context_info &context_info, ADD_PROCESSED_STATE_INDEXED_VARIANT(GL_TRANSFORM_FEEDBACK_BUFFER_SIZE, i); } + restore_buffer_binding(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, GL_TRANSFORM_FEEDBACK_BUFFER, remapper); + ADD_PROCESSED_STATE(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, 0); + // restore uniform buffer binding target, and the indexed variants - restore_buffer_binding(GL_UNIFORM_BUFFER_BINDING, GL_UNIFORM_BUFFER, remapper); - ADD_PROCESSED_STATE(GL_UNIFORM_BUFFER_BINDING, 0); for (uint i = 0; i < context_info.get_max_uniform_buffer_bindings(); i++) { restore_buffer_binding_range(GL_UNIFORM_BUFFER_BINDING, GL_UNIFORM_BUFFER_START, GL_UNIFORM_BUFFER_SIZE, GL_UNIFORM_BUFFER, i, true, remapper); @@ -1857,6 +1859,28 @@ bool vogl_general_context_state::restore(const vogl_context_info &context_info, ADD_PROCESSED_STATE_INDEXED_VARIANT(GL_UNIFORM_BUFFER_SIZE, i); } + restore_buffer_binding(GL_UNIFORM_BUFFER_BINDING, GL_UNIFORM_BUFFER, remapper); + ADD_PROCESSED_STATE(GL_UNIFORM_BUFFER_BINDING, 0); + + // Restore indexed blending state (we've already restored the global state, which sets all the indexed states) + for (uint i = 0; i < context_info.get_max_draw_buffers(); i++) + { + GLint enabled = 0; + if (get(GL_BLEND, i, &enabled, 1, true)) + { + if (enabled) + { + GL_ENTRYPOINT(glEnablei)(GL_BLEND, i); + VOGL_CHECK_GL_ERROR; + } + else + { + GL_ENTRYPOINT(glDisablei)(GL_BLEND, i); + VOGL_CHECK_GL_ERROR; + } + } + } + // TODO: these GL4 guys have indexed and offset/size variants restore_buffer_binding(GL_ATOMIC_COUNTER_BUFFER_BINDING, GL_ATOMIC_COUNTER_BUFFER, remapper); ADD_PROCESSED_STATE(GL_ATOMIC_COUNTER_BUFFER_BINDING, 0); @@ -2304,6 +2328,9 @@ bool vogl_general_context_state::restore(const vogl_context_info &context_info, //---------------------------------------- + GL_ENTRYPOINT(glBindBuffer)(GL_ARRAY_BUFFER, 0); + VOGL_CHECK_GL_ERROR; + GL_ENTRYPOINT(glBindBuffer)(GL_ARRAY_BUFFER, prev_array_buffer_binding); VOGL_CHECK_GL_ERROR; diff --git a/src/voglcommon/vogl_gl_replayer.cpp b/src/voglcommon/vogl_gl_replayer.cpp index 2a91fe2..e5023c7 100644 --- a/src/voglcommon/vogl_gl_replayer.cpp +++ b/src/voglcommon/vogl_gl_replayer.cpp @@ -1499,6 +1499,32 @@ void vogl_gl_replayer::debug_callback_arb(GLenum source, GLenum type, GLuint id, } } +//---------------------------------------------------------------------------------------------------------------------- +// vogl_replayer::debug_callback +//---------------------------------------------------------------------------------------------------------------------- +void vogl_gl_replayer::debug_callback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, GLvoid *pUser_param) +{ + VOGL_FUNC_TRACER + + VOGL_NOTE_UNUSED(length); + + char final_message[4096]; + + context_state *pContext_state = (context_state *)(pUser_param); + + vogl_format_debug_output_arb(final_message, sizeof(final_message), source, type, id, severity, reinterpret_cast(message)); + + if (pContext_state) + { + vogl_warning_printf("%s: Trace context: 0x%" PRIX64 ", Replay context 0x%" PRIX64 ", Last trace call counter: %" PRIu64 "\n%s\n", VOGL_FUNCTION_NAME, + cast_val_to_uint64(pContext_state->m_trace_context), cast_val_to_uint64(pContext_state->m_replay_context), cast_val_to_uint64(pContext_state->m_last_call_counter), final_message); + } + else + { + vogl_warning_printf("%s: %s\n", VOGL_FUNCTION_NAME, final_message); + } +} + //---------------------------------------------------------------------------------------------------------------------- // vogl_replayer::is_extension_supported //---------------------------------------------------------------------------------------------------------------------- @@ -3991,7 +4017,7 @@ vogl_gl_replayer::status_t vogl_gl_replayer::process_gl_entrypoint_packet_intern if (!vogl_display_list_state::is_call_listable(entrypoint_id, trace_packet)) { if (!g_vogl_entrypoint_descs[entrypoint_id].m_whitelisted_for_displaylists) - process_entrypoint_error("%s: Failed serializing trace packet into display list shadow! Call is not listable.\n", VOGL_FUNCTION_NAME); + process_entrypoint_error("%s: Failed serializing trace packet into display list shadow! Call is not whitelisted for display list usage by vogl.\n", VOGL_FUNCTION_NAME); else process_entrypoint_warning("%s: Failed serializing trace packet into display list shadow! Call with these parameters is not listable.\n", VOGL_FUNCTION_NAME); } @@ -7461,51 +7487,6 @@ vogl_gl_replayer::status_t vogl_gl_replayer::process_gl_entrypoint_packet_intern break; } - case VOGL_ENTRYPOINT_glReadPixels: - { -// TODO: This is causing huge stalls when replaying metro, not sure why. Also, the # of traced bytes is zero in metro. -#if 0 - if (!benchmark_mode()) - { - GLint x = trace_packet.get_param_value(0); - GLint y = trace_packet.get_param_value(1); - GLsizei width = trace_packet.get_param_value(2); - GLsizei height = trace_packet.get_param_value(3); - GLenum format = trace_packet.get_param_value(4); - GLenum type = trace_packet.get_param_value(5); - const GLvoid *trace_data = trace_packet.get_param_client_memory(6); - uint trace_data_size = trace_packet.get_param_client_memory_data_size(6); - - size_t replay_data_size = vogl_get_image_size(format, type, width, height, 1); - if (replay_data_size != trace_data_size) - { - process_entrypoint_warning("%s: Unexpected trace data size, got %u expected %" PRIu64 "\n", VOGL_METHOD_NAME, trace_data_size, (uint64_t)replay_data_size); - } - else if (!trace_data) - { - process_entrypoint_warning("%s: Trace data is missing from packet\n", VOGL_METHOD_NAME); - } - - if (replay_data_size > cUINT32_MAX) - { - process_entrypoint_error("%s: Replay data size is too large (%" PRIu64 ")!\n", VOGL_METHOD_NAME, (uint64_t)replay_data_size); - return cStatusHardFailure; - } - - vogl::vector data(static_cast(replay_data_size)); - GL_ENTRYPOINT(glReadPixels)(x, y, width, height, format, type, data.get_ptr()); - - if ((trace_data_size == replay_data_size) && (trace_data_size) && (trace_data)) - { - if (memcmp(data.get_ptr(), trace_data, trace_data_size) != 0) - { - process_entrypoint_error("%s: Replay's returned pixel data differed from trace's!\n", VOGL_METHOD_NAME); - } - } - } -#endif - break; - } case VOGL_ENTRYPOINT_glGetTexLevelParameterfv: { if (!benchmark_mode()) @@ -8449,14 +8430,6 @@ vogl_gl_replayer::status_t vogl_gl_replayer::process_gl_entrypoint_packet_intern // TODO - we need to hook up this extension to the tracer break; } - case VOGL_ENTRYPOINT_glDebugMessageCallbackARB: - case VOGL_ENTRYPOINT_glGetDebugMessageLogARB: - case VOGL_ENTRYPOINT_glDebugMessageControlARB: - case VOGL_ENTRYPOINT_glDebugMessageInsertARB: - { - // TODO - break; - } case VOGL_ENTRYPOINT_glBitmap: { VOGL_REPLAY_LOAD_PARAMS_HELPER_glBitmap; @@ -8723,6 +8696,243 @@ vogl_gl_replayer::status_t vogl_gl_replayer::process_gl_entrypoint_packet_intern break; } + case VOGL_ENTRYPOINT_glDebugMessageInsert: + { + VOGL_REPLAY_LOAD_PARAMS_HELPER_glDebugMessageInsert; + + VOGL_REPLAY_CALL_GL_HELPER_glDebugMessageInsert; + break; + } + case VOGL_ENTRYPOINT_glDebugMessageInsertARB: + { + VOGL_REPLAY_LOAD_PARAMS_HELPER_glDebugMessageInsertARB; + + VOGL_REPLAY_CALL_GL_HELPER_glDebugMessageInsertARB; + break; + } + case VOGL_ENTRYPOINT_glDebugMessageCallbackARB: + { + GL_ENTRYPOINT(glDebugMessageCallbackARB)(debug_callback_arb, (GLvoid *)m_pCur_context_state); + + break; + } + case VOGL_ENTRYPOINT_glDebugMessageCallback: + { + GL_ENTRYPOINT(glDebugMessageCallback)(debug_callback, (GLvoid *)m_pCur_context_state); + + break; + } + case VOGL_ENTRYPOINT_glObjectLabel: + { + VOGL_REPLAY_LOAD_PARAMS_HELPER_glObjectLabel; + + switch (identifier) + { + case GL_BUFFER: + { + name = map_handle(get_shared_state()->m_buffers, name); + break; + } + case GL_SHADER: + case GL_PROGRAM: + { + name = map_handle(get_shared_state()->m_shadow_state.m_objs, name); + break; + } + case GL_VERTEX_ARRAY: + { + name = map_handle(get_shared_state()->m_vertex_array_objects, name); + break; + } + case GL_QUERY: + { + name = map_handle(get_shared_state()->m_queries, name); + break; + } + case GL_SAMPLER: + { + name = map_handle(get_shared_state()->m_sampler_objects, name); + break; + } + case GL_TEXTURE: + { + name = map_handle(get_shared_state()->m_shadow_state.m_textures, name); + break; + } + case GL_RENDERBUFFER: + { + name = map_handle(get_shared_state()->m_shadow_state.m_rbos, name); + break; + } + case GL_FRAMEBUFFER: + { + name = map_handle(get_shared_state()->m_framebuffers, name); + break; + } + case GL_DISPLAY_LIST: + { + name = map_handle(get_shared_state()->m_lists, name); + break; + } + case GL_TRANSFORM_FEEDBACK: // TODO: Investigate this more + case GL_PROGRAM_PIPELINE: // TODO: We don't support program pipelines yet + default: + { + process_entrypoint_error("%s: Unsupported object identifier 0x%X\n", VOGL_METHOD_NAME, identifier); + return cStatusSoftFailure; + } + } + + VOGL_REPLAY_CALL_GL_HELPER_glObjectLabel; + + break; + } + case VOGL_ENTRYPOINT_glObjectPtrLabel: + { + vogl_sync_ptr_value trace_sync = trace_packet.get_param_ptr_value(0); + GLsizei length = trace_packet.get_param_value(1); + const GLchar *pTrace_label = reinterpret_cast(trace_packet.get_param_client_memory_ptr(2)); + GLsync replay_sync = NULL; + + if (trace_sync) + { + gl_sync_hash_map::const_iterator it = get_shared_state()->m_syncs.find(trace_sync); + if (it == get_shared_state()->m_syncs.end()) + { + process_entrypoint_error("%s: Failed remapping trace sync value 0x%" PRIx64 "\n", VOGL_METHOD_NAME, static_cast(trace_sync)); + return cStatusSoftFailure; + } + else + { + replay_sync = it->second; + } + } + + GL_ENTRYPOINT(glObjectPtrLabel)(replay_sync, length, pTrace_label); + + break; + } + case VOGL_ENTRYPOINT_glReadPixels: + { + GLint x = trace_packet.get_param_value(0); + GLint y = trace_packet.get_param_value(1); + GLsizei width = trace_packet.get_param_value(2); + GLsizei height = trace_packet.get_param_value(3); + GLenum format = trace_packet.get_param_value(4); + GLenum type = trace_packet.get_param_value(5); + + GLuint pixel_pack_buf = vogl_get_bound_gl_buffer(GL_PIXEL_PACK_BUFFER); + if (pixel_pack_buf) + { + GL_ENTRYPOINT(glReadPixels)(x, y, width, height, format, type, reinterpret_cast(trace_packet.get_param_ptr_value(6))); + } + else + { + const GLvoid *trace_data = trace_packet.get_param_client_memory(6); + uint trace_data_size = trace_packet.get_param_client_memory_data_size(6); + + size_t replay_data_size = vogl_get_image_size(format, type, width, height, 1); + if (replay_data_size != trace_data_size) + { + process_entrypoint_warning("%s: Unexpected trace data size, got %u expected %" PRIu64 "\n", VOGL_METHOD_NAME, trace_data_size, (uint64_t)replay_data_size); + } + else if (!trace_data) + { + process_entrypoint_warning("%s: Trace data is missing from packet\n", VOGL_METHOD_NAME); + } + + if (replay_data_size > cUINT32_MAX) + { + process_entrypoint_error("%s: Replay data size is too large (%" PRIu64 ")!\n", VOGL_METHOD_NAME, (uint64_t)replay_data_size); + return cStatusHardFailure; + } + + vogl::vector data(static_cast(replay_data_size)); + GL_ENTRYPOINT(glReadPixels)(x, y, width, height, format, type, data.get_ptr()); + + if ((trace_data_size == replay_data_size) && (trace_data_size) && (trace_data)) + { + if (memcmp(data.get_ptr(), trace_data, trace_data_size) != 0) + { + process_entrypoint_error("%s: Replay's returned pixel data differed from trace's!\n", VOGL_METHOD_NAME); + } + } + else + { + process_entrypoint_warning("%s: Replay's computed glReadPixels image size differs from traces (%u vs %u)!\n", VOGL_METHOD_NAME, static_cast(trace_data_size), static_cast(replay_data_size)); + } + } + + break; + } + case VOGL_ENTRYPOINT_glGetTexImage: + { + VOGL_REPLAY_LOAD_PARAMS_HELPER_glGetTexImage; + + GLuint pixel_pack_buf = vogl_get_bound_gl_buffer(GL_PIXEL_PACK_BUFFER); + if (pixel_pack_buf) + { + GLvoid *pReplay_pixels = reinterpret_cast(trace_packet.get_param_ptr_value(4)); + + VOGL_REPLAY_CALL_GL_HELPER_glGetTexImage; + } + else + { + uint trace_data_size = trace_packet.get_param_client_memory_data_size(4); + + size_t replay_data_size = vogl_get_tex_target_image_size(target, level, format, type); + + if (replay_data_size > cUINT32_MAX) + { + process_entrypoint_error("%s: Replay data size is too large (%" PRIu64 ")!\n", VOGL_METHOD_NAME, (uint64_t)replay_data_size); + return cStatusHardFailure; + } + + uint8_vec data(static_cast(replay_data_size)); + + GLvoid *pReplay_pixels = data.get_ptr(); + + VOGL_REPLAY_CALL_GL_HELPER_glGetTexImage; + + if ((trace_data_size == replay_data_size) && (trace_data_size) && (pTrace_pixels)) + { + if (memcmp(data.get_ptr(), pTrace_pixels, trace_data_size) != 0) + { + process_entrypoint_error("%s: Replay's returned pixel data differed from trace's!\n", VOGL_METHOD_NAME); + } + } + else + { + process_entrypoint_warning("%s: Replay's computed glGetTexImage() image size differs from traces (%u vs %u)!\n", VOGL_METHOD_NAME, static_cast(trace_data_size), static_cast(replay_data_size)); + } + } + + break; + } + case VOGL_ENTRYPOINT_glGetCompressedTexImage: + { + VOGL_REPLAY_LOAD_PARAMS_HELPER_glGetCompressedTexImage + + VOGL_NOTE_UNUSED(pTrace_img); + + GLuint pixel_pack_buf = vogl_get_bound_gl_buffer(GL_PIXEL_PACK_BUFFER); + if (pixel_pack_buf) + { + GLvoid *pReplay_img = reinterpret_cast(trace_packet.get_param_ptr_value(2)); + + VOGL_REPLAY_CALL_GL_HELPER_glGetCompressedTexImage; + } + else + { + // TODO: Implement non-pixel pack buffer path, compare for divergence + } + + break; + } + case VOGL_ENTRYPOINT_glGetDebugMessageLogARB: + case VOGL_ENTRYPOINT_glGetObjectLabel: + case VOGL_ENTRYPOINT_glGetObjectPtrLabel: + case VOGL_ENTRYPOINT_glGetDebugMessageLog: case VOGL_ENTRYPOINT_glAreTexturesResident: case VOGL_ENTRYPOINT_glAreTexturesResidentEXT: case VOGL_ENTRYPOINT_glGetActiveAtomicCounterBufferiv: @@ -8764,7 +8974,6 @@ vogl_gl_replayer::status_t vogl_gl_replayer::process_gl_entrypoint_packet_intern case VOGL_ENTRYPOINT_glGetCombinerOutputParameterivNV: case VOGL_ENTRYPOINT_glGetCombinerStageParameterfvNV: case VOGL_ENTRYPOINT_glGetCompressedMultiTexImageEXT: - case VOGL_ENTRYPOINT_glGetCompressedTexImage: case VOGL_ENTRYPOINT_glGetCompressedTexImageARB: case VOGL_ENTRYPOINT_glGetCompressedTextureImageEXT: case VOGL_ENTRYPOINT_glGetConvolutionFilter: @@ -8774,7 +8983,6 @@ vogl_gl_replayer::status_t vogl_gl_replayer::process_gl_entrypoint_packet_intern case VOGL_ENTRYPOINT_glGetConvolutionParameteriv: case VOGL_ENTRYPOINT_glGetConvolutionParameterivEXT: case VOGL_ENTRYPOINT_glGetConvolutionParameterxvOES: - case VOGL_ENTRYPOINT_glGetDebugMessageLog: case VOGL_ENTRYPOINT_glGetDebugMessageLogAMD: case VOGL_ENTRYPOINT_glGetDetailTexFuncSGIS: case VOGL_ENTRYPOINT_glGetDoubleIndexedvEXT: @@ -8876,10 +9084,8 @@ vogl_gl_replayer::status_t vogl_gl_replayer::process_gl_entrypoint_packet_intern case VOGL_ENTRYPOINT_glGetNamedStringivARB: case VOGL_ENTRYPOINT_glGetObjectBufferfvATI: case VOGL_ENTRYPOINT_glGetObjectBufferivATI: - case VOGL_ENTRYPOINT_glGetObjectLabel: case VOGL_ENTRYPOINT_glGetObjectParameterfvARB: case VOGL_ENTRYPOINT_glGetObjectParameterivAPPLE: - case VOGL_ENTRYPOINT_glGetObjectPtrLabel: case VOGL_ENTRYPOINT_glGetOcclusionQueryivNV: case VOGL_ENTRYPOINT_glGetOcclusionQueryuivNV: case VOGL_ENTRYPOINT_glGetPathColorGenfvNV: @@ -8961,7 +9167,6 @@ vogl_gl_replayer::status_t vogl_gl_replayer::process_gl_entrypoint_packet_intern case VOGL_ENTRYPOINT_glGetTexEnvxvOES: case VOGL_ENTRYPOINT_glGetTexFilterFuncSGIS: case VOGL_ENTRYPOINT_glGetTexGenxvOES: - case VOGL_ENTRYPOINT_glGetTexImage: case VOGL_ENTRYPOINT_glGetTexLevelParameterxvOES: case VOGL_ENTRYPOINT_glGetTexParameterIivEXT: case VOGL_ENTRYPOINT_glGetTexParameterIuivEXT: @@ -10241,6 +10446,8 @@ void vogl_gl_replayer::trace_to_replay_handle_remapper::delete_handle_and_object //---------------------------------------------------------------------------------------------------------------------- // vogl_replayer::trace_to_replay_handle_remapper::declare_location +// from_location - trace location +// to_location - replay/GL location //---------------------------------------------------------------------------------------------------------------------- void vogl_gl_replayer::trace_to_replay_handle_remapper::declare_location(uint32 from_program_handle, uint32 to_program_handle, int32 from_location, int32 to_location) { diff --git a/src/voglcommon/vogl_gl_replayer.h b/src/voglcommon/vogl_gl_replayer.h index 4d15b54..2ae259c 100644 --- a/src/voglcommon/vogl_gl_replayer.h +++ b/src/voglcommon/vogl_gl_replayer.h @@ -1281,6 +1281,7 @@ private: // Loosely derived from http://www.altdevblogaday.com/2011/06/23/improving-opengl-error-messages/ static void debug_callback_arb(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, GLvoid *pUser_param); + static void debug_callback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, GLvoid *pUser_param); bool is_extension_supported(const char *pExt); diff --git a/src/voglcommon/vogl_gl_utils.cpp b/src/voglcommon/vogl_gl_utils.cpp index b80f3d7..2ee7779 100644 --- a/src/voglcommon/vogl_gl_utils.cpp +++ b/src/voglcommon/vogl_gl_utils.cpp @@ -33,7 +33,7 @@ #include "vogl_backtrace.h" #define VOGL_DECLARE_PNAME_DEF_TABLE -#include "gl_pname_defs.inc" +#include "gl_pname_defs.h" #define VOGL_NAMESPACES_IMPLEMENTATION #include "vogl_namespaces.h" diff --git a/src/voglcommon/vogl_program_state.cpp b/src/voglcommon/vogl_program_state.cpp index bfc8a99..5998a41 100644 --- a/src/voglcommon/vogl_program_state.cpp +++ b/src/voglcommon/vogl_program_state.cpp @@ -779,7 +779,7 @@ bool vogl_program_state::restore_uniforms(uint32 handle32, const vogl_context_in const GLint restore_location = restore_uniform.m_base_location; for (uint i = 0; i < array_size; i++) - remapper.declare_location(m_snapshot_handle, handle32, restore_uniform.m_base_location + i, restore_location + i); + remapper.declare_location(m_snapshot_handle, handle32, trace_uniform.m_base_location + i, restore_location + i); if (array_size) { diff --git a/src/voglcommon/vogl_replay_window.cpp b/src/voglcommon/vogl_replay_window.cpp index 8ad3ecd..46b7140 100644 --- a/src/voglcommon/vogl_replay_window.cpp +++ b/src/voglcommon/vogl_replay_window.cpp @@ -44,7 +44,7 @@ vogl_replay_window::~vogl_replay_window() close(); } -bool vogl_replay_window::open(int width, int height) +bool vogl_replay_window::open(int width, int height, int samples) { VOGL_FUNC_TRACER @@ -54,20 +54,28 @@ bool vogl_replay_window::open(int width, int height) return false; // TODO: These attribs (especially the sizes) should be passed in by the caller! - static int fbAttribs[] = - { - GLX_RENDER_TYPE, GLX_RGBA_BIT, - GLX_X_RENDERABLE, True, - GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT, - GLX_DOUBLEBUFFER, True, - GLX_RED_SIZE, 8, - GLX_BLUE_SIZE, 8, - GLX_GREEN_SIZE, 8, - GLX_ALPHA_SIZE, 8, - GLX_DEPTH_SIZE, 24, - GLX_STENCIL_SIZE, 8, - 0 - }; + int fbAttribs[64]; + + int *pAttribs = fbAttribs; + + *pAttribs++ = GLX_RENDER_TYPE; *pAttribs++ = GLX_RGBA_BIT; + *pAttribs++ = GLX_X_RENDERABLE; *pAttribs++ = True; + *pAttribs++ = GLX_DRAWABLE_TYPE; *pAttribs++ = GLX_WINDOW_BIT; + *pAttribs++ = GLX_DOUBLEBUFFER; *pAttribs++ = True; + *pAttribs++ = GLX_RED_SIZE; *pAttribs++ = 8; + *pAttribs++ = GLX_BLUE_SIZE; *pAttribs++ = 8; + *pAttribs++ = GLX_GREEN_SIZE; *pAttribs++ = 8; + *pAttribs++ = GLX_ALPHA_SIZE; *pAttribs++ = 8; + *pAttribs++ = GLX_DEPTH_SIZE; *pAttribs++ = 24; + *pAttribs++ = GLX_STENCIL_SIZE; *pAttribs++ = 8; + + if (samples > 1) + { + *pAttribs++ = GLX_SAMPLE_BUFFERS; *pAttribs++ = 1; + *pAttribs++ = GLX_SAMPLES; *pAttribs++ = samples; + } + + *pAttribs++ = 0; // Tell X we are going to use the display m_dpy = XOpenDisplay(NULL); diff --git a/src/voglcommon/vogl_replay_window.h b/src/voglcommon/vogl_replay_window.h index 0d9586b..48c31c7 100644 --- a/src/voglcommon/vogl_replay_window.h +++ b/src/voglcommon/vogl_replay_window.h @@ -44,7 +44,7 @@ public: return (m_width > 0) && (m_dpy != NULL); } - bool open(int width, int height); + bool open(int width, int height, int samples = 1); void set_title(const char *pTitle); diff --git a/src/voglcommon/vogl_state_vector.cpp b/src/voglcommon/vogl_state_vector.cpp index dc67489..9da242b 100644 --- a/src/voglcommon/vogl_state_vector.cpp +++ b/src/voglcommon/vogl_state_vector.cpp @@ -26,7 +26,7 @@ // File: vogl_state_vector.cpp #include "vogl_state_vector.h" #include "vogl_sort.h" -#include "gl_pname_defs.inc" +#include "gl_pname_defs.h" #include "vogl_growable_array.h" #define VOGL_CONTEXT_STATE_DEBUG 0 diff --git a/src/voglcommon/vogl_texture_state.cpp b/src/voglcommon/vogl_texture_state.cpp index b3b5363..834093a 100644 --- a/src/voglcommon/vogl_texture_state.cpp +++ b/src/voglcommon/vogl_texture_state.cpp @@ -1272,10 +1272,10 @@ bool vogl_texture_state::restore(const vogl_context_info &context_info, vogl_han } } - // TODO: Support immutable textures, incomplete textures, etc. Lots more to do here. + // TODO: Support immutable textures if (is_immutable_format) { - vogl_warning_printf("%s: TODO: Support immutable textures\n", VOGL_METHOD_NAME); + vogl_warning_printf_once("%s: TODO: Support immutable textures (texture will be created non-immutable)\n", VOGL_METHOD_NAME); } for (face = 0; face < num_faces; face++) diff --git a/src/vogleditor/CMakeLists.txt b/src/vogleditor/CMakeLists.txt index 75f5d07..597567a 100644 --- a/src/vogleditor/CMakeLists.txt +++ b/src/vogleditor/CMakeLists.txt @@ -15,7 +15,7 @@ include_directories( ${SRC_DIR} ${SRC_DIR}/voglcore ${SRC_DIR}/voglcommon - ${SRC_DIR}/voglinc + ${CMAKE_BINARY_DIR}/voglinc ${SRC_DIR}/extlib/loki/include/loki ${SRC_DIR}/libtelemetry ${CMAKE_CURRENT_BINARY_DIR} @@ -53,6 +53,9 @@ set(SRC_LIST vogleditor_qtextureexplorer.cpp vogleditor_qtextureviewer.cpp vogleditor_qtimelineview.cpp + vogleditor_qtrimdialog.cpp + vogleditor_output.cpp + vogleditor_settings.cpp vogleditor_statetreearbprogramitem.cpp vogleditor_statetreearbprogramenvitem.cpp vogleditor_statetreebufferitem.cpp @@ -91,6 +94,7 @@ set(UI_HEADER_LIST vogleditor_qtextureviewer.h vogleditor_qtextureexplorer.h vogleditor_qtimelineview.h + vogleditor_qtrimdialog.h ) # these are for non-QOBJECT headers @@ -101,6 +105,8 @@ set(HEADER_LIST vogleditor_apicalltreeitem.h vogleditor_frameitem.h vogleditor_gl_state_snapshot.h + vogleditor_output.h + vogleditor_settings.h vogleditor_snapshotitem.h vogleditor_statetreearbprogramitem.h vogleditor_statetreearbprogramenvitem.h @@ -134,6 +140,7 @@ set(FORM_LIST vogleditor_qprogramexplorer.ui vogleditor_qshaderexplorer.ui vogleditor_qtextureexplorer.ui + vogleditor_qtrimdialog.ui ) set(RESOURCE_LIST @@ -151,6 +158,8 @@ add_executable(${PROJECT_NAME} ${SRC_LIST} ${HEADER_LIST} ${QT_GEN_RESOURCE_RCC_LIST} ) +add_dependencies(${PROJECT_NAME} voglgen_make_inc) + target_link_libraries(${PROJECT_NAME} ${QT_QTMAIN_LIBRARY} ${QT_QTCORE_LIBRARY} diff --git a/src/vogleditor/vogleditor.cpp b/src/vogleditor/vogleditor.cpp index ea33ffa..14da0b2 100644 --- a/src/vogleditor/vogleditor.cpp +++ b/src/vogleditor/vogleditor.cpp @@ -27,6 +27,7 @@ #include #include #include +#include #include #include #include @@ -46,21 +47,29 @@ #include "vogl_texture_format.h" #include "vogl_trace_file_reader.h" #include "vogl_trace_file_writer.h" -#include "vogleditor_qstatetreemodel.h" +#include "vogleditor_output.h" +#include "vogleditor_settings.h" #include "vogleditor_statetreetextureitem.h" #include "vogleditor_statetreeprogramitem.h" #include "vogleditor_statetreeshaderitem.h" #include "vogleditor_statetreeframebufferitem.h" +#include "vogleditor_qstatetreemodel.h" #include "vogleditor_qtextureexplorer.h" +#include "vogleditor_qtrimdialog.h" + +#define VOGLEDITOR_DISABLE_STATE_TAB(tab) ui->tabWidget->setTabEnabled(ui->tabWidget->indexOf(tab), false); +#define VOGLEDITOR_ENABLE_STATE_TAB(tab) ui->tabWidget->setTabEnabled(ui->tabWidget->indexOf(tab), true); -#define VOGLEDITOR_DISABLE_TAB(tab) ui->tabWidget->setTabEnabled(ui->tabWidget->indexOf(tab), false); -#define VOGLEDITOR_ENABLE_TAB(tab) ui->tabWidget->setTabEnabled(ui->tabWidget->indexOf(tab), true); +#define VOGLEDITOR_DISABLE_BOTTOM_TAB(tab) ui->bottomTabWidget->setTabEnabled(ui->bottomTabWidget->indexOf(tab), false); +#define VOGLEDITOR_ENABLE_BOTTOM_TAB(tab) ui->bottomTabWidget->setTabEnabled(ui->bottomTabWidget->indexOf(tab), true); //---------------------------------------------------------------------------------------------------------------------- // globals //---------------------------------------------------------------------------------------------------------------------- static void *g_actual_libgl_module_handle; static QString g_PROJECT_NAME = "Vogl Editor"; +static vogleditor_settings g_settings; +static const char* g_SETTINGS_FILE = "./vogleditor_settings.json"; //---------------------------------------------------------------------------------------------------------------------- // vogl_get_proc_address_helper @@ -105,21 +114,26 @@ static bool load_gl() VoglEditor::VoglEditor(QWidget *parent) : QMainWindow(parent), ui(new Ui::VoglEditor), - m_statusLabel(NULL), - m_framebufferExplorer(NULL), - m_textureExplorer(NULL), - m_renderbufferExplorer(NULL), - m_programExplorer(NULL), - m_shaderExplorer(NULL), + m_pFramebufferExplorer(NULL), + m_pTextureExplorer(NULL), + m_pRenderbufferExplorer(NULL), + m_pProgramExplorer(NULL), + m_pShaderExplorer(NULL), m_timeline(NULL), + m_pFramebufferTab_layout(NULL), + m_pTextureTab_layout(NULL), + m_pRenderbufferTab_layout(NULL), + m_pProgramTab_layout(NULL), + m_pShaderTab_layout(NULL), m_currentSnapshot(NULL), m_pCurrentCallTreeItem(NULL), + m_pVoglReplayProcess(new QProcess()), m_pPlayButton(NULL), - m_pPauseButton(NULL), m_pTrimButton(NULL), - m_pStopButton(NULL), m_pTraceReader(NULL), - m_pApicallTreeModel(NULL) + m_pTimelineModel(NULL), + m_pApiCallTreeModel(NULL), + m_pStateTreeModel(NULL) { ui->setupUi(this); @@ -128,42 +142,50 @@ VoglEditor::VoglEditor(QWidget *parent) : vogl_init_actual_gl_entrypoints(vogl_get_proc_address_helper); } - m_statusLabel = new QLabel(ui->statusBar); - m_statusLabel->setBaseSize(150, 12); - ui->statusBar->addWidget(m_statusLabel, 1); + // load the settings file. This will only succeed if the file already exists + g_settings.load(g_SETTINGS_FILE); + + // always save/resave the file wiill either be created or so that new settings will be added + g_settings.save(g_SETTINGS_FILE); + + this->move(g_settings.window_position_left(), g_settings.window_position_top()); + this->resize(g_settings.window_size_width(), g_settings.window_size_height()); + + vogleditor_output_init(ui->outputTextEdit); + vogleditor_output_message("Welcome to VoglEditor!"); // cache the original background color of the search text box m_searchTextboxBackgroundColor = ui->searchTextBox->palette().base().color(); // setup framebuffer tab - QGridLayout* framebufferTab_layout = new QGridLayout; - m_framebufferExplorer = new vogleditor_QFramebufferExplorer(ui->framebufferTab); - framebufferTab_layout->addWidget(m_framebufferExplorer, 0, 0); - ui->framebufferTab->setLayout(framebufferTab_layout); + m_pFramebufferTab_layout = new QGridLayout(); + m_pFramebufferExplorer = new vogleditor_QFramebufferExplorer(ui->framebufferTab); + m_pFramebufferTab_layout->addWidget(m_pFramebufferExplorer, 0, 0); + ui->framebufferTab->setLayout(m_pFramebufferTab_layout); // setup texture tab - QGridLayout* textureTab_layout = new QGridLayout; - m_textureExplorer = new vogleditor_QTextureExplorer(ui->textureTab); - textureTab_layout->addWidget(m_textureExplorer, 0, 0); - ui->textureTab->setLayout(textureTab_layout); + m_pTextureTab_layout = new QGridLayout(); + m_pTextureExplorer = new vogleditor_QTextureExplorer(ui->textureTab); + m_pTextureTab_layout->addWidget(m_pTextureExplorer, 0, 0); + ui->textureTab->setLayout(m_pTextureTab_layout); // setup renderbuffer tab - QGridLayout* rbTab_layout = new QGridLayout; - m_renderbufferExplorer = new vogleditor_QTextureExplorer(ui->renderbufferTab); - rbTab_layout->addWidget(m_renderbufferExplorer, 0, 0); - ui->renderbufferTab->setLayout(rbTab_layout); + m_pRenderbufferTab_layout = new QGridLayout(); + m_pRenderbufferExplorer = new vogleditor_QTextureExplorer(ui->renderbufferTab); + m_pRenderbufferTab_layout->addWidget(m_pRenderbufferExplorer, 0, 0); + ui->renderbufferTab->setLayout(m_pRenderbufferTab_layout); // setup program tab - QGridLayout* programTab_layout = new QGridLayout; - m_programExplorer = new vogleditor_QProgramExplorer(ui->programTab); - programTab_layout->addWidget(m_programExplorer, 0, 0); - ui->programTab->setLayout(programTab_layout); + m_pProgramTab_layout = new QGridLayout(); + m_pProgramExplorer = new vogleditor_QProgramExplorer(ui->programTab); + m_pProgramTab_layout->addWidget(m_pProgramExplorer, 0, 0); + ui->programTab->setLayout(m_pProgramTab_layout); // setup shader tab - QGridLayout* shaderTab_layout = new QGridLayout; - m_shaderExplorer = new vogleditor_QShaderExplorer(ui->shaderTab); - shaderTab_layout->addWidget(m_shaderExplorer, 0, 0); - ui->shaderTab->setLayout(shaderTab_layout); + m_pShaderTab_layout = new QGridLayout(); + m_pShaderExplorer = new vogleditor_QShaderExplorer(ui->shaderTab); + m_pShaderTab_layout->addWidget(m_pShaderExplorer, 0, 0); + ui->shaderTab->setLayout(m_pShaderTab_layout); // setup timeline m_timeline = new vogleditor_QTimelineView(); @@ -173,69 +195,123 @@ VoglEditor::VoglEditor(QWidget *parent) : // add buttons to toolbar m_pPlayButton = new QToolButton(ui->mainToolBar); - m_pPlayButton->setText("Play trace"); + m_pPlayButton->setText("Play Trace"); m_pPlayButton->setEnabled(false); - m_pPauseButton = new QToolButton(ui->mainToolBar); - m_pPauseButton->setText("Pause"); - m_pPauseButton->setEnabled(false); - m_pTrimButton = new QToolButton(ui->mainToolBar); - m_pTrimButton->setText("Trim"); + m_pTrimButton->setText("Trim Trace"); m_pTrimButton->setEnabled(false); - m_pStopButton = new QToolButton(ui->mainToolBar); - m_pStopButton->setText("Stop"); - m_pStopButton->setEnabled(false); - - // Temporarily hide the other buttons (until asyncronous playback is supported) - m_pPauseButton->setVisible(false); - m_pTrimButton->setVisible(false); - m_pStopButton->setVisible(false); - ui->mainToolBar->addWidget(m_pPlayButton); - ui->mainToolBar->addWidget(m_pPauseButton); ui->mainToolBar->addWidget(m_pTrimButton); - ui->mainToolBar->addWidget(m_pStopButton); connect(m_pPlayButton, SIGNAL(clicked()), this, SLOT(playCurrentTraceFile())); - connect(m_pPauseButton, SIGNAL(clicked()), this, SLOT(pauseCurrentTraceFile())); connect(m_pTrimButton, SIGNAL(clicked()), this, SLOT(trimCurrentTraceFile())); - connect(m_pStopButton, SIGNAL(clicked()), this, SLOT(stopCurrentTraceFile())); - connect(m_programExplorer, SIGNAL(program_edited(vogl_program_state*)), this, SLOT(on_program_edited(vogl_program_state*))); + connect(m_pProgramExplorer, SIGNAL(program_edited(vogl_program_state*)), this, SLOT(slot_program_edited(vogl_program_state*))); + + connect(m_pVoglReplayProcess, SIGNAL(readyReadStandardOutput()), this, SLOT(slot_readReplayStandardOutput())); + connect(m_pVoglReplayProcess, SIGNAL(readyReadStandardError()), this, SLOT(slot_readReplayStandardError())); reset_tracefile_ui(); } VoglEditor::~VoglEditor() { - close_trace_file(); - delete ui; + // update any settings and save the settings file + g_settings.set_window_position_left(this->x()); + g_settings.set_window_position_top(this->y()); + g_settings.set_window_size_width(this->width()); + g_settings.set_window_size_height(this->height()); + g_settings.save(g_SETTINGS_FILE); - if (m_textureExplorer != NULL) - { - delete m_textureExplorer; - m_textureExplorer = NULL; - } + close_trace_file(); + delete ui; + vogleditor_output_deinit(); - if (m_renderbufferExplorer != NULL) - { - delete m_renderbufferExplorer; - m_renderbufferExplorer = NULL; - } + if (m_pFramebufferExplorer != NULL) + { + delete m_pFramebufferExplorer; + m_pFramebufferExplorer = NULL; + } - if (m_programExplorer != NULL) - { - delete m_programExplorer; - m_programExplorer = NULL; - } + if (m_pTextureExplorer != NULL) + { + delete m_pTextureExplorer; + m_pTextureExplorer = NULL; + } - if (m_shaderExplorer != NULL) - { - delete m_shaderExplorer; - m_shaderExplorer = NULL; - } + if (m_pRenderbufferExplorer != NULL) + { + delete m_pRenderbufferExplorer; + m_pRenderbufferExplorer = NULL; + } + + if (m_pProgramExplorer != NULL) + { + delete m_pProgramExplorer; + m_pProgramExplorer = NULL; + } + + if (m_pShaderExplorer != NULL) + { + delete m_pShaderExplorer; + m_pShaderExplorer = NULL; + } + + if (m_pPlayButton != NULL) + { + delete m_pPlayButton; + m_pPlayButton = NULL; + } + + if (m_pTrimButton != NULL) + { + delete m_pTrimButton; + m_pTrimButton = NULL; + } + + if (m_pFramebufferTab_layout != NULL) + { + delete m_pFramebufferTab_layout; + m_pFramebufferTab_layout = NULL; + } + + if (m_pTextureTab_layout != NULL) + { + delete m_pTextureTab_layout; + m_pTextureTab_layout = NULL; + } + + if (m_pRenderbufferTab_layout != NULL) + { + delete m_pRenderbufferTab_layout; + m_pRenderbufferTab_layout = NULL; + } + + if (m_pProgramTab_layout != NULL) + { + delete m_pProgramTab_layout; + m_pProgramTab_layout = NULL; + } + + if (m_pShaderTab_layout != NULL) + { + delete m_pShaderTab_layout; + m_pShaderTab_layout = NULL; + } + + if (m_pStateTreeModel != NULL) + { + delete m_pStateTreeModel; + m_pStateTreeModel = NULL; + } + + if (m_pVoglReplayProcess != NULL) + { + delete m_pVoglReplayProcess; + m_pVoglReplayProcess = NULL; + } } void VoglEditor::playCurrentTraceFile() @@ -245,71 +321,116 @@ void VoglEditor::playCurrentTraceFile() // update UI m_pPlayButton->setEnabled(false); - m_pPauseButton->setEnabled(true); - m_pTrimButton->setEnabled(true); - m_pStopButton->setEnabled(true); - m_statusLabel->clear(); + m_pTrimButton->setEnabled(false); - if (m_traceReplayer.replay(m_pTraceReader, m_pApicallTreeModel->root(), NULL, 0, true)) + if (m_traceReplayer.replay(m_pTraceReader, m_pApiCallTreeModel->root(), NULL, 0, true)) { // replay was successful m_pPlayButton->setEnabled(true); - m_pPauseButton->setEnabled(false); - m_pTrimButton->setEnabled(false); - m_pStopButton->setEnabled(false); + m_pTrimButton->setEnabled(true); } else { - m_statusLabel->setText("Failed to replay the trace."); + vogleditor_output_error("Failed to replay the trace."); } setCursor(origCursor); } -void VoglEditor::pauseCurrentTraceFile() +void VoglEditor::trimCurrentTraceFile() +{ + trim_trace_file(m_openFilename, static_cast(m_pTraceReader->get_max_frame_index()), g_settings.trim_large_trace_prompt_size()); +} + +/// \return True if the new trim file is now open in the editor +/// \return False if there was an error, or the user elected NOT to open the new trim file +bool VoglEditor::trim_trace_file(QString filename, uint maxFrameIndex, uint maxAllowedTrimLen) { - if (m_traceReplayer.pause()) + // open a dialog to gather parameters for the replayer + vogleditor_QTrimDialog trimDialog(filename, maxFrameIndex, maxAllowedTrimLen, this); + int code = trimDialog.exec(); + + if (code == QDialog::Rejected) { - // update UI - m_pPlayButton->setEnabled(true); - m_pPauseButton->setEnabled(false); - m_pTrimButton->setEnabled(true); - m_pStopButton->setEnabled(true); - m_statusLabel->clear(); + return false; } - else + + QStringList arguments; + arguments << "--trim_frame" << trimDialog.trim_frame() << "--trim_len" << trimDialog.trim_len() << "--trim_file" << trimDialog.trim_file() << filename; + +#ifdef __i386__ + QString executable = "./voglreplay32"; +#else + QString executable = "./voglreplay64"; +#endif + + QString cmdLine = executable + " " + arguments.join(" "); + + vogleditor_output_message("Trimming trace file"); + vogleditor_output_message(cmdLine.toStdString().c_str()); + m_pVoglReplayProcess->start(executable, arguments); + if (m_pVoglReplayProcess->waitForStarted() == false) { - m_statusLabel->setText("Failed to pause the trace replay."); + vogleditor_output_error("voglreplay could not be executed."); + return false; } -} -void VoglEditor::trimCurrentTraceFile() -{ - if (m_traceReplayer.trim()) + // This is a bad idea as it will wait forever, + // but if the replay is taking forever then we have bigger problems. + if(m_pVoglReplayProcess->waitForFinished(-1)) { - m_statusLabel->clear(); + vogleditor_output_message("Trim Completed!"); + } + + int procRetValue = m_pVoglReplayProcess->exitCode(); + + bool bCompleted = false; + if (procRetValue == -2) + { + // proc failed to starts + vogleditor_output_error("voglreplay could not be executed."); + } + else if (procRetValue == -1) + { + // proc crashed + vogleditor_output_error("voglreplay aborted unexpectedly."); + } + else if (procRetValue == 0) + { + // success + bCompleted = true; } else { - m_statusLabel->setText("Failed to trim the trace replay."); + // some other return value + bCompleted = false; } -} -void VoglEditor::stopCurrentTraceFile() -{ - if (m_traceReplayer.stop()) + if (bCompleted) { - // update UI - m_pPlayButton->setEnabled(true); - m_pPauseButton->setEnabled(false); - m_pTrimButton->setEnabled(false); - m_pStopButton->setEnabled(false); - m_statusLabel->clear(); + int ret = QMessageBox::warning(this, tr("Trim Trace"), tr("Would you like to load the new trimmed trace file?"), + QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes); + + if (ret == QMessageBox::Yes) + { + close_trace_file(); + if (open_trace_file(trimDialog.trim_file().toStdString().c_str())) + { + return true; + } + else + { + vogleditor_output_error("Could not open trace file."); + QMessageBox::critical(this, tr("Error"), tr("Could not open trace file.")); + } + } } else { - m_statusLabel->setText("Failed to stop the trace replay."); + vogleditor_output_error("Failed to trim the trace file."); + QMessageBox::critical(this, tr("Error"), tr("Failed to trim the trace file.")); } + return false; } void VoglEditor::on_actionE_xit_triggered() @@ -320,14 +441,14 @@ void VoglEditor::on_actionE_xit_triggered() void VoglEditor::on_action_Open_triggered() { QString fileName = QFileDialog::getOpenFileName(this, tr("Open File"), QString(), - tr("GLI Binary Files (*.bin);;JSON Files (*.json)")); + tr("VOGL Binary Files (*.bin);;VOGL JSON Files (*.json)")); if (!fileName.isEmpty()) { vogl::dynamic_string filename; filename.set(fileName.toStdString().c_str()); if (open_trace_file(filename) == false) { - QMessageBox::critical(this, tr("Error"), tr("Could not open file")); + QMessageBox::critical(this, tr("Error"), tr("Could not open trace file.")); return; } } @@ -342,6 +463,8 @@ void VoglEditor::close_trace_file() { if (m_pTraceReader != NULL) { + vogleditor_output_message("Closing trace file."); + vogleditor_output_message("-------------------"); m_pTraceReader->close(); vogl_delete(m_pTraceReader); m_pTraceReader = NULL; @@ -365,6 +488,12 @@ void VoglEditor::close_trace_file() delete m_pTimelineModel; m_pTimelineModel = NULL; } + + if (m_pApiCallTreeModel != NULL) + { + delete m_pApiCallTreeModel; + m_pApiCallTreeModel = NULL; + } } } @@ -558,7 +687,7 @@ bool VoglEditor::load_session_from_disk(QString sessionFile) if (callIndex.is_valid()) { // the snapshot is associated with an api call - vogleditor_apiCallTreeItem* pItem = m_pApicallTreeModel->find_call_number(callIndex.as_uint64()); + vogleditor_apiCallTreeItem* pItem = m_pApiCallTreeModel->find_call_number(callIndex.as_uint64()); if (pItem != NULL) { pItem->set_snapshot(pContainer); @@ -578,7 +707,7 @@ bool VoglEditor::load_session_from_disk(QString sessionFile) // If we allow NULL snapshots, that we could accidently remove the initial snapshot that was loaded with the trace file. if (pSnapshot != NULL) { - vogleditor_apiCallTreeItem* pItem = m_pApicallTreeModel->find_frame_number(frameNumber.as_uint64()); + vogleditor_apiCallTreeItem* pItem = m_pApiCallTreeModel->find_frame_number(frameNumber.as_uint64()); if (pItem != NULL) { pItem->set_snapshot(pContainer); @@ -700,7 +829,7 @@ bool VoglEditor::save_session_to_disk(QString sessionFile) sessionDataNode.add_key_value("rel_path", sessionDataFolder.toStdString().c_str()); json_node& snapshotArray = sessionDataNode.add_array("snapshots"); - vogleditor_apiCallTreeItem* pItem = m_pApicallTreeModel->find_next_snapshot(NULL); + vogleditor_apiCallTreeItem* pItem = m_pApiCallTreeModel->find_next_snapshot(NULL); vogleditor_apiCallTreeItem* pLastItem = NULL; bool bSavedSuccessfully = true; while (pItem != pLastItem && pItem != NULL) @@ -755,7 +884,7 @@ bool VoglEditor::save_session_to_disk(QString sessionFile) } pLastItem = pItem; - pItem = m_pApicallTreeModel->find_next_snapshot(pLastItem); + pItem = m_pApiCallTreeModel->find_next_snapshot(pLastItem); } if (bSavedSuccessfully) @@ -913,7 +1042,6 @@ vogl_gl_state_snapshot* VoglEditor::read_state_snapshot_from_trace(vogl_trace_fi return pSnapshot; } - bool VoglEditor::open_trace_file(dynamic_string filename) { QCursor origCursor = this->cursor(); @@ -925,18 +1053,45 @@ bool VoglEditor::open_trace_file(dynamic_string filename) dynamic_string actual_keyframe_filename; + vogleditor_output_message("*********************"); + vogleditor_output_message("Opening trace file..."); + vogleditor_output_message(filename.c_str()); + vogl_trace_file_reader* tmpReader = vogl_open_trace_file(filename, actual_keyframe_filename, NULL); if (tmpReader == NULL) { - m_statusLabel->setText("Failed to open: "); - m_statusLabel->setText(m_statusLabel->text().append(filename.c_str())); + vogleditor_output_error("Unable to open trace file."); this->setCursor(origCursor); return false; } else { - m_statusLabel->clear(); + vogleditor_output_message("... success!"); + } + + if (tmpReader->get_max_frame_index() > g_settings.trim_large_trace_prompt_size()) + { + int ret = QMessageBox::warning(this, tr(g_PROJECT_NAME.toStdString().c_str()), tr("The loaded trace file has many frames and debugging may be difficult.\nWould you like to trim the trace?"), + QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes); + + if (ret == QMessageBox::Yes) + { + if (trim_trace_file(filename.c_str(), static_cast(tmpReader->get_max_frame_index()), g_settings.trim_large_trace_prompt_size())) + { + // user decided to open the new trim file, and the UI should already be updated + // clean up here and return + vogl_delete(tmpReader); + this->setCursor(origCursor); + return true; + } + else + { + // either there was an error, or the user decided NOT to open the trim file, + // so continue to load the original file + vogleditor_output_warning("Large trace files may be difficult to debug."); + } + } } // now that we know the new trace file can be opened, @@ -947,19 +1102,18 @@ bool VoglEditor::open_trace_file(dynamic_string filename) vogl_ctypes trace_ctypes; trace_ctypes.init(m_pTraceReader->get_sof_packet().m_pointer_sizes); - m_pApicallTreeModel = new vogleditor_QApiCallTreeModel(m_pTraceReader); - ui->treeView->setModel(m_pApicallTreeModel); + m_pApiCallTreeModel = new vogleditor_QApiCallTreeModel(m_pTraceReader); + ui->treeView->setModel(m_pApiCallTreeModel); if (ui->treeView->selectionModel() != NULL) { - //connect(ui->treeView->selectionModel(), SIGNAL(selectionChanged(const QItemSelection&, const QItemSelection&)), this, SLOT(on_treeView_selectionChanged(const QItemSelection&, const QItemSelection&))); - connect(ui->treeView->selectionModel(), SIGNAL(currentChanged(const QModelIndex &, const QModelIndex &)), this, SLOT(on_treeView_currentChanged(const QModelIndex &, const QModelIndex &))); + connect(ui->treeView->selectionModel(), SIGNAL(currentChanged(const QModelIndex &, const QModelIndex &)), this, SLOT(slot_treeView_currentChanged(const QModelIndex &, const QModelIndex &))); } - if (m_pApicallTreeModel->hasChildren()) + if (m_pApiCallTreeModel->hasChildren()) { - ui->treeView->setExpanded(m_pApicallTreeModel->index(0,0), true); - ui->treeView->setCurrentIndex(m_pApicallTreeModel->index(0,0)); + ui->treeView->setExpanded(m_pApiCallTreeModel->index(0,0), true); + ui->treeView->setCurrentIndex(m_pApiCallTreeModel->index(0,0)); } int flagsColumnWidth = 30; @@ -1017,20 +1171,22 @@ bool VoglEditor::open_trace_file(dynamic_string filename) } } - QList backtraceSplitterSizes = ui->splitter_3->sizes(); - int backtraceSplitterTotalSize = backtraceSplitterSizes[0] + backtraceSplitterSizes[1]; - QList newBacktraceSplitterSizes; - if (!bBacktraceVisible) + if (bBacktraceVisible) { - newBacktraceSplitterSizes.append(backtraceSplitterTotalSize); - newBacktraceSplitterSizes.append(0); - ui->splitter_3->setSizes(newBacktraceSplitterSizes); + if (ui->bottomTabWidget->indexOf(ui->callStackTab) == -1) + { + // unhide the tab + ui->bottomTabWidget->insertTab(1, ui->callStackTab, "Call Stack"); + VOGLEDITOR_ENABLE_BOTTOM_TAB(ui->callStackTab); + } + else + { + VOGLEDITOR_ENABLE_BOTTOM_TAB(ui->callStackTab); + } } else { - newBacktraceSplitterSizes << (backtraceSplitterTotalSize * 0.75) - << (backtraceSplitterTotalSize * 0.25); - ui->splitter_3->setSizes(newBacktraceSplitterSizes); + ui->bottomTabWidget->removeTab(ui->bottomTabWidget->indexOf(ui->callStackTab)); } // machine info @@ -1045,12 +1201,10 @@ bool VoglEditor::open_trace_file(dynamic_string filename) // update toolbar m_pPlayButton->setEnabled(true); - m_pPauseButton->setEnabled(false); - m_pTrimButton->setEnabled(false); - m_pStopButton->setEnabled(false); + m_pTrimButton->setEnabled(true); // timeline - m_pTimelineModel = new vogleditor_apiCallTimelineModel(m_pApicallTreeModel->root()); + m_pTimelineModel = new vogleditor_apiCallTimelineModel(m_pApiCallTreeModel->root()); m_timeline->setModel(m_pTimelineModel); m_timeline->repaint(); @@ -1144,6 +1298,10 @@ void VoglEditor::displayMachineInfoHelper(QString prefix, const QString& section void VoglEditor::displayMachineInfo() { VOGL_ASSERT(m_pTraceReader != NULL); + if (m_pTraceReader == NULL) + { + return; + } bool bMachineInfoVisible = false; if (m_pTraceReader->get_archive_blob_manager().does_exist(VOGL_TRACE_ARCHIVE_MACHINE_INFO_FILENAME)) @@ -1174,19 +1332,20 @@ void VoglEditor::displayMachineInfo() if (bMachineInfoVisible) { - if (ui->tabWidget->indexOf(ui->machineInfoTab) == -1) + if (ui->bottomTabWidget->indexOf(ui->machineInfoTab) == -1) { // unhide the tab - ui->tabWidget->insertTab(0, ui->machineInfoTab, "Machine Info"); + ui->bottomTabWidget->insertTab(1, ui->machineInfoTab, "Machine Info"); + VOGLEDITOR_ENABLE_BOTTOM_TAB(ui->machineInfoTab); } else { - VOGLEDITOR_ENABLE_TAB(ui->machineInfoTab); + VOGLEDITOR_ENABLE_BOTTOM_TAB(ui->machineInfoTab); } } else { - ui->tabWidget->removeTab(ui->tabWidget->indexOf(ui->machineInfoTab)); + ui->bottomTabWidget->removeTab(ui->bottomTabWidget->indexOf(ui->machineInfoTab)); } } @@ -1205,13 +1364,11 @@ void VoglEditor::reset_tracefile_ui() ui->searchPrevButton->setEnabled(false); ui->searchNextButton->setEnabled(false); - m_statusLabel->clear(); m_pPlayButton->setEnabled(false); - m_pPauseButton->setEnabled(false); m_pTrimButton->setEnabled(false); - m_pStopButton->setEnabled(false); - VOGLEDITOR_DISABLE_TAB(ui->machineInfoTab); + VOGLEDITOR_DISABLE_BOTTOM_TAB(ui->machineInfoTab); + VOGLEDITOR_DISABLE_BOTTOM_TAB(ui->callStackTab); reset_snapshot_ui(); } @@ -1220,22 +1377,22 @@ void VoglEditor::reset_snapshot_ui() { m_currentSnapshot = NULL; - m_framebufferExplorer->clear(); - m_textureExplorer->clear(); - m_renderbufferExplorer->clear(); - m_programExplorer->clear(); - m_shaderExplorer->clear(); + m_pFramebufferExplorer->clear(); + m_pTextureExplorer->clear(); + m_pRenderbufferExplorer->clear(); + m_pProgramExplorer->clear(); + m_pShaderExplorer->clear(); ui->stateTreeView->setModel(NULL); QWidget* pCurrentTab = ui->tabWidget->currentWidget(); - VOGLEDITOR_DISABLE_TAB(ui->stateTab); - VOGLEDITOR_DISABLE_TAB(ui->framebufferTab); - VOGLEDITOR_DISABLE_TAB(ui->programTab); - VOGLEDITOR_DISABLE_TAB(ui->shaderTab); - VOGLEDITOR_DISABLE_TAB(ui->textureTab); - VOGLEDITOR_DISABLE_TAB(ui->renderbufferTab); + VOGLEDITOR_DISABLE_STATE_TAB(ui->stateTab); + VOGLEDITOR_DISABLE_STATE_TAB(ui->framebufferTab); + VOGLEDITOR_DISABLE_STATE_TAB(ui->programTab); + VOGLEDITOR_DISABLE_STATE_TAB(ui->shaderTab); + VOGLEDITOR_DISABLE_STATE_TAB(ui->textureTab); + VOGLEDITOR_DISABLE_STATE_TAB(ui->renderbufferTab); ui->tabWidget->setCurrentWidget(pCurrentTab); } @@ -1330,18 +1487,22 @@ void VoglEditor::update_ui_for_snapshot(vogleditor_gl_state_snapshot* pStateSnap this->setCursor(Qt::WaitCursor); // state viewer - vogleditor_QStateTreeModel* pStateModel = new vogleditor_QStateTreeModel(NULL); + if (m_pStateTreeModel != NULL) + { + delete m_pStateTreeModel; + } + m_pStateTreeModel = new vogleditor_QStateTreeModel(NULL); - vogleditor_gl_state_snapshot* pBaseSnapshot = findMostRecentSnapshot(m_pApicallTreeModel->root(), m_currentSnapshot); - pStateModel->set_diff_base_snapshot(pBaseSnapshot); + vogleditor_gl_state_snapshot* pBaseSnapshot = findMostRecentSnapshot(m_pApiCallTreeModel->root(), m_currentSnapshot); + m_pStateTreeModel->set_diff_base_snapshot(pBaseSnapshot); - pStateModel->set_snapshot(pStateSnapshot); + m_pStateTreeModel->set_snapshot(pStateSnapshot); - ui->stateTreeView->setModel(pStateModel); + ui->stateTreeView->setModel(m_pStateTreeModel); ui->stateTreeView->expandToDepth(1); ui->stateTreeView->setColumnWidth(0, ui->stateTreeView->width() * 0.5); - VOGLEDITOR_ENABLE_TAB(ui->stateTab); + VOGLEDITOR_ENABLE_STATE_TAB(ui->stateTab); if (pStateSnapshot->get_contexts().size() > 0) { @@ -1353,7 +1514,7 @@ void VoglEditor::update_ui_for_snapshot(vogleditor_gl_state_snapshot* pStateSnap // textures vogl_gl_object_state_ptr_vec textureObjects; pContext->get_all_objects_of_category(cGLSTTexture, textureObjects); - m_textureExplorer->set_texture_objects(textureObjects); + m_pTextureExplorer->set_texture_objects(textureObjects); GLuint curActiveTextureUnit = pContext->get_general_state().get_value(GL_ACTIVE_TEXTURE); if (curActiveTextureUnit >= GL_TEXTURE0 && curActiveTextureUnit < (GL_TEXTURE0 + pContext->get_context_info().get_max_texture_image_units())) @@ -1365,28 +1526,28 @@ void VoglEditor::update_ui_for_snapshot(vogleditor_gl_state_snapshot* pStateSnap // renderbuffers vogl_gl_object_state_ptr_vec renderbufferObjects; pContext->get_all_objects_of_category(cGLSTRenderbuffer, renderbufferObjects); - m_renderbufferExplorer->set_texture_objects(renderbufferObjects); - if (renderbufferObjects.size() > 0) { VOGLEDITOR_ENABLE_TAB(ui->renderbufferTab); } + m_pRenderbufferExplorer->set_texture_objects(renderbufferObjects); + if (renderbufferObjects.size() > 0) { VOGLEDITOR_ENABLE_STATE_TAB(ui->renderbufferTab); } // framebuffer vogl_gl_object_state_ptr_vec framebufferObjects; pContext->get_all_objects_of_category(cGLSTFramebuffer, framebufferObjects); - m_framebufferExplorer->set_framebuffer_objects(framebufferObjects, *pContext, pStateSnapshot->get_default_framebuffer()); + m_pFramebufferExplorer->set_framebuffer_objects(framebufferObjects, *pContext, pStateSnapshot->get_default_framebuffer()); GLuint64 curDrawFramebuffer = pContext->get_general_state().get_value(GL_DRAW_FRAMEBUFFER_BINDING); displayFramebuffer(curDrawFramebuffer, false); // programs vogl_gl_object_state_ptr_vec programObjects; pContext->get_all_objects_of_category(cGLSTProgram, programObjects); - m_programExplorer->set_program_objects(programObjects); + m_pProgramExplorer->set_program_objects(programObjects); GLuint64 curProgram = pContext->get_general_state().get_value(GL_CURRENT_PROGRAM); - m_programExplorer->set_active_program(curProgram); - if (programObjects.size() > 0) { VOGLEDITOR_ENABLE_TAB(ui->programTab); } + m_pProgramExplorer->set_active_program(curProgram); + if (programObjects.size() > 0) { VOGLEDITOR_ENABLE_STATE_TAB(ui->programTab); } // shaders vogl_gl_object_state_ptr_vec shaderObjects; pContext->get_all_objects_of_category(cGLSTShader, shaderObjects); - m_shaderExplorer->set_shader_objects(shaderObjects); + m_pShaderExplorer->set_shader_objects(shaderObjects); if (curProgram != 0) { for (vogl_gl_object_state_ptr_vec::iterator iter = programObjects.begin(); iter != programObjects.end(); iter++) @@ -1397,13 +1558,13 @@ void VoglEditor::update_ui_for_snapshot(vogleditor_gl_state_snapshot* pStateSnap if (pProgramState->get_attached_shaders().size() > 0) { uint curShader = pProgramState->get_attached_shaders()[0]; - m_shaderExplorer->set_active_shader(curShader); + m_pShaderExplorer->set_active_shader(curShader); } break; } } } - if (shaderObjects.size() > 0) { VOGLEDITOR_ENABLE_TAB(ui->shaderTab); } + if (shaderObjects.size() > 0) { VOGLEDITOR_ENABLE_STATE_TAB(ui->shaderTab); } } } @@ -1478,7 +1639,7 @@ void VoglEditor::on_stateTreeView_clicked(const QModelIndex &index) bool VoglEditor::displayShader(GLuint64 shaderHandle, bool bBringTabToFront) { bool bDisplayed = false; - if (m_shaderExplorer->set_active_shader(shaderHandle)) + if (m_pShaderExplorer->set_active_shader(shaderHandle)) { if (bBringTabToFront) { @@ -1491,7 +1652,7 @@ bool VoglEditor::displayShader(GLuint64 shaderHandle, bool bBringTabToFront) void VoglEditor::displayProgram(GLuint64 programHandle, bool bBringTabToFront) { - if (m_programExplorer->set_active_program(programHandle)) + if (m_pProgramExplorer->set_active_program(programHandle)) { if (bBringTabToFront) { @@ -1502,11 +1663,11 @@ void VoglEditor::displayProgram(GLuint64 programHandle, bool bBringTabToFront) void VoglEditor::displayFramebuffer(GLuint64 framebufferHandle, bool bBringTabToFront) { - bool bDisplayedFBO = m_framebufferExplorer->set_active_framebuffer(framebufferHandle); + bool bDisplayedFBO = m_pFramebufferExplorer->set_active_framebuffer(framebufferHandle); if (bDisplayedFBO) { - VOGLEDITOR_ENABLE_TAB(ui->framebufferTab); + VOGLEDITOR_ENABLE_STATE_TAB(ui->framebufferTab); if (bBringTabToFront) { ui->tabWidget->setCurrentWidget(ui->framebufferTab); @@ -1516,11 +1677,11 @@ void VoglEditor::displayFramebuffer(GLuint64 framebufferHandle, bool bBringTabTo bool VoglEditor::displayTexture(GLuint64 textureHandle, bool bBringTabToFront) { - bool bDisplayedTexture = m_textureExplorer->set_active_texture(textureHandle); + bool bDisplayedTexture = m_pTextureExplorer->set_active_texture(textureHandle); if (bDisplayedTexture) { - VOGLEDITOR_ENABLE_TAB(ui->textureTab); + VOGLEDITOR_ENABLE_STATE_TAB(ui->textureTab); if (bBringTabToFront) { ui->tabWidget->setCurrentWidget(ui->textureTab); @@ -1530,7 +1691,7 @@ bool VoglEditor::displayTexture(GLuint64 textureHandle, bool bBringTabToFront) return bDisplayedTexture; } -void VoglEditor::on_treeView_currentChanged(const QModelIndex & current, const QModelIndex & previous) +void VoglEditor::slot_treeView_currentChanged(const QModelIndex & current, const QModelIndex & previous) { VOGL_NOTE_UNUSED(previous); onApiCallSelected(current, false); @@ -1561,7 +1722,7 @@ void VoglEditor::onApiCallSelected(const QModelIndex &index, bool bAllowStateSna vogleditor_gl_state_snapshot* pNewSnapshot = NULL; QCursor origCursor = cursor(); setCursor(Qt::WaitCursor); - m_traceReplayer.replay(m_pTraceReader, m_pApicallTreeModel->root(), &pNewSnapshot, pApiCallItem->globalCallIndex(), false); + m_traceReplayer.replay(m_pTraceReader, m_pApiCallTreeModel->root(), &pNewSnapshot, pApiCallItem->globalCallIndex(), false); setCursor(origCursor); pCallTreeItem->set_snapshot(pNewSnapshot); } @@ -1642,9 +1803,9 @@ void VoglEditor::on_searchTextBox_textChanged(const QString &searchText) palette.setColor(QPalette::Base, m_searchTextboxBackgroundColor); ui->searchTextBox->setPalette(palette); - if (m_pApicallTreeModel != NULL) + if (m_pApiCallTreeModel != NULL) { - m_pApicallTreeModel->set_highlight_search_string(searchText); + m_pApiCallTreeModel->set_highlight_search_string(searchText); } // need to briefly give the treeview focus so that it properly redraws and highlights the matching rows @@ -1655,9 +1816,9 @@ void VoglEditor::on_searchTextBox_textChanged(const QString &searchText) void VoglEditor::on_searchNextButton_clicked() { - if (m_pApicallTreeModel != NULL) + if (m_pApiCallTreeModel != NULL) { - QModelIndex index = m_pApicallTreeModel->find_next_search_result(m_pCurrentCallTreeItem, ui->searchTextBox->text()); + QModelIndex index = m_pApiCallTreeModel->find_next_search_result(m_pCurrentCallTreeItem, ui->searchTextBox->text()); if (index.isValid()) { selectApicallModelIndex(index, true, true); @@ -1668,9 +1829,9 @@ void VoglEditor::on_searchNextButton_clicked() void VoglEditor::on_searchPrevButton_clicked() { - if (m_pApicallTreeModel != NULL) + if (m_pApiCallTreeModel != NULL) { - QModelIndex index = m_pApicallTreeModel->find_prev_search_result(m_pCurrentCallTreeItem, ui->searchTextBox->text()); + QModelIndex index = m_pApiCallTreeModel->find_prev_search_result(m_pCurrentCallTreeItem, ui->searchTextBox->text()); if (index.isValid()) { selectApicallModelIndex(index, true, true); @@ -1681,12 +1842,12 @@ void VoglEditor::on_searchPrevButton_clicked() void VoglEditor::on_prevSnapshotButton_clicked() { - if (m_pApicallTreeModel != NULL) + if (m_pApiCallTreeModel != NULL) { - vogleditor_apiCallTreeItem* pPrevItemWithSnapshot = m_pApicallTreeModel->find_prev_snapshot(m_pCurrentCallTreeItem); + vogleditor_apiCallTreeItem* pPrevItemWithSnapshot = m_pApiCallTreeModel->find_prev_snapshot(m_pCurrentCallTreeItem); if (pPrevItemWithSnapshot != NULL) { - selectApicallModelIndex(m_pApicallTreeModel->indexOf(pPrevItemWithSnapshot), true, true); + selectApicallModelIndex(m_pApiCallTreeModel->indexOf(pPrevItemWithSnapshot), true, true); ui->treeView->setFocus(); } } @@ -1694,12 +1855,12 @@ void VoglEditor::on_prevSnapshotButton_clicked() void VoglEditor::on_nextSnapshotButton_clicked() { - if (m_pApicallTreeModel != NULL) + if (m_pApiCallTreeModel != NULL) { - vogleditor_apiCallTreeItem* pNextItemWithSnapshot = m_pApicallTreeModel->find_next_snapshot(m_pCurrentCallTreeItem); + vogleditor_apiCallTreeItem* pNextItemWithSnapshot = m_pApiCallTreeModel->find_next_snapshot(m_pCurrentCallTreeItem); if (pNextItemWithSnapshot != NULL) { - selectApicallModelIndex(m_pApicallTreeModel->indexOf(pNextItemWithSnapshot), true, true); + selectApicallModelIndex(m_pApiCallTreeModel->indexOf(pNextItemWithSnapshot), true, true); ui->treeView->setFocus(); } } @@ -1707,12 +1868,12 @@ void VoglEditor::on_nextSnapshotButton_clicked() void VoglEditor::on_prevDrawcallButton_clicked() { - if (m_pApicallTreeModel != NULL) + if (m_pApiCallTreeModel != NULL) { - vogleditor_apiCallTreeItem* pPrevItem = m_pApicallTreeModel->find_prev_drawcall(m_pCurrentCallTreeItem); + vogleditor_apiCallTreeItem* pPrevItem = m_pApiCallTreeModel->find_prev_drawcall(m_pCurrentCallTreeItem); if (pPrevItem != NULL) { - selectApicallModelIndex(m_pApicallTreeModel->indexOf(pPrevItem), true, true); + selectApicallModelIndex(m_pApiCallTreeModel->indexOf(pPrevItem), true, true); ui->treeView->setFocus(); } } @@ -1720,18 +1881,18 @@ void VoglEditor::on_prevDrawcallButton_clicked() void VoglEditor::on_nextDrawcallButton_clicked() { - if (m_pApicallTreeModel != NULL) + if (m_pApiCallTreeModel != NULL) { - vogleditor_apiCallTreeItem* pNextItem = m_pApicallTreeModel->find_next_drawcall(m_pCurrentCallTreeItem); + vogleditor_apiCallTreeItem* pNextItem = m_pApiCallTreeModel->find_next_drawcall(m_pCurrentCallTreeItem); if (pNextItem != NULL) { - selectApicallModelIndex(m_pApicallTreeModel->indexOf(pNextItem), true, true); + selectApicallModelIndex(m_pApiCallTreeModel->indexOf(pNextItem), true, true); ui->treeView->setFocus(); } } } -void VoglEditor::on_program_edited(vogl_program_state* pNewProgramState) +void VoglEditor::slot_program_edited(vogl_program_state* pNewProgramState) { VOGL_NOTE_UNUSED(pNewProgramState); @@ -1739,7 +1900,7 @@ void VoglEditor::on_program_edited(vogl_program_state* pNewProgramState) // update all the snapshot flags bool bFoundEditedSnapshot = false; - recursive_update_snapshot_flags(m_pApicallTreeModel->root(), bFoundEditedSnapshot); + recursive_update_snapshot_flags(m_pApiCallTreeModel->root(), bFoundEditedSnapshot); // give the tree view focus so that it redraws. This is something of a hack, we don't really want to be changing around which control has focus, // but right now I don't see it being a major issue. It may be an issue later on depending on how we implement more state editing (ie, if arrow @@ -1777,8 +1938,11 @@ void VoglEditor::recursive_update_snapshot_flags(vogleditor_apiCallTreeItem* pIt } } -#undef VOGLEDITOR_DISABLE_TAB -#undef VOGLEDITOR_ENABLE_TAB +#undef VOGLEDITOR_DISABLE_STATE_TAB +#undef VOGLEDITOR_ENABLE_STATE_TAB + +#undef VOGLEDITOR_DISABLE_BOTTOM_TAB +#undef VOGLEDITOR_ENABLE_BOTTOM_TAB void VoglEditor::on_actionSave_Session_triggered() { @@ -1796,7 +1960,7 @@ void VoglEditor::on_actionSave_Session_triggered() if (!save_session_to_disk(sessionFilename)) { - m_statusLabel->setText("ERROR: Failed to save session"); + vogleditor_output_error("Failed to save session."); } } @@ -1809,7 +1973,7 @@ void VoglEditor::on_actionOpen_Session_triggered() if (!load_session_from_disk(sessionFilename)) { - m_statusLabel->setText("ERROR: Failed to load session"); + vogleditor_output_error("Failed to load session."); } setCursor(origCursor); @@ -1817,9 +1981,9 @@ void VoglEditor::on_actionOpen_Session_triggered() void VoglEditor::on_searchTextBox_returnPressed() { - if (m_pApicallTreeModel != NULL) + if (m_pApiCallTreeModel != NULL) { - QModelIndex index = m_pApicallTreeModel->find_next_search_result(m_pCurrentCallTreeItem, ui->searchTextBox->text()); + QModelIndex index = m_pApiCallTreeModel->find_next_search_result(m_pCurrentCallTreeItem, ui->searchTextBox->text()); if (index.isValid()) { // a valid item was found, scroll to it and select it @@ -1834,3 +1998,31 @@ void VoglEditor::on_searchTextBox_returnPressed() } } } + +void VoglEditor::slot_readReplayStandardOutput() +{ + m_pVoglReplayProcess->setReadChannel(QProcess::StandardOutput); + while (m_pVoglReplayProcess->canReadLine()) + { + QByteArray output = m_pVoglReplayProcess->readLine(); + if (output.endsWith("\n")) + { + output.remove(output.size() - 1, 1); + } + vogleditor_output_message(output.constData()); + } +} + +void VoglEditor::slot_readReplayStandardError() +{ + m_pVoglReplayProcess->setReadChannel(QProcess::StandardError); + while (m_pVoglReplayProcess->canReadLine()) + { + QByteArray output = m_pVoglReplayProcess->readLine(); + if (output.endsWith("\n")) + { + output.remove(output.size() - 1, 1); + } + vogleditor_output_error(output.constData()); + } +} diff --git a/src/vogleditor/vogleditor.h b/src/vogleditor/vogleditor.h index 30ffd58..647877e 100644 --- a/src/vogleditor/vogleditor.h +++ b/src/vogleditor/vogleditor.h @@ -51,6 +51,7 @@ class vogleditor_QTextureExplorer; class QItemSelection; class QModelIndex; +class QProcess; class QSortFilterProxyModel; class QToolButton; class vogl_context_snapshot; @@ -67,6 +68,7 @@ class vogleditor_apiCallTimelineModel; class vogleditor_apiCallTreeItem; class vogleditor_gl_state_snapshot; class vogleditor_QApiCallTreeModel; +class vogleditor_QStateTreeModel; class VoglEditor : public QMainWindow { @@ -85,14 +87,14 @@ private slots: void on_actionE_xit_triggered(); void on_actionExport_API_Calls_triggered(); - void on_treeView_currentChanged(const QModelIndex & current, const QModelIndex & previous); + void slot_treeView_currentChanged(const QModelIndex & current, const QModelIndex & previous); void on_treeView_clicked(const QModelIndex& index); void playCurrentTraceFile(); - void pauseCurrentTraceFile(); void trimCurrentTraceFile(); - void stopCurrentTraceFile(); + + bool trim_trace_file(QString filename, uint maxFrameIndex, uint maxAllowedTrimLen); void on_stateTreeView_clicked(const QModelIndex &index); @@ -104,7 +106,7 @@ private slots: void on_prevDrawcallButton_clicked(); void on_nextDrawcallButton_clicked(); - void on_program_edited(vogl_program_state* pNewProgramState); + void slot_program_edited(vogl_program_state* pNewProgramState); void on_actionSave_Session_triggered(); @@ -112,6 +114,9 @@ private slots: void on_searchTextBox_returnPressed(); + void slot_readReplayStandardOutput(); + void slot_readReplayStandardError(); + private: Ui::VoglEditor* ui; @@ -144,21 +149,25 @@ private: bool save_snapshot_to_disk(vogl_gl_state_snapshot* pSnapshot, dynamic_string filename, vogl_blob_manager *pBlob_manager); QString m_openFilename; - QLabel* m_statusLabel; - vogleditor_QFramebufferExplorer* m_framebufferExplorer; - vogleditor_QTextureExplorer* m_textureExplorer; - vogleditor_QTextureExplorer* m_renderbufferExplorer; - vogleditor_QProgramExplorer* m_programExplorer; - vogleditor_QShaderExplorer* m_shaderExplorer; + vogleditor_QFramebufferExplorer* m_pFramebufferExplorer; + vogleditor_QTextureExplorer* m_pTextureExplorer; + vogleditor_QTextureExplorer* m_pRenderbufferExplorer; + vogleditor_QProgramExplorer* m_pProgramExplorer; + vogleditor_QShaderExplorer* m_pShaderExplorer; vogleditor_QTimelineView* m_timeline; + QGridLayout* m_pFramebufferTab_layout; + QGridLayout* m_pTextureTab_layout; + QGridLayout* m_pRenderbufferTab_layout; + QGridLayout* m_pProgramTab_layout; + QGridLayout* m_pShaderTab_layout; + vogleditor_gl_state_snapshot* m_currentSnapshot; vogleditor_apiCallTreeItem* m_pCurrentCallTreeItem; + QProcess* m_pVoglReplayProcess; QToolButton* m_pPlayButton; - QToolButton* m_pPauseButton; QToolButton* m_pTrimButton; - QToolButton* m_pStopButton; vogleditor_traceReplayer m_traceReplayer; vogl_trace_file_reader* m_pTraceReader; @@ -166,8 +175,9 @@ private: vogl::hash_map m_backtraceToJsonMap; vogleditor_apiCallTimelineModel* m_pTimelineModel; + vogleditor_QApiCallTreeModel* m_pApiCallTreeModel; + vogleditor_QStateTreeModel* m_pStateTreeModel; - vogleditor_QApiCallTreeModel* m_pApicallTreeModel; QColor m_searchTextboxBackgroundColor; }; diff --git a/src/vogleditor/vogleditor.ui b/src/vogleditor/vogleditor.ui index 278d2ba..863eec2 100644 --- a/src/vogleditor/vogleditor.ui +++ b/src/vogleditor/vogleditor.ui @@ -14,7 +14,7 @@ Vogl Editor - + @@ -233,22 +233,8 @@ QTabWidget::Rounded - 1 + 0 - - - Machine Info - - - - - - QTextEdit::NoWrap - - - - - State @@ -297,7 +283,7 @@ - + 0 @@ -310,9 +296,71 @@ 100 - - QTextEdit::NoWrap + + QTabWidget::North + + + QTabWidget::Rounded + + + 0 + + + Output + + + + + + true + + + + + + + + Machine Info + + + + + + QTextEdit::NoWrap + + + + + machineInfoText + machineInfoText + + + + Call Stack + + + + + + + 0 + 100 + + + + + 0 + 100 + + + + QTextEdit::NoWrap + + + + + diff --git a/src/vogleditor/vogleditor_apicalltreeitem.cpp b/src/vogleditor/vogleditor_apicalltreeitem.cpp index 3fd2d7f..e616f0f 100644 --- a/src/vogleditor/vogleditor_apicalltreeitem.cpp +++ b/src/vogleditor/vogleditor_apicalltreeitem.cpp @@ -99,19 +99,19 @@ vogleditor_apiCallTreeItem::~vogleditor_apiCallTreeItem() { if (m_pFrameItem != NULL) { - delete m_pFrameItem; + vogl_delete(m_pFrameItem); m_pFrameItem = NULL; } if (m_pApiCallItem != NULL) { - delete m_pApiCallItem; + vogl_delete(m_pApiCallItem); m_pApiCallItem = NULL; } for (int i = 0; i < m_childItems.size(); i++) { - delete m_childItems[i]; + vogl_delete(m_childItems[i]); m_childItems[i] = NULL; } diff --git a/src/vogleditor/vogleditor_frameitem.h b/src/vogleditor/vogleditor_frameitem.h index c35b400..bd26806 100644 --- a/src/vogleditor/vogleditor_frameitem.h +++ b/src/vogleditor/vogleditor_frameitem.h @@ -45,11 +45,6 @@ public: ~vogleditor_frameItem() { - for (int i = 0; i < m_apiCallList.size(); i++) - { - vogl_delete(m_apiCallList[i]); - m_apiCallList[i] = NULL; - } m_apiCallList.clear(); } diff --git a/src/vogleditor/vogleditor_output.cpp b/src/vogleditor/vogleditor_output.cpp new file mode 100644 index 0000000..c96a06d --- /dev/null +++ b/src/vogleditor/vogleditor_output.cpp @@ -0,0 +1,37 @@ +#include "vogleditor_output.h" +#include + +vogleditor_output::vogleditor_output() +{ +} + +vogleditor_output::~vogleditor_output() +{ +} + +void vogleditor_output::message(const char* pMessage) +{ + if (m_pTextEdit != NULL) + { + m_pTextEdit->append(pMessage); + } +} + +void vogleditor_output::warning(const char* pWarning) +{ + if (m_pTextEdit != NULL) + { + m_pTextEdit->append("Warning: "); + m_pTextEdit->append(pWarning); + } +} + + +void vogleditor_output::error(const char* pError) +{ + if (m_pTextEdit != NULL) + { + m_pTextEdit->append("ERROR: "); + m_pTextEdit->append(pError); + } +} diff --git a/src/vogleditor/vogleditor_output.h b/src/vogleditor/vogleditor_output.h new file mode 100644 index 0000000..bbeec1c --- /dev/null +++ b/src/vogleditor/vogleditor_output.h @@ -0,0 +1,30 @@ +#ifndef VOGLEDITOR_OUTPUT_H +#define VOGLEDITOR_OUTPUT_H + +class QTextEdit; + +class vogleditor_output +{ +public: + vogleditor_output(); + ~vogleditor_output(); + + void init(QTextEdit* pTextEdit) { m_pTextEdit = pTextEdit; } + + void message(const char* pMessage); + void warning(const char* pWarning); + void error(const char* pError); + +private: + QTextEdit* m_pTextEdit; +}; + +static vogleditor_output gs_OUTPUT; + +static void vogleditor_output_init(QTextEdit* pTextEdit) { gs_OUTPUT.init(pTextEdit); } +static void vogleditor_output_message(const char* pMessage) { gs_OUTPUT.message(pMessage); } +static void vogleditor_output_warning(const char* pWarning) { gs_OUTPUT.warning(pWarning); } +static void vogleditor_output_error(const char* pError) { gs_OUTPUT.error(pError); } +static void vogleditor_output_deinit() { gs_OUTPUT.init(0); } + +#endif // VOGLEDITOR_OUTPUT_H diff --git a/src/vogleditor/vogleditor_qapicalltreemodel.cpp b/src/vogleditor/vogleditor_qapicalltreemodel.cpp index e661f1c..a3f8ca3 100644 --- a/src/vogleditor/vogleditor_qapicalltreemodel.cpp +++ b/src/vogleditor/vogleditor_qapicalltreemodel.cpp @@ -34,7 +34,7 @@ vogleditor_QApiCallTreeModel::vogleditor_QApiCallTreeModel(vogl_trace_file_reader* reader, QObject *parent) : QAbstractItemModel(parent) { - m_rootItem = new vogleditor_apiCallTreeItem(this); + m_rootItem = vogl_new(vogleditor_apiCallTreeItem, this); setupModelData(reader, m_rootItem); } @@ -42,7 +42,7 @@ vogleditor_QApiCallTreeModel::~vogleditor_QApiCallTreeModel() { if (m_rootItem != NULL) { - delete m_rootItem; + vogl_delete(m_rootItem); m_rootItem = NULL; } @@ -196,7 +196,7 @@ void vogleditor_QApiCallTreeModel::setupModelData(vogl_trace_file_reader* pTrace // and append it to the parent if (pCurFrame == NULL) { - pCurFrame = new vogleditor_frameItem(total_swaps); + pCurFrame = vogl_new(vogleditor_frameItem, total_swaps); vogleditor_apiCallTreeItem* pNewFrameNode = vogl_new(vogleditor_apiCallTreeItem, pCurFrame, pCurParent); pCurParent->appendChild(pNewFrameNode); m_itemList.append(pNewFrameNode); @@ -235,6 +235,16 @@ void vogleditor_QApiCallTreeModel::setupModelData(vogl_trace_file_reader* pTrace // reset the CurFrame so that a new frame node will be created on the next api call pCurFrame = NULL; } + else if (entrypoint_id == VOGL_ENTRYPOINT_glBegin) + { + // items in the glBegin/glEnd block will be nested, including the glEnd + pCurParent = item; + } + else if (entrypoint_id == VOGL_ENTRYPOINT_glEnd) + { + // move the parent back one level of the hierarchy, to its own parent + pCurParent = pCurParent->parent(); + } } if (pTrace_reader->get_packet_type() == cTSPTEOF) @@ -528,7 +538,9 @@ vogleditor_apiCallTreeItem *vogleditor_QApiCallTreeModel::find_prev_drawcall(vog { gl_entrypoint_id_t entrypointId = static_cast(pItem->apiCallItem()->getGLPacket()->m_entrypoint_id); if (vogl_is_draw_entrypoint(entrypointId) || - vogl_is_clear_entrypoint(entrypointId)) + vogl_is_clear_entrypoint(entrypointId) || + (entrypointId == VOGL_ENTRYPOINT_glBitmap) || + (entrypointId == VOGL_ENTRYPOINT_glEnd)) { pFound = iter.peekPrevious(); break; @@ -561,7 +573,9 @@ vogleditor_apiCallTreeItem *vogleditor_QApiCallTreeModel::find_next_drawcall(vog { gl_entrypoint_id_t entrypointId = static_cast(pItem->apiCallItem()->getGLPacket()->m_entrypoint_id); if (vogl_is_draw_entrypoint(entrypointId) || - vogl_is_clear_entrypoint(entrypointId)) + vogl_is_clear_entrypoint(entrypointId) || + (entrypointId == VOGL_ENTRYPOINT_glBitmap) || + (entrypointId == VOGL_ENTRYPOINT_glEnd)) { pFound = iter.peekNext(); break; diff --git a/src/vogleditor/vogleditor_qframebufferexplorer.cpp b/src/vogleditor/vogleditor_qframebufferexplorer.cpp index a67bf28..d24dde7 100644 --- a/src/vogleditor/vogleditor_qframebufferexplorer.cpp +++ b/src/vogleditor/vogleditor_qframebufferexplorer.cpp @@ -316,7 +316,7 @@ void vogleditor_QFramebufferExplorer::selectedFramebufferIndexChanged(int index) (*iter)->setFixedHeight((*iter)->get_preferred_height()); ++viewerIndex; - connect(*iter, SIGNAL(zoomFactorChanged(double)), this, SLOT(on_zoomFactorChanged(double))); + connect(*iter, SIGNAL(zoomFactorChanged(double)), this, SLOT(slot_zoomFactorChanged(double))); } } @@ -335,7 +335,7 @@ void vogleditor_QFramebufferExplorer::selectedFramebufferIndexChanged(int index) m_depthExplorer->set_texture_objects(depthVec); m_depthExplorer->set_active_texture(depthVec[0]->get_snapshot_handle()); } - connect(m_depthExplorer, SIGNAL(zoomFactorChanged(double)), this, SLOT(on_zoomFactorChanged(double))); + connect(m_depthExplorer, SIGNAL(zoomFactorChanged(double)), this, SLOT(slot_zoomFactorChanged(double))); m_depthExplorer->setMinimumHeight(m_depthExplorer->get_preferred_height()); } @@ -354,7 +354,7 @@ void vogleditor_QFramebufferExplorer::selectedFramebufferIndexChanged(int index) m_stencilExplorer->set_texture_objects(stencilVec); m_stencilExplorer->set_active_texture(stencilVec[0]->get_snapshot_handle()); } - connect(m_stencilExplorer, SIGNAL(zoomFactorChanged(double)), this, SLOT(on_zoomFactorChanged(double))); + connect(m_stencilExplorer, SIGNAL(zoomFactorChanged(double)), this, SLOT(slot_zoomFactorChanged(double))); m_stencilExplorer->setMinimumHeight(m_stencilExplorer->get_preferred_height()); } } @@ -403,7 +403,7 @@ vogl_renderbuffer_state* vogleditor_QFramebufferExplorer::get_renderbuffer_attac return pRenderbufferState; } -void vogleditor_QFramebufferExplorer::on_zoomFactorChanged(double zoomFactor) +void vogleditor_QFramebufferExplorer::slot_zoomFactorChanged(double zoomFactor) { VOGL_NOTE_UNUSED(zoomFactor); diff --git a/src/vogleditor/vogleditor_qframebufferexplorer.h b/src/vogleditor/vogleditor_qframebufferexplorer.h index c00025c..b275a34 100644 --- a/src/vogleditor/vogleditor_qframebufferexplorer.h +++ b/src/vogleditor/vogleditor_qframebufferexplorer.h @@ -53,7 +53,7 @@ private: private slots: void selectedFramebufferIndexChanged(int index); - void on_zoomFactorChanged(double zoomFactor); + void slot_zoomFactorChanged(double zoomFactor); }; #endif // VOGLEDITOR_QFRAMEBUFFEREXPLORER_H diff --git a/src/vogleditor/vogleditor_qtrimdialog.cpp b/src/vogleditor/vogleditor_qtrimdialog.cpp new file mode 100644 index 0000000..aeeef6a --- /dev/null +++ b/src/vogleditor/vogleditor_qtrimdialog.cpp @@ -0,0 +1,141 @@ +#include "vogleditor_qtrimdialog.h" +#include "ui_vogleditor_qtrimdialog.h" +#include +#include + +vogleditor_QTrimDialog::vogleditor_QTrimDialog(QString parentTraceFile, uint maxFrameIndex, uint maxTrimLength, QWidget *parent) : + QDialog(parent), + ui(new Ui::vogleditor_QTrimDialog), + m_maxFrameIndex(maxFrameIndex), + m_maxTrimLength(maxTrimLength), + m_trim_frame("0"), + m_trim_len("1") +{ + ui->setupUi(this); + ui->trimFrameLineEdit->setText(m_trim_frame); + ui->trimLenLineEdit->setText(m_trim_len); + + QString trimFilename = parentTraceFile; + trimFilename.insert(trimFilename.lastIndexOf("."), "-trim"); + ui->trimFileLineEdit->setText(trimFilename); +} + +vogleditor_QTrimDialog::~vogleditor_QTrimDialog() +{ + delete ui; +} + +void vogleditor_QTrimDialog::on_buttonBox_clicked(QAbstractButton *button) +{ + if (button == ui->buttonBox->button(QDialogButtonBox::Ok)) + { + // validate the trim start frame + bool bValidFrame = false; + uint tmpFrame = ui->trimFrameLineEdit->text().toUInt(&bValidFrame); + bValidFrame = bValidFrame && (tmpFrame <= m_maxFrameIndex); + + if (!bValidFrame) + { + QMessageBox::warning(this, tr("Invalid Trim Frame"), tr("Please enter a valid frame number at which to start the trim."), + QMessageBox::Ok, QMessageBox::Ok); + ui->trimFrameLineEdit->setFocus(); + return; + } + + // validate the trim length + bool bValidLen = false; + uint tmpLen = ui->trimLenLineEdit->text().toUInt(&bValidLen); + bValidLen = bValidLen && (tmpLen > 0 && tmpLen <= m_maxTrimLength); + + if (!bValidLen) + { + QMessageBox::warning(this, tr("Invalid Trim Count"), tr("Please enter a valid nubmer of frames to trim."), + QMessageBox::Ok, QMessageBox::Ok); + ui->trimLenLineEdit->setFocus(); + return; + } + + // validate the filename + QFile file(ui->trimFileLineEdit->text()); + if (file.exists()) + { + QString message = ui->trimFileLineEdit->text(); + message += " already exits.\nWould you like to overwrite it?"; + int ret = QMessageBox::warning(this, tr("File Already Exists"), tr(message.toStdString().c_str()), + QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes); + + if (ret == QMessageBox::No) + { + // return so that the user can update the path + ui->trimFileLineEdit->setFocus(); + return; + } + } + + m_trim_frame = ui->trimFrameLineEdit->text(); + m_trim_len = ui->trimLenLineEdit->text(); + m_trim_file = ui->trimFileLineEdit->text(); + accept(); + } +} + +void vogleditor_QTrimDialog::on_buttonBox_rejected() +{ + reject(); +} + +void vogleditor_QTrimDialog::on_pickTrimFileButton_pressed() +{ + // open file dialog + QString suggestedName = ui->trimFileLineEdit->text(); + QString selectedName = QFileDialog::getSaveFileName(this, tr("Save Trim File"), suggestedName, tr("Trace file (*.bin)")); + + if (!selectedName.isEmpty()) + { + ui->trimFileLineEdit->setText(selectedName); + } +} + +void vogleditor_QTrimDialog::on_trimLenLineEdit_textChanged(const QString &arg1) +{ + bool bConverted = false; + uint trimLen = arg1.toUInt(&bConverted); + + // make sure the length could be converted to a UINT, and that it isn't more than the allowed length + if (bConverted == false || trimLen > m_maxTrimLength) + { + // turn background red + QPalette palette(ui->trimLenLineEdit->palette()); + palette.setColor(QPalette::Base, Qt::red); + ui->trimLenLineEdit->setPalette(palette); + } + else + { + // restore background color + QPalette palette(ui->trimLenLineEdit->palette()); + palette.setColor(QPalette::Base, Qt::white); + ui->trimLenLineEdit->setPalette(palette); + } +} + +void vogleditor_QTrimDialog::on_trimFrameLineEdit_textChanged(const QString &arg1) +{ + bool bConverted = false; + uint trimFrame = arg1.toUInt(&bConverted); + + // make sure frame could be converted to a UINT, and that it isn't greater than the number of frames in the trace + if (bConverted == false || trimFrame > m_maxFrameIndex) + { + // turn background red + QPalette palette(ui->trimFrameLineEdit->palette()); + palette.setColor(QPalette::Base, Qt::red); + ui->trimFrameLineEdit->setPalette(palette); + } + else + { + // restore background color + QPalette palette(ui->trimFrameLineEdit->palette()); + palette.setColor(QPalette::Base, Qt::white); + ui->trimFrameLineEdit->setPalette(palette); + } +} diff --git a/src/vogleditor/vogleditor_qtrimdialog.h b/src/vogleditor/vogleditor_qtrimdialog.h new file mode 100644 index 0000000..a952cfb --- /dev/null +++ b/src/vogleditor/vogleditor_qtrimdialog.h @@ -0,0 +1,56 @@ +#ifndef VOGLEDITOR_QTRIMDIALOG_H +#define VOGLEDITOR_QTRIMDIALOG_H + +#include +#include + +class QAbstractButton; + +namespace Ui { +class vogleditor_QTrimDialog; +} + +class vogleditor_QTrimDialog : public QDialog +{ + Q_OBJECT + +public: + explicit vogleditor_QTrimDialog(QString parentTraceFile, uint maxFrameIndex, uint maxTrimLength, QWidget *parent = 0); + ~vogleditor_QTrimDialog(); + + QString trim_frame() + { + return m_trim_frame; + } + + QString trim_len() + { + return m_trim_len; + } + + QString trim_file() + { + return m_trim_file; + } + +private slots: + void on_buttonBox_clicked(QAbstractButton *button); + + void on_buttonBox_rejected(); + + void on_pickTrimFileButton_pressed(); + + void on_trimLenLineEdit_textChanged(const QString &arg1); + + void on_trimFrameLineEdit_textChanged(const QString &arg1); + +private: + Ui::vogleditor_QTrimDialog *ui; + uint m_maxFrameIndex; + uint m_maxTrimLength; + QString m_trim_frame; + QString m_trim_len; + QString m_trim_file; +}; + +#endif // VOGLEDITOR_QTRIMDIALOG_H diff --git a/src/vogleditor/vogleditor_qtrimdialog.ui b/src/vogleditor/vogleditor_qtrimdialog.ui new file mode 100644 index 0000000..58c1b48 --- /dev/null +++ b/src/vogleditor/vogleditor_qtrimdialog.ui @@ -0,0 +1,181 @@ + + + vogleditor_QTrimDialog + + + + 0 + 0 + 434 + 154 + + + + + 0 + 0 + + + + Trim Trace + + + + + + What range of frames would you like to trim? + + + Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop + + + true + + + + + + + + + Trim Frame: + + + + + + + + + + + + + + + + + + + + Trim Length: + + + + + + + + + + + + + + + + + + + + + + + + Trim File: + + + + + + + + 1 + 0 + + + + + + + + + 80 + 16777215 + + + + ... + + + + + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + + 0 + 0 + + + + Qt::Horizontal + + + QDialogButtonBox::Cancel|QDialogButtonBox::Ok + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + + + + + buttonBox + rejected() + vogleditor_QTrimDialog + reject() + + + 316 + 260 + + + 286 + 274 + + + + + diff --git a/src/vogleditor/vogleditor_settings.cpp b/src/vogleditor/vogleditor_settings.cpp new file mode 100644 index 0000000..84d12b9 --- /dev/null +++ b/src/vogleditor/vogleditor_settings.cpp @@ -0,0 +1,120 @@ +#include "vogleditor_settings.h" +#include "vogl_common.h" +#include "vogl_file_utils.h" + +static const unsigned int VOGLEDITOR_SETTINGS_FILE_FORMAT_VERSION_1 = 1; +static const unsigned int VOGLEDITOR_SETTINGS_FILE_FORMAT_VERSION = VOGLEDITOR_SETTINGS_FILE_FORMAT_VERSION_1; + +vogleditor_settings::vogleditor_settings() + : m_file_format_version(VOGLEDITOR_SETTINGS_FILE_FORMAT_VERSION_1) +{ + m_defaults.trim_large_trace_prompt_size = 200; + m_defaults.window_position_left = 0; + m_defaults.window_position_top = 0; + m_defaults.window_size_width = 1024; + m_defaults.window_size_height = 768; + + m_settings = m_defaults; +} + +dynamic_string vogleditor_settings::get_settings_path(const char* settingsFilename) +{ + dynamic_string settingsPath; + const char* xdgConfigHome = getenv("XDG_CONFIG_HOME"); + const char* home = getenv("HOME"); + if (xdgConfigHome != NULL && strlen(xdgConfigHome) != 0) + { + settingsPath = xdgConfigHome; + settingsPath += "/vogleditor/"; + if (vogl::file_utils::does_dir_exist(settingsPath.c_str()) == false) + { + if (vogl::file_utils::create_directories_from_full_path(settingsPath) == false) + { + VOGL_ASSERT(!"Failed to create directories for settings file."); + } + } + } + else if (home != NULL && strlen(home) != 0) + { + settingsPath += home; + settingsPath += "/.config/vogleditor/"; + if (vogl::file_utils::does_dir_exist(settingsPath.c_str())== false) + { + if (vogl::file_utils::create_directories_from_full_path(settingsPath) == false) + { + VOGL_ASSERT(!"Failed to create directories for settings file."); + } + } + } + else + { + // the settings file will end up in the current working directory + } + + settingsPath += settingsFilename; + return settingsPath; +} + +bool vogleditor_settings::load(const char* settingsFile) +{ + bool bLoaded = false; + json_document settingsDoc; + dynamic_string path = get_settings_path(settingsFile); + if (settingsDoc.deserialize_file(path.c_str())) + { + // validate metadata + json_node* pMetadata = settingsDoc.get_root()->find_child_object("metadata"); + if (pMetadata == NULL) + { + return false; + } + + const json_value& rFormatVersion = pMetadata->find_value("vogleditor_settings_file_format_version"); + if (!rFormatVersion.is_valid() || rFormatVersion.as_uint32() != VOGLEDITOR_SETTINGS_FILE_FORMAT_VERSION_1) + { + return false; + } + + m_file_format_version = rFormatVersion.as_uint32(VOGLEDITOR_SETTINGS_FILE_FORMAT_VERSION); + + // validate that settings node exists + json_node* pSettingsNode = settingsDoc.get_root()->find_child_object("settings"); + if (pSettingsNode == NULL) + { + return false; + } + + // if so, consider the file successfully loaded + bLoaded = true; + + // all settings should be considered optional, if they are not in the file, then the default value is used + m_settings.trim_large_trace_prompt_size = pSettingsNode->value_as_uint32("trim_large_trace_prompt_size", m_defaults.trim_large_trace_prompt_size); + + m_settings.window_position_left = pSettingsNode->value_as_int("window_position_left", m_defaults.window_position_left); + m_settings.window_position_top = pSettingsNode->value_as_int("window_position_top", m_defaults.window_position_top); + m_settings.window_size_width = pSettingsNode->value_as_int("window_size_width", m_defaults.window_size_width); + m_settings.window_size_height = pSettingsNode->value_as_int("window_size_height", m_defaults.window_size_height); + } + + return bLoaded; +} + +bool vogleditor_settings::save(const char* settingsFile) +{ + json_document settingsDoc; + json_node& metadata = settingsDoc.get_root()->add_object("metadata"); + metadata.add_key_value("vogleditor_settings_file_format_version", to_hex_string(VOGLEDITOR_SETTINGS_FILE_FORMAT_VERSION)); + + // settings + json_node& settings = settingsDoc.get_root()->add_object("settings"); + settings.add_key_value("trim_large_trace_prompt_size", m_settings.trim_large_trace_prompt_size); + + settings.add_key_value("window_position_left", m_settings.window_position_left); + settings.add_key_value("window_position_top", m_settings.window_position_top); + settings.add_key_value("window_size_width", m_settings.window_size_width); + settings.add_key_value("window_size_height", m_settings.window_size_height); + + dynamic_string path = get_settings_path(settingsFile); + bool bSavedSuccessfully = settingsDoc.serialize_to_file(path.c_str()); + return bSavedSuccessfully; +} diff --git a/src/vogleditor/vogleditor_settings.h b/src/vogleditor/vogleditor_settings.h new file mode 100644 index 0000000..3da7a75 --- /dev/null +++ b/src/vogleditor/vogleditor_settings.h @@ -0,0 +1,44 @@ +#ifndef VOGLEDITOR_SETTINGS_H +#define VOGLEDITOR_SETTINGS_H + +#include "vogl_dynamic_string.h" + +struct vogleditor_setting_struct +{ + int window_position_left; + int window_position_top; + int window_size_width; + int window_size_height; + unsigned int trim_large_trace_prompt_size; +}; + +class vogleditor_settings +{ +public: + vogleditor_settings(); + virtual ~vogleditor_settings() {} + + bool load(const char* settingsFile); + bool save(const char* settingsFile); + + int window_position_left() { return m_settings.window_position_left; } + int window_position_top() { return m_settings.window_position_top; } + int window_size_width() { return m_settings.window_size_width; } + int window_size_height() { return m_settings.window_size_height; } + void set_window_position_left(int window_position_left) { m_settings.window_position_left = window_position_left; } + void set_window_position_top(int window_position_top) { m_settings.window_position_top = window_position_top; } + void set_window_size_width(int window_size_width) { m_settings.window_size_width = window_size_width; } + void set_window_size_height(int window_size_height) { m_settings.window_size_height = window_size_height; } + + unsigned int trim_large_trace_prompt_size() { return m_settings.trim_large_trace_prompt_size; } + void set_trim_large_trace_prompt_size(unsigned int trim_large_trace_prompt_size) { m_settings.trim_large_trace_prompt_size = trim_large_trace_prompt_size; } + +private: + unsigned int m_file_format_version; + vogleditor_setting_struct m_settings; + vogleditor_setting_struct m_defaults; + + vogl::dynamic_string get_settings_path(const char* settingsFilename); +}; + +#endif // VOGLEDITOR_SETTINGS_H diff --git a/src/vogleditor/vogleditor_statetreetextureitem.cpp b/src/vogleditor/vogleditor_statetreetextureitem.cpp index 25ffb6e..e86045a 100644 --- a/src/vogleditor/vogleditor_statetreetextureitem.cpp +++ b/src/vogleditor/vogleditor_statetreetextureitem.cpp @@ -23,9 +23,9 @@ vogleditor_stateTreeTextureItem::vogleditor_stateTreeTextureItem(QString name, Q #define STR_INT1(val) tmp.sprintf("%d", val[0]) -#define GET_INT(name, num) if (m_pTexture->get_params().get(name, 0, iVals, num)) { vogleditor_stateTreeStateVecIntItem* pItem = new vogleditor_stateTreeStateVecIntItem(#name, name, 0, m_pTexture->get_params(), iVals, num, false, this); m_diffableItems.push_back(pItem); this->appendChild(pItem); } -#define GET_ENUM(name, num) if (m_pTexture->get_params().get(name, 0, iVals, num)) { vogleditor_stateTreeStateVecEnumItem* pItem = new vogleditor_stateTreeStateVecEnumItem(#name, name, 0, m_pTexture->get_params(), iVals, num, false, this); m_diffableItems.push_back(pItem); this->appendChild(pItem); } -#define GET_FLOAT(name, num) if (m_pTexture->get_params().get(name, 0, fVals, num)) { vogleditor_stateTreeStateVecFloatItem* pItem = new vogleditor_stateTreeStateVecFloatItem(#name, name, 0, m_pTexture->get_params(), fVals, num, false, this); m_diffableItems.push_back(pItem); this->appendChild(pItem); } +#define GET_INT(name, num) memset(iVals, 0, sizeof(iVals)); if (m_pTexture->get_params().get(name, 0, iVals, num)) { vogleditor_stateTreeStateVecIntItem* pItem = new vogleditor_stateTreeStateVecIntItem(#name, name, 0, m_pTexture->get_params(), iVals, num, false, this); m_diffableItems.push_back(pItem); this->appendChild(pItem); } +#define GET_ENUM(name, num) memset(iVals, 0, sizeof(iVals)); if (m_pTexture->get_params().get(name, 0, iVals, num)) { vogleditor_stateTreeStateVecEnumItem* pItem = new vogleditor_stateTreeStateVecEnumItem(#name, name, 0, m_pTexture->get_params(), iVals, num, false, this); m_diffableItems.push_back(pItem); this->appendChild(pItem); } +#define GET_FLOAT(name, num) memset(fVals, 0, sizeof(fVals)); if (m_pTexture->get_params().get(name, 0, fVals, num)) { vogleditor_stateTreeStateVecFloatItem* pItem = new vogleditor_stateTreeStateVecFloatItem(#name, name, 0, m_pTexture->get_params(), fVals, num, false, this); m_diffableItems.push_back(pItem); this->appendChild(pItem); } GET_INT(GL_TEXTURE_BASE_LEVEL, 1); int base_level = iVals[0]; GET_INT(GL_TEXTURE_MAX_LEVEL, 1); diff --git a/src/voglgen/CMakeLists.txt b/src/voglgen/CMakeLists.txt index 908a195..3d006ee 100644 --- a/src/voglgen/CMakeLists.txt +++ b/src/voglgen/CMakeLists.txt @@ -4,6 +4,7 @@ cmake_minimum_required(VERSION 2.8) include("${SRC_DIR}/build_options.cmake") set(SRC_LIST voglgen.cpp) +set(SPEC_DIR "${CMAKE_SOURCE_DIR}/../glspec") add_definitions(-DTIXML_USE_STL) @@ -19,5 +20,13 @@ target_link_libraries(${PROJECT_NAME} ${TinyXML_LIBRARIES} ) +# Generate stuff and copy it. Generator must handle copying internally in the future. +add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD + COMMAND ${PROJECT_NAME} --specdir ${SPEC_DIR} + COMMAND mkdir -p "${CMAKE_BINARY_DIR}/voglinc/" + COMMAND mv "${SPEC_DIR}/*.inc" "${CMAKE_BINARY_DIR}/voglinc/" + COMMAND mv "${SPEC_DIR}/libvogltrace_linker_script.txt" "${CMAKE_SOURCE_DIR}/vogltrace/") +add_custom_target(voglgen_make_inc DEPENDS ${PROJECT_NAME}) + build_options_finalize() diff --git a/src/voglgen/voglgen.cpp b/src/voglgen/voglgen.cpp index aa8eb96..add362d 100644 --- a/src/voglgen/voglgen.cpp +++ b/src/voglgen/voglgen.cpp @@ -63,6 +63,7 @@ static command_line_param_desc g_command_line_param_descs[] = { "ctype_regex", 1, false, NULL }, { "namespace_regex", 1, false, NULL }, { "srcdir", 1, false, NULL }, + { "specdir", 1, false, NULL }, }; //----------------------------------------------------------------------------------------------------------------------- @@ -2019,7 +2020,14 @@ public: bool init() { // TODO: I'm going to move the "glspec" dir from under bin to raddebugger/glspec (or whatever) - if (!file_utils::does_file_exist("gl.spec")) + dynamic_string specdir; + + if (g_command_line_params.get_value_as_string(specdir, "specdir")) + { + file_utils::change_directory(specdir.c_str()); + console::warning("Changing current directory to %s\n", specdir.c_str()); + } + else if (!file_utils::does_file_exist("gl.spec")) { if (file_utils::does_file_exist("glspec/gl.spec")) { diff --git a/src/voglreplay/CMakeLists.txt b/src/voglreplay/CMakeLists.txt index be7ed89..a9c6324 100644 --- a/src/voglreplay/CMakeLists.txt +++ b/src/voglreplay/CMakeLists.txt @@ -16,7 +16,7 @@ include_directories( include_directories( ${SRC_DIR}/voglcore - ${SRC_DIR}/voglinc + ${CMAKE_BINARY_DIR}/voglinc ${SRC_DIR}/voglcommon ${SRC_DIR}/libtelemetry ${SRC_DIR}/extlib/loki/include/loki @@ -32,6 +32,7 @@ set(SRC_LIST # add_compiler_flag("-DVOGL_REMOTING") add_executable(${PROJECT_NAME} ${SRC_LIST}) +add_dependencies(${PROJECT_NAME} voglgen_make_inc) target_link_libraries(${PROJECT_NAME} ${TELEMETRY_LIBRARY} diff --git a/src/voglreplay/vogl_replay_tool.cpp b/src/voglreplay/vogl_replay_tool.cpp index 40e23a4..3a2d0f6 100644 --- a/src/voglreplay/vogl_replay_tool.cpp +++ b/src/voglreplay/vogl_replay_tool.cpp @@ -78,8 +78,9 @@ static command_line_param_desc g_command_line_param_descs[] = { "compare_hash_files", 0, false, "Compare two files containing CRC's or per-component sums (presumably written using dump_backbuffer_hashes)" }, // replay specific - { "width", 1, false, "Replay: Set initial window width (default is 1024)" }, - { "height", 1, false, "Replay: Set initial window height (default is 768)" }, + { "width", 1, false, "Replay: Set replay window's initial width (default is 1024)" }, + { "height", 1, false, "Replay: Set replay window's initial height (default is 768)" }, + { "msaa", 1, false, "Replay: Set replay window's multisamples (default is 0)." }, { "lock_window_dimensions", 0, false, "Replay: Don't automatically change window's dimensions during replay" }, { "trim_file", 1, false, "Replay: Create a trimmed trace file during replay, must also specify -trim_frame" }, { "trim_frame", 1, false, "Replay: Frame index to begin trim, 0=beginning of trace, 1=first API call after first swap, etc." }, @@ -661,7 +662,7 @@ static bool tool_replay_mode() // TODO: This will create a window with default attributes, which seems fine for the majority of traces. // Unfortunately, some GL call streams *don't* want an alpha channel, or depth, or stencil etc. in the default framebuffer so this may become a problem. // Also, this design only supports a single window, which is going to be a problem with multiple window traces. - if (!window.open(g_command_line_params.get_value_as_int("width", 0, 1024, 1, 65535), g_command_line_params.get_value_as_int("height", 0, 768, 1, 65535))) + if (!window.open(g_command_line_params.get_value_as_int("width", 0, 1024, 1, 65535), g_command_line_params.get_value_as_int("height", 0, 768, 1, 65535), g_command_line_params.get_value_as_int("msaa", 0, 0, 0, 65535))) { vogl_error_printf("%s: Failed initializing replay window\n", VOGL_FUNCTION_NAME); return false; diff --git a/src/voglsyms/CMakeLists.txt b/src/voglsyms/CMakeLists.txt index 0792eab..2ba8a2b 100644 --- a/src/voglsyms/CMakeLists.txt +++ b/src/voglsyms/CMakeLists.txt @@ -6,10 +6,10 @@ include("${SRC_DIR}/build_options.cmake") include_directories( ${CMAKE_CURRENT_BINARY_DIR} ${SRC_DIR}/voglcore - ${SRC_DIR}/voglinc + ${CMAKE_BINARY_DIR}/voglinc ${SRC_DIR}/voglcommon - ${SRC_DIR}/libtelemetry - ${SRC_DIR}/libbacktrace + ${SRC_DIR}/libtelemetry + ${SRC_DIR}/libbacktrace ${SRC_DIR}/extlib/loki/include/loki ) @@ -18,6 +18,7 @@ set(SRC_LIST ) add_executable(${PROJECT_NAME} ${SRC_LIST}) +add_dependencies(${PROJECT_NAME} voglgen_make_inc) target_link_libraries(${PROJECT_NAME} backtrace diff --git a/src/vogltrace/CMakeLists.txt b/src/vogltrace/CMakeLists.txt index 6320b4e..66566a9 100644 --- a/src/vogltrace/CMakeLists.txt +++ b/src/vogltrace/CMakeLists.txt @@ -37,7 +37,7 @@ include_directories( ${SRC_DIR}/libbacktrace ${SRC_DIR}/extlib/loki/include/loki ${SRC_DIR}/voglcommon - ${SRC_DIR}/voglinc + ${CMAKE_BINARY_DIR}/voglinc ${SRC_DIR}/voglcore ${SRC_DIR}/libtelemetry ) @@ -47,6 +47,7 @@ add_shared_linker_flag("-Wl,-Bsymbolic") add_shared_linker_flag("-Wl,--version-script=${PROJECT_SOURCE_DIR}/libvogltrace_linker_script.txt") add_library(${PROJECT_NAME} SHARED ${SRC_LIST}) +add_dependencies(${PROJECT_NAME} voglgen_make_inc) target_link_libraries(${PROJECT_NAME} ${TELEMETRY_LIBRARY} diff --git a/src/vogltrace/vogl_intercept.cpp b/src/vogltrace/vogl_intercept.cpp index e8c8121..9037524 100644 --- a/src/vogltrace/vogl_intercept.cpp +++ b/src/vogltrace/vogl_intercept.cpp @@ -3080,6 +3080,12 @@ static inline bool vogl_func_is_nulled(gl_entrypoint_id_t id) #define DEF_FUNCTION_PARAM_COMPUTE_ARRAY_SIZE_FUNC_glMap2f_points(e, c, rt, r, nu, ne, a, p) vogl_determine_glMap2_size(target, ustride, uorder, vstride, vorder) #define DEF_FUNCTION_PARAM_COMPUTE_ARRAY_SIZE_FUNC_glMap2d_points(e, c, rt, r, nu, ne, a, p) vogl_determine_glMap2_size(target, ustride, uorder, vstride, vorder) +// KHR_debug +#define DEF_FUNCTION_PARAM_COMPUTE_ARRAY_SIZE_FUNC_glDebugMessageInsert_buf(e, c, rt, r, nu, ne, a, p) ((length < 0) ? (buf ? strlen((const char *)buf) : 0 ) : length) +#define DEF_FUNCTION_PARAM_COMPUTE_ARRAY_SIZE_FUNC_glPushDebugGroup_message(e, c, rt, r, nu, ne, a, p) ((length < 0) ? (message ? strlen((const char *)message) : 0 ) : length) +#define DEF_FUNCTION_PARAM_COMPUTE_ARRAY_SIZE_FUNC_glObjectLabel_label(e, c, rt, r, nu, ne, a, p) ((length < 0) ? (label ? strlen((const char *)label) : 0 ) : length) +#define DEF_FUNCTION_PARAM_COMPUTE_ARRAY_SIZE_FUNC_glObjectPtrLabel_label(e, c, rt, r, nu, ne, a, p) ((length < 0) ? (label ? strlen((const char *)label) : 0 ) : length) + //---------------------------------------------------------------------------------------------------------------------- // Texture/image API's array size helper macros // TODO: For glTexImage3DEXT, glTexSubImage1DEXT, etc. - should these check the currently bound GL_PIXEL_UNPACK_BUFFER?