[PATCH 0/7] MR10019: opengl32: Move wglGetProcAddress implementation to the PE side.
This better splits client / host extension lists, allowing to more easily check for available host-side extensions in win32u later on, then moves the function registry to the PE side to get rid of the remaining extension logic in opengl32 unix side. Doing that, it also drops the driver function check, and always expose extension functions to the client if their extension dependency is satisfied. I'm not completely sure this is right, but I think the unix side tends to expose functions from eglGetProcAddress more often than the opposite. We could also keep a mechanism to check the driver availability, with a bit of additional complexity. On the unix side, all OpenGL functions are queried on initialization instead of just core functions, simplifying their use later on. -- https://gitlab.winehq.org/wine/wine/-/merge_requests/10019
From: Rémi Bernon <rbernon@codeweavers.com> --- dlls/opengl32/unix_wgl.c | 56 ++++++++++++++++++++++++++++++++++++ include/wine/opengl_driver.h | 10 +++++++ 2 files changed, 66 insertions(+) diff --git a/dlls/opengl32/unix_wgl.c b/dlls/opengl32/unix_wgl.c index 315aa3cee27..86bcd43f066 100644 --- a/dlls/opengl32/unix_wgl.c +++ b/dlls/opengl32/unix_wgl.c @@ -191,6 +191,7 @@ static ULONG_PTR zero_bits; static const struct vulkan_funcs *vk_funcs; static VkInstance vk_instance; static PFN_vkDestroyInstance p_vkDestroyInstance; +static struct opengl_extensions enabled_extensions; static int vk_device_cmp( const void *key, const struct rb_entry *entry ) { @@ -1153,9 +1154,62 @@ static BOOL initialize_vk_device( TEB *teb, struct context *ctx ) return FALSE; } +static void add_extension( struct opengl_extensions *extensions, const char *ext, size_t len, BOOL set ) +{ +#define USE_GL_EXT(x) if (!strncmp( #x, ext, len )) extensions->has_ ## x = set; else + ALL_GL_EXTS + ALL_WGL_EXTS +#undef USE_GL_EXT + WARN( "Extension %s is not supported.\n", debugstr_an( ext, len ) ); +} + +static void parse_extensions( struct opengl_extensions *extensions, const char *ext, BOOL set ) +{ + const char *end; + for (end = ext; *end; end++) + { + if (*end != ' ') continue; + add_extension( extensions, ext, end - ext, set ); + ext = end + 1; + } + if (end > ext) add_extension( extensions, ext, end - ext, set ); +} + +static void dump_extensions( const char *prefix, struct opengl_extensions *extensions ) +{ + if (TRACE_ON(opengl)) + { + TRACE( "%s extensions:\n", prefix ); +#define USE_GL_EXT(x) if (extensions->has_ ## x) TRACE( " - %s\n", #x ); + ALL_GL_EXTS + ALL_WGL_EXTS +#undef USE_GL_EXT + } +} + +static void init_enabled_extensions(void) +{ + char *enabled, *disabled; + + if ((enabled = query_opengl_option( "EnabledExtensions" ))) + parse_extensions( &enabled_extensions, enabled, TRUE ); + else + memset( &enabled_extensions, 0xff, sizeof(enabled_extensions) ); + + if ((disabled = query_opengl_option( "DisabledExtensions" ))) + parse_extensions( &enabled_extensions, disabled, FALSE ); + + if (enabled || disabled) dump_extensions( "Enabled", &enabled_extensions ); + + free( enabled ); + free( disabled ); +} + static void make_context_current( TEB *teb, const struct opengl_funcs *funcs, HDC draw_hdc, HDC read_hdc, HGLRC client_context, struct context *ctx ) { + static pthread_once_t once = PTHREAD_ONCE_INIT; + DWORD tid = HandleToULong(teb->ClientId.UniqueThread); size_t size = ARRAYSIZE(legacy_extensions) - 1, count = 0; const char *version, *rest = "", **extensions; @@ -1169,6 +1223,8 @@ static void make_context_current( TEB *teb, const struct opengl_funcs *funcs, HD teb->glTable = (void *)funcs; pop_default_fbo( teb ); + pthread_once( &once, init_enabled_extensions ); + if (ctx->major_version) return; /* already synced */ version = (const char *)funcs->p_glGetString( GL_VERSION ); diff --git a/include/wine/opengl_driver.h b/include/wine/opengl_driver.h index 0ca0a4708fc..05730fcf093 100644 --- a/include/wine/opengl_driver.h +++ b/include/wine/opengl_driver.h @@ -59,6 +59,16 @@ struct wgl_pixel_format int float_components; }; +struct opengl_extensions +{ +#define USE_GL_EXT(x) unsigned has_ ## x : 1; + ALL_GL_EXTS + ALL_WGL_EXTS +#undef USE_GL_EXT +}; + +C_ASSERT( sizeof(struct opengl_extensions) <= 0x80 ); + struct opengl_client_context { struct HGLRC__ obj; /* client object header */ -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10019
From: Rémi Bernon <rbernon@codeweavers.com> --- dlls/opengl32/tests/opengl.c | 17 +++++++- dlls/opengl32/unix_wgl.c | 7 ++++ dlls/opengl32/wgl.c | 61 +++++++++++++-------------- dlls/win32u/opengl.c | 79 +++++++++++++---------------------- dlls/wineandroid.drv/opengl.c | 6 +-- dlls/winemac.drv/opengl.c | 33 +++++---------- dlls/winewayland.drv/opengl.c | 2 +- dlls/winex11.drv/opengl.c | 39 ++++++----------- include/wine/opengl_driver.h | 5 ++- 9 files changed, 112 insertions(+), 137 deletions(-) diff --git a/dlls/opengl32/tests/opengl.c b/dlls/opengl32/tests/opengl.c index e0fc1ae1426..107dfc3f9ff 100644 --- a/dlls/opengl32/tests/opengl.c +++ b/dlls/opengl32/tests/opengl.c @@ -66,6 +66,7 @@ static HGLRC (WINAPI *pwglCreateContextAttribsARB)(HDC hDC, HGLRC hShareContext, /* WGL_ARB_extensions_string */ static const char* (WINAPI *pwglGetExtensionsStringARB)(HDC); +static const char* (WINAPI *pwglGetExtensionsStringEXT)(void); /* WGL_ARB_make_current_read */ static BOOL (WINAPI *pwglMakeContextCurrentARB)(HDC hdraw, HDC hread, HGLRC hglrc); @@ -153,6 +154,7 @@ static void init_functions(void) /* WGL_ARB_extensions_string */ GET_PROC(wglGetExtensionsStringARB) + GET_PROC(wglGetExtensionsStringEXT) /* WGL_ARB_make_current_read */ GET_PROC(wglMakeContextCurrentARB); @@ -1653,6 +1655,11 @@ static void test_bitmap_rendering( BOOL use_dib ) ret = wglMakeCurrent( hdc, hglrc ); ok( ret, "wglMakeCurrent failed, error %lu\n", GetLastError() ); + pwglGetExtensionsStringEXT = (void *)wglGetProcAddress( "wglGetExtensionsStringEXT" ); + todo_wine ok(!pwglGetExtensionsStringEXT, "got wglGetExtensionsStringEXT %p\n", pwglGetExtensionsStringEXT); + pwglGetExtensionsStringARB = (void *)wglGetProcAddress( "wglGetExtensionsStringARB" ); + todo_wine ok(!pwglGetExtensionsStringARB, "got wglGetExtensionsStringARB %p\n", pwglGetExtensionsStringARB); + glGetIntegerv( GL_READ_BUFFER, &object ); ok( object == GL_FRONT, "got %u\n", object ); glGetIntegerv( GL_DRAW_BUFFER, &object ); @@ -3839,6 +3846,7 @@ START_TEST(opengl) HMODULE gdi32 = GetModuleHandleA("gdi32.dll"); HDC hdc; int iPixelFormat, res; + const char *tmp; HGLRC hglrc; DWORD error; @@ -3927,7 +3935,14 @@ START_TEST(opengl) test_memory_map(hdc); test_gl_error(hdc); - wgl_extensions = pwglGetExtensionsStringARB(hdc); + tmp = pwglGetExtensionsStringEXT(); + ok(tmp && *tmp, "got wgl_extensions %s\n", debugstr_a(tmp)); + wgl_extensions = tmp; + + tmp = pwglGetExtensionsStringARB(hdc); + ok(tmp && *tmp, "got wgl_extensions %s\n", debugstr_a(tmp)); + ok(!strcmp(tmp, wgl_extensions), "got wgl_extensions %s\n", debugstr_a(tmp)); + if(wgl_extensions == NULL) skip("Skipping opengl32 tests because this OpenGL implementation doesn't support WGL extensions!\n"); if(strstr(wgl_extensions, "WGL_ARB_create_context")) diff --git a/dlls/opengl32/unix_wgl.c b/dlls/opengl32/unix_wgl.c index 86bcd43f066..32a939ff4a0 100644 --- a/dlls/opengl32/unix_wgl.c +++ b/dlls/opengl32/unix_wgl.c @@ -1210,6 +1210,7 @@ static void make_context_current( TEB *teb, const struct opengl_funcs *funcs, HD { static pthread_once_t once = PTHREAD_ONCE_INIT; + struct opengl_client_context *client = opengl_client_context_from_client( ctx->base.client_context ); DWORD tid = HandleToULong(teb->ClientId.UniqueThread); size_t size = ARRAYSIZE(legacy_extensions) - 1, count = 0; const char *version, *rest = "", **extensions; @@ -1232,6 +1233,12 @@ static void make_context_current( TEB *teb, const struct opengl_funcs *funcs, HD if (!ctx->major_version) ctx->major_version = 1; TRACE( "context %p version %d.%d\n", ctx, ctx->major_version, ctx->minor_version ); + funcs->p_init_extensions( &ctx->base.extensions ); + +#define USE_GL_EXT(x) if (enabled_extensions.has_ ## x) client->extensions.has_ ## x = ctx->base.extensions.has_ ## x; + ALL_WGL_EXTS +#undef USE_GL_EXT + if (funcs->p_glImportMemoryWin32HandleEXT) size++; if (funcs->p_glImportSemaphoreWin32HandleEXT) size++; diff --git a/dlls/opengl32/wgl.c b/dlls/opengl32/wgl.c index 45b9761b6f9..e7fa8eef712 100644 --- a/dlls/opengl32/wgl.c +++ b/dlls/opengl32/wgl.c @@ -57,6 +57,7 @@ static CRITICAL_SECTION_DEBUG wgl_cs_debug = { 0, 0, { (DWORD_PTR)(__FILE__ ": wgl_cs") } }; static CRITICAL_SECTION wgl_cs = { &wgl_cs_debug, -1, 0, 0, 0, 0 }; +static char *wgl_extensions; #ifndef _WIN64 @@ -98,6 +99,22 @@ static void cleanup_wow64_strings(void) #endif +static void init_wgl_extensions( const struct opengl_extensions *extensions ) +{ + char *str; +#define USE_GL_EXT(x) + (extensions->has_ ## x ? sizeof(#x) : 0) + UINT pos = 0, len = 0 ALL_WGL_EXTS; +#undef USE_GL_EXT + + if (!(str = realloc( wgl_extensions, len + 1 ))) return; +#define USE_GL_EXT(x) if (extensions->has_ ## x) pos += sprintf( str + pos, "%s ", #x ); + ALL_WGL_EXTS +#undef USE_GL_EXT + str[pos - 1] = 0; + + wgl_extensions = str; +} + struct handle_entry { UINT handle; @@ -1334,14 +1351,24 @@ int WINAPI wglGetLayerPaletteEntries( HDC hdc, int plane, int start, int count, PROC WINAPI wglGetProcAddress( LPCSTR name ) { struct wglGetProcAddress_params args = { .teb = NtCurrentTeb(), .lpszProc = name }; + struct context *ctx; const void *proc; NTSTATUS status; if (!name) return NULL; + if (!(ctx = context_from_handle( NtCurrentTeb()->glCurrentRC ))) return NULL; + if ((status = UNIX_CALL( wglGetProcAddress, &args ))) WARN( "wglGetProcAddress %s returned %#lx\n", debugstr_a(name), status ); if (args.ret == (void *)-1) return NULL; + if (!strncmp( name, "wglGetExtensionsString", 22 )) + { + EnterCriticalSection( &wgl_cs ); + init_wgl_extensions( &ctx->base.extensions ); + LeaveCriticalSection( &wgl_cs ); + } + proc = extension_procs[(UINT_PTR)args.ret]; TRACE( "returning %s -> %p\n", name, proc ); return proc; @@ -2043,44 +2070,14 @@ const GLubyte * WINAPI glGetString( GLenum name ) const char * WINAPI wglGetExtensionsStringARB( HDC hdc ) { - struct wglGetExtensionsStringARB_params args = { .teb = NtCurrentTeb(), .hdc = hdc }; - NTSTATUS status; -#ifndef _WIN64 - char *wow64_str = NULL; -#endif - TRACE( "hdc %p\n", hdc ); - -#ifndef _WIN64 - if (UNIX_CALL( wglGetExtensionsStringARB, &args ) == STATUS_BUFFER_TOO_SMALL) args.ret = wow64_str = malloc( (size_t)args.ret ); -#endif - if ((status = UNIX_CALL( wglGetExtensionsStringARB, &args ))) WARN( "wglGetExtensionsStringARB returned %#lx\n", status ); -#ifndef _WIN64 - if (args.ret != wow64_str) free( wow64_str ); - else if (args.ret) append_wow64_string( wow64_str ); -#endif - return args.ret; + return wgl_extensions; } const char * WINAPI wglGetExtensionsStringEXT(void) { - struct wglGetExtensionsStringEXT_params args = { .teb = NtCurrentTeb() }; - NTSTATUS status; -#ifndef _WIN64 - char *wow64_str = NULL; -#endif - TRACE( "\n" ); - -#ifndef _WIN64 - if (UNIX_CALL( wglGetExtensionsStringEXT, &args ) == STATUS_BUFFER_TOO_SMALL) args.ret = wow64_str = malloc( (size_t)args.ret ); -#endif - if ((status = UNIX_CALL( wglGetExtensionsStringEXT, &args ))) WARN( "wglGetExtensionsStringEXT returned %#lx\n", status ); -#ifndef _WIN64 - if (args.ret != wow64_str) free( wow64_str ); - else if (args.ret) append_wow64_string( wow64_str ); -#endif - return args.ret; + return wgl_extensions; } const GLchar * WINAPI wglQueryCurrentRendererStringWINE( GLenum attribute ) diff --git a/dlls/win32u/opengl.c b/dlls/win32u/opengl.c index 3558b66c792..225b3fe1c8a 100644 --- a/dlls/win32u/opengl.c +++ b/dlls/win32u/opengl.c @@ -64,9 +64,9 @@ static struct list devices_egl = LIST_INIT( devices_egl ); static struct egl_platform display_egl; static struct opengl_funcs display_funcs; +static struct opengl_extensions global_extensions; static struct wgl_pixel_format *pixel_formats; static UINT formats_count, onscreen_count; -static char wgl_extensions[4096]; static BOOL has_extension( const char *list, const char *ext ) { @@ -99,17 +99,6 @@ static void dump_extensions( const char *list ) TRACE( "%s\n", start ); } -static void register_extension( char *list, size_t size, const char *name ) -{ - if (!has_extension( list, name )) - { - size_t len = strlen( list ); - assert( size - len >= strlen( name ) + 1 ); - if (*list) strcat( list + len, " " ); - strcat( list + len, name ); - } -} - void *opengl_drawable_create( UINT size, const struct opengl_drawable_funcs *funcs, int format, struct client_surface *client ) { struct opengl_drawable *drawable; @@ -652,9 +641,8 @@ static BOOL egldrv_describe_pixel_format( int format, struct wgl_pixel_format *d return describe_egl_config( egl->configs[format % count], desc, pixel_format_flags[format / count] ); } -static const char *egldrv_init_wgl_extensions( struct opengl_funcs *funcs ) +static void egldrv_init_extensions( struct opengl_funcs *funcs, struct opengl_extensions *extensions ) { - return ""; } static BOOL egldrv_surface_create( HWND hwnd, int format, struct opengl_drawable **drawable ) @@ -863,7 +851,7 @@ static const struct opengl_driver_funcs egldrv_funcs = .p_get_proc_address = egldrv_get_proc_address, .p_init_pixel_formats = egldrv_init_pixel_formats, .p_describe_pixel_format = egldrv_describe_pixel_format, - .p_init_wgl_extensions = egldrv_init_wgl_extensions, + .p_init_extensions = egldrv_init_extensions, .p_surface_create = egldrv_surface_create, .p_pbuffer_create = egldrv_pbuffer_create, .p_pbuffer_updated = egldrv_pbuffer_updated, @@ -1258,9 +1246,8 @@ static BOOL nulldrv_describe_pixel_format( int format, struct wgl_pixel_format * return TRUE; } -static const char *nulldrv_init_wgl_extensions( struct opengl_funcs *funcs ) +static void nulldrv_init_extensions( struct opengl_funcs *funcs, struct opengl_extensions *extensions ) { - return ""; } static BOOL nulldrv_surface_create( HWND hwnd, int format, struct opengl_drawable **drawable ) @@ -1304,7 +1291,7 @@ static const struct opengl_driver_funcs nulldrv_funcs = .p_get_proc_address = nulldrv_get_proc_address, .p_init_pixel_formats = nulldrv_init_pixel_formats, .p_describe_pixel_format = nulldrv_describe_pixel_format, - .p_init_wgl_extensions = nulldrv_init_wgl_extensions, + .p_init_extensions = nulldrv_init_extensions, .p_surface_create = nulldrv_surface_create, .p_pbuffer_create = nulldrv_pbuffer_create, .p_pbuffer_updated = nulldrv_pbuffer_updated, @@ -1314,20 +1301,6 @@ static const struct opengl_driver_funcs nulldrv_funcs = .p_make_current = nulldrv_make_current, }; -static const char *win32u_wglGetExtensionsStringARB( HDC hdc ) -{ - TRACE( "hdc %p\n", hdc ); - if (TRACE_ON(wgl)) dump_extensions( wgl_extensions ); - return wgl_extensions; -} - -static const char *win32u_wglGetExtensionsStringEXT(void) -{ - TRACE( "\n" ); - if (TRACE_ON(wgl)) dump_extensions( wgl_extensions ); - return wgl_extensions; -} - static int win32u_wglGetPixelFormat( HDC hdc ) { BOOL is_display = is_dc_display( hdc ); @@ -1741,6 +1714,11 @@ static PROC win32u_wglGetProcAddress( const char *name ) return ret; } +static void win32u_init_extensions( struct opengl_extensions *extensions ) +{ + *extensions = global_extensions; +} + static void win32u_get_pixel_formats( struct wgl_pixel_format *formats, UINT max_formats, UINT *num_formats, UINT *num_onscreen_formats ) { @@ -2707,9 +2685,10 @@ static void display_funcs_init(void) #undef USE_GL_FUNC display_funcs.p_wglGetProcAddress = win32u_wglGetProcAddress; + display_funcs.p_init_extensions = win32u_init_extensions; display_funcs.p_get_pixel_formats = win32u_get_pixel_formats; - strcpy( wgl_extensions, driver_funcs->p_init_wgl_extensions( &display_funcs ) ); + driver_funcs->p_init_extensions( &display_funcs, &global_extensions ); display_funcs.p_wglGetPixelFormat = win32u_wglGetPixelFormat; display_funcs.p_wglSetPixelFormat = win32u_wglSetPixelFormat; @@ -2725,52 +2704,52 @@ static void display_funcs_init(void) display_funcs.p_context_destroy = win32u_context_destroy; display_funcs.p_context_reset = win32u_context_reset; - register_extension( wgl_extensions, ARRAY_SIZE(wgl_extensions), "WGL_ARB_pixel_format" ); + global_extensions.has_WGL_ARB_pixel_format = 1; display_funcs.p_wglChoosePixelFormatARB = (void *)1; /* never called */ display_funcs.p_wglGetPixelFormatAttribfvARB = (void *)1; /* never called */ display_funcs.p_wglGetPixelFormatAttribivARB = (void *)1; /* never called */ if (display_egl.has_EGL_EXT_pixel_format_float) { - register_extension( wgl_extensions, ARRAY_SIZE(wgl_extensions), "WGL_ARB_pixel_format_float" ); - register_extension( wgl_extensions, ARRAY_SIZE(wgl_extensions), "WGL_ATI_pixel_format_float" ); + global_extensions.has_WGL_ARB_pixel_format_float = 1; + global_extensions.has_WGL_ATI_pixel_format_float = 1; } - register_extension( wgl_extensions, ARRAY_SIZE(wgl_extensions), "WGL_ARB_extensions_string" ); - display_funcs.p_wglGetExtensionsStringARB = win32u_wglGetExtensionsStringARB; + global_extensions.has_WGL_ARB_extensions_string = 1; + display_funcs.p_wglGetExtensionsStringARB = (void *)1 /* never called */; - register_extension( wgl_extensions, ARRAY_SIZE(wgl_extensions), "WGL_EXT_extensions_string" ); - display_funcs.p_wglGetExtensionsStringEXT = win32u_wglGetExtensionsStringEXT; + global_extensions.has_WGL_EXT_extensions_string = 1; + display_funcs.p_wglGetExtensionsStringEXT = (void *)1 /* never called */; /* In WineD3D we need the ability to set the pixel format more than once (e.g. after a device reset). * The default wglSetPixelFormat doesn't allow this, so add our own which allows it. */ - register_extension( wgl_extensions, ARRAY_SIZE(wgl_extensions), "WGL_WINE_pixel_format_passthrough" ); + global_extensions.has_WGL_WINE_pixel_format_passthrough = 1; display_funcs.p_wglSetPixelFormatWINE = win32u_wglSetPixelFormatWINE; - register_extension( wgl_extensions, ARRAY_SIZE(wgl_extensions), "WGL_ARB_create_context" ); - register_extension( wgl_extensions, ARRAY_SIZE(wgl_extensions), "WGL_ARB_create_context_no_error" ); - register_extension( wgl_extensions, ARRAY_SIZE(wgl_extensions), "WGL_ARB_create_context_profile" ); + global_extensions.has_WGL_ARB_create_context = 1; + global_extensions.has_WGL_ARB_create_context_no_error = 1; + global_extensions.has_WGL_ARB_create_context_profile = 1; display_funcs.p_wglCreateContextAttribsARB = (void *)1; /* never called */ - register_extension( wgl_extensions, ARRAY_SIZE(wgl_extensions), "WGL_ARB_make_current_read" ); + global_extensions.has_WGL_ARB_make_current_read = 1; display_funcs.p_wglGetCurrentReadDCARB = (void *)1; /* never called */ display_funcs.p_wglMakeContextCurrentARB = win32u_wglMakeContextCurrentARB; - register_extension( wgl_extensions, ARRAY_SIZE(wgl_extensions), "WGL_ARB_pbuffer" ); + global_extensions.has_WGL_ARB_pbuffer = 1; display_funcs.p_wglCreatePbufferARB = win32u_wglCreatePbufferARB; display_funcs.p_wglDestroyPbufferARB = win32u_wglDestroyPbufferARB; display_funcs.p_wglGetPbufferDCARB = win32u_wglGetPbufferDCARB; display_funcs.p_wglReleasePbufferDCARB = win32u_wglReleasePbufferDCARB; display_funcs.p_wglQueryPbufferARB = win32u_wglQueryPbufferARB; - register_extension( wgl_extensions, ARRAY_SIZE(wgl_extensions), "WGL_ARB_render_texture" ); + global_extensions.has_WGL_ARB_render_texture = 1; display_funcs.p_wglBindTexImageARB = win32u_wglBindTexImageARB; display_funcs.p_wglReleaseTexImageARB = win32u_wglReleaseTexImageARB; display_funcs.p_wglSetPbufferAttribARB = win32u_wglSetPbufferAttribARB; - register_extension( wgl_extensions, ARRAY_SIZE(wgl_extensions), "WGL_EXT_swap_control" ); - register_extension( wgl_extensions, ARRAY_SIZE(wgl_extensions), "WGL_EXT_swap_control_tear" ); + global_extensions.has_WGL_EXT_swap_control = 1; + global_extensions.has_WGL_EXT_swap_control_tear = 1; display_funcs.p_wglSwapIntervalEXT = win32u_wglSwapIntervalEXT; display_funcs.p_wglGetSwapIntervalEXT = win32u_wglGetSwapIntervalEXT; @@ -2787,7 +2766,7 @@ static void display_funcs_init(void) if (!list_empty( &devices_egl )) { - register_extension( wgl_extensions, ARRAY_SIZE(wgl_extensions), "WGL_WINE_query_renderer" ); + global_extensions.has_WGL_WINE_query_renderer = 1; display_funcs.p_query_renderer = win32u_query_renderer; display_funcs.p_wglQueryCurrentRendererIntegerWINE = win32u_wglQueryCurrentRendererIntegerWINE; display_funcs.p_wglQueryCurrentRendererStringWINE = win32u_wglQueryCurrentRendererStringWINE; diff --git a/dlls/wineandroid.drv/opengl.c b/dlls/wineandroid.drv/opengl.c index 1efd312b940..35ad091e91f 100644 --- a/dlls/wineandroid.drv/opengl.c +++ b/dlls/wineandroid.drv/opengl.c @@ -157,16 +157,16 @@ static void android_drawable_flush( struct opengl_drawable *base, UINT flags ) if (flags & GL_FLUSH_INTERVAL) funcs->p_eglSwapInterval( egl->display, abs( base->interval ) ); } -static const char *android_init_wgl_extensions( struct opengl_funcs *funcs ) +static void android_init_extensions( struct opengl_funcs *funcs, struct opengl_extensions *extensions ) { - return "WGL_EXT_framebuffer_sRGB"; + extensions->has_WGL_EXT_framebuffer_sRGB = 1; } static struct opengl_driver_funcs android_driver_funcs = { .p_init_egl_platform = android_init_egl_platform, .p_get_proc_address = android_get_proc_address, - .p_init_wgl_extensions = android_init_wgl_extensions, + .p_init_extensions = android_init_extensions, .p_surface_create = android_surface_create, }; diff --git a/dlls/winemac.drv/opengl.c b/dlls/winemac.drv/opengl.c index e60fc04a82e..b7226bb07a4 100644 --- a/dlls/winemac.drv/opengl.c +++ b/dlls/winemac.drv/opengl.c @@ -46,8 +46,6 @@ WINE_DEFAULT_DEBUG_CHANNEL(wgl); struct gl_info { char *glExtensions; - char wglExtensions[4096]; - GLint max_viewport_dims[2]; unsigned int max_major, max_minor; @@ -2537,16 +2535,7 @@ static BOOL macdrv_pbuffer_updated(HDC hdc, struct opengl_drawable *base, GLenum return GL_TRUE; } -static void register_extension(const char *ext) -{ - if (gl_info.wglExtensions[0]) - strcat(gl_info.wglExtensions, " "); - strcat(gl_info.wglExtensions, ext); - - TRACE("'%s'\n", ext); -} - -static const char *macdrv_init_wgl_extensions(struct opengl_funcs *funcs) +static void macdrv_init_extensions(struct opengl_funcs *funcs, struct opengl_extensions *extensions) { /* * ARB Extensions @@ -2554,42 +2543,40 @@ static const char *macdrv_init_wgl_extensions(struct opengl_funcs *funcs) if (gluCheckExtension((GLubyte*)"GL_ARB_color_buffer_float", (GLubyte*)gl_info.glExtensions)) { - register_extension("WGL_ARB_pixel_format_float"); - register_extension("WGL_ATI_pixel_format_float"); + extensions->has_WGL_ARB_pixel_format_float = 1; + extensions->has_WGL_ATI_pixel_format_float = 1; } if (gluCheckExtension((GLubyte*)"GL_ARB_multisample", (GLubyte*)gl_info.glExtensions)) - register_extension("WGL_ARB_multisample"); + extensions->has_WGL_ARB_multisample = 1; if (gluCheckExtension((GLubyte*)"GL_ARB_framebuffer_sRGB", (GLubyte*)gl_info.glExtensions)) - register_extension("WGL_ARB_framebuffer_sRGB"); + extensions->has_WGL_ARB_framebuffer_sRGB = 1; if (gluCheckExtension((GLubyte*)"GL_APPLE_pixel_buffer", (GLubyte*)gl_info.glExtensions)) { if (gluCheckExtension((GLubyte*)"GL_ARB_texture_rectangle", (GLubyte*)gl_info.glExtensions) || gluCheckExtension((GLubyte*)"GL_EXT_texture_rectangle", (GLubyte*)gl_info.glExtensions)) - register_extension("WGL_NV_render_texture_rectangle"); + extensions->has_WGL_NV_render_texture_rectangle = 1; } /* Presumably identical to [W]GL_ARB_framebuffer_sRGB, above, but clients may check for either, so register them separately. */ if (gluCheckExtension((GLubyte*)"GL_EXT_framebuffer_sRGB", (GLubyte*)gl_info.glExtensions)) - register_extension("WGL_EXT_framebuffer_sRGB"); + extensions->has_WGL_EXT_framebuffer_sRGB = 1; if (gluCheckExtension((GLubyte*)"GL_EXT_packed_float", (GLubyte*)gl_info.glExtensions)) - register_extension("WGL_EXT_pixel_format_packed_float"); + extensions->has_WGL_EXT_pixel_format_packed_float = 1; /* * WINE-specific WGL Extensions */ - register_extension("WGL_WINE_query_renderer"); + extensions->has_WGL_WINE_query_renderer = 1; funcs->p_wglQueryCurrentRendererIntegerWINE = macdrv_wglQueryCurrentRendererIntegerWINE; funcs->p_wglQueryCurrentRendererStringWINE = macdrv_wglQueryCurrentRendererStringWINE; funcs->p_wglQueryRendererIntegerWINE = macdrv_wglQueryRendererIntegerWINE; funcs->p_wglQueryRendererStringWINE = macdrv_wglQueryRendererStringWINE; - - return gl_info.wglExtensions; } /********************************************************************** @@ -2769,7 +2756,7 @@ static const struct opengl_driver_funcs macdrv_driver_funcs = .p_get_proc_address = macdrv_get_proc_address, .p_init_pixel_formats = macdrv_init_pixel_formats, .p_describe_pixel_format = macdrv_describe_pixel_format, - .p_init_wgl_extensions = macdrv_init_wgl_extensions, + .p_init_extensions = macdrv_init_extensions, .p_surface_create = macdrv_surface_create, .p_context_create = macdrv_context_create, .p_context_destroy = macdrv_context_destroy, diff --git a/dlls/winewayland.drv/opengl.c b/dlls/winewayland.drv/opengl.c index 9a4b14ec7d9..0e78259f3c1 100644 --- a/dlls/winewayland.drv/opengl.c +++ b/dlls/winewayland.drv/opengl.c @@ -259,7 +259,7 @@ UINT WAYLAND_OpenGLInit(UINT version, const struct opengl_funcs *opengl_funcs, c wayland_driver_funcs.p_get_proc_address = (*driver_funcs)->p_get_proc_address; wayland_driver_funcs.p_init_pixel_formats = (*driver_funcs)->p_init_pixel_formats; wayland_driver_funcs.p_describe_pixel_format = (*driver_funcs)->p_describe_pixel_format; - wayland_driver_funcs.p_init_wgl_extensions = (*driver_funcs)->p_init_wgl_extensions; + wayland_driver_funcs.p_init_extensions = (*driver_funcs)->p_init_extensions; wayland_driver_funcs.p_context_create = (*driver_funcs)->p_context_create; wayland_driver_funcs.p_context_destroy = (*driver_funcs)->p_context_destroy; wayland_driver_funcs.p_make_current = (*driver_funcs)->p_make_current; diff --git a/dlls/winex11.drv/opengl.c b/dlls/winex11.drv/opengl.c index 01eb3b9c356..6c4a5f08994 100644 --- a/dlls/winex11.drv/opengl.c +++ b/dlls/winex11.drv/opengl.c @@ -181,7 +181,6 @@ typedef XID GLXPbuffer; static const char *glExtensions; static const char *glxExtensions; -static char wglExtensions[4096]; static int glxVersion[2]; static int glx_opcode; @@ -1376,29 +1375,19 @@ static BOOL glxRequireVersion(int requiredVersion) return (requiredVersion <= glxVersion[1]); } -static void register_extension(const char *ext) +static void x11drv_init_extensions( struct opengl_funcs *funcs, struct opengl_extensions *extensions ) { - if (wglExtensions[0]) - strcat(wglExtensions, " "); - strcat(wglExtensions, ext); - - TRACE("'%s'\n", ext); -} - -static const char *x11drv_init_wgl_extensions( struct opengl_funcs *funcs ) -{ - wglExtensions[0] = 0; - /* ARB Extensions */ - if (has_extension( glxExtensions, "GLX_ARB_multisample")) register_extension( "WGL_ARB_multisample" ); + if (has_extension( glxExtensions, "GLX_ARB_multisample")) + extensions->has_WGL_ARB_multisample = 1; - register_extension("WGL_ARB_pixel_format"); + extensions->has_WGL_ARB_pixel_format = 1; if (has_extension( glxExtensions, "GLX_ARB_fbconfig_float")) { - register_extension("WGL_ARB_pixel_format_float"); - register_extension("WGL_ATI_pixel_format_float"); + extensions->has_WGL_ARB_pixel_format_float = 1; + extensions->has_WGL_ATI_pixel_format_float = 1; } /* Support WGL_ARB_render_texture when there's support or pbuffer based emulation */ @@ -1406,20 +1395,20 @@ static const char *x11drv_init_wgl_extensions( struct opengl_funcs *funcs ) { /* The WGL version of GLX_NV_float_buffer requires render_texture */ if (has_extension( glxExtensions, "GLX_NV_float_buffer")) - register_extension("WGL_NV_float_buffer"); + extensions->has_WGL_NV_float_buffer = 1; /* Again there's no GLX equivalent for this extension, so depend on the required GL extension */ if (has_extension(glExtensions, "GL_NV_texture_rectangle")) - register_extension("WGL_NV_render_texture_rectangle"); + extensions->has_WGL_NV_render_texture_rectangle = 1; } /* EXT Extensions */ if (has_extension( glxExtensions, "GLX_EXT_framebuffer_sRGB")) - register_extension("WGL_EXT_framebuffer_sRGB"); + extensions->has_WGL_EXT_framebuffer_sRGB = 1; if (has_extension( glxExtensions, "GLX_EXT_fbconfig_packed_float")) - register_extension("WGL_EXT_pixel_format_packed_float"); + extensions->has_WGL_EXT_pixel_format_packed_float = 1; if (has_extension( glxExtensions, "GLX_EXT_swap_control")) { @@ -1438,7 +1427,7 @@ static const char *x11drv_init_wgl_extensions( struct opengl_funcs *funcs ) /* The OpenGL extension GL_NV_vertex_array_range adds wgl/glX functions which aren't exported as 'real' wgl/glX extensions. */ if (has_extension(glExtensions, "GL_NV_vertex_array_range")) { - register_extension( "WGL_NV_vertex_array_range" ); + extensions->has_WGL_NV_vertex_array_range = 1; funcs->p_wglAllocateMemoryNV = pglXAllocateMemoryNV; funcs->p_wglFreeMemoryNV = pglXFreeMemoryNV; } @@ -1450,14 +1439,12 @@ static const char *x11drv_init_wgl_extensions( struct opengl_funcs *funcs ) if (has_extension( glxExtensions, "GLX_MESA_query_renderer" )) { - register_extension( "WGL_WINE_query_renderer" ); + extensions->has_WGL_WINE_query_renderer = 1; funcs->p_wglQueryCurrentRendererIntegerWINE = X11DRV_wglQueryCurrentRendererIntegerWINE; funcs->p_wglQueryCurrentRendererStringWINE = X11DRV_wglQueryCurrentRendererStringWINE; funcs->p_wglQueryRendererIntegerWINE = X11DRV_wglQueryRendererIntegerWINE; funcs->p_wglQueryRendererStringWINE = X11DRV_wglQueryRendererStringWINE; } - - return wglExtensions; } static BOOL x11drv_surface_swap( struct opengl_drawable *base ) @@ -1525,7 +1512,7 @@ static struct opengl_driver_funcs x11drv_driver_funcs = .p_get_proc_address = x11drv_get_proc_address, .p_init_pixel_formats = x11drv_init_pixel_formats, .p_describe_pixel_format = x11drv_describe_pixel_format, - .p_init_wgl_extensions = x11drv_init_wgl_extensions, + .p_init_extensions = x11drv_init_extensions, .p_surface_create = x11drv_surface_create, .p_context_create = x11drv_context_create, .p_context_destroy = x11drv_context_destroy, diff --git a/include/wine/opengl_driver.h b/include/wine/opengl_driver.h index 05730fcf093..2d05fc677c9 100644 --- a/include/wine/opengl_driver.h +++ b/include/wine/opengl_driver.h @@ -75,6 +75,7 @@ struct opengl_client_context UINT64 unix_handle; UINT64 unix_funcs; GLenum last_error; + struct opengl_extensions extensions; /* exposed client extensions */ }; static inline struct opengl_client_context *opengl_client_context_from_client( HGLRC client_context ) @@ -114,6 +115,7 @@ struct opengl_context HGLRC client_context; /* client side context pointer */ void *driver_private; /* driver context / private data */ void *internal_context; /* driver context for win32u internal use */ + struct opengl_extensions extensions; /* available host extensions */ int format; /* pixel format of the context */ struct opengl_drawable *draw; /* currently bound draw surface */ struct opengl_drawable *read; /* currently bound read surface */ @@ -136,6 +138,7 @@ struct opengl_funcs ALL_GL_FUNCS ALL_GL_EXT_FUNCS #undef USE_GL_FUNC + void (*p_init_extensions)( struct opengl_extensions *extensions ); void (*p_get_pixel_formats)( struct wgl_pixel_format *formats, UINT max_formats, UINT *num_formats, UINT *num_onscreen_formats ); BOOL (*p_query_renderer)( UINT attribute, void *value ); BOOL (*p_context_flush)( struct opengl_context *context, void (*flush)(void), UINT flags ); @@ -228,7 +231,7 @@ struct opengl_driver_funcs void *(*p_get_proc_address)(const char *); UINT (*p_init_pixel_formats)(UINT*); BOOL (*p_describe_pixel_format)(int,struct wgl_pixel_format*); - const char *(*p_init_wgl_extensions)(struct opengl_funcs *funcs); + void (*p_init_extensions)( struct opengl_funcs *funcs, struct opengl_extensions *extensions ); BOOL (*p_surface_create)( HWND hwnd, int format, struct opengl_drawable **drawable ); BOOL (*p_context_create)( int format, void *share, const int *attribs, void **context ); BOOL (*p_context_destroy)(void*); -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10019
From: Rémi Bernon <rbernon@codeweavers.com> --- dlls/opengl32/unix_wgl.c | 54 ++++++++++++++++++++++++++-------------- dlls/win32u/opengl.c | 1 + 2 files changed, 37 insertions(+), 18 deletions(-) diff --git a/dlls/opengl32/unix_wgl.c b/dlls/opengl32/unix_wgl.c index 32a939ff4a0..ba00b548f39 100644 --- a/dlls/opengl32/unix_wgl.c +++ b/dlls/opengl32/unix_wgl.c @@ -887,12 +887,6 @@ const GLubyte *wrap_glGetStringi( TEB *teb, GLenum name, GLuint index ) { const struct opengl_funcs *funcs = teb->glTable; - if (!funcs->p_glGetStringi) - { - void **func_ptr = (void **)&funcs->p_glGetStringi; - *func_ptr = funcs->p_wglGetProcAddress( "glGetStringi" ); - } - if (name == GL_EXTENSIONS) { struct context *ctx = get_current_context( teb, NULL, NULL ); @@ -980,7 +974,7 @@ static BOOL initialize_vk_device( TEB *teb, struct context *ctx ) static PFN_vkGetPhysicalDeviceProperties2KHR p_vkGetPhysicalDeviceProperties2KHR; if (ctx->buffers->vk_device) return TRUE; /* already initialized */ - if (!is_extension_supported( ctx, "GL_EXT_memory_object_fd" )) + if (!ctx->base.extensions.has_GL_EXT_memory_object_fd) { TRACE( "GL_EXT_memory_object_fd is not supported\n" ); return FALSE; @@ -1213,7 +1207,7 @@ static void make_context_current( TEB *teb, const struct opengl_funcs *funcs, HD struct opengl_client_context *client = opengl_client_context_from_client( ctx->base.client_context ); DWORD tid = HandleToULong(teb->ClientId.UniqueThread); size_t size = ARRAYSIZE(legacy_extensions) - 1, count = 0; - const char *version, *rest = "", **extensions; + const char *version, *rest = "", **extensions, *ext; int i, j; static const char *disabled, *enabled; @@ -1235,7 +1229,24 @@ static void make_context_current( TEB *teb, const struct opengl_funcs *funcs, HD funcs->p_init_extensions( &ctx->base.extensions ); + if (ctx->major_version >= 3) + { + GLint num; + funcs->p_glGetIntegerv( GL_NUM_EXTENSIONS, &num ); + for (GLint i = 0; i < num; i++) + { + ext = (const char *)funcs->p_glGetStringi( GL_EXTENSIONS, i ); + add_extension( &ctx->base.extensions, ext, strlen( ext ), TRUE ); + } + } + else if ((ext = (const char *)funcs->p_glGetString( GL_EXTENSIONS ))) + { + parse_extensions( &ctx->base.extensions, ext, TRUE ); + } + dump_extensions( "Host", &ctx->base.extensions ); + #define USE_GL_EXT(x) if (enabled_extensions.has_ ## x) client->extensions.has_ ## x = ctx->base.extensions.has_ ## x; + ALL_GL_CLIENT_EXTS ALL_WGL_EXTS #undef USE_GL_EXT @@ -1245,13 +1256,6 @@ static void make_context_current( TEB *teb, const struct opengl_funcs *funcs, HD if (ctx->major_version >= 3) { GLint extensions_count; - - if (!funcs->p_glGetStringi) - { - void **func_ptr = (void **)&funcs->p_glGetStringi; - *func_ptr = funcs->p_wglGetProcAddress( "glGetStringi" ); - } - funcs->p_glGetIntegerv( GL_NUM_EXTENSIONS, &extensions_count ); size += extensions_count; if (!(extensions = malloc( size * sizeof(*extensions) ))) return; @@ -1298,15 +1302,24 @@ static void make_context_current( TEB *teb, const struct opengl_funcs *funcs, HD count = j; } - if (funcs->p_glImportMemoryWin32HandleEXT) extensions[count++] = "GL_EXT_memory_object_win32"; - if (funcs->p_glImportSemaphoreWin32HandleEXT) extensions[count++] = "GL_EXT_semaphore_win32"; + if (funcs->p_glImportMemoryWin32HandleEXT) + { + client->extensions.has_GL_EXT_memory_object_win32 = 1; + extensions[count++] = "GL_EXT_memory_object_win32"; + } + if (funcs->p_glImportSemaphoreWin32HandleEXT) + { + client->extensions.has_GL_EXT_semaphore_win32 = 1; + extensions[count++] = "GL_EXT_semaphore_win32"; + } + for (i = 0; legacy_extensions[i]; i++) extensions[count++] = legacy_extensions[i]; qsort( extensions, count, sizeof(*extensions), string_array_cmp ); ctx->extension_array = extensions; ctx->extension_count = count; if (is_win64 && ctx->buffers && !initialize_vk_device( teb, ctx ) - && !(ctx->use_pinned_memory = is_extension_supported( ctx, "GL_AMD_pinned_memory" ))) + && !(ctx->use_pinned_memory = ctx->base.extensions.has_GL_AMD_pinned_memory)) { if (ctx->major_version > 4 || (ctx->major_version == 4 && ctx->minor_version > 3)) { @@ -1325,6 +1338,11 @@ static void make_context_current( TEB *teb, const struct opengl_funcs *funcs, HD } extensions[j++] = ext; } + if (client->extensions.has_GL_ARB_buffer_storage) + { + FIXME( "Disabling has_GL_ARB_buffer_storage extension on wow64\n" ); + client->extensions.has_GL_ARB_buffer_storage = 0; + } ctx->extension_count = j; } diff --git a/dlls/win32u/opengl.c b/dlls/win32u/opengl.c index 225b3fe1c8a..a65e791c534 100644 --- a/dlls/win32u/opengl.c +++ b/dlls/win32u/opengl.c @@ -2674,6 +2674,7 @@ static void display_funcs_init(void) USE_GL_FUNC(glDeleteFramebuffers) USE_GL_FUNC(glDeleteRenderbuffers) USE_GL_FUNC(glGetNamedFramebufferAttachmentParameteriv) + USE_GL_FUNC(glGetStringi) USE_GL_FUNC(glGetUnsignedBytei_vEXT) USE_GL_FUNC(glGetUnsignedBytevEXT) USE_GL_FUNC(glImportMemoryFdEXT) -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10019
From: Rémi Bernon <rbernon@codeweavers.com> --- dlls/opengl32/make_opengl | 1 + dlls/opengl32/thunks.c | 8 -------- dlls/opengl32/unix_wgl.c | 33 +++++++++++++-------------------- dlls/opengl32/wgl.c | 23 +++++++++++++++++++++++ include/wine/opengl_driver.h | 2 ++ 5 files changed, 39 insertions(+), 28 deletions(-) diff --git a/dlls/opengl32/make_opengl b/dlls/opengl32/make_opengl index 6d0cfd9029c..d799eb2a4d7 100755 --- a/dlls/opengl32/make_opengl +++ b/dlls/opengl32/make_opengl @@ -168,6 +168,7 @@ my %manual_win_thunks = "glCreateSyncFromCLeventARB" => 1, "glDeleteSync" => 1, "glFenceSync" => 1, + "glGetIntegerv" => 1, "glGetString" => 1, "glGetStringi" => 1, "glImportSyncEXT" => 1, diff --git a/dlls/opengl32/thunks.c b/dlls/opengl32/thunks.c index 3c60ec5d6bb..c3696f3406b 100644 --- a/dlls/opengl32/thunks.c +++ b/dlls/opengl32/thunks.c @@ -882,14 +882,6 @@ void WINAPI glGetFloatv( GLenum pname, GLfloat *data ) if ((status = UNIX_CALL( glGetFloatv, &args ))) WARN( "glGetFloatv returned %#lx\n", status ); } -void WINAPI glGetIntegerv( GLenum pname, GLint *data ) -{ - struct glGetIntegerv_params args = { .teb = NtCurrentTeb(), .pname = pname, .data = data }; - NTSTATUS status; - TRACE( "pname %d, data %p\n", pname, data ); - if ((status = UNIX_CALL( glGetIntegerv, &args ))) WARN( "glGetIntegerv returned %#lx\n", status ); -} - void WINAPI glGetLightfv( GLenum light, GLenum pname, GLfloat *params ) { struct glGetLightfv_params args = { .teb = NtCurrentTeb(), .light = light, .pname = pname, .params = params }; diff --git a/dlls/opengl32/unix_wgl.c b/dlls/opengl32/unix_wgl.c index ba00b548f39..72c5850c844 100644 --- a/dlls/opengl32/unix_wgl.c +++ b/dlls/opengl32/unix_wgl.c @@ -126,8 +126,6 @@ struct context HGLRC share; /* context to be shared with */ int *attribs; /* creation attributes */ DWORD tid; /* thread that the context is current in */ - int major_version; /* major GL version */ - int minor_version; /* minor GL version */ UINT64 debug_callback; /* client pointer */ UINT64 debug_user; /* client pointer */ GLubyte *extensions; /* extension string */ @@ -713,6 +711,7 @@ static GLubyte *filter_extensions( struct context *ctx, const char *extensions, /* Check if any GL extension from the list is supported */ static BOOL is_any_extension_supported( struct context *ctx, const char *extension ) { + struct opengl_client_context *client = opengl_client_context_from_client( ctx->base.client_context ); size_t len; /* We use the GetProcAddress function from the display driver to retrieve function pointers @@ -739,10 +738,10 @@ static BOOL is_any_extension_supported( struct context *ctx, const char *extensi /* Compare the major/minor version numbers of the native OpenGL library and what is required by the function. * The gl_version string is guaranteed to have at least a major/minor and sometimes it has a release number as well. */ - if (ctx->major_version > major || (ctx->major_version == major && ctx->minor_version >= minor)) return TRUE; + if (client->major_version > major || (client->major_version == major && client->minor_version >= minor)) return TRUE; WARN( "The function requires OpenGL version '%d.%d' while your drivers only provide '%d.%d'\n", - major, minor, ctx->major_version, ctx->minor_version ); + major, minor, client->major_version, client->minor_version ); } extension += len + 1; @@ -810,12 +809,6 @@ static BOOL get_integer( TEB *teb, GLenum pname, GLint *data ) switch (pname) { - case GL_MAJOR_VERSION: - *data = ctx->major_version; - return TRUE; - case GL_MINOR_VERSION: - *data = ctx->minor_version; - return TRUE; case GL_NUM_EXTENSIONS: *data = ctx->extension_count; return TRUE; @@ -1220,16 +1213,16 @@ static void make_context_current( TEB *teb, const struct opengl_funcs *funcs, HD pthread_once( &once, init_enabled_extensions ); - if (ctx->major_version) return; /* already synced */ + if (client->major_version) return; /* already synced */ version = (const char *)funcs->p_glGetString( GL_VERSION ); - if (version) rest = parse_gl_version( version, &ctx->major_version, &ctx->minor_version ); - if (!ctx->major_version) ctx->major_version = 1; - TRACE( "context %p version %d.%d\n", ctx, ctx->major_version, ctx->minor_version ); + if (version) rest = parse_gl_version( version, &client->major_version, &client->minor_version ); + if (!client->major_version) client->major_version = 1; + TRACE( "context %p version %d.%d\n", ctx, client->major_version, client->minor_version ); funcs->p_init_extensions( &ctx->base.extensions ); - if (ctx->major_version >= 3) + if (client->major_version >= 3) { GLint num; funcs->p_glGetIntegerv( GL_NUM_EXTENSIONS, &num ); @@ -1253,7 +1246,7 @@ static void make_context_current( TEB *teb, const struct opengl_funcs *funcs, HD if (funcs->p_glImportMemoryWin32HandleEXT) size++; if (funcs->p_glImportSemaphoreWin32HandleEXT) size++; - if (ctx->major_version >= 3) + if (client->major_version >= 3) { GLint extensions_count; funcs->p_glGetIntegerv( GL_NUM_EXTENSIONS, &extensions_count ); @@ -1321,11 +1314,11 @@ static void make_context_current( TEB *teb, const struct opengl_funcs *funcs, HD if (is_win64 && ctx->buffers && !initialize_vk_device( teb, ctx ) && !(ctx->use_pinned_memory = ctx->base.extensions.has_GL_AMD_pinned_memory)) { - if (ctx->major_version > 4 || (ctx->major_version == 4 && ctx->minor_version > 3)) + if (client->major_version > 4 || (client->major_version == 4 && client->minor_version > 3)) { - FIXME( "GL version %d.%d is not supported on wow64, using 4.3\n", ctx->major_version, ctx->minor_version ); - ctx->major_version = 4; - ctx->minor_version = 3; + FIXME( "GL version %d.%d is not supported on wow64, using 4.3\n", client->major_version, client->minor_version ); + client->major_version = 4; + client->minor_version = 3; asprintf( &ctx->wow64_version, "4.3%s", rest ); } for (i = 0, j = 0; i < count; i++) diff --git a/dlls/opengl32/wgl.c b/dlls/opengl32/wgl.c index e7fa8eef712..312cc38c263 100644 --- a/dlls/opengl32/wgl.c +++ b/dlls/opengl32/wgl.c @@ -2018,6 +2018,29 @@ GLsync WINAPI glImportSyncEXT( GLenum external_sync_type, GLintptr external_sync return NULL; } +void WINAPI glGetIntegerv( GLenum name, GLint *data ) +{ + struct glGetIntegerv_params args = { .teb = NtCurrentTeb(), .pname = name, .data = data }; + struct context *ctx; + NTSTATUS status; + + TRACE( "name %d, data %p\n", name, data ); + + if (!(ctx = context_from_handle( NtCurrentTeb()->glCurrentRC ))) return; + + switch (name) + { + case GL_MAJOR_VERSION: + *data = ctx->base.major_version; + return; + case GL_MINOR_VERSION: + *data = ctx->base.minor_version; + return; + } + + if ((status = UNIX_CALL( glGetIntegerv, &args ))) WARN( "glGetIntegerv returned %#lx\n", status ); +} + const GLubyte * WINAPI glGetStringi( GLenum name, GLuint index ) { struct glGetStringi_params args = diff --git a/include/wine/opengl_driver.h b/include/wine/opengl_driver.h index 2d05fc677c9..402e2997869 100644 --- a/include/wine/opengl_driver.h +++ b/include/wine/opengl_driver.h @@ -75,6 +75,8 @@ struct opengl_client_context UINT64 unix_handle; UINT64 unix_funcs; GLenum last_error; + int major_version; + int minor_version; struct opengl_extensions extensions; /* exposed client extensions */ }; -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10019
From: Rémi Bernon <rbernon@codeweavers.com> --- dlls/opengl32/make_opengl | 1 - dlls/opengl32/unix_thunks.c | 4 +- dlls/opengl32/unix_thunks.h | 1 - dlls/opengl32/unix_wgl.c | 108 ++++++++++------------------------- dlls/opengl32/wgl.c | 54 ++++++++++++++++++ include/wine/opengl_driver.h | 7 +++ 6 files changed, 92 insertions(+), 83 deletions(-) diff --git a/dlls/opengl32/make_opengl b/dlls/opengl32/make_opengl index d799eb2a4d7..8704ec90b13 100755 --- a/dlls/opengl32/make_opengl +++ b/dlls/opengl32/make_opengl @@ -214,7 +214,6 @@ my %manual_unix_thunks = "glGetInteger64v" => 1, "glGetIntegerv" => 1, "glGetString" => 1, - "glGetStringi" => 1, "glGetUnsignedBytevEXT" => 1, "glImportSyncEXT" => 1, "glNamedFramebufferDrawBuffer" => 1, diff --git a/dlls/opengl32/unix_thunks.c b/dlls/opengl32/unix_thunks.c index 3a93f2e61e0..73ecc42cffb 100644 --- a/dlls/opengl32/unix_thunks.c +++ b/dlls/opengl32/unix_thunks.c @@ -12301,7 +12301,7 @@ static NTSTATUS ext_glGetStringi( void *args ) struct glGetStringi_params *params = args; const struct opengl_funcs *funcs = params->teb->glTable; if (!funcs->p_glGetStringi) return STATUS_NOT_IMPLEMENTED; - params->ret = wrap_glGetStringi( params->teb, params->name, params->index ); + params->ret = funcs->p_glGetStringi( params->name, params->index ); return STATUS_SUCCESS; } @@ -55059,7 +55059,7 @@ static NTSTATUS wow64_ext_glGetStringi( void *args ) const GLubyte *ret; const struct opengl_funcs *funcs = teb->glTable; if (!funcs->p_glGetStringi) return STATUS_NOT_IMPLEMENTED; - ret = wrap_glGetStringi( teb, params->name, params->index ); + ret = funcs->p_glGetStringi( params->name, params->index ); return return_wow64_string( ret, ¶ms->ret ); } diff --git a/dlls/opengl32/unix_thunks.h b/dlls/opengl32/unix_thunks.h index 2c0824e0268..a86626520f4 100644 --- a/dlls/opengl32/unix_thunks.h +++ b/dlls/opengl32/unix_thunks.h @@ -34,7 +34,6 @@ extern void wrap_glFramebufferDrawBuffersEXT( TEB *teb, GLuint framebuffer, GLsi extern void wrap_glFramebufferReadBufferEXT( TEB *teb, GLuint framebuffer, GLenum mode ); extern void wrap_glGetFramebufferParameterivEXT( TEB *teb, GLuint framebuffer, GLenum pname, GLint *params ); extern void wrap_glGetInteger64v( TEB *teb, GLenum pname, GLint64 *data ); -extern const GLubyte *wrap_glGetStringi( TEB *teb, GLenum name, GLuint index ); extern void wrap_glGetUnsignedBytevEXT( TEB *teb, GLenum pname, GLubyte *data ); extern GLsync wrap_glImportSyncEXT( TEB *teb, GLenum external_sync_type, GLintptr external_sync, GLbitfield flags, GLsync handle ); extern void wrap_glNamedFramebufferDrawBuffer( TEB *teb, GLuint framebuffer, GLenum buf ); diff --git a/dlls/opengl32/unix_wgl.c b/dlls/opengl32/unix_wgl.c index 72c5850c844..98c1d7fc68c 100644 --- a/dlls/opengl32/unix_wgl.c +++ b/dlls/opengl32/unix_wgl.c @@ -653,61 +653,6 @@ static BOOL is_extension_supported( struct context *ctx, const char *extension ) sizeof(ctx->extension_array[0]), string_array_cmp ) != NULL; } -static char *append_extension( char *ptr, const char *name ) -{ - size_t size = strlen( name ); - memcpy( ptr, name, size ); - ptr += size; - *ptr++ = ' '; - return ptr; -} - -/* build the extension string by filtering out the disabled extensions */ -static GLubyte *filter_extensions( struct context *ctx, const char *extensions, const struct opengl_funcs *funcs ) -{ - const char *end, **extra; - size_t size; - char *p, *str; - - size = strlen( extensions ) + 2; - if (funcs->p_glImportMemoryWin32HandleEXT) size += strlen( "GL_EXT_memory_object_win32" ) + 1; - if (funcs->p_glImportSemaphoreWin32HandleEXT) size += strlen( "GL_EXT_semaphore_win32" ) + 1; - for (extra = legacy_extensions; *extra; extra++) size += strlen( *extra ) + 1; - if (!(p = str = malloc( size ))) return NULL; - - TRACE( "GL_EXTENSIONS:\n" ); - - for (;;) - { - while (*extensions == ' ') extensions++; - if (!*extensions) break; - - if (!(end = strchr( extensions, ' ' ))) end = extensions + strlen( extensions ); - memcpy( p, extensions, end - extensions ); - p[end - extensions] = 0; - - if (is_extension_supported( ctx, p )) - { - TRACE( "++ %s\n", p ); - p += end - extensions; - *p++ = ' '; - } - else - { - TRACE( "-- %s (disabled in context)\n", p ); - } - extensions = end; - } - - if (funcs->p_glImportMemoryWin32HandleEXT) p = append_extension( p, "GL_EXT_memory_object_win32" ); - if (funcs->p_glImportSemaphoreWin32HandleEXT) p = append_extension( p, "GL_EXT_semaphore_win32" ); - for (extra = legacy_extensions; *extra; extra++) p = append_extension( p, *extra ); - - if (p != str) --p; - *p = 0; - return (GLubyte *)str; -} - /* Check if any GL extension from the list is supported */ static BOOL is_any_extension_supported( struct context *ctx, const char *extension ) { @@ -809,9 +754,6 @@ static BOOL get_integer( TEB *teb, GLenum pname, GLint *data ) switch (pname) { - case GL_NUM_EXTENSIONS: - *data = ctx->extension_count; - return TRUE; case GL_DRAW_FRAMEBUFFER_BINDING: if (!draw->draw_fbo) break; *data = ctx->draw_fbo; @@ -860,12 +802,6 @@ const GLubyte *wrap_glGetString( TEB *teb, GLenum name ) const char *renderer = funcs->p_wglQueryCurrentRendererStringWINE( WGL_RENDERER_DEVICE_ID_WINE ); return renderer ? (const GLubyte *)renderer : ret; } - if (name == GL_EXTENSIONS) - { - struct context *ctx = get_current_context( teb, NULL, NULL ); - GLubyte **extensions = &ctx->extensions; - if (*extensions || (*extensions = filter_extensions( ctx, (const char *)ret, funcs ))) return *extensions; - } else if (name == GL_VERSION) { struct context *ctx = get_current_context( teb, NULL, NULL ); @@ -876,20 +812,6 @@ const GLubyte *wrap_glGetString( TEB *teb, GLenum name ) return ret; } -const GLubyte *wrap_glGetStringi( TEB *teb, GLenum name, GLuint index ) -{ - const struct opengl_funcs *funcs = teb->glTable; - - if (name == GL_EXTENSIONS) - { - struct context *ctx = get_current_context( teb, NULL, NULL ); - if (index < ctx->extension_count) return (const GLubyte *)ctx->extension_array[index]; - index = -1; - } - - return funcs->p_glGetStringi( name, index ); -} - static int registry_entry_cmp( const void *a, const void *b ) { const struct registry_entry *entry_a = a, *entry_b = b; @@ -1141,6 +1063,20 @@ static BOOL initialize_vk_device( TEB *teb, struct context *ctx ) return FALSE; } +static USHORT *add_extension_index( struct opengl_extensions *extensions, const char *ext, size_t len, USHORT *ptr ) +{ + UINT index = 0; +#define USE_GL_EXT(x) \ + if (++index && !strncmp( #x, ext, len )) \ + { \ + if (extensions->has_ ## x) *ptr++ = index; \ + return ptr; \ + } + ALL_GL_CLIENT_EXTS +#undef USE_GL_EXT + return ptr; +} + static void add_extension( struct opengl_extensions *extensions, const char *ext, size_t len, BOOL set ) { #define USE_GL_EXT(x) if (!strncmp( #x, ext, len )) extensions->has_ ## x = set; else @@ -1339,7 +1275,21 @@ static void make_context_current( TEB *teb, const struct opengl_funcs *funcs, HD ctx->extension_count = j; } - if (TRACE_ON(opengl)) for (i = 0; i < count; i++) TRACE( "++ %s\n", extensions[i] ); + dump_extensions( "Client", &client->extensions ); + + if ((ext = (const char *)funcs->p_glGetString( GL_EXTENSIONS ))) + { + USHORT *ptr = client->compat_indexes; + const char *end; + + for (end = ext; *end; end++) + { + if (*end != ' ') continue; + ptr = add_extension_index( &client->extensions, ext, end - ext, ptr ); + ext = end + 1; + } + if (end > ext) ptr = add_extension_index( &client->extensions, ext, end - ext, ptr ); + } } BOOL wrap_wglMakeCurrent( TEB *teb, HDC hdc, HGLRC client_context ) diff --git a/dlls/opengl32/wgl.c b/dlls/opengl32/wgl.c index 312cc38c263..a959bc17e1c 100644 --- a/dlls/opengl32/wgl.c +++ b/dlls/opengl32/wgl.c @@ -259,6 +259,7 @@ struct context { struct opengl_client_context base; struct handle_table syncs; + char *extensions; }; static struct context *context_from_opengl_client_context( struct opengl_client_context *base ) @@ -304,6 +305,7 @@ static void free_client_context( struct handle_entry *ptr ) { struct context *context = context_from_opengl_client_context( ptr->context ); free_handle( &contexts, ptr ); + free( context->extensions ); free( context ); } @@ -2036,6 +2038,11 @@ void WINAPI glGetIntegerv( GLenum name, GLint *data ) case GL_MINOR_VERSION: *data = ctx->base.minor_version; return; + case GL_NUM_EXTENSIONS: +#define USE_GL_EXT(x) + ctx->base.extensions.has_ ## x + *data = 0 ALL_GL_CLIENT_EXTS + ctx->base.extensions.has_WGL_EXT_extensions_string + ctx->base.extensions.has_WGL_EXT_swap_control; +#undef USE_GL_EXT + return; } if ((status = UNIX_CALL( glGetIntegerv, &args ))) WARN( "glGetIntegerv returned %#lx\n", status ); @@ -2053,9 +2060,23 @@ const GLubyte * WINAPI glGetStringi( GLenum name, GLuint index ) #ifndef _WIN64 GLubyte *wow64_str = NULL; #endif + struct context *ctx; TRACE( "name %d, index %d\n", name, index ); + if (!(ctx = context_from_handle( NtCurrentTeb()->glCurrentRC ))) return NULL; + + switch (name) + { + case GL_EXTENSIONS: +#define USE_GL_EXT(x) if (ctx->base.extensions.has_ ## x && !index--) return (const GLubyte *)#x; + ALL_GL_CLIENT_EXTS +#undef USE_GL_EXT + if (ctx->base.extensions.has_WGL_EXT_extensions_string && !index--) return (const GLubyte *)"WGL_EXT_extensions_string"; + if (ctx->base.extensions.has_WGL_EXT_swap_control && !index--) return (const GLubyte *)"WGL_EXT_swap_control"; + return NULL; + } + #ifndef _WIN64 if (UNIX_CALL( glGetStringi, &args ) == STATUS_BUFFER_TOO_SMALL) args.ret = wow64_str = malloc( (size_t)args.ret ); #endif @@ -2073,6 +2094,7 @@ const GLubyte * WINAPI glGetStringi( GLenum name, GLuint index ) const GLubyte * WINAPI glGetString( GLenum name ) { struct glGetString_params args = { .teb = NtCurrentTeb(), .name = name }; + struct context *ctx; NTSTATUS status; #ifndef _WIN64 GLubyte *wow64_str = NULL; @@ -2080,6 +2102,38 @@ const GLubyte * WINAPI glGetString( GLenum name ) TRACE( "name %d\n", name ); + if (!(ctx = context_from_handle( NtCurrentTeb()->glCurrentRC ))) return NULL; + + switch (name) + { + case GL_EXTENSIONS: + if (!ctx->extensions && *ctx->base.compat_indexes) + { + #define USE_GL_EXT(x) #x, + static const char *names[] = { ALL_GL_CLIENT_EXTS }; + #undef USE_GL_EXT + const USHORT *indexes = ctx->base.compat_indexes; + UINT size = 0; + char *ptr; + + for (UINT i = 0; indexes[i]; i++) size += strlen( names[indexes[i] - 1] ) + 1; + if (ctx->base.extensions.has_GL_EXT_memory_object_win32) size += strlen( "GL_EXT_memory_object_win32 " ); + if (ctx->base.extensions.has_GL_EXT_semaphore_win32) size += strlen( "GL_EXT_semaphore_win32 " ); + if (ctx->base.extensions.has_WGL_EXT_extensions_string) size += strlen( "WGL_EXT_extensions_string " ); + if (ctx->base.extensions.has_WGL_EXT_swap_control) size += strlen( "WGL_EXT_swap_control " ); + if (!(ptr = ctx->extensions = malloc( size ))) return NULL; + + for (UINT i = 0; indexes[i]; i++) ptr += sprintf( ptr, "%s ", names[indexes[i] - 1] ); + if (ctx->base.extensions.has_GL_EXT_memory_object_win32) ptr += sprintf( ptr, "GL_EXT_memory_object_win32 " ); + if (ctx->base.extensions.has_GL_EXT_semaphore_win32) ptr += sprintf( ptr, "GL_EXT_semaphore_win32 " ); + if (ctx->base.extensions.has_WGL_EXT_extensions_string) ptr += sprintf( ptr, "WGL_EXT_extensions_string " ); + if (ctx->base.extensions.has_WGL_EXT_swap_control) ptr += sprintf( ptr, "WGL_EXT_swap_control " ); + if (ptr != ctx->extensions) ptr[-1] = 0; + } + + return (const GLubyte *)ctx->extensions; + } + #ifndef _WIN64 if (UNIX_CALL( glGetString, &args ) == STATUS_BUFFER_TOO_SMALL) args.ret = wow64_str = malloc( (size_t)args.ret ); #endif diff --git a/include/wine/opengl_driver.h b/include/wine/opengl_driver.h index 402e2997869..0141596867f 100644 --- a/include/wine/opengl_driver.h +++ b/include/wine/opengl_driver.h @@ -78,8 +78,15 @@ struct opengl_client_context int major_version; int minor_version; struct opengl_extensions extensions; /* exposed client extensions */ +#define USE_GL_EXT(x) +1 + USHORT compat_indexes[1 ALL_GL_CLIENT_EXTS]; /* compat extension indexes */ +#undef USE_GL_EXT }; +/* make sure client context size stays small */ +C_ASSERT( ARRAY_SIZE(((struct opengl_client_context *)0)->compat_indexes) <= 0x10000 ); +C_ASSERT( sizeof(struct opengl_client_context) <= 0x800 ); + static inline struct opengl_client_context *opengl_client_context_from_client( HGLRC client_context ) { return CONTAINING_RECORD( client_context, struct opengl_client_context, obj ); -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10019
From: Rémi Bernon <rbernon@codeweavers.com> --- dlls/opengl32/unix_wgl.c | 25 ++++--------------------- dlls/win32u/opengl.c | 18 +----------------- 2 files changed, 5 insertions(+), 38 deletions(-) diff --git a/dlls/opengl32/unix_wgl.c b/dlls/opengl32/unix_wgl.c index 98c1d7fc68c..4bd84429cd3 100644 --- a/dlls/opengl32/unix_wgl.c +++ b/dlls/opengl32/unix_wgl.c @@ -936,15 +936,6 @@ static BOOL initialize_vk_device( TEB *teb, struct context *ctx ) } if (!vk_instance) return FALSE; -#define GET_GL_FUNC(name) if (!funcs->p_##name) funcs->p_##name = (void *)funcs->p_wglGetProcAddress( #name ) - GET_GL_FUNC( glBufferStorageMemEXT ); - GET_GL_FUNC( glCreateMemoryObjectsEXT ); - GET_GL_FUNC( glDeleteMemoryObjectsEXT ); - GET_GL_FUNC( glGetUnsignedBytei_vEXT ); - GET_GL_FUNC( glImportMemoryFdEXT ); - GET_GL_FUNC( glNamedBufferStorageMemEXT ); -#undef GET_GL_FUNC - funcs->p_glGetIntegerv( GL_NUM_DEVICE_UUIDS_EXT, &uuid_count ); for (i = 0; i < uuid_count; i++) { @@ -2128,37 +2119,29 @@ NTSTATUS return_wow64_string( const void *str, PTR32 *wow64_str ) static GLint get_buffer_param( TEB *teb, GLenum target, GLenum param ) { const struct opengl_funcs *funcs = teb->glTable; - typeof(*funcs->p_glGetBufferParameteriv) *func; GLint size = 0; - if (!(func = funcs->p_glGetBufferParameteriv)) func = (void *)funcs->p_wglGetProcAddress( "glGetBufferParameteriv" ); - if (func) func( target, param, &size ); + if (funcs->p_glGetBufferParameteriv) funcs->p_glGetBufferParameteriv( target, param, &size ); return size; } static GLint get_named_buffer_param( TEB *teb, GLint buffer, GLenum param ) { const struct opengl_funcs *funcs = teb->glTable; - typeof(*funcs->p_glGetNamedBufferParameteriv) *func; GLint size = 0; - if (!(func = funcs->p_glGetNamedBufferParameteriv)) func = (void *)funcs->p_wglGetProcAddress( "glGetNamedBufferParameteriv" ); - if (func) func( buffer, param, &size ); + if (funcs->p_glGetNamedBufferParameteriv) funcs->p_glGetNamedBufferParameteriv( buffer, param, &size ); return size; } static void unmap_buffer( TEB *teb, GLenum target ) { const struct opengl_funcs *funcs = teb->glTable; - typeof(*funcs->p_glUnmapBuffer) *func; - if (!(func = funcs->p_glUnmapBuffer)) func = (void *)funcs->p_wglGetProcAddress( "glUnmapBuffer" ); - if (func) func( target ); + if (funcs->p_glUnmapBuffer) funcs->p_glUnmapBuffer( target ); } static void unmap_named_buffer( TEB *teb, GLint buffer ) { const struct opengl_funcs *funcs = teb->glTable; - typeof(*funcs->p_glUnmapNamedBuffer) *func; - if (!(func = funcs->p_glUnmapNamedBuffer)) func = (void *)funcs->p_wglGetProcAddress( "glUnmapNamedBuffer" ); - if (func) func( buffer ); + if (funcs->p_glUnmapNamedBuffer) funcs->p_glUnmapNamedBuffer( buffer ); } static GLuint get_target_name( TEB *teb, GLenum target ) diff --git a/dlls/win32u/opengl.c b/dlls/win32u/opengl.c index a65e791c534..d42fe265f14 100644 --- a/dlls/win32u/opengl.c +++ b/dlls/win32u/opengl.c @@ -2666,23 +2666,7 @@ static void display_funcs_init(void) if (!display_funcs.p_##func && !(display_funcs.p_##func = driver_funcs->p_get_proc_address( #func ))) \ WARN( "%s not found.\n", #func ); ALL_GL_FUNCS - USE_GL_FUNC(glBindFramebuffer) - USE_GL_FUNC(glBlitFramebuffer) - USE_GL_FUNC(glCheckNamedFramebufferStatus) - USE_GL_FUNC(glCreateFramebuffers) - USE_GL_FUNC(glCreateRenderbuffers) - USE_GL_FUNC(glDeleteFramebuffers) - USE_GL_FUNC(glDeleteRenderbuffers) - USE_GL_FUNC(glGetNamedFramebufferAttachmentParameteriv) - USE_GL_FUNC(glGetStringi) - USE_GL_FUNC(glGetUnsignedBytei_vEXT) - USE_GL_FUNC(glGetUnsignedBytevEXT) - USE_GL_FUNC(glImportMemoryFdEXT) - USE_GL_FUNC(glImportSemaphoreFdEXT) - USE_GL_FUNC(glNamedFramebufferDrawBuffer) - USE_GL_FUNC(glNamedFramebufferReadBuffer) - USE_GL_FUNC(glNamedFramebufferRenderbuffer) - USE_GL_FUNC(glNamedRenderbufferStorageMultisample) + ALL_GL_EXT_FUNCS #undef USE_GL_FUNC display_funcs.p_wglGetProcAddress = win32u_wglGetProcAddress; -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10019
From: Rémi Bernon <rbernon@codeweavers.com> --- dlls/opengl32/make_opengl | 93 +- dlls/opengl32/private.h | 4 +- dlls/opengl32/thunks.c | 5550 +++++++++++++++++----------------- dlls/opengl32/unix_private.h | 10 - dlls/opengl32/unix_thunks.c | 2772 +---------------- dlls/opengl32/unix_thunks.h | 1 - dlls/opengl32/unix_wgl.c | 221 +- dlls/opengl32/unixlib.h | 2 +- dlls/opengl32/wgl.c | 7 +- 9 files changed, 2864 insertions(+), 5796 deletions(-) diff --git a/dlls/opengl32/make_opengl b/dlls/opengl32/make_opengl index 8704ec90b13..97908bd6c8d 100755 --- a/dlls/opengl32/make_opengl +++ b/dlls/opengl32/make_opengl @@ -226,7 +226,6 @@ my %manual_unix_thunks = "wglCreateContext" => 1, "wglCreateContextAttribsARB" => 1, "wglDeleteContext" => 1, - "wglGetProcAddress" => 1, "wglMakeContextCurrentARB" => 1, "wglMakeCurrent" => 1, "wglShareLists" => 1, @@ -1128,6 +1127,14 @@ sub add_extension($) } } +sub check_extension($) +{ + my $ext = shift; + return "extensions->has_$ext" unless $ext =~ /_VERSION_/; + my ($major, $minor) = ($ext =~ /.*_VERSION_(\d+)_(\d+).*/); + return "(major > $major || (major == $major && minor >= $minor))"; +} + sub parse_registry($) { my $file = shift; @@ -1568,7 +1575,7 @@ print OUT "#include \"winbase.h\"\n"; print OUT "#include \"winternl.h\"\n"; print OUT "#include \"wingdi.h\"\n"; print OUT "#include \"ntuser.h\"\n\n"; -print OUT "#include \"wine/wgl.h\"\n"; +print OUT "#include \"wine/opengl_driver.h\"\n"; print OUT "#include \"wine/unixlib.h\"\n\n"; print OUT "struct process_attach_params\n"; @@ -1653,7 +1660,8 @@ open OUT, ">thunks.c" or die "cannot create thunks.c"; print OUT "/* Automatically generated from http://www.opengl.org/registry files; DO NOT EDIT! */\n\n"; print OUT "#include <stdarg.h>\n"; -print OUT "#include <stddef.h>\n\n"; +print OUT "#include <stddef.h>\n"; +print OUT "#include <stdlib.h>\n\n"; print OUT "#include \"ntstatus.h\"\n"; print OUT "#define WIN32_NO_STATUS\n"; @@ -1696,14 +1704,57 @@ foreach (sort keys %ext_functions) printf OUT "extern %s WINAPI %s(%s);\n", $func_ret, $_, $decl_args; } -print OUT "const void *extension_procs[] =\n"; +print OUT "struct function_entry\n"; print OUT "{\n"; +print OUT " const char *name;\n"; +print OUT " void *function;\n"; +print OUT " BOOL supported;\n"; +print OUT "};\n"; +print OUT "\n"; +print OUT "static int function_entry_cmp( const void *a, const void *b )\n"; +print OUT "{\n"; +print OUT " const struct function_entry *entry_a = a, *entry_b = b;\n"; +print OUT " return strcmp( entry_a->name, entry_b->name );\n"; +print OUT "};\n"; +print OUT "\n"; +print OUT "void *get_proc_address( const char *name, const struct opengl_client_context *ctx )\n"; +print OUT "{\n"; +print OUT " const int major = ctx->major_version, minor = ctx->minor_version;\n"; +print OUT " const struct opengl_extensions *extensions = &ctx->extensions;\n"; +print OUT " const struct function_entry *found, entry = { .name = name }, functions[] =\n"; +print OUT " {\n"; foreach (sort keys %ext_functions) { next unless is_exposed_function( $ext_functions{$_} ); - printf OUT " %s,\n", $_; -} -print OUT "};\n"; + my $func = $ext_functions{$_}; + my @checks; + + print OUT " { \"$_\", $_, "; + foreach my $ext (@{$func->[2]}) + { + next unless is_exposed_extension( $ext ); + push @checks, check_extension( $ext ); + for my $alias (@{$extension_aliases{$ext}}) + { + next unless is_exposed_extension( $alias ); + push @checks, check_extension( $alias ); + } + } + print OUT join(" || ", sort @checks) . " },\n"; +} +print OUT " };\n"; +print OUT " if (!(found = bsearch( &entry, functions, ARRAY_SIZE(functions), sizeof(entry), function_entry_cmp )))\n"; +print OUT " {\n"; +print OUT " WARN( \"Function %s unknown\\n\", name );\n"; +print OUT " return NULL;\n"; +print OUT " }\n"; +print OUT " if (!found->supported)\n"; +print OUT " {\n"; +print OUT " WARN( \"Function %s not supported\\n\", name );\n"; +print OUT " return NULL;\n"; +print OUT " }\n"; +print OUT " return found->function;\n"; +print OUT "}\n"; close OUT; @@ -1899,32 +1950,4 @@ foreach (sort keys %norm_functions) print OUT " .p_$_ = null_$_,\n"; } print OUT "};\n"; - -# Then the table giving the string <-> function correspondence */ -my $count = 0; -foreach (keys %ext_functions) -{ - next unless is_exposed_function( $ext_functions{$_} ); - $count += 1; -} -print OUT "\nconst int extension_registry_size = $count;\n"; -print OUT "const struct registry_entry extension_registry[$count] =\n"; -print OUT "{\n"; -foreach (sort keys %ext_functions) -{ - next unless is_exposed_function( $ext_functions{$_} ); - my $func = $ext_functions{$_}; - my @exts; - foreach my $ext (@{$func->[2]}) - { - push @exts, $ext; - foreach my $alias (@{$extension_aliases{$ext}}) - { - push @exts, $alias; - } - } - printf OUT " { \"%s\", \"%s\\0\", offsetof(struct opengl_funcs, p_$_) },\n", $_, join("\\0", sort @exts); -} -print OUT "};\n"; - close OUT; diff --git a/dlls/opengl32/private.h b/dlls/opengl32/private.h index 42298ac9ccc..63821690c52 100644 --- a/dlls/opengl32/private.h +++ b/dlls/opengl32/private.h @@ -27,14 +27,14 @@ #include "winbase.h" #include "winternl.h" #include "wingdi.h" +#include "wine/opengl_driver.h" #include "wine/wgl.h" -extern const void *extension_procs[]; - extern int WINAPI wglDescribePixelFormat( HDC hdc, int ipfd, UINT cjpfd, PIXELFORMATDESCRIPTOR *ppfd ); extern BOOL get_pbuffer_from_handle( HPBUFFERARB handle, HPBUFFERARB *obj ); extern BOOL get_context_from_handle( HGLRC handle, HGLRC *obj ); extern BOOL get_sync_from_handle( GLsync handle, GLsync *obj ); extern void set_gl_error( GLenum error ); +extern void *get_proc_address( const char *name, const struct opengl_client_context *ctx ); #endif /* __WINE_OPENGL32_PRIVATE_H */ diff --git a/dlls/opengl32/thunks.c b/dlls/opengl32/thunks.c index c3696f3406b..3e6ab97f5d7 100644 --- a/dlls/opengl32/thunks.c +++ b/dlls/opengl32/thunks.c @@ -2,6 +2,7 @@ #include <stdarg.h> #include <stddef.h> +#include <stdlib.h> #include "ntstatus.h" #define WIN32_NO_STATUS @@ -24833,2764 +24834,2793 @@ extern BOOL WINAPI wglGetPixelFormatAttribivARB( HDC hdc, int iPixelFormat, int extern BOOL WINAPI wglMakeContextCurrentARB( HDC hDrawDC, HDC hReadDC, HGLRC hglrc ); extern const GLchar * WINAPI wglQueryCurrentRendererStringWINE( GLenum attribute ); extern const GLchar * WINAPI wglQueryRendererStringWINE( HDC dc, GLint renderer, GLenum attribute ); -const void *extension_procs[] = -{ - glAccumxOES, - glAcquireKeyedMutexWin32EXT, - glActiveProgramEXT, - glActiveShaderProgram, - glActiveStencilFaceEXT, - glActiveTexture, - glActiveTextureARB, - glActiveVaryingNV, - glAlphaFragmentOp1ATI, - glAlphaFragmentOp2ATI, - glAlphaFragmentOp3ATI, - glAlphaFuncx, - glAlphaFuncxOES, - glAlphaToCoverageDitherControlNV, - glApplyFramebufferAttachmentCMAAINTEL, - glApplyTextureEXT, - glAreProgramsResidentNV, - glAreTexturesResidentEXT, - glArrayElementEXT, - glArrayObjectATI, - glAsyncCopyBufferSubDataNVX, - glAsyncCopyImageSubDataNVX, - glAsyncMarkerSGIX, - glAttachObjectARB, - glAttachShader, - glBeginConditionalRender, - glBeginConditionalRenderNV, - glBeginConditionalRenderNVX, - glBeginFragmentShaderATI, - glBeginOcclusionQueryNV, - glBeginPerfMonitorAMD, - glBeginPerfQueryINTEL, - glBeginQuery, - glBeginQueryARB, - glBeginQueryIndexed, - glBeginTransformFeedback, - glBeginTransformFeedbackEXT, - glBeginTransformFeedbackNV, - glBeginVertexShaderEXT, - glBeginVideoCaptureNV, - glBindAttribLocation, - glBindAttribLocationARB, - glBindBuffer, - glBindBufferARB, - glBindBufferBase, - glBindBufferBaseEXT, - glBindBufferBaseNV, - glBindBufferOffsetEXT, - glBindBufferOffsetNV, - glBindBufferRange, - glBindBufferRangeEXT, - glBindBufferRangeNV, - glBindBuffersBase, - glBindBuffersRange, - glBindFragDataLocation, - glBindFragDataLocationEXT, - glBindFragDataLocationIndexed, - glBindFragmentShaderATI, - glBindFramebuffer, - glBindFramebufferEXT, - glBindImageTexture, - glBindImageTextureEXT, - glBindImageTextures, - glBindLightParameterEXT, - glBindMaterialParameterEXT, - glBindMultiTextureEXT, - glBindParameterEXT, - glBindProgramARB, - glBindProgramNV, - glBindProgramPipeline, - glBindRenderbuffer, - glBindRenderbufferEXT, - glBindSampler, - glBindSamplers, - glBindShadingRateImageNV, - glBindTexGenParameterEXT, - glBindTextureEXT, - glBindTextureUnit, - glBindTextureUnitParameterEXT, - glBindTextures, - glBindTransformFeedback, - glBindTransformFeedbackNV, - glBindVertexArray, - glBindVertexArrayAPPLE, - glBindVertexBuffer, - glBindVertexBuffers, - glBindVertexShaderEXT, - glBindVideoCaptureStreamBufferNV, - glBindVideoCaptureStreamTextureNV, - glBinormal3bEXT, - glBinormal3bvEXT, - glBinormal3dEXT, - glBinormal3dvEXT, - glBinormal3fEXT, - glBinormal3fvEXT, - glBinormal3iEXT, - glBinormal3ivEXT, - glBinormal3sEXT, - glBinormal3svEXT, - glBinormalPointerEXT, - glBitmapxOES, - glBlendBarrier, - glBlendBarrierKHR, - glBlendBarrierNV, - glBlendColor, - glBlendColorEXT, - glBlendColorxOES, - glBlendEquation, - glBlendEquationEXT, - glBlendEquationIndexedAMD, - glBlendEquationSeparate, - glBlendEquationSeparateEXT, - glBlendEquationSeparateIndexedAMD, - glBlendEquationSeparatei, - glBlendEquationSeparateiARB, - glBlendEquationi, - glBlendEquationiARB, - glBlendFuncIndexedAMD, - glBlendFuncSeparate, - glBlendFuncSeparateEXT, - glBlendFuncSeparateINGR, - glBlendFuncSeparateIndexedAMD, - glBlendFuncSeparatei, - glBlendFuncSeparateiARB, - glBlendFunci, - glBlendFunciARB, - glBlendParameteriNV, - glBlitFramebuffer, - glBlitFramebufferEXT, - glBlitFramebufferLayerEXT, - glBlitFramebufferLayersEXT, - glBlitNamedFramebuffer, - glBufferAddressRangeNV, - glBufferAttachMemoryNV, - glBufferData, - glBufferDataARB, - glBufferPageCommitmentARB, - glBufferPageCommitmentMemNV, - glBufferParameteriAPPLE, - glBufferRegionEnabled, - glBufferStorage, - glBufferStorageExternalEXT, - glBufferStorageMemEXT, - glBufferSubData, - glBufferSubDataARB, - glCallCommandListNV, - glCheckFramebufferStatus, - glCheckFramebufferStatusEXT, - glCheckNamedFramebufferStatus, - glCheckNamedFramebufferStatusEXT, - glClampColor, - glClampColorARB, - glClearAccumxOES, - glClearBufferData, - glClearBufferSubData, - glClearBufferfi, - glClearBufferfv, - glClearBufferiv, - glClearBufferuiv, - glClearColorIiEXT, - glClearColorIuiEXT, - glClearColorx, - glClearColorxOES, - glClearDepthdNV, - glClearDepthf, - glClearDepthfOES, - glClearDepthx, - glClearDepthxOES, - glClearNamedBufferData, - glClearNamedBufferDataEXT, - glClearNamedBufferSubData, - glClearNamedBufferSubDataEXT, - glClearNamedFramebufferfi, - glClearNamedFramebufferfv, - glClearNamedFramebufferiv, - glClearNamedFramebufferuiv, - glClearTexImage, - glClearTexSubImage, - glClientActiveTexture, - glClientActiveTextureARB, - glClientActiveVertexStreamATI, - glClientAttribDefaultEXT, - glClientWaitSemaphoreui64NVX, - glClientWaitSync, - glClipControl, - glClipPlanef, - glClipPlanefOES, - glClipPlanex, - glClipPlanexOES, - glColor3fVertex3fSUN, - glColor3fVertex3fvSUN, - glColor3hNV, - glColor3hvNV, - glColor3xOES, - glColor3xvOES, - glColor4fNormal3fVertex3fSUN, - glColor4fNormal3fVertex3fvSUN, - glColor4hNV, - glColor4hvNV, - glColor4ubVertex2fSUN, - glColor4ubVertex2fvSUN, - glColor4ubVertex3fSUN, - glColor4ubVertex3fvSUN, - glColor4x, - glColor4xOES, - glColor4xvOES, - glColorFormatNV, - glColorFragmentOp1ATI, - glColorFragmentOp2ATI, - glColorFragmentOp3ATI, - glColorMaskIndexedEXT, - glColorMaski, - glColorP3ui, - glColorP3uiv, - glColorP4ui, - glColorP4uiv, - glColorPointerEXT, - glColorPointerListIBM, - glColorPointervINTEL, - glColorSubTable, - glColorSubTableEXT, - glColorTable, - glColorTableEXT, - glColorTableParameterfv, - glColorTableParameterfvSGI, - glColorTableParameteriv, - glColorTableParameterivSGI, - glColorTableSGI, - glCombinerInputNV, - glCombinerOutputNV, - glCombinerParameterfNV, - glCombinerParameterfvNV, - glCombinerParameteriNV, - glCombinerParameterivNV, - glCombinerStageParameterfvNV, - glCommandListSegmentsNV, - glCompileCommandListNV, - glCompileShader, - glCompileShaderARB, - glCompileShaderIncludeARB, - glCompressedMultiTexImage1DEXT, - glCompressedMultiTexImage2DEXT, - glCompressedMultiTexImage3DEXT, - glCompressedMultiTexSubImage1DEXT, - glCompressedMultiTexSubImage2DEXT, - glCompressedMultiTexSubImage3DEXT, - glCompressedTexImage1D, - glCompressedTexImage1DARB, - glCompressedTexImage2D, - glCompressedTexImage2DARB, - glCompressedTexImage3D, - glCompressedTexImage3DARB, - glCompressedTexSubImage1D, - glCompressedTexSubImage1DARB, - glCompressedTexSubImage2D, - glCompressedTexSubImage2DARB, - glCompressedTexSubImage3D, - glCompressedTexSubImage3DARB, - glCompressedTextureImage1DEXT, - glCompressedTextureImage2DEXT, - glCompressedTextureImage3DEXT, - glCompressedTextureSubImage1D, - glCompressedTextureSubImage1DEXT, - glCompressedTextureSubImage2D, - glCompressedTextureSubImage2DEXT, - glCompressedTextureSubImage3D, - glCompressedTextureSubImage3DEXT, - glConservativeRasterParameterfNV, - glConservativeRasterParameteriNV, - glConvolutionFilter1D, - glConvolutionFilter1DEXT, - glConvolutionFilter2D, - glConvolutionFilter2DEXT, - glConvolutionParameterf, - glConvolutionParameterfEXT, - glConvolutionParameterfv, - glConvolutionParameterfvEXT, - glConvolutionParameteri, - glConvolutionParameteriEXT, - glConvolutionParameteriv, - glConvolutionParameterivEXT, - glConvolutionParameterxOES, - glConvolutionParameterxvOES, - glCopyBufferSubData, - glCopyColorSubTable, - glCopyColorSubTableEXT, - glCopyColorTable, - glCopyColorTableSGI, - glCopyConvolutionFilter1D, - glCopyConvolutionFilter1DEXT, - glCopyConvolutionFilter2D, - glCopyConvolutionFilter2DEXT, - glCopyImageSubData, - glCopyImageSubDataNV, - glCopyMultiTexImage1DEXT, - glCopyMultiTexImage2DEXT, - glCopyMultiTexSubImage1DEXT, - glCopyMultiTexSubImage2DEXT, - glCopyMultiTexSubImage3DEXT, - glCopyNamedBufferSubData, - glCopyPathNV, - glCopyTexImage1DEXT, - glCopyTexImage2DEXT, - glCopyTexSubImage1DEXT, - glCopyTexSubImage2DEXT, - glCopyTexSubImage3D, - glCopyTexSubImage3DEXT, - glCopyTextureImage1DEXT, - glCopyTextureImage2DEXT, - glCopyTextureSubImage1D, - glCopyTextureSubImage1DEXT, - glCopyTextureSubImage2D, - glCopyTextureSubImage2DEXT, - glCopyTextureSubImage3D, - glCopyTextureSubImage3DEXT, - glCoverFillPathInstancedNV, - glCoverFillPathNV, - glCoverStrokePathInstancedNV, - glCoverStrokePathNV, - glCoverageModulationNV, - glCoverageModulationTableNV, - glCreateBuffers, - glCreateCommandListsNV, - glCreateFramebuffers, - glCreateMemoryObjectsEXT, - glCreatePerfQueryINTEL, - glCreateProgram, - glCreateProgramObjectARB, - glCreateProgramPipelines, - glCreateProgressFenceNVX, - glCreateQueries, - glCreateRenderbuffers, - glCreateSamplers, - glCreateSemaphoresNV, - glCreateShader, - glCreateShaderObjectARB, - glCreateShaderProgramEXT, - glCreateShaderProgramv, - glCreateStatesNV, - glCreateSyncFromCLeventARB, - glCreateTextures, - glCreateTransformFeedbacks, - glCreateVertexArrays, - glCullParameterdvEXT, - glCullParameterfvEXT, - glCurrentPaletteMatrixARB, - glDebugMessageCallback, - glDebugMessageCallbackAMD, - glDebugMessageCallbackARB, - glDebugMessageControl, - glDebugMessageControlARB, - glDebugMessageEnableAMD, - glDebugMessageInsert, - glDebugMessageInsertAMD, - glDebugMessageInsertARB, - glDeformSGIX, - glDeformationMap3dSGIX, - glDeformationMap3fSGIX, - glDeleteAsyncMarkersSGIX, - glDeleteBufferRegion, - glDeleteBuffers, - glDeleteBuffersARB, - glDeleteCommandListsNV, - glDeleteFencesAPPLE, - glDeleteFencesNV, - glDeleteFragmentShaderATI, - glDeleteFramebuffers, - glDeleteFramebuffersEXT, - glDeleteMemoryObjectsEXT, - glDeleteNamedStringARB, - glDeleteNamesAMD, - glDeleteObjectARB, - glDeleteObjectBufferATI, - glDeleteOcclusionQueriesNV, - glDeletePathsNV, - glDeletePerfMonitorsAMD, - glDeletePerfQueryINTEL, - glDeleteProgram, - glDeleteProgramPipelines, - glDeleteProgramsARB, - glDeleteProgramsNV, - glDeleteQueries, - glDeleteQueriesARB, - glDeleteQueryResourceTagNV, - glDeleteRenderbuffers, - glDeleteRenderbuffersEXT, - glDeleteSamplers, - glDeleteSemaphoresEXT, - glDeleteShader, - glDeleteStatesNV, - glDeleteSync, - glDeleteTexturesEXT, - glDeleteTransformFeedbacks, - glDeleteTransformFeedbacksNV, - glDeleteVertexArrays, - glDeleteVertexArraysAPPLE, - glDeleteVertexShaderEXT, - glDepthBoundsEXT, - glDepthBoundsdNV, - glDepthRangeArraydvNV, - glDepthRangeArrayv, - glDepthRangeIndexed, - glDepthRangeIndexeddNV, - glDepthRangedNV, - glDepthRangef, - glDepthRangefOES, - glDepthRangex, - glDepthRangexOES, - glDetachObjectARB, - glDetachShader, - glDetailTexFuncSGIS, - glDisableClientStateIndexedEXT, - glDisableClientStateiEXT, - glDisableIndexedEXT, - glDisableVariantClientStateEXT, - glDisableVertexArrayAttrib, - glDisableVertexArrayAttribEXT, - glDisableVertexArrayEXT, - glDisableVertexAttribAPPLE, - glDisableVertexAttribArray, - glDisableVertexAttribArrayARB, - glDisablei, - glDispatchCompute, - glDispatchComputeGroupSizeARB, - glDispatchComputeIndirect, - glDrawArraysEXT, - glDrawArraysIndirect, - glDrawArraysInstanced, - glDrawArraysInstancedARB, - glDrawArraysInstancedBaseInstance, - glDrawArraysInstancedEXT, - glDrawBufferRegion, - glDrawBuffers, - glDrawBuffersARB, - glDrawBuffersATI, - glDrawCommandsAddressNV, - glDrawCommandsNV, - glDrawCommandsStatesAddressNV, - glDrawCommandsStatesNV, - glDrawElementArrayAPPLE, - glDrawElementArrayATI, - glDrawElementsBaseVertex, - glDrawElementsIndirect, - glDrawElementsInstanced, - glDrawElementsInstancedARB, - glDrawElementsInstancedBaseInstance, - glDrawElementsInstancedBaseVertex, - glDrawElementsInstancedBaseVertexBaseInstance, - glDrawElementsInstancedEXT, - glDrawMeshArraysSUN, - glDrawMeshTasksEXT, - glDrawMeshTasksIndirectEXT, - glDrawMeshTasksIndirectNV, - glDrawMeshTasksNV, - glDrawRangeElementArrayAPPLE, - glDrawRangeElementArrayATI, - glDrawRangeElements, - glDrawRangeElementsBaseVertex, - glDrawRangeElementsEXT, - glDrawTextureNV, - glDrawTransformFeedback, - glDrawTransformFeedbackInstanced, - glDrawTransformFeedbackNV, - glDrawTransformFeedbackStream, - glDrawTransformFeedbackStreamInstanced, - glDrawVkImageNV, - glEGLImageTargetTexStorageEXT, - glEGLImageTargetTextureStorageEXT, - glEdgeFlagFormatNV, - glEdgeFlagPointerEXT, - glEdgeFlagPointerListIBM, - glElementPointerAPPLE, - glElementPointerATI, - glEnableClientStateIndexedEXT, - glEnableClientStateiEXT, - glEnableIndexedEXT, - glEnableVariantClientStateEXT, - glEnableVertexArrayAttrib, - glEnableVertexArrayAttribEXT, - glEnableVertexArrayEXT, - glEnableVertexAttribAPPLE, - glEnableVertexAttribArray, - glEnableVertexAttribArrayARB, - glEnablei, - glEndConditionalRender, - glEndConditionalRenderNV, - glEndConditionalRenderNVX, - glEndFragmentShaderATI, - glEndOcclusionQueryNV, - glEndPerfMonitorAMD, - glEndPerfQueryINTEL, - glEndQuery, - glEndQueryARB, - glEndQueryIndexed, - glEndTransformFeedback, - glEndTransformFeedbackEXT, - glEndTransformFeedbackNV, - glEndVertexShaderEXT, - glEndVideoCaptureNV, - glEvalCoord1xOES, - glEvalCoord1xvOES, - glEvalCoord2xOES, - glEvalCoord2xvOES, - glEvalMapsNV, - glEvaluateDepthValuesARB, - glExecuteProgramNV, - glExtractComponentEXT, - glFeedbackBufferxOES, - glFenceSync, - glFinalCombinerInputNV, - glFinishAsyncSGIX, - glFinishFenceAPPLE, - glFinishFenceNV, - glFinishObjectAPPLE, - glFinishTextureSUNX, - glFlushMappedBufferRange, - glFlushMappedBufferRangeAPPLE, - glFlushMappedNamedBufferRange, - glFlushMappedNamedBufferRangeEXT, - glFlushPixelDataRangeNV, - glFlushRasterSGIX, - glFlushStaticDataIBM, - glFlushVertexArrayRangeAPPLE, - glFlushVertexArrayRangeNV, - glFogCoordFormatNV, - glFogCoordPointer, - glFogCoordPointerEXT, - glFogCoordPointerListIBM, - glFogCoordd, - glFogCoorddEXT, - glFogCoorddv, - glFogCoorddvEXT, - glFogCoordf, - glFogCoordfEXT, - glFogCoordfv, - glFogCoordfvEXT, - glFogCoordhNV, - glFogCoordhvNV, - glFogFuncSGIS, - glFogx, - glFogxOES, - glFogxv, - glFogxvOES, - glFragmentColorMaterialSGIX, - glFragmentCoverageColorNV, - glFragmentLightModelfSGIX, - glFragmentLightModelfvSGIX, - glFragmentLightModeliSGIX, - glFragmentLightModelivSGIX, - glFragmentLightfSGIX, - glFragmentLightfvSGIX, - glFragmentLightiSGIX, - glFragmentLightivSGIX, - glFragmentMaterialfSGIX, - glFragmentMaterialfvSGIX, - glFragmentMaterialiSGIX, - glFragmentMaterialivSGIX, - glFrameTerminatorGREMEDY, - glFrameZoomSGIX, - glFramebufferDrawBufferEXT, - glFramebufferDrawBuffersEXT, - glFramebufferFetchBarrierEXT, - glFramebufferParameteri, - glFramebufferParameteriMESA, - glFramebufferReadBufferEXT, - glFramebufferRenderbuffer, - glFramebufferRenderbufferEXT, - glFramebufferSampleLocationsfvARB, - glFramebufferSampleLocationsfvNV, - glFramebufferSamplePositionsfvAMD, - glFramebufferShadingRateEXT, - glFramebufferTexture, - glFramebufferTexture1D, - glFramebufferTexture1DEXT, - glFramebufferTexture2D, - glFramebufferTexture2DEXT, - glFramebufferTexture3D, - glFramebufferTexture3DEXT, - glFramebufferTextureARB, - glFramebufferTextureEXT, - glFramebufferTextureFaceARB, - glFramebufferTextureFaceEXT, - glFramebufferTextureLayer, - glFramebufferTextureLayerARB, - glFramebufferTextureLayerEXT, - glFramebufferTextureMultiviewOVR, - glFreeObjectBufferATI, - glFrustumf, - glFrustumfOES, - glFrustumx, - glFrustumxOES, - glGenAsyncMarkersSGIX, - glGenBuffers, - glGenBuffersARB, - glGenFencesAPPLE, - glGenFencesNV, - glGenFragmentShadersATI, - glGenFramebuffers, - glGenFramebuffersEXT, - glGenNamesAMD, - glGenOcclusionQueriesNV, - glGenPathsNV, - glGenPerfMonitorsAMD, - glGenProgramPipelines, - glGenProgramsARB, - glGenProgramsNV, - glGenQueries, - glGenQueriesARB, - glGenQueryResourceTagNV, - glGenRenderbuffers, - glGenRenderbuffersEXT, - glGenSamplers, - glGenSemaphoresEXT, - glGenSymbolsEXT, - glGenTexturesEXT, - glGenTransformFeedbacks, - glGenTransformFeedbacksNV, - glGenVertexArrays, - glGenVertexArraysAPPLE, - glGenVertexShadersEXT, - glGenerateMipmap, - glGenerateMipmapEXT, - glGenerateMultiTexMipmapEXT, - glGenerateTextureMipmap, - glGenerateTextureMipmapEXT, - glGetActiveAtomicCounterBufferiv, - glGetActiveAttrib, - glGetActiveAttribARB, - glGetActiveSubroutineName, - glGetActiveSubroutineUniformName, - glGetActiveSubroutineUniformiv, - glGetActiveUniform, - glGetActiveUniformARB, - glGetActiveUniformBlockName, - glGetActiveUniformBlockiv, - glGetActiveUniformName, - glGetActiveUniformsiv, - glGetActiveVaryingNV, - glGetArrayObjectfvATI, - glGetArrayObjectivATI, - glGetAttachedObjectsARB, - glGetAttachedShaders, - glGetAttribLocation, - glGetAttribLocationARB, - glGetBooleanIndexedvEXT, - glGetBooleani_v, - glGetBufferParameteri64v, - glGetBufferParameteriv, - glGetBufferParameterivARB, - glGetBufferParameterui64vNV, - glGetBufferPointerv, - glGetBufferPointervARB, - glGetBufferSubData, - glGetBufferSubDataARB, - glGetClipPlanef, - glGetClipPlanefOES, - glGetClipPlanex, - glGetClipPlanexOES, - glGetColorTable, - glGetColorTableEXT, - glGetColorTableParameterfv, - glGetColorTableParameterfvEXT, - glGetColorTableParameterfvSGI, - glGetColorTableParameteriv, - glGetColorTableParameterivEXT, - glGetColorTableParameterivSGI, - glGetColorTableSGI, - glGetCombinerInputParameterfvNV, - glGetCombinerInputParameterivNV, - glGetCombinerOutputParameterfvNV, - glGetCombinerOutputParameterivNV, - glGetCombinerStageParameterfvNV, - glGetCommandHeaderNV, - glGetCompressedMultiTexImageEXT, - glGetCompressedTexImage, - glGetCompressedTexImageARB, - glGetCompressedTextureImage, - glGetCompressedTextureImageEXT, - glGetCompressedTextureSubImage, - glGetConvolutionFilter, - glGetConvolutionFilterEXT, - glGetConvolutionParameterfv, - glGetConvolutionParameterfvEXT, - glGetConvolutionParameteriv, - glGetConvolutionParameterivEXT, - glGetConvolutionParameterxvOES, - glGetCoverageModulationTableNV, - glGetDebugMessageLog, - glGetDebugMessageLogAMD, - glGetDebugMessageLogARB, - glGetDetailTexFuncSGIS, - glGetDoubleIndexedvEXT, - glGetDoublei_v, - glGetDoublei_vEXT, - glGetFenceivNV, - glGetFinalCombinerInputParameterfvNV, - glGetFinalCombinerInputParameterivNV, - glGetFirstPerfQueryIdINTEL, - glGetFixedv, - glGetFixedvOES, - glGetFloatIndexedvEXT, - glGetFloati_v, - glGetFloati_vEXT, - glGetFogFuncSGIS, - glGetFragDataIndex, - glGetFragDataLocation, - glGetFragDataLocationEXT, - glGetFragmentLightfvSGIX, - glGetFragmentLightivSGIX, - glGetFragmentMaterialfvSGIX, - glGetFragmentMaterialivSGIX, - glGetFragmentShadingRatesEXT, - glGetFramebufferAttachmentParameteriv, - glGetFramebufferAttachmentParameterivEXT, - glGetFramebufferParameterfvAMD, - glGetFramebufferParameteriv, - glGetFramebufferParameterivEXT, - glGetFramebufferParameterivMESA, - glGetGraphicsResetStatus, - glGetGraphicsResetStatusARB, - glGetHandleARB, - glGetHistogram, - glGetHistogramEXT, - glGetHistogramParameterfv, - glGetHistogramParameterfvEXT, - glGetHistogramParameteriv, - glGetHistogramParameterivEXT, - glGetHistogramParameterxvOES, - glGetImageHandleARB, - glGetImageHandleNV, - glGetImageTransformParameterfvHP, - glGetImageTransformParameterivHP, - glGetInfoLogARB, - glGetInstrumentsSGIX, - glGetInteger64i_v, - glGetInteger64v, - glGetIntegerIndexedvEXT, - glGetIntegeri_v, - glGetIntegerui64i_vNV, - glGetIntegerui64vNV, - glGetInternalformatSampleivNV, - glGetInternalformati64v, - glGetInternalformativ, - glGetInvariantBooleanvEXT, - glGetInvariantFloatvEXT, - glGetInvariantIntegervEXT, - glGetLightxOES, - glGetLightxv, - glGetListParameterfvSGIX, - glGetListParameterivSGIX, - glGetLocalConstantBooleanvEXT, - glGetLocalConstantFloatvEXT, - glGetLocalConstantIntegervEXT, - glGetMapAttribParameterfvNV, - glGetMapAttribParameterivNV, - glGetMapControlPointsNV, - glGetMapParameterfvNV, - glGetMapParameterivNV, - glGetMapxvOES, - glGetMaterialxOES, - glGetMaterialxv, - glGetMemoryObjectDetachedResourcesuivNV, - glGetMemoryObjectParameterivEXT, - glGetMinmax, - glGetMinmaxEXT, - glGetMinmaxParameterfv, - glGetMinmaxParameterfvEXT, - glGetMinmaxParameteriv, - glGetMinmaxParameterivEXT, - glGetMultiTexEnvfvEXT, - glGetMultiTexEnvivEXT, - glGetMultiTexGendvEXT, - glGetMultiTexGenfvEXT, - glGetMultiTexGenivEXT, - glGetMultiTexImageEXT, - glGetMultiTexLevelParameterfvEXT, - glGetMultiTexLevelParameterivEXT, - glGetMultiTexParameterIivEXT, - glGetMultiTexParameterIuivEXT, - glGetMultiTexParameterfvEXT, - glGetMultiTexParameterivEXT, - glGetMultisamplefv, - glGetMultisamplefvNV, - glGetNamedBufferParameteri64v, - glGetNamedBufferParameteriv, - glGetNamedBufferParameterivEXT, - glGetNamedBufferParameterui64vNV, - glGetNamedBufferPointerv, - glGetNamedBufferPointervEXT, - glGetNamedBufferSubData, - glGetNamedBufferSubDataEXT, - glGetNamedFramebufferAttachmentParameteriv, - glGetNamedFramebufferAttachmentParameterivEXT, - glGetNamedFramebufferParameterfvAMD, - glGetNamedFramebufferParameteriv, - glGetNamedFramebufferParameterivEXT, - glGetNamedProgramLocalParameterIivEXT, - glGetNamedProgramLocalParameterIuivEXT, - glGetNamedProgramLocalParameterdvEXT, - glGetNamedProgramLocalParameterfvEXT, - glGetNamedProgramStringEXT, - glGetNamedProgramivEXT, - glGetNamedRenderbufferParameteriv, - glGetNamedRenderbufferParameterivEXT, - glGetNamedStringARB, - glGetNamedStringivARB, - glGetNextPerfQueryIdINTEL, - glGetObjectBufferfvATI, - glGetObjectBufferivATI, - glGetObjectLabel, - glGetObjectLabelEXT, - glGetObjectParameterfvARB, - glGetObjectParameterivAPPLE, - glGetObjectParameterivARB, - glGetObjectPtrLabel, - glGetOcclusionQueryivNV, - glGetOcclusionQueryuivNV, - glGetPathColorGenfvNV, - glGetPathColorGenivNV, - glGetPathCommandsNV, - glGetPathCoordsNV, - glGetPathDashArrayNV, - glGetPathLengthNV, - glGetPathMetricRangeNV, - glGetPathMetricsNV, - glGetPathParameterfvNV, - glGetPathParameterivNV, - glGetPathSpacingNV, - glGetPathTexGenfvNV, - glGetPathTexGenivNV, - glGetPerfCounterInfoINTEL, - glGetPerfMonitorCounterDataAMD, - glGetPerfMonitorCounterInfoAMD, - glGetPerfMonitorCounterStringAMD, - glGetPerfMonitorCountersAMD, - glGetPerfMonitorGroupStringAMD, - glGetPerfMonitorGroupsAMD, - glGetPerfQueryDataINTEL, - glGetPerfQueryIdByNameINTEL, - glGetPerfQueryInfoINTEL, - glGetPixelMapxv, - glGetPixelTexGenParameterfvSGIS, - glGetPixelTexGenParameterivSGIS, - glGetPixelTransformParameterfvEXT, - glGetPixelTransformParameterivEXT, - glGetPointerIndexedvEXT, - glGetPointeri_vEXT, - glGetPointervEXT, - glGetProgramBinary, - glGetProgramEnvParameterIivNV, - glGetProgramEnvParameterIuivNV, - glGetProgramEnvParameterdvARB, - glGetProgramEnvParameterfvARB, - glGetProgramInfoLog, - glGetProgramInterfaceiv, - glGetProgramLocalParameterIivNV, - glGetProgramLocalParameterIuivNV, - glGetProgramLocalParameterdvARB, - glGetProgramLocalParameterfvARB, - glGetProgramNamedParameterdvNV, - glGetProgramNamedParameterfvNV, - glGetProgramParameterdvNV, - glGetProgramParameterfvNV, - glGetProgramPipelineInfoLog, - glGetProgramPipelineiv, - glGetProgramResourceIndex, - glGetProgramResourceLocation, - glGetProgramResourceLocationIndex, - glGetProgramResourceName, - glGetProgramResourcefvNV, - glGetProgramResourceiv, - glGetProgramStageiv, - glGetProgramStringARB, - glGetProgramStringNV, - glGetProgramSubroutineParameteruivNV, - glGetProgramiv, - glGetProgramivARB, - glGetProgramivNV, - glGetQueryBufferObjecti64v, - glGetQueryBufferObjectiv, - glGetQueryBufferObjectui64v, - glGetQueryBufferObjectuiv, - glGetQueryIndexediv, - glGetQueryObjecti64v, - glGetQueryObjecti64vEXT, - glGetQueryObjectiv, - glGetQueryObjectivARB, - glGetQueryObjectui64v, - glGetQueryObjectui64vEXT, - glGetQueryObjectuiv, - glGetQueryObjectuivARB, - glGetQueryiv, - glGetQueryivARB, - glGetRenderbufferParameteriv, - glGetRenderbufferParameterivEXT, - glGetSamplerParameterIiv, - glGetSamplerParameterIuiv, - glGetSamplerParameterfv, - glGetSamplerParameteriv, - glGetSemaphoreParameterivNV, - glGetSemaphoreParameterui64vEXT, - glGetSeparableFilter, - glGetSeparableFilterEXT, - glGetShaderInfoLog, - glGetShaderPrecisionFormat, - glGetShaderSource, - glGetShaderSourceARB, - glGetShaderiv, - glGetShadingRateImagePaletteNV, - glGetShadingRateSampleLocationivNV, - glGetSharpenTexFuncSGIS, - glGetStageIndexNV, - glGetStringi, - glGetSubroutineIndex, - glGetSubroutineUniformLocation, - glGetSynciv, - glGetTexBumpParameterfvATI, - glGetTexBumpParameterivATI, - glGetTexEnvxv, - glGetTexEnvxvOES, - glGetTexFilterFuncSGIS, - glGetTexGenxvOES, - glGetTexLevelParameterxvOES, - glGetTexParameterIiv, - glGetTexParameterIivEXT, - glGetTexParameterIuiv, - glGetTexParameterIuivEXT, - glGetTexParameterPointervAPPLE, - glGetTexParameterxv, - glGetTexParameterxvOES, - glGetTextureHandleARB, - glGetTextureHandleNV, - glGetTextureImage, - glGetTextureImageEXT, - glGetTextureLevelParameterfv, - glGetTextureLevelParameterfvEXT, - glGetTextureLevelParameteriv, - glGetTextureLevelParameterivEXT, - glGetTextureParameterIiv, - glGetTextureParameterIivEXT, - glGetTextureParameterIuiv, - glGetTextureParameterIuivEXT, - glGetTextureParameterfv, - glGetTextureParameterfvEXT, - glGetTextureParameteriv, - glGetTextureParameterivEXT, - glGetTextureSamplerHandleARB, - glGetTextureSamplerHandleNV, - glGetTextureSubImage, - glGetTrackMatrixivNV, - glGetTransformFeedbackVarying, - glGetTransformFeedbackVaryingEXT, - glGetTransformFeedbackVaryingNV, - glGetTransformFeedbacki64_v, - glGetTransformFeedbacki_v, - glGetTransformFeedbackiv, - glGetUniformBlockIndex, - glGetUniformBufferSizeEXT, - glGetUniformIndices, - glGetUniformLocation, - glGetUniformLocationARB, - glGetUniformOffsetEXT, - glGetUniformSubroutineuiv, - glGetUniformdv, - glGetUniformfv, - glGetUniformfvARB, - glGetUniformi64vARB, - glGetUniformi64vNV, - glGetUniformiv, - glGetUniformivARB, - glGetUniformui64vARB, - glGetUniformui64vNV, - glGetUniformuiv, - glGetUniformuivEXT, - glGetUnsignedBytei_vEXT, - glGetUnsignedBytevEXT, - glGetVariantArrayObjectfvATI, - glGetVariantArrayObjectivATI, - glGetVariantBooleanvEXT, - glGetVariantFloatvEXT, - glGetVariantIntegervEXT, - glGetVariantPointervEXT, - glGetVaryingLocationNV, - glGetVertexArrayIndexed64iv, - glGetVertexArrayIndexediv, - glGetVertexArrayIntegeri_vEXT, - glGetVertexArrayIntegervEXT, - glGetVertexArrayPointeri_vEXT, - glGetVertexArrayPointervEXT, - glGetVertexArrayiv, - glGetVertexAttribArrayObjectfvATI, - glGetVertexAttribArrayObjectivATI, - glGetVertexAttribIiv, - glGetVertexAttribIivEXT, - glGetVertexAttribIuiv, - glGetVertexAttribIuivEXT, - glGetVertexAttribLdv, - glGetVertexAttribLdvEXT, - glGetVertexAttribLi64vNV, - glGetVertexAttribLui64vARB, - glGetVertexAttribLui64vNV, - glGetVertexAttribPointerv, - glGetVertexAttribPointervARB, - glGetVertexAttribPointervNV, - glGetVertexAttribdv, - glGetVertexAttribdvARB, - glGetVertexAttribdvNV, - glGetVertexAttribfv, - glGetVertexAttribfvARB, - glGetVertexAttribfvNV, - glGetVertexAttribiv, - glGetVertexAttribivARB, - glGetVertexAttribivNV, - glGetVideoCaptureStreamdvNV, - glGetVideoCaptureStreamfvNV, - glGetVideoCaptureStreamivNV, - glGetVideoCaptureivNV, - glGetVideoi64vNV, - glGetVideoivNV, - glGetVideoui64vNV, - glGetVideouivNV, - glGetVkProcAddrNV, - glGetnColorTable, - glGetnColorTableARB, - glGetnCompressedTexImage, - glGetnCompressedTexImageARB, - glGetnConvolutionFilter, - glGetnConvolutionFilterARB, - glGetnHistogram, - glGetnHistogramARB, - glGetnMapdv, - glGetnMapdvARB, - glGetnMapfv, - glGetnMapfvARB, - glGetnMapiv, - glGetnMapivARB, - glGetnMinmax, - glGetnMinmaxARB, - glGetnPixelMapfv, - glGetnPixelMapfvARB, - glGetnPixelMapuiv, - glGetnPixelMapuivARB, - glGetnPixelMapusv, - glGetnPixelMapusvARB, - glGetnPolygonStipple, - glGetnPolygonStippleARB, - glGetnSeparableFilter, - glGetnSeparableFilterARB, - glGetnTexImage, - glGetnTexImageARB, - glGetnUniformdv, - glGetnUniformdvARB, - glGetnUniformfv, - glGetnUniformfvARB, - glGetnUniformi64vARB, - glGetnUniformiv, - glGetnUniformivARB, - glGetnUniformui64vARB, - glGetnUniformuiv, - glGetnUniformuivARB, - glGlobalAlphaFactorbSUN, - glGlobalAlphaFactordSUN, - glGlobalAlphaFactorfSUN, - glGlobalAlphaFactoriSUN, - glGlobalAlphaFactorsSUN, - glGlobalAlphaFactorubSUN, - glGlobalAlphaFactoruiSUN, - glGlobalAlphaFactorusSUN, - glHintPGI, - glHistogram, - glHistogramEXT, - glIglooInterfaceSGIX, - glImageTransformParameterfHP, - glImageTransformParameterfvHP, - glImageTransformParameteriHP, - glImageTransformParameterivHP, - glImportMemoryWin32HandleEXT, - glImportMemoryWin32NameEXT, - glImportSemaphoreWin32HandleEXT, - glImportSemaphoreWin32NameEXT, - glImportSyncEXT, - glIndexFormatNV, - glIndexFuncEXT, - glIndexMaterialEXT, - glIndexPointerEXT, - glIndexPointerListIBM, - glIndexxOES, - glIndexxvOES, - glInsertComponentEXT, - glInsertEventMarkerEXT, - glInstrumentsBufferSGIX, - glInterpolatePathsNV, - glInvalidateBufferData, - glInvalidateBufferSubData, - glInvalidateFramebuffer, - glInvalidateNamedFramebufferData, - glInvalidateNamedFramebufferSubData, - glInvalidateSubFramebuffer, - glInvalidateTexImage, - glInvalidateTexSubImage, - glIsAsyncMarkerSGIX, - glIsBuffer, - glIsBufferARB, - glIsBufferResidentNV, - glIsCommandListNV, - glIsEnabledIndexedEXT, - glIsEnabledi, - glIsFenceAPPLE, - glIsFenceNV, - glIsFramebuffer, - glIsFramebufferEXT, - glIsImageHandleResidentARB, - glIsImageHandleResidentNV, - glIsMemoryObjectEXT, - glIsNameAMD, - glIsNamedBufferResidentNV, - glIsNamedStringARB, - glIsObjectBufferATI, - glIsOcclusionQueryNV, - glIsPathNV, - glIsPointInFillPathNV, - glIsPointInStrokePathNV, - glIsProgram, - glIsProgramARB, - glIsProgramNV, - glIsProgramPipeline, - glIsQuery, - glIsQueryARB, - glIsRenderbuffer, - glIsRenderbufferEXT, - glIsSampler, - glIsSemaphoreEXT, - glIsShader, - glIsStateNV, - glIsSync, - glIsTextureEXT, - glIsTextureHandleResidentARB, - glIsTextureHandleResidentNV, - glIsTransformFeedback, - glIsTransformFeedbackNV, - glIsVariantEnabledEXT, - glIsVertexArray, - glIsVertexArrayAPPLE, - glIsVertexAttribEnabledAPPLE, - glLGPUCopyImageSubDataNVX, - glLGPUInterlockNVX, - glLGPUNamedBufferSubDataNVX, - glLabelObjectEXT, - glLightEnviSGIX, - glLightModelx, - glLightModelxOES, - glLightModelxv, - glLightModelxvOES, - glLightx, - glLightxOES, - glLightxv, - glLightxvOES, - glLineWidthx, - glLineWidthxOES, - glLinkProgram, - glLinkProgramARB, - glListDrawCommandsStatesClientNV, - glListParameterfSGIX, - glListParameterfvSGIX, - glListParameteriSGIX, - glListParameterivSGIX, - glLoadIdentityDeformationMapSGIX, - glLoadMatrixx, - glLoadMatrixxOES, - glLoadProgramNV, - glLoadTransposeMatrixd, - glLoadTransposeMatrixdARB, - glLoadTransposeMatrixf, - glLoadTransposeMatrixfARB, - glLoadTransposeMatrixxOES, - glLockArraysEXT, - glMTexCoord2fSGIS, - glMTexCoord2fvSGIS, - glMakeBufferNonResidentNV, - glMakeBufferResidentNV, - glMakeImageHandleNonResidentARB, - glMakeImageHandleNonResidentNV, - glMakeImageHandleResidentARB, - glMakeImageHandleResidentNV, - glMakeNamedBufferNonResidentNV, - glMakeNamedBufferResidentNV, - glMakeTextureHandleNonResidentARB, - glMakeTextureHandleNonResidentNV, - glMakeTextureHandleResidentARB, - glMakeTextureHandleResidentNV, - glMap1xOES, - glMap2xOES, - glMapBuffer, - glMapBufferARB, - glMapBufferRange, - glMapControlPointsNV, - glMapGrid1xOES, - glMapGrid2xOES, - glMapNamedBuffer, - glMapNamedBufferEXT, - glMapNamedBufferRange, - glMapNamedBufferRangeEXT, - glMapObjectBufferATI, - glMapParameterfvNV, - glMapParameterivNV, - glMapTexture2DINTEL, - glMapVertexAttrib1dAPPLE, - glMapVertexAttrib1fAPPLE, - glMapVertexAttrib2dAPPLE, - glMapVertexAttrib2fAPPLE, - glMaterialx, - glMaterialxOES, - glMaterialxv, - glMaterialxvOES, - glMatrixFrustumEXT, - glMatrixIndexPointerARB, - glMatrixIndexubvARB, - glMatrixIndexuivARB, - glMatrixIndexusvARB, - glMatrixLoad3x2fNV, - glMatrixLoad3x3fNV, - glMatrixLoadIdentityEXT, - glMatrixLoadTranspose3x3fNV, - glMatrixLoadTransposedEXT, - glMatrixLoadTransposefEXT, - glMatrixLoaddEXT, - glMatrixLoadfEXT, - glMatrixMult3x2fNV, - glMatrixMult3x3fNV, - glMatrixMultTranspose3x3fNV, - glMatrixMultTransposedEXT, - glMatrixMultTransposefEXT, - glMatrixMultdEXT, - glMatrixMultfEXT, - glMatrixOrthoEXT, - glMatrixPopEXT, - glMatrixPushEXT, - glMatrixRotatedEXT, - glMatrixRotatefEXT, - glMatrixScaledEXT, - glMatrixScalefEXT, - glMatrixTranslatedEXT, - glMatrixTranslatefEXT, - glMaxShaderCompilerThreadsARB, - glMaxShaderCompilerThreadsKHR, - glMemoryBarrier, - glMemoryBarrierByRegion, - glMemoryBarrierEXT, - glMemoryObjectParameterivEXT, - glMinSampleShading, - glMinSampleShadingARB, - glMinmax, - glMinmaxEXT, - glMultMatrixx, - glMultMatrixxOES, - glMultTransposeMatrixd, - glMultTransposeMatrixdARB, - glMultTransposeMatrixf, - glMultTransposeMatrixfARB, - glMultTransposeMatrixxOES, - glMultiDrawArrays, - glMultiDrawArraysEXT, - glMultiDrawArraysIndirect, - glMultiDrawArraysIndirectAMD, - glMultiDrawArraysIndirectBindlessCountNV, - glMultiDrawArraysIndirectBindlessNV, - glMultiDrawArraysIndirectCount, - glMultiDrawArraysIndirectCountARB, - glMultiDrawElementArrayAPPLE, - glMultiDrawElements, - glMultiDrawElementsBaseVertex, - glMultiDrawElementsEXT, - glMultiDrawElementsIndirect, - glMultiDrawElementsIndirectAMD, - glMultiDrawElementsIndirectBindlessCountNV, - glMultiDrawElementsIndirectBindlessNV, - glMultiDrawElementsIndirectCount, - glMultiDrawElementsIndirectCountARB, - glMultiDrawMeshTasksIndirectCountEXT, - glMultiDrawMeshTasksIndirectCountNV, - glMultiDrawMeshTasksIndirectEXT, - glMultiDrawMeshTasksIndirectNV, - glMultiDrawRangeElementArrayAPPLE, - glMultiModeDrawArraysIBM, - glMultiModeDrawElementsIBM, - glMultiTexBufferEXT, - glMultiTexCoord1bOES, - glMultiTexCoord1bvOES, - glMultiTexCoord1d, - glMultiTexCoord1dARB, - glMultiTexCoord1dSGIS, - glMultiTexCoord1dv, - glMultiTexCoord1dvARB, - glMultiTexCoord1dvSGIS, - glMultiTexCoord1f, - glMultiTexCoord1fARB, - glMultiTexCoord1fSGIS, - glMultiTexCoord1fv, - glMultiTexCoord1fvARB, - glMultiTexCoord1fvSGIS, - glMultiTexCoord1hNV, - glMultiTexCoord1hvNV, - glMultiTexCoord1i, - glMultiTexCoord1iARB, - glMultiTexCoord1iSGIS, - glMultiTexCoord1iv, - glMultiTexCoord1ivARB, - glMultiTexCoord1ivSGIS, - glMultiTexCoord1s, - glMultiTexCoord1sARB, - glMultiTexCoord1sSGIS, - glMultiTexCoord1sv, - glMultiTexCoord1svARB, - glMultiTexCoord1svSGIS, - glMultiTexCoord1xOES, - glMultiTexCoord1xvOES, - glMultiTexCoord2bOES, - glMultiTexCoord2bvOES, - glMultiTexCoord2d, - glMultiTexCoord2dARB, - glMultiTexCoord2dSGIS, - glMultiTexCoord2dv, - glMultiTexCoord2dvARB, - glMultiTexCoord2dvSGIS, - glMultiTexCoord2f, - glMultiTexCoord2fARB, - glMultiTexCoord2fSGIS, - glMultiTexCoord2fv, - glMultiTexCoord2fvARB, - glMultiTexCoord2fvSGIS, - glMultiTexCoord2hNV, - glMultiTexCoord2hvNV, - glMultiTexCoord2i, - glMultiTexCoord2iARB, - glMultiTexCoord2iSGIS, - glMultiTexCoord2iv, - glMultiTexCoord2ivARB, - glMultiTexCoord2ivSGIS, - glMultiTexCoord2s, - glMultiTexCoord2sARB, - glMultiTexCoord2sSGIS, - glMultiTexCoord2sv, - glMultiTexCoord2svARB, - glMultiTexCoord2svSGIS, - glMultiTexCoord2xOES, - glMultiTexCoord2xvOES, - glMultiTexCoord3bOES, - glMultiTexCoord3bvOES, - glMultiTexCoord3d, - glMultiTexCoord3dARB, - glMultiTexCoord3dSGIS, - glMultiTexCoord3dv, - glMultiTexCoord3dvARB, - glMultiTexCoord3dvSGIS, - glMultiTexCoord3f, - glMultiTexCoord3fARB, - glMultiTexCoord3fSGIS, - glMultiTexCoord3fv, - glMultiTexCoord3fvARB, - glMultiTexCoord3fvSGIS, - glMultiTexCoord3hNV, - glMultiTexCoord3hvNV, - glMultiTexCoord3i, - glMultiTexCoord3iARB, - glMultiTexCoord3iSGIS, - glMultiTexCoord3iv, - glMultiTexCoord3ivARB, - glMultiTexCoord3ivSGIS, - glMultiTexCoord3s, - glMultiTexCoord3sARB, - glMultiTexCoord3sSGIS, - glMultiTexCoord3sv, - glMultiTexCoord3svARB, - glMultiTexCoord3svSGIS, - glMultiTexCoord3xOES, - glMultiTexCoord3xvOES, - glMultiTexCoord4bOES, - glMultiTexCoord4bvOES, - glMultiTexCoord4d, - glMultiTexCoord4dARB, - glMultiTexCoord4dSGIS, - glMultiTexCoord4dv, - glMultiTexCoord4dvARB, - glMultiTexCoord4dvSGIS, - glMultiTexCoord4f, - glMultiTexCoord4fARB, - glMultiTexCoord4fSGIS, - glMultiTexCoord4fv, - glMultiTexCoord4fvARB, - glMultiTexCoord4fvSGIS, - glMultiTexCoord4hNV, - glMultiTexCoord4hvNV, - glMultiTexCoord4i, - glMultiTexCoord4iARB, - glMultiTexCoord4iSGIS, - glMultiTexCoord4iv, - glMultiTexCoord4ivARB, - glMultiTexCoord4ivSGIS, - glMultiTexCoord4s, - glMultiTexCoord4sARB, - glMultiTexCoord4sSGIS, - glMultiTexCoord4sv, - glMultiTexCoord4svARB, - glMultiTexCoord4svSGIS, - glMultiTexCoord4x, - glMultiTexCoord4xOES, - glMultiTexCoord4xvOES, - glMultiTexCoordP1ui, - glMultiTexCoordP1uiv, - glMultiTexCoordP2ui, - glMultiTexCoordP2uiv, - glMultiTexCoordP3ui, - glMultiTexCoordP3uiv, - glMultiTexCoordP4ui, - glMultiTexCoordP4uiv, - glMultiTexCoordPointerEXT, - glMultiTexCoordPointerSGIS, - glMultiTexEnvfEXT, - glMultiTexEnvfvEXT, - glMultiTexEnviEXT, - glMultiTexEnvivEXT, - glMultiTexGendEXT, - glMultiTexGendvEXT, - glMultiTexGenfEXT, - glMultiTexGenfvEXT, - glMultiTexGeniEXT, - glMultiTexGenivEXT, - glMultiTexImage1DEXT, - glMultiTexImage2DEXT, - glMultiTexImage3DEXT, - glMultiTexParameterIivEXT, - glMultiTexParameterIuivEXT, - glMultiTexParameterfEXT, - glMultiTexParameterfvEXT, - glMultiTexParameteriEXT, - glMultiTexParameterivEXT, - glMultiTexRenderbufferEXT, - glMultiTexSubImage1DEXT, - glMultiTexSubImage2DEXT, - glMultiTexSubImage3DEXT, - glMulticastBarrierNV, - glMulticastBlitFramebufferNV, - glMulticastBufferSubDataNV, - glMulticastCopyBufferSubDataNV, - glMulticastCopyImageSubDataNV, - glMulticastFramebufferSampleLocationsfvNV, - glMulticastGetQueryObjecti64vNV, - glMulticastGetQueryObjectivNV, - glMulticastGetQueryObjectui64vNV, - glMulticastGetQueryObjectuivNV, - glMulticastScissorArrayvNVX, - glMulticastViewportArrayvNVX, - glMulticastViewportPositionWScaleNVX, - glMulticastWaitSyncNV, - glNamedBufferAttachMemoryNV, - glNamedBufferData, - glNamedBufferDataEXT, - glNamedBufferPageCommitmentARB, - glNamedBufferPageCommitmentEXT, - glNamedBufferPageCommitmentMemNV, - glNamedBufferStorage, - glNamedBufferStorageEXT, - glNamedBufferStorageExternalEXT, - glNamedBufferStorageMemEXT, - glNamedBufferSubData, - glNamedBufferSubDataEXT, - glNamedCopyBufferSubDataEXT, - glNamedFramebufferDrawBuffer, - glNamedFramebufferDrawBuffers, - glNamedFramebufferParameteri, - glNamedFramebufferParameteriEXT, - glNamedFramebufferReadBuffer, - glNamedFramebufferRenderbuffer, - glNamedFramebufferRenderbufferEXT, - glNamedFramebufferSampleLocationsfvARB, - glNamedFramebufferSampleLocationsfvNV, - glNamedFramebufferSamplePositionsfvAMD, - glNamedFramebufferTexture, - glNamedFramebufferTexture1DEXT, - glNamedFramebufferTexture2DEXT, - glNamedFramebufferTexture3DEXT, - glNamedFramebufferTextureEXT, - glNamedFramebufferTextureFaceEXT, - glNamedFramebufferTextureLayer, - glNamedFramebufferTextureLayerEXT, - glNamedFramebufferTextureMultiviewOVR, - glNamedProgramLocalParameter4dEXT, - glNamedProgramLocalParameter4dvEXT, - glNamedProgramLocalParameter4fEXT, - glNamedProgramLocalParameter4fvEXT, - glNamedProgramLocalParameterI4iEXT, - glNamedProgramLocalParameterI4ivEXT, - glNamedProgramLocalParameterI4uiEXT, - glNamedProgramLocalParameterI4uivEXT, - glNamedProgramLocalParameters4fvEXT, - glNamedProgramLocalParametersI4ivEXT, - glNamedProgramLocalParametersI4uivEXT, - glNamedProgramStringEXT, - glNamedRenderbufferStorage, - glNamedRenderbufferStorageEXT, - glNamedRenderbufferStorageMultisample, - glNamedRenderbufferStorageMultisampleAdvancedAMD, - glNamedRenderbufferStorageMultisampleCoverageEXT, - glNamedRenderbufferStorageMultisampleEXT, - glNamedStringARB, - glNewBufferRegion, - glNewObjectBufferATI, - glNormal3fVertex3fSUN, - glNormal3fVertex3fvSUN, - glNormal3hNV, - glNormal3hvNV, - glNormal3x, - glNormal3xOES, - glNormal3xvOES, - glNormalFormatNV, - glNormalP3ui, - glNormalP3uiv, - glNormalPointerEXT, - glNormalPointerListIBM, - glNormalPointervINTEL, - glNormalStream3bATI, - glNormalStream3bvATI, - glNormalStream3dATI, - glNormalStream3dvATI, - glNormalStream3fATI, - glNormalStream3fvATI, - glNormalStream3iATI, - glNormalStream3ivATI, - glNormalStream3sATI, - glNormalStream3svATI, - glObjectLabel, - glObjectPtrLabel, - glObjectPurgeableAPPLE, - glObjectUnpurgeableAPPLE, - glOrthof, - glOrthofOES, - glOrthox, - glOrthoxOES, - glPNTrianglesfATI, - glPNTrianglesiATI, - glPassTexCoordATI, - glPassThroughxOES, - glPatchParameterfv, - glPatchParameteri, - glPathColorGenNV, - glPathCommandsNV, - glPathCoordsNV, - glPathCoverDepthFuncNV, - glPathDashArrayNV, - glPathFogGenNV, - glPathGlyphIndexArrayNV, - glPathGlyphIndexRangeNV, - glPathGlyphRangeNV, - glPathGlyphsNV, - glPathMemoryGlyphIndexArrayNV, - glPathParameterfNV, - glPathParameterfvNV, - glPathParameteriNV, - glPathParameterivNV, - glPathStencilDepthOffsetNV, - glPathStencilFuncNV, - glPathStringNV, - glPathSubCommandsNV, - glPathSubCoordsNV, - glPathTexGenNV, - glPauseTransformFeedback, - glPauseTransformFeedbackNV, - glPixelDataRangeNV, - glPixelMapx, - glPixelStorex, - glPixelTexGenParameterfSGIS, - glPixelTexGenParameterfvSGIS, - glPixelTexGenParameteriSGIS, - glPixelTexGenParameterivSGIS, - glPixelTexGenSGIX, - glPixelTransferxOES, - glPixelTransformParameterfEXT, - glPixelTransformParameterfvEXT, - glPixelTransformParameteriEXT, - glPixelTransformParameterivEXT, - glPixelZoomxOES, - glPointAlongPathNV, - glPointParameterf, - glPointParameterfARB, - glPointParameterfEXT, - glPointParameterfSGIS, - glPointParameterfv, - glPointParameterfvARB, - glPointParameterfvEXT, - glPointParameterfvSGIS, - glPointParameteri, - glPointParameteriNV, - glPointParameteriv, - glPointParameterivNV, - glPointParameterx, - glPointParameterxv, - glPointParameterxvOES, - glPointSizex, - glPointSizexOES, - glPollAsyncSGIX, - glPollInstrumentsSGIX, - glPolygonOffsetClamp, - glPolygonOffsetClampEXT, - glPolygonOffsetEXT, - glPolygonOffsetx, - glPolygonOffsetxOES, - glPopDebugGroup, - glPopGroupMarkerEXT, - glPresentFrameDualFillNV, - glPresentFrameKeyedNV, - glPrimitiveBoundingBox, - glPrimitiveBoundingBoxARB, - glPrimitiveRestartIndex, - glPrimitiveRestartIndexNV, - glPrimitiveRestartNV, - glPrioritizeTexturesEXT, - glPrioritizeTexturesxOES, - glProgramBinary, - glProgramBufferParametersIivNV, - glProgramBufferParametersIuivNV, - glProgramBufferParametersfvNV, - glProgramEnvParameter4dARB, - glProgramEnvParameter4dvARB, - glProgramEnvParameter4fARB, - glProgramEnvParameter4fvARB, - glProgramEnvParameterI4iNV, - glProgramEnvParameterI4ivNV, - glProgramEnvParameterI4uiNV, - glProgramEnvParameterI4uivNV, - glProgramEnvParameters4fvEXT, - glProgramEnvParametersI4ivNV, - glProgramEnvParametersI4uivNV, - glProgramLocalParameter4dARB, - glProgramLocalParameter4dvARB, - glProgramLocalParameter4fARB, - glProgramLocalParameter4fvARB, - glProgramLocalParameterI4iNV, - glProgramLocalParameterI4ivNV, - glProgramLocalParameterI4uiNV, - glProgramLocalParameterI4uivNV, - glProgramLocalParameters4fvEXT, - glProgramLocalParametersI4ivNV, - glProgramLocalParametersI4uivNV, - glProgramNamedParameter4dNV, - glProgramNamedParameter4dvNV, - glProgramNamedParameter4fNV, - glProgramNamedParameter4fvNV, - glProgramParameter4dNV, - glProgramParameter4dvNV, - glProgramParameter4fNV, - glProgramParameter4fvNV, - glProgramParameteri, - glProgramParameteriARB, - glProgramParameteriEXT, - glProgramParameters4dvNV, - glProgramParameters4fvNV, - glProgramPathFragmentInputGenNV, - glProgramStringARB, - glProgramSubroutineParametersuivNV, - glProgramUniform1d, - glProgramUniform1dEXT, - glProgramUniform1dv, - glProgramUniform1dvEXT, - glProgramUniform1f, - glProgramUniform1fEXT, - glProgramUniform1fv, - glProgramUniform1fvEXT, - glProgramUniform1i, - glProgramUniform1i64ARB, - glProgramUniform1i64NV, - glProgramUniform1i64vARB, - glProgramUniform1i64vNV, - glProgramUniform1iEXT, - glProgramUniform1iv, - glProgramUniform1ivEXT, - glProgramUniform1ui, - glProgramUniform1ui64ARB, - glProgramUniform1ui64NV, - glProgramUniform1ui64vARB, - glProgramUniform1ui64vNV, - glProgramUniform1uiEXT, - glProgramUniform1uiv, - glProgramUniform1uivEXT, - glProgramUniform2d, - glProgramUniform2dEXT, - glProgramUniform2dv, - glProgramUniform2dvEXT, - glProgramUniform2f, - glProgramUniform2fEXT, - glProgramUniform2fv, - glProgramUniform2fvEXT, - glProgramUniform2i, - glProgramUniform2i64ARB, - glProgramUniform2i64NV, - glProgramUniform2i64vARB, - glProgramUniform2i64vNV, - glProgramUniform2iEXT, - glProgramUniform2iv, - glProgramUniform2ivEXT, - glProgramUniform2ui, - glProgramUniform2ui64ARB, - glProgramUniform2ui64NV, - glProgramUniform2ui64vARB, - glProgramUniform2ui64vNV, - glProgramUniform2uiEXT, - glProgramUniform2uiv, - glProgramUniform2uivEXT, - glProgramUniform3d, - glProgramUniform3dEXT, - glProgramUniform3dv, - glProgramUniform3dvEXT, - glProgramUniform3f, - glProgramUniform3fEXT, - glProgramUniform3fv, - glProgramUniform3fvEXT, - glProgramUniform3i, - glProgramUniform3i64ARB, - glProgramUniform3i64NV, - glProgramUniform3i64vARB, - glProgramUniform3i64vNV, - glProgramUniform3iEXT, - glProgramUniform3iv, - glProgramUniform3ivEXT, - glProgramUniform3ui, - glProgramUniform3ui64ARB, - glProgramUniform3ui64NV, - glProgramUniform3ui64vARB, - glProgramUniform3ui64vNV, - glProgramUniform3uiEXT, - glProgramUniform3uiv, - glProgramUniform3uivEXT, - glProgramUniform4d, - glProgramUniform4dEXT, - glProgramUniform4dv, - glProgramUniform4dvEXT, - glProgramUniform4f, - glProgramUniform4fEXT, - glProgramUniform4fv, - glProgramUniform4fvEXT, - glProgramUniform4i, - glProgramUniform4i64ARB, - glProgramUniform4i64NV, - glProgramUniform4i64vARB, - glProgramUniform4i64vNV, - glProgramUniform4iEXT, - glProgramUniform4iv, - glProgramUniform4ivEXT, - glProgramUniform4ui, - glProgramUniform4ui64ARB, - glProgramUniform4ui64NV, - glProgramUniform4ui64vARB, - glProgramUniform4ui64vNV, - glProgramUniform4uiEXT, - glProgramUniform4uiv, - glProgramUniform4uivEXT, - glProgramUniformHandleui64ARB, - glProgramUniformHandleui64NV, - glProgramUniformHandleui64vARB, - glProgramUniformHandleui64vNV, - glProgramUniformMatrix2dv, - glProgramUniformMatrix2dvEXT, - glProgramUniformMatrix2fv, - glProgramUniformMatrix2fvEXT, - glProgramUniformMatrix2x3dv, - glProgramUniformMatrix2x3dvEXT, - glProgramUniformMatrix2x3fv, - glProgramUniformMatrix2x3fvEXT, - glProgramUniformMatrix2x4dv, - glProgramUniformMatrix2x4dvEXT, - glProgramUniformMatrix2x4fv, - glProgramUniformMatrix2x4fvEXT, - glProgramUniformMatrix3dv, - glProgramUniformMatrix3dvEXT, - glProgramUniformMatrix3fv, - glProgramUniformMatrix3fvEXT, - glProgramUniformMatrix3x2dv, - glProgramUniformMatrix3x2dvEXT, - glProgramUniformMatrix3x2fv, - glProgramUniformMatrix3x2fvEXT, - glProgramUniformMatrix3x4dv, - glProgramUniformMatrix3x4dvEXT, - glProgramUniformMatrix3x4fv, - glProgramUniformMatrix3x4fvEXT, - glProgramUniformMatrix4dv, - glProgramUniformMatrix4dvEXT, - glProgramUniformMatrix4fv, - glProgramUniformMatrix4fvEXT, - glProgramUniformMatrix4x2dv, - glProgramUniformMatrix4x2dvEXT, - glProgramUniformMatrix4x2fv, - glProgramUniformMatrix4x2fvEXT, - glProgramUniformMatrix4x3dv, - glProgramUniformMatrix4x3dvEXT, - glProgramUniformMatrix4x3fv, - glProgramUniformMatrix4x3fvEXT, - glProgramUniformui64NV, - glProgramUniformui64vNV, - glProgramVertexLimitNV, - glProvokingVertex, - glProvokingVertexEXT, - glPushClientAttribDefaultEXT, - glPushDebugGroup, - glPushGroupMarkerEXT, - glQueryCounter, - glQueryMatrixxOES, - glQueryObjectParameteruiAMD, - glQueryResourceNV, - glQueryResourceTagNV, - glRasterPos2xOES, - glRasterPos2xvOES, - glRasterPos3xOES, - glRasterPos3xvOES, - glRasterPos4xOES, - glRasterPos4xvOES, - glRasterSamplesEXT, - glReadBufferRegion, - glReadInstrumentsSGIX, - glReadnPixels, - glReadnPixelsARB, - glRectxOES, - glRectxvOES, - glReferencePlaneSGIX, - glReleaseKeyedMutexWin32EXT, - glReleaseShaderCompiler, - glRenderGpuMaskNV, - glRenderbufferStorage, - glRenderbufferStorageEXT, - glRenderbufferStorageMultisample, - glRenderbufferStorageMultisampleAdvancedAMD, - glRenderbufferStorageMultisampleCoverageNV, - glRenderbufferStorageMultisampleEXT, - glReplacementCodePointerSUN, - glReplacementCodeubSUN, - glReplacementCodeubvSUN, - glReplacementCodeuiColor3fVertex3fSUN, - glReplacementCodeuiColor3fVertex3fvSUN, - glReplacementCodeuiColor4fNormal3fVertex3fSUN, - glReplacementCodeuiColor4fNormal3fVertex3fvSUN, - glReplacementCodeuiColor4ubVertex3fSUN, - glReplacementCodeuiColor4ubVertex3fvSUN, - glReplacementCodeuiNormal3fVertex3fSUN, - glReplacementCodeuiNormal3fVertex3fvSUN, - glReplacementCodeuiSUN, - glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN, - glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN, - glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN, - glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN, - glReplacementCodeuiTexCoord2fVertex3fSUN, - glReplacementCodeuiTexCoord2fVertex3fvSUN, - glReplacementCodeuiVertex3fSUN, - glReplacementCodeuiVertex3fvSUN, - glReplacementCodeuivSUN, - glReplacementCodeusSUN, - glReplacementCodeusvSUN, - glRequestResidentProgramsNV, - glResetHistogram, - glResetHistogramEXT, - glResetMemoryObjectParameterNV, - glResetMinmax, - glResetMinmaxEXT, - glResizeBuffersMESA, - glResolveDepthValuesNV, - glResumeTransformFeedback, - glResumeTransformFeedbackNV, - glRotatex, - glRotatexOES, - glSampleCoverage, - glSampleCoverageARB, - glSampleCoveragex, - glSampleMapATI, - glSampleMaskEXT, - glSampleMaskIndexedNV, - glSampleMaskSGIS, - glSampleMaski, - glSamplePatternEXT, - glSamplePatternSGIS, - glSamplerParameterIiv, - glSamplerParameterIuiv, - glSamplerParameterf, - glSamplerParameterfv, - glSamplerParameteri, - glSamplerParameteriv, - glScalex, - glScalexOES, - glScissorArrayv, - glScissorExclusiveArrayvNV, - glScissorExclusiveNV, - glScissorIndexed, - glScissorIndexedv, - glSecondaryColor3b, - glSecondaryColor3bEXT, - glSecondaryColor3bv, - glSecondaryColor3bvEXT, - glSecondaryColor3d, - glSecondaryColor3dEXT, - glSecondaryColor3dv, - glSecondaryColor3dvEXT, - glSecondaryColor3f, - glSecondaryColor3fEXT, - glSecondaryColor3fv, - glSecondaryColor3fvEXT, - glSecondaryColor3hNV, - glSecondaryColor3hvNV, - glSecondaryColor3i, - glSecondaryColor3iEXT, - glSecondaryColor3iv, - glSecondaryColor3ivEXT, - glSecondaryColor3s, - glSecondaryColor3sEXT, - glSecondaryColor3sv, - glSecondaryColor3svEXT, - glSecondaryColor3ub, - glSecondaryColor3ubEXT, - glSecondaryColor3ubv, - glSecondaryColor3ubvEXT, - glSecondaryColor3ui, - glSecondaryColor3uiEXT, - glSecondaryColor3uiv, - glSecondaryColor3uivEXT, - glSecondaryColor3us, - glSecondaryColor3usEXT, - glSecondaryColor3usv, - glSecondaryColor3usvEXT, - glSecondaryColorFormatNV, - glSecondaryColorP3ui, - glSecondaryColorP3uiv, - glSecondaryColorPointer, - glSecondaryColorPointerEXT, - glSecondaryColorPointerListIBM, - glSelectPerfMonitorCountersAMD, - glSelectTextureCoordSetSGIS, - glSelectTextureSGIS, - glSemaphoreParameterivNV, - glSemaphoreParameterui64vEXT, - glSeparableFilter2D, - glSeparableFilter2DEXT, - glSetFenceAPPLE, - glSetFenceNV, - glSetFragmentShaderConstantATI, - glSetInvariantEXT, - glSetLocalConstantEXT, - glSetMultisamplefvAMD, - glShaderBinary, - glShaderOp1EXT, - glShaderOp2EXT, - glShaderOp3EXT, - glShaderSource, - glShaderSourceARB, - glShaderStorageBlockBinding, - glShadingRateCombinerOpsEXT, - glShadingRateEXT, - glShadingRateImageBarrierNV, - glShadingRateImagePaletteNV, - glShadingRateSampleOrderCustomNV, - glShadingRateSampleOrderNV, - glSharpenTexFuncSGIS, - glSignalSemaphoreEXT, - glSignalSemaphoreui64NVX, - glSignalVkFenceNV, - glSignalVkSemaphoreNV, - glSpecializeShader, - glSpecializeShaderARB, - glSpriteParameterfSGIX, - glSpriteParameterfvSGIX, - glSpriteParameteriSGIX, - glSpriteParameterivSGIX, - glStartInstrumentsSGIX, - glStateCaptureNV, - glStencilClearTagEXT, - glStencilFillPathInstancedNV, - glStencilFillPathNV, - glStencilFuncSeparate, - glStencilFuncSeparateATI, - glStencilMaskSeparate, - glStencilOpSeparate, - glStencilOpSeparateATI, - glStencilOpValueAMD, - glStencilStrokePathInstancedNV, - glStencilStrokePathNV, - glStencilThenCoverFillPathInstancedNV, - glStencilThenCoverFillPathNV, - glStencilThenCoverStrokePathInstancedNV, - glStencilThenCoverStrokePathNV, - glStopInstrumentsSGIX, - glStringMarkerGREMEDY, - glSubpixelPrecisionBiasNV, - glSwizzleEXT, - glSyncTextureINTEL, - glTagSampleBufferSGIX, - glTangent3bEXT, - glTangent3bvEXT, - glTangent3dEXT, - glTangent3dvEXT, - glTangent3fEXT, - glTangent3fvEXT, - glTangent3iEXT, - glTangent3ivEXT, - glTangent3sEXT, - glTangent3svEXT, - glTangentPointerEXT, - glTbufferMask3DFX, - glTessellationFactorAMD, - glTessellationModeAMD, - glTestFenceAPPLE, - glTestFenceNV, - glTestObjectAPPLE, - glTexAttachMemoryNV, - glTexBuffer, - glTexBufferARB, - glTexBufferEXT, - glTexBufferRange, - glTexBumpParameterfvATI, - glTexBumpParameterivATI, - glTexCoord1bOES, - glTexCoord1bvOES, - glTexCoord1hNV, - glTexCoord1hvNV, - glTexCoord1xOES, - glTexCoord1xvOES, - glTexCoord2bOES, - glTexCoord2bvOES, - glTexCoord2fColor3fVertex3fSUN, - glTexCoord2fColor3fVertex3fvSUN, - glTexCoord2fColor4fNormal3fVertex3fSUN, - glTexCoord2fColor4fNormal3fVertex3fvSUN, - glTexCoord2fColor4ubVertex3fSUN, - glTexCoord2fColor4ubVertex3fvSUN, - glTexCoord2fNormal3fVertex3fSUN, - glTexCoord2fNormal3fVertex3fvSUN, - glTexCoord2fVertex3fSUN, - glTexCoord2fVertex3fvSUN, - glTexCoord2hNV, - glTexCoord2hvNV, - glTexCoord2xOES, - glTexCoord2xvOES, - glTexCoord3bOES, - glTexCoord3bvOES, - glTexCoord3hNV, - glTexCoord3hvNV, - glTexCoord3xOES, - glTexCoord3xvOES, - glTexCoord4bOES, - glTexCoord4bvOES, - glTexCoord4fColor4fNormal3fVertex4fSUN, - glTexCoord4fColor4fNormal3fVertex4fvSUN, - glTexCoord4fVertex4fSUN, - glTexCoord4fVertex4fvSUN, - glTexCoord4hNV, - glTexCoord4hvNV, - glTexCoord4xOES, - glTexCoord4xvOES, - glTexCoordFormatNV, - glTexCoordP1ui, - glTexCoordP1uiv, - glTexCoordP2ui, - glTexCoordP2uiv, - glTexCoordP3ui, - glTexCoordP3uiv, - glTexCoordP4ui, - glTexCoordP4uiv, - glTexCoordPointerEXT, - glTexCoordPointerListIBM, - glTexCoordPointervINTEL, - glTexEnvx, - glTexEnvxOES, - glTexEnvxv, - glTexEnvxvOES, - glTexFilterFuncSGIS, - glTexGenxOES, - glTexGenxvOES, - glTexImage2DMultisample, - glTexImage2DMultisampleCoverageNV, - glTexImage3D, - glTexImage3DEXT, - glTexImage3DMultisample, - glTexImage3DMultisampleCoverageNV, - glTexImage4DSGIS, - glTexPageCommitmentARB, - glTexPageCommitmentMemNV, - glTexParameterIiv, - glTexParameterIivEXT, - glTexParameterIuiv, - glTexParameterIuivEXT, - glTexParameterx, - glTexParameterxOES, - glTexParameterxv, - glTexParameterxvOES, - glTexRenderbufferNV, - glTexStorage1D, - glTexStorage1DEXT, - glTexStorage2D, - glTexStorage2DEXT, - glTexStorage2DMultisample, - glTexStorage3D, - glTexStorage3DEXT, - glTexStorage3DMultisample, - glTexStorageMem1DEXT, - glTexStorageMem2DEXT, - glTexStorageMem2DMultisampleEXT, - glTexStorageMem3DEXT, - glTexStorageMem3DMultisampleEXT, - glTexStorageSparseAMD, - glTexSubImage1DEXT, - glTexSubImage2DEXT, - glTexSubImage3D, - glTexSubImage3DEXT, - glTexSubImage4DSGIS, - glTextureAttachMemoryNV, - glTextureBarrier, - glTextureBarrierNV, - glTextureBuffer, - glTextureBufferEXT, - glTextureBufferRange, - glTextureBufferRangeEXT, - glTextureColorMaskSGIS, - glTextureImage1DEXT, - glTextureImage2DEXT, - glTextureImage2DMultisampleCoverageNV, - glTextureImage2DMultisampleNV, - glTextureImage3DEXT, - glTextureImage3DMultisampleCoverageNV, - glTextureImage3DMultisampleNV, - glTextureLightEXT, - glTextureMaterialEXT, - glTextureNormalEXT, - glTexturePageCommitmentEXT, - glTexturePageCommitmentMemNV, - glTextureParameterIiv, - glTextureParameterIivEXT, - glTextureParameterIuiv, - glTextureParameterIuivEXT, - glTextureParameterf, - glTextureParameterfEXT, - glTextureParameterfv, - glTextureParameterfvEXT, - glTextureParameteri, - glTextureParameteriEXT, - glTextureParameteriv, - glTextureParameterivEXT, - glTextureRangeAPPLE, - glTextureRenderbufferEXT, - glTextureStorage1D, - glTextureStorage1DEXT, - glTextureStorage2D, - glTextureStorage2DEXT, - glTextureStorage2DMultisample, - glTextureStorage2DMultisampleEXT, - glTextureStorage3D, - glTextureStorage3DEXT, - glTextureStorage3DMultisample, - glTextureStorage3DMultisampleEXT, - glTextureStorageMem1DEXT, - glTextureStorageMem2DEXT, - glTextureStorageMem2DMultisampleEXT, - glTextureStorageMem3DEXT, - glTextureStorageMem3DMultisampleEXT, - glTextureStorageSparseAMD, - glTextureSubImage1D, - glTextureSubImage1DEXT, - glTextureSubImage2D, - glTextureSubImage2DEXT, - glTextureSubImage3D, - glTextureSubImage3DEXT, - glTextureView, - glTrackMatrixNV, - glTransformFeedbackAttribsNV, - glTransformFeedbackBufferBase, - glTransformFeedbackBufferRange, - glTransformFeedbackStreamAttribsNV, - glTransformFeedbackVaryings, - glTransformFeedbackVaryingsEXT, - glTransformFeedbackVaryingsNV, - glTransformPathNV, - glTranslatex, - glTranslatexOES, - glUniform1d, - glUniform1dv, - glUniform1f, - glUniform1fARB, - glUniform1fv, - glUniform1fvARB, - glUniform1i, - glUniform1i64ARB, - glUniform1i64NV, - glUniform1i64vARB, - glUniform1i64vNV, - glUniform1iARB, - glUniform1iv, - glUniform1ivARB, - glUniform1ui, - glUniform1ui64ARB, - glUniform1ui64NV, - glUniform1ui64vARB, - glUniform1ui64vNV, - glUniform1uiEXT, - glUniform1uiv, - glUniform1uivEXT, - glUniform2d, - glUniform2dv, - glUniform2f, - glUniform2fARB, - glUniform2fv, - glUniform2fvARB, - glUniform2i, - glUniform2i64ARB, - glUniform2i64NV, - glUniform2i64vARB, - glUniform2i64vNV, - glUniform2iARB, - glUniform2iv, - glUniform2ivARB, - glUniform2ui, - glUniform2ui64ARB, - glUniform2ui64NV, - glUniform2ui64vARB, - glUniform2ui64vNV, - glUniform2uiEXT, - glUniform2uiv, - glUniform2uivEXT, - glUniform3d, - glUniform3dv, - glUniform3f, - glUniform3fARB, - glUniform3fv, - glUniform3fvARB, - glUniform3i, - glUniform3i64ARB, - glUniform3i64NV, - glUniform3i64vARB, - glUniform3i64vNV, - glUniform3iARB, - glUniform3iv, - glUniform3ivARB, - glUniform3ui, - glUniform3ui64ARB, - glUniform3ui64NV, - glUniform3ui64vARB, - glUniform3ui64vNV, - glUniform3uiEXT, - glUniform3uiv, - glUniform3uivEXT, - glUniform4d, - glUniform4dv, - glUniform4f, - glUniform4fARB, - glUniform4fv, - glUniform4fvARB, - glUniform4i, - glUniform4i64ARB, - glUniform4i64NV, - glUniform4i64vARB, - glUniform4i64vNV, - glUniform4iARB, - glUniform4iv, - glUniform4ivARB, - glUniform4ui, - glUniform4ui64ARB, - glUniform4ui64NV, - glUniform4ui64vARB, - glUniform4ui64vNV, - glUniform4uiEXT, - glUniform4uiv, - glUniform4uivEXT, - glUniformBlockBinding, - glUniformBufferEXT, - glUniformHandleui64ARB, - glUniformHandleui64NV, - glUniformHandleui64vARB, - glUniformHandleui64vNV, - glUniformMatrix2dv, - glUniformMatrix2fv, - glUniformMatrix2fvARB, - glUniformMatrix2x3dv, - glUniformMatrix2x3fv, - glUniformMatrix2x4dv, - glUniformMatrix2x4fv, - glUniformMatrix3dv, - glUniformMatrix3fv, - glUniformMatrix3fvARB, - glUniformMatrix3x2dv, - glUniformMatrix3x2fv, - glUniformMatrix3x4dv, - glUniformMatrix3x4fv, - glUniformMatrix4dv, - glUniformMatrix4fv, - glUniformMatrix4fvARB, - glUniformMatrix4x2dv, - glUniformMatrix4x2fv, - glUniformMatrix4x3dv, - glUniformMatrix4x3fv, - glUniformSubroutinesuiv, - glUniformui64NV, - glUniformui64vNV, - glUnlockArraysEXT, - glUnmapBuffer, - glUnmapBufferARB, - glUnmapNamedBuffer, - glUnmapNamedBufferEXT, - glUnmapObjectBufferATI, - glUnmapTexture2DINTEL, - glUpdateObjectBufferATI, - glUploadGpuMaskNVX, - glUseProgram, - glUseProgramObjectARB, - glUseProgramStages, - glUseShaderProgramEXT, - glVDPAUFiniNV, - glVDPAUGetSurfaceivNV, - glVDPAUInitNV, - glVDPAUIsSurfaceNV, - glVDPAUMapSurfacesNV, - glVDPAURegisterOutputSurfaceNV, - glVDPAURegisterVideoSurfaceNV, - glVDPAURegisterVideoSurfaceWithPictureStructureNV, - glVDPAUSurfaceAccessNV, - glVDPAUUnmapSurfacesNV, - glVDPAUUnregisterSurfaceNV, - glValidateProgram, - glValidateProgramARB, - glValidateProgramPipeline, - glVariantArrayObjectATI, - glVariantPointerEXT, - glVariantbvEXT, - glVariantdvEXT, - glVariantfvEXT, - glVariantivEXT, - glVariantsvEXT, - glVariantubvEXT, - glVariantuivEXT, - glVariantusvEXT, - glVertex2bOES, - glVertex2bvOES, - glVertex2hNV, - glVertex2hvNV, - glVertex2xOES, - glVertex2xvOES, - glVertex3bOES, - glVertex3bvOES, - glVertex3hNV, - glVertex3hvNV, - glVertex3xOES, - glVertex3xvOES, - glVertex4bOES, - glVertex4bvOES, - glVertex4hNV, - glVertex4hvNV, - glVertex4xOES, - glVertex4xvOES, - glVertexArrayAttribBinding, - glVertexArrayAttribFormat, - glVertexArrayAttribIFormat, - glVertexArrayAttribLFormat, - glVertexArrayBindVertexBufferEXT, - glVertexArrayBindingDivisor, - glVertexArrayColorOffsetEXT, - glVertexArrayEdgeFlagOffsetEXT, - glVertexArrayElementBuffer, - glVertexArrayFogCoordOffsetEXT, - glVertexArrayIndexOffsetEXT, - glVertexArrayMultiTexCoordOffsetEXT, - glVertexArrayNormalOffsetEXT, - glVertexArrayParameteriAPPLE, - glVertexArrayRangeAPPLE, - glVertexArrayRangeNV, - glVertexArraySecondaryColorOffsetEXT, - glVertexArrayTexCoordOffsetEXT, - glVertexArrayVertexAttribBindingEXT, - glVertexArrayVertexAttribDivisorEXT, - glVertexArrayVertexAttribFormatEXT, - glVertexArrayVertexAttribIFormatEXT, - glVertexArrayVertexAttribIOffsetEXT, - glVertexArrayVertexAttribLFormatEXT, - glVertexArrayVertexAttribLOffsetEXT, - glVertexArrayVertexAttribOffsetEXT, - glVertexArrayVertexBindingDivisorEXT, - glVertexArrayVertexBuffer, - glVertexArrayVertexBuffers, - glVertexArrayVertexOffsetEXT, - glVertexAttrib1d, - glVertexAttrib1dARB, - glVertexAttrib1dNV, - glVertexAttrib1dv, - glVertexAttrib1dvARB, - glVertexAttrib1dvNV, - glVertexAttrib1f, - glVertexAttrib1fARB, - glVertexAttrib1fNV, - glVertexAttrib1fv, - glVertexAttrib1fvARB, - glVertexAttrib1fvNV, - glVertexAttrib1hNV, - glVertexAttrib1hvNV, - glVertexAttrib1s, - glVertexAttrib1sARB, - glVertexAttrib1sNV, - glVertexAttrib1sv, - glVertexAttrib1svARB, - glVertexAttrib1svNV, - glVertexAttrib2d, - glVertexAttrib2dARB, - glVertexAttrib2dNV, - glVertexAttrib2dv, - glVertexAttrib2dvARB, - glVertexAttrib2dvNV, - glVertexAttrib2f, - glVertexAttrib2fARB, - glVertexAttrib2fNV, - glVertexAttrib2fv, - glVertexAttrib2fvARB, - glVertexAttrib2fvNV, - glVertexAttrib2hNV, - glVertexAttrib2hvNV, - glVertexAttrib2s, - glVertexAttrib2sARB, - glVertexAttrib2sNV, - glVertexAttrib2sv, - glVertexAttrib2svARB, - glVertexAttrib2svNV, - glVertexAttrib3d, - glVertexAttrib3dARB, - glVertexAttrib3dNV, - glVertexAttrib3dv, - glVertexAttrib3dvARB, - glVertexAttrib3dvNV, - glVertexAttrib3f, - glVertexAttrib3fARB, - glVertexAttrib3fNV, - glVertexAttrib3fv, - glVertexAttrib3fvARB, - glVertexAttrib3fvNV, - glVertexAttrib3hNV, - glVertexAttrib3hvNV, - glVertexAttrib3s, - glVertexAttrib3sARB, - glVertexAttrib3sNV, - glVertexAttrib3sv, - glVertexAttrib3svARB, - glVertexAttrib3svNV, - glVertexAttrib4Nbv, - glVertexAttrib4NbvARB, - glVertexAttrib4Niv, - glVertexAttrib4NivARB, - glVertexAttrib4Nsv, - glVertexAttrib4NsvARB, - glVertexAttrib4Nub, - glVertexAttrib4NubARB, - glVertexAttrib4Nubv, - glVertexAttrib4NubvARB, - glVertexAttrib4Nuiv, - glVertexAttrib4NuivARB, - glVertexAttrib4Nusv, - glVertexAttrib4NusvARB, - glVertexAttrib4bv, - glVertexAttrib4bvARB, - glVertexAttrib4d, - glVertexAttrib4dARB, - glVertexAttrib4dNV, - glVertexAttrib4dv, - glVertexAttrib4dvARB, - glVertexAttrib4dvNV, - glVertexAttrib4f, - glVertexAttrib4fARB, - glVertexAttrib4fNV, - glVertexAttrib4fv, - glVertexAttrib4fvARB, - glVertexAttrib4fvNV, - glVertexAttrib4hNV, - glVertexAttrib4hvNV, - glVertexAttrib4iv, - glVertexAttrib4ivARB, - glVertexAttrib4s, - glVertexAttrib4sARB, - glVertexAttrib4sNV, - glVertexAttrib4sv, - glVertexAttrib4svARB, - glVertexAttrib4svNV, - glVertexAttrib4ubNV, - glVertexAttrib4ubv, - glVertexAttrib4ubvARB, - glVertexAttrib4ubvNV, - glVertexAttrib4uiv, - glVertexAttrib4uivARB, - glVertexAttrib4usv, - glVertexAttrib4usvARB, - glVertexAttribArrayObjectATI, - glVertexAttribBinding, - glVertexAttribDivisor, - glVertexAttribDivisorARB, - glVertexAttribFormat, - glVertexAttribFormatNV, - glVertexAttribI1i, - glVertexAttribI1iEXT, - glVertexAttribI1iv, - glVertexAttribI1ivEXT, - glVertexAttribI1ui, - glVertexAttribI1uiEXT, - glVertexAttribI1uiv, - glVertexAttribI1uivEXT, - glVertexAttribI2i, - glVertexAttribI2iEXT, - glVertexAttribI2iv, - glVertexAttribI2ivEXT, - glVertexAttribI2ui, - glVertexAttribI2uiEXT, - glVertexAttribI2uiv, - glVertexAttribI2uivEXT, - glVertexAttribI3i, - glVertexAttribI3iEXT, - glVertexAttribI3iv, - glVertexAttribI3ivEXT, - glVertexAttribI3ui, - glVertexAttribI3uiEXT, - glVertexAttribI3uiv, - glVertexAttribI3uivEXT, - glVertexAttribI4bv, - glVertexAttribI4bvEXT, - glVertexAttribI4i, - glVertexAttribI4iEXT, - glVertexAttribI4iv, - glVertexAttribI4ivEXT, - glVertexAttribI4sv, - glVertexAttribI4svEXT, - glVertexAttribI4ubv, - glVertexAttribI4ubvEXT, - glVertexAttribI4ui, - glVertexAttribI4uiEXT, - glVertexAttribI4uiv, - glVertexAttribI4uivEXT, - glVertexAttribI4usv, - glVertexAttribI4usvEXT, - glVertexAttribIFormat, - glVertexAttribIFormatNV, - glVertexAttribIPointer, - glVertexAttribIPointerEXT, - glVertexAttribL1d, - glVertexAttribL1dEXT, - glVertexAttribL1dv, - glVertexAttribL1dvEXT, - glVertexAttribL1i64NV, - glVertexAttribL1i64vNV, - glVertexAttribL1ui64ARB, - glVertexAttribL1ui64NV, - glVertexAttribL1ui64vARB, - glVertexAttribL1ui64vNV, - glVertexAttribL2d, - glVertexAttribL2dEXT, - glVertexAttribL2dv, - glVertexAttribL2dvEXT, - glVertexAttribL2i64NV, - glVertexAttribL2i64vNV, - glVertexAttribL2ui64NV, - glVertexAttribL2ui64vNV, - glVertexAttribL3d, - glVertexAttribL3dEXT, - glVertexAttribL3dv, - glVertexAttribL3dvEXT, - glVertexAttribL3i64NV, - glVertexAttribL3i64vNV, - glVertexAttribL3ui64NV, - glVertexAttribL3ui64vNV, - glVertexAttribL4d, - glVertexAttribL4dEXT, - glVertexAttribL4dv, - glVertexAttribL4dvEXT, - glVertexAttribL4i64NV, - glVertexAttribL4i64vNV, - glVertexAttribL4ui64NV, - glVertexAttribL4ui64vNV, - glVertexAttribLFormat, - glVertexAttribLFormatNV, - glVertexAttribLPointer, - glVertexAttribLPointerEXT, - glVertexAttribP1ui, - glVertexAttribP1uiv, - glVertexAttribP2ui, - glVertexAttribP2uiv, - glVertexAttribP3ui, - glVertexAttribP3uiv, - glVertexAttribP4ui, - glVertexAttribP4uiv, - glVertexAttribParameteriAMD, - glVertexAttribPointer, - glVertexAttribPointerARB, - glVertexAttribPointerNV, - glVertexAttribs1dvNV, - glVertexAttribs1fvNV, - glVertexAttribs1hvNV, - glVertexAttribs1svNV, - glVertexAttribs2dvNV, - glVertexAttribs2fvNV, - glVertexAttribs2hvNV, - glVertexAttribs2svNV, - glVertexAttribs3dvNV, - glVertexAttribs3fvNV, - glVertexAttribs3hvNV, - glVertexAttribs3svNV, - glVertexAttribs4dvNV, - glVertexAttribs4fvNV, - glVertexAttribs4hvNV, - glVertexAttribs4svNV, - glVertexAttribs4ubvNV, - glVertexBindingDivisor, - glVertexBlendARB, - glVertexBlendEnvfATI, - glVertexBlendEnviATI, - glVertexFormatNV, - glVertexP2ui, - glVertexP2uiv, - glVertexP3ui, - glVertexP3uiv, - glVertexP4ui, - glVertexP4uiv, - glVertexPointerEXT, - glVertexPointerListIBM, - glVertexPointervINTEL, - glVertexStream1dATI, - glVertexStream1dvATI, - glVertexStream1fATI, - glVertexStream1fvATI, - glVertexStream1iATI, - glVertexStream1ivATI, - glVertexStream1sATI, - glVertexStream1svATI, - glVertexStream2dATI, - glVertexStream2dvATI, - glVertexStream2fATI, - glVertexStream2fvATI, - glVertexStream2iATI, - glVertexStream2ivATI, - glVertexStream2sATI, - glVertexStream2svATI, - glVertexStream3dATI, - glVertexStream3dvATI, - glVertexStream3fATI, - glVertexStream3fvATI, - glVertexStream3iATI, - glVertexStream3ivATI, - glVertexStream3sATI, - glVertexStream3svATI, - glVertexStream4dATI, - glVertexStream4dvATI, - glVertexStream4fATI, - glVertexStream4fvATI, - glVertexStream4iATI, - glVertexStream4ivATI, - glVertexStream4sATI, - glVertexStream4svATI, - glVertexWeightPointerEXT, - glVertexWeightfEXT, - glVertexWeightfvEXT, - glVertexWeighthNV, - glVertexWeighthvNV, - glVideoCaptureNV, - glVideoCaptureStreamParameterdvNV, - glVideoCaptureStreamParameterfvNV, - glVideoCaptureStreamParameterivNV, - glViewportArrayv, - glViewportIndexedf, - glViewportIndexedfv, - glViewportPositionWScaleNV, - glViewportSwizzleNV, - glWaitSemaphoreEXT, - glWaitSemaphoreui64NVX, - glWaitSync, - glWaitVkSemaphoreNV, - glWeightPathsNV, - glWeightPointerARB, - glWeightbvARB, - glWeightdvARB, - glWeightfvARB, - glWeightivARB, - glWeightsvARB, - glWeightubvARB, - glWeightuivARB, - glWeightusvARB, - glWindowPos2d, - glWindowPos2dARB, - glWindowPos2dMESA, - glWindowPos2dv, - glWindowPos2dvARB, - glWindowPos2dvMESA, - glWindowPos2f, - glWindowPos2fARB, - glWindowPos2fMESA, - glWindowPos2fv, - glWindowPos2fvARB, - glWindowPos2fvMESA, - glWindowPos2i, - glWindowPos2iARB, - glWindowPos2iMESA, - glWindowPos2iv, - glWindowPos2ivARB, - glWindowPos2ivMESA, - glWindowPos2s, - glWindowPos2sARB, - glWindowPos2sMESA, - glWindowPos2sv, - glWindowPos2svARB, - glWindowPos2svMESA, - glWindowPos3d, - glWindowPos3dARB, - glWindowPos3dMESA, - glWindowPos3dv, - glWindowPos3dvARB, - glWindowPos3dvMESA, - glWindowPos3f, - glWindowPos3fARB, - glWindowPos3fMESA, - glWindowPos3fv, - glWindowPos3fvARB, - glWindowPos3fvMESA, - glWindowPos3i, - glWindowPos3iARB, - glWindowPos3iMESA, - glWindowPos3iv, - glWindowPos3ivARB, - glWindowPos3ivMESA, - glWindowPos3s, - glWindowPos3sARB, - glWindowPos3sMESA, - glWindowPos3sv, - glWindowPos3svARB, - glWindowPos3svMESA, - glWindowPos4dMESA, - glWindowPos4dvMESA, - glWindowPos4fMESA, - glWindowPos4fvMESA, - glWindowPos4iMESA, - glWindowPos4ivMESA, - glWindowPos4sMESA, - glWindowPos4svMESA, - glWindowRectanglesEXT, - glWriteMaskEXT, - wglAllocateMemoryNV, - wglBindTexImageARB, - wglChoosePixelFormatARB, - wglCreateContextAttribsARB, - wglCreatePbufferARB, - wglDestroyPbufferARB, - wglFreeMemoryNV, - wglGetCurrentReadDCARB, - wglGetExtensionsStringARB, - wglGetExtensionsStringEXT, - wglGetPbufferDCARB, - wglGetPixelFormatAttribfvARB, - wglGetPixelFormatAttribivARB, - wglGetSwapIntervalEXT, - wglMakeContextCurrentARB, - wglQueryCurrentRendererIntegerWINE, - wglQueryCurrentRendererStringWINE, - wglQueryPbufferARB, - wglQueryRendererIntegerWINE, - wglQueryRendererStringWINE, - wglReleasePbufferDCARB, - wglReleaseTexImageARB, - wglSetPbufferAttribARB, - wglSetPixelFormatWINE, - wglSwapIntervalEXT, +struct function_entry +{ + const char *name; + void *function; + BOOL supported; +}; + +static int function_entry_cmp( const void *a, const void *b ) +{ + const struct function_entry *entry_a = a, *entry_b = b; + return strcmp( entry_a->name, entry_b->name ); }; + +void *get_proc_address( const char *name, const struct opengl_client_context *ctx ) +{ + const int major = ctx->major_version, minor = ctx->minor_version; + const struct opengl_extensions *extensions = &ctx->extensions; + const struct function_entry *found, entry = { .name = name }, functions[] = + { + { "glAccumxOES", glAccumxOES, extensions->has_GL_OES_fixed_point }, + { "glAcquireKeyedMutexWin32EXT", glAcquireKeyedMutexWin32EXT, extensions->has_GL_EXT_win32_keyed_mutex }, + { "glActiveProgramEXT", glActiveProgramEXT, extensions->has_GL_EXT_separate_shader_objects }, + { "glActiveShaderProgram", glActiveShaderProgram, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glActiveStencilFaceEXT", glActiveStencilFaceEXT, extensions->has_GL_EXT_stencil_two_side }, + { "glActiveTexture", glActiveTexture, (major > 1 || (major == 1 && minor >= 3)) }, + { "glActiveTextureARB", glActiveTextureARB, extensions->has_GL_ARB_multitexture }, + { "glActiveVaryingNV", glActiveVaryingNV, extensions->has_GL_NV_transform_feedback }, + { "glAlphaFragmentOp1ATI", glAlphaFragmentOp1ATI, extensions->has_GL_ATI_fragment_shader }, + { "glAlphaFragmentOp2ATI", glAlphaFragmentOp2ATI, extensions->has_GL_ATI_fragment_shader }, + { "glAlphaFragmentOp3ATI", glAlphaFragmentOp3ATI, extensions->has_GL_ATI_fragment_shader }, + { "glAlphaFuncx", glAlphaFuncx, extensions->has_GL_NV_ES1_1_compatibility }, + { "glAlphaFuncxOES", glAlphaFuncxOES, extensions->has_GL_OES_fixed_point }, + { "glAlphaToCoverageDitherControlNV", glAlphaToCoverageDitherControlNV, extensions->has_GL_NV_alpha_to_coverage_dither_control }, + { "glApplyFramebufferAttachmentCMAAINTEL", glApplyFramebufferAttachmentCMAAINTEL, extensions->has_GL_INTEL_framebuffer_CMAA }, + { "glApplyTextureEXT", glApplyTextureEXT, extensions->has_GL_EXT_light_texture }, + { "glAreProgramsResidentNV", glAreProgramsResidentNV, extensions->has_GL_NV_vertex_program }, + { "glAreTexturesResidentEXT", glAreTexturesResidentEXT, extensions->has_GL_EXT_texture_object }, + { "glArrayElementEXT", glArrayElementEXT, extensions->has_GL_EXT_vertex_array }, + { "glArrayObjectATI", glArrayObjectATI, extensions->has_GL_ATI_vertex_array_object }, + { "glAsyncCopyBufferSubDataNVX", glAsyncCopyBufferSubDataNVX, extensions->has_GL_NVX_gpu_multicast2 }, + { "glAsyncCopyImageSubDataNVX", glAsyncCopyImageSubDataNVX, extensions->has_GL_NVX_gpu_multicast2 }, + { "glAsyncMarkerSGIX", glAsyncMarkerSGIX, extensions->has_GL_SGIX_async }, + { "glAttachObjectARB", glAttachObjectARB, extensions->has_GL_ARB_shader_objects }, + { "glAttachShader", glAttachShader, (major > 2 || (major == 2 && minor >= 0)) }, + { "glBeginConditionalRender", glBeginConditionalRender, (major > 3 || (major == 3 && minor >= 0)) }, + { "glBeginConditionalRenderNV", glBeginConditionalRenderNV, extensions->has_GL_NV_conditional_render }, + { "glBeginConditionalRenderNVX", glBeginConditionalRenderNVX, extensions->has_GL_NVX_conditional_render }, + { "glBeginFragmentShaderATI", glBeginFragmentShaderATI, extensions->has_GL_ATI_fragment_shader }, + { "glBeginOcclusionQueryNV", glBeginOcclusionQueryNV, extensions->has_GL_NV_occlusion_query }, + { "glBeginPerfMonitorAMD", glBeginPerfMonitorAMD, extensions->has_GL_AMD_performance_monitor }, + { "glBeginPerfQueryINTEL", glBeginPerfQueryINTEL, extensions->has_GL_INTEL_performance_query }, + { "glBeginQuery", glBeginQuery, (major > 1 || (major == 1 && minor >= 5)) }, + { "glBeginQueryARB", glBeginQueryARB, extensions->has_GL_ARB_occlusion_query }, + { "glBeginQueryIndexed", glBeginQueryIndexed, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_transform_feedback3 }, + { "glBeginTransformFeedback", glBeginTransformFeedback, (major > 3 || (major == 3 && minor >= 0)) }, + { "glBeginTransformFeedbackEXT", glBeginTransformFeedbackEXT, extensions->has_GL_EXT_transform_feedback }, + { "glBeginTransformFeedbackNV", glBeginTransformFeedbackNV, extensions->has_GL_NV_transform_feedback }, + { "glBeginVertexShaderEXT", glBeginVertexShaderEXT, extensions->has_GL_EXT_vertex_shader }, + { "glBeginVideoCaptureNV", glBeginVideoCaptureNV, extensions->has_GL_NV_video_capture }, + { "glBindAttribLocation", glBindAttribLocation, (major > 2 || (major == 2 && minor >= 0)) }, + { "glBindAttribLocationARB", glBindAttribLocationARB, extensions->has_GL_ARB_vertex_shader }, + { "glBindBuffer", glBindBuffer, (major > 1 || (major == 1 && minor >= 5)) }, + { "glBindBufferARB", glBindBufferARB, extensions->has_GL_ARB_vertex_buffer_object }, + { "glBindBufferBase", glBindBufferBase, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_uniform_buffer_object }, + { "glBindBufferBaseEXT", glBindBufferBaseEXT, extensions->has_GL_EXT_transform_feedback }, + { "glBindBufferBaseNV", glBindBufferBaseNV, extensions->has_GL_NV_transform_feedback }, + { "glBindBufferOffsetEXT", glBindBufferOffsetEXT, extensions->has_GL_EXT_transform_feedback }, + { "glBindBufferOffsetNV", glBindBufferOffsetNV, extensions->has_GL_NV_transform_feedback }, + { "glBindBufferRange", glBindBufferRange, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_uniform_buffer_object }, + { "glBindBufferRangeEXT", glBindBufferRangeEXT, extensions->has_GL_EXT_transform_feedback }, + { "glBindBufferRangeNV", glBindBufferRangeNV, extensions->has_GL_NV_transform_feedback }, + { "glBindBuffersBase", glBindBuffersBase, (major > 4 || (major == 4 && minor >= 4)) || extensions->has_GL_ARB_multi_bind }, + { "glBindBuffersRange", glBindBuffersRange, (major > 4 || (major == 4 && minor >= 4)) || extensions->has_GL_ARB_multi_bind }, + { "glBindFragDataLocation", glBindFragDataLocation, (major > 3 || (major == 3 && minor >= 0)) }, + { "glBindFragDataLocationEXT", glBindFragDataLocationEXT, extensions->has_GL_EXT_gpu_shader4 }, + { "glBindFragDataLocationIndexed", glBindFragDataLocationIndexed, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_blend_func_extended }, + { "glBindFragmentShaderATI", glBindFragmentShaderATI, extensions->has_GL_ATI_fragment_shader }, + { "glBindFramebuffer", glBindFramebuffer, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_framebuffer_object }, + { "glBindFramebufferEXT", glBindFramebufferEXT, extensions->has_GL_EXT_framebuffer_object }, + { "glBindImageTexture", glBindImageTexture, (major > 4 || (major == 4 && minor >= 2)) || extensions->has_GL_ARB_shader_image_load_store }, + { "glBindImageTextureEXT", glBindImageTextureEXT, extensions->has_GL_EXT_shader_image_load_store }, + { "glBindImageTextures", glBindImageTextures, (major > 4 || (major == 4 && minor >= 4)) || extensions->has_GL_ARB_multi_bind }, + { "glBindLightParameterEXT", glBindLightParameterEXT, extensions->has_GL_EXT_vertex_shader }, + { "glBindMaterialParameterEXT", glBindMaterialParameterEXT, extensions->has_GL_EXT_vertex_shader }, + { "glBindMultiTextureEXT", glBindMultiTextureEXT, extensions->has_GL_EXT_direct_state_access }, + { "glBindParameterEXT", glBindParameterEXT, extensions->has_GL_EXT_vertex_shader }, + { "glBindProgramARB", glBindProgramARB, extensions->has_GL_ARB_fragment_program || extensions->has_GL_ARB_vertex_program }, + { "glBindProgramNV", glBindProgramNV, extensions->has_GL_NV_vertex_program }, + { "glBindProgramPipeline", glBindProgramPipeline, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glBindRenderbuffer", glBindRenderbuffer, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_framebuffer_object }, + { "glBindRenderbufferEXT", glBindRenderbufferEXT, extensions->has_GL_EXT_framebuffer_object }, + { "glBindSampler", glBindSampler, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_sampler_objects }, + { "glBindSamplers", glBindSamplers, (major > 4 || (major == 4 && minor >= 4)) || extensions->has_GL_ARB_multi_bind }, + { "glBindShadingRateImageNV", glBindShadingRateImageNV, extensions->has_GL_NV_shading_rate_image }, + { "glBindTexGenParameterEXT", glBindTexGenParameterEXT, extensions->has_GL_EXT_vertex_shader }, + { "glBindTextureEXT", glBindTextureEXT, extensions->has_GL_EXT_texture_object }, + { "glBindTextureUnit", glBindTextureUnit, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glBindTextureUnitParameterEXT", glBindTextureUnitParameterEXT, extensions->has_GL_EXT_vertex_shader }, + { "glBindTextures", glBindTextures, (major > 4 || (major == 4 && minor >= 4)) || extensions->has_GL_ARB_multi_bind }, + { "glBindTransformFeedback", glBindTransformFeedback, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_transform_feedback2 }, + { "glBindTransformFeedbackNV", glBindTransformFeedbackNV, extensions->has_GL_NV_transform_feedback2 }, + { "glBindVertexArray", glBindVertexArray, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_vertex_array_object }, + { "glBindVertexArrayAPPLE", glBindVertexArrayAPPLE, extensions->has_GL_APPLE_vertex_array_object }, + { "glBindVertexBuffer", glBindVertexBuffer, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_vertex_attrib_binding }, + { "glBindVertexBuffers", glBindVertexBuffers, (major > 4 || (major == 4 && minor >= 4)) || extensions->has_GL_ARB_multi_bind }, + { "glBindVertexShaderEXT", glBindVertexShaderEXT, extensions->has_GL_EXT_vertex_shader }, + { "glBindVideoCaptureStreamBufferNV", glBindVideoCaptureStreamBufferNV, extensions->has_GL_NV_video_capture }, + { "glBindVideoCaptureStreamTextureNV", glBindVideoCaptureStreamTextureNV, extensions->has_GL_NV_video_capture }, + { "glBinormal3bEXT", glBinormal3bEXT, extensions->has_GL_EXT_coordinate_frame }, + { "glBinormal3bvEXT", glBinormal3bvEXT, extensions->has_GL_EXT_coordinate_frame }, + { "glBinormal3dEXT", glBinormal3dEXT, extensions->has_GL_EXT_coordinate_frame }, + { "glBinormal3dvEXT", glBinormal3dvEXT, extensions->has_GL_EXT_coordinate_frame }, + { "glBinormal3fEXT", glBinormal3fEXT, extensions->has_GL_EXT_coordinate_frame }, + { "glBinormal3fvEXT", glBinormal3fvEXT, extensions->has_GL_EXT_coordinate_frame }, + { "glBinormal3iEXT", glBinormal3iEXT, extensions->has_GL_EXT_coordinate_frame }, + { "glBinormal3ivEXT", glBinormal3ivEXT, extensions->has_GL_EXT_coordinate_frame }, + { "glBinormal3sEXT", glBinormal3sEXT, extensions->has_GL_EXT_coordinate_frame }, + { "glBinormal3svEXT", glBinormal3svEXT, extensions->has_GL_EXT_coordinate_frame }, + { "glBinormalPointerEXT", glBinormalPointerEXT, extensions->has_GL_EXT_coordinate_frame }, + { "glBitmapxOES", glBitmapxOES, extensions->has_GL_OES_fixed_point }, + { "glBlendBarrier", glBlendBarrier, extensions->has_GL_ARB_ES3_2_compatibility }, + { "glBlendBarrierKHR", glBlendBarrierKHR, extensions->has_GL_KHR_blend_equation_advanced }, + { "glBlendBarrierNV", glBlendBarrierNV, extensions->has_GL_NV_blend_equation_advanced }, + { "glBlendColor", glBlendColor, (major > 1 || (major == 1 && minor >= 4)) || extensions->has_GL_ARB_imaging }, + { "glBlendColorEXT", glBlendColorEXT, extensions->has_GL_EXT_blend_color }, + { "glBlendColorxOES", glBlendColorxOES, extensions->has_GL_OES_fixed_point }, + { "glBlendEquation", glBlendEquation, (major > 1 || (major == 1 && minor >= 4)) || extensions->has_GL_ARB_imaging }, + { "glBlendEquationEXT", glBlendEquationEXT, extensions->has_GL_EXT_blend_minmax }, + { "glBlendEquationIndexedAMD", glBlendEquationIndexedAMD, extensions->has_GL_AMD_draw_buffers_blend }, + { "glBlendEquationSeparate", glBlendEquationSeparate, (major > 2 || (major == 2 && minor >= 0)) }, + { "glBlendEquationSeparateEXT", glBlendEquationSeparateEXT, extensions->has_GL_ATI_blend_equation_separate || extensions->has_GL_EXT_blend_equation_separate }, + { "glBlendEquationSeparateIndexedAMD", glBlendEquationSeparateIndexedAMD, extensions->has_GL_AMD_draw_buffers_blend }, + { "glBlendEquationSeparatei", glBlendEquationSeparatei, (major > 4 || (major == 4 && minor >= 0)) }, + { "glBlendEquationSeparateiARB", glBlendEquationSeparateiARB, extensions->has_GL_ARB_draw_buffers_blend }, + { "glBlendEquationi", glBlendEquationi, (major > 4 || (major == 4 && minor >= 0)) }, + { "glBlendEquationiARB", glBlendEquationiARB, extensions->has_GL_ARB_draw_buffers_blend }, + { "glBlendFuncIndexedAMD", glBlendFuncIndexedAMD, extensions->has_GL_AMD_draw_buffers_blend }, + { "glBlendFuncSeparate", glBlendFuncSeparate, (major > 1 || (major == 1 && minor >= 4)) }, + { "glBlendFuncSeparateEXT", glBlendFuncSeparateEXT, extensions->has_GL_EXT_blend_func_separate }, + { "glBlendFuncSeparateINGR", glBlendFuncSeparateINGR, extensions->has_GL_INGR_blend_func_separate }, + { "glBlendFuncSeparateIndexedAMD", glBlendFuncSeparateIndexedAMD, extensions->has_GL_AMD_draw_buffers_blend }, + { "glBlendFuncSeparatei", glBlendFuncSeparatei, (major > 4 || (major == 4 && minor >= 0)) }, + { "glBlendFuncSeparateiARB", glBlendFuncSeparateiARB, extensions->has_GL_ARB_draw_buffers_blend }, + { "glBlendFunci", glBlendFunci, (major > 4 || (major == 4 && minor >= 0)) }, + { "glBlendFunciARB", glBlendFunciARB, extensions->has_GL_ARB_draw_buffers_blend }, + { "glBlendParameteriNV", glBlendParameteriNV, extensions->has_GL_NV_blend_equation_advanced }, + { "glBlitFramebuffer", glBlitFramebuffer, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_framebuffer_object }, + { "glBlitFramebufferEXT", glBlitFramebufferEXT, extensions->has_GL_EXT_framebuffer_blit }, + { "glBlitFramebufferLayerEXT", glBlitFramebufferLayerEXT, extensions->has_GL_EXT_framebuffer_blit_layers }, + { "glBlitFramebufferLayersEXT", glBlitFramebufferLayersEXT, extensions->has_GL_EXT_framebuffer_blit_layers }, + { "glBlitNamedFramebuffer", glBlitNamedFramebuffer, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glBufferAddressRangeNV", glBufferAddressRangeNV, extensions->has_GL_NV_vertex_buffer_unified_memory }, + { "glBufferAttachMemoryNV", glBufferAttachMemoryNV, extensions->has_GL_NV_memory_attachment }, + { "glBufferData", glBufferData, (major > 1 || (major == 1 && minor >= 5)) }, + { "glBufferDataARB", glBufferDataARB, extensions->has_GL_ARB_vertex_buffer_object }, + { "glBufferPageCommitmentARB", glBufferPageCommitmentARB, extensions->has_GL_ARB_sparse_buffer }, + { "glBufferPageCommitmentMemNV", glBufferPageCommitmentMemNV, extensions->has_GL_NV_memory_object_sparse }, + { "glBufferParameteriAPPLE", glBufferParameteriAPPLE, extensions->has_GL_APPLE_flush_buffer_range }, + { "glBufferRegionEnabled", glBufferRegionEnabled, extensions->has_GL_KTX_buffer_region }, + { "glBufferStorage", glBufferStorage, (major > 4 || (major == 4 && minor >= 4)) || extensions->has_GL_ARB_buffer_storage }, + { "glBufferStorageExternalEXT", glBufferStorageExternalEXT, extensions->has_GL_EXT_external_buffer }, + { "glBufferStorageMemEXT", glBufferStorageMemEXT, extensions->has_GL_EXT_memory_object }, + { "glBufferSubData", glBufferSubData, (major > 1 || (major == 1 && minor >= 5)) }, + { "glBufferSubDataARB", glBufferSubDataARB, extensions->has_GL_ARB_vertex_buffer_object }, + { "glCallCommandListNV", glCallCommandListNV, extensions->has_GL_NV_command_list }, + { "glCheckFramebufferStatus", glCheckFramebufferStatus, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_framebuffer_object }, + { "glCheckFramebufferStatusEXT", glCheckFramebufferStatusEXT, extensions->has_GL_EXT_framebuffer_object }, + { "glCheckNamedFramebufferStatus", glCheckNamedFramebufferStatus, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glCheckNamedFramebufferStatusEXT", glCheckNamedFramebufferStatusEXT, extensions->has_GL_EXT_direct_state_access }, + { "glClampColor", glClampColor, (major > 3 || (major == 3 && minor >= 0)) }, + { "glClampColorARB", glClampColorARB, extensions->has_GL_ARB_color_buffer_float }, + { "glClearAccumxOES", glClearAccumxOES, extensions->has_GL_OES_fixed_point }, + { "glClearBufferData", glClearBufferData, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_clear_buffer_object }, + { "glClearBufferSubData", glClearBufferSubData, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_clear_buffer_object }, + { "glClearBufferfi", glClearBufferfi, (major > 3 || (major == 3 && minor >= 0)) }, + { "glClearBufferfv", glClearBufferfv, (major > 3 || (major == 3 && minor >= 0)) }, + { "glClearBufferiv", glClearBufferiv, (major > 3 || (major == 3 && minor >= 0)) }, + { "glClearBufferuiv", glClearBufferuiv, (major > 3 || (major == 3 && minor >= 0)) }, + { "glClearColorIiEXT", glClearColorIiEXT, extensions->has_GL_EXT_texture_integer }, + { "glClearColorIuiEXT", glClearColorIuiEXT, extensions->has_GL_EXT_texture_integer }, + { "glClearColorx", glClearColorx, extensions->has_GL_NV_ES1_1_compatibility }, + { "glClearColorxOES", glClearColorxOES, extensions->has_GL_OES_fixed_point }, + { "glClearDepthdNV", glClearDepthdNV, extensions->has_GL_NV_depth_buffer_float }, + { "glClearDepthf", glClearDepthf, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_ES2_compatibility }, + { "glClearDepthfOES", glClearDepthfOES, extensions->has_GL_OES_single_precision }, + { "glClearDepthx", glClearDepthx, extensions->has_GL_NV_ES1_1_compatibility }, + { "glClearDepthxOES", glClearDepthxOES, extensions->has_GL_OES_fixed_point }, + { "glClearNamedBufferData", glClearNamedBufferData, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glClearNamedBufferDataEXT", glClearNamedBufferDataEXT, extensions->has_GL_EXT_direct_state_access }, + { "glClearNamedBufferSubData", glClearNamedBufferSubData, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glClearNamedBufferSubDataEXT", glClearNamedBufferSubDataEXT, extensions->has_GL_EXT_direct_state_access }, + { "glClearNamedFramebufferfi", glClearNamedFramebufferfi, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glClearNamedFramebufferfv", glClearNamedFramebufferfv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glClearNamedFramebufferiv", glClearNamedFramebufferiv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glClearNamedFramebufferuiv", glClearNamedFramebufferuiv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glClearTexImage", glClearTexImage, (major > 4 || (major == 4 && minor >= 4)) || extensions->has_GL_ARB_clear_texture }, + { "glClearTexSubImage", glClearTexSubImage, (major > 4 || (major == 4 && minor >= 4)) || extensions->has_GL_ARB_clear_texture }, + { "glClientActiveTexture", glClientActiveTexture, (major > 1 || (major == 1 && minor >= 3)) }, + { "glClientActiveTextureARB", glClientActiveTextureARB, extensions->has_GL_ARB_multitexture }, + { "glClientActiveVertexStreamATI", glClientActiveVertexStreamATI, extensions->has_GL_ATI_vertex_streams }, + { "glClientAttribDefaultEXT", glClientAttribDefaultEXT, extensions->has_GL_EXT_direct_state_access }, + { "glClientWaitSemaphoreui64NVX", glClientWaitSemaphoreui64NVX, extensions->has_GL_NVX_progress_fence }, + { "glClientWaitSync", glClientWaitSync, (major > 3 || (major == 3 && minor >= 2)) || extensions->has_GL_ARB_sync }, + { "glClipControl", glClipControl, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_clip_control }, + { "glClipPlanef", glClipPlanef, extensions->has_GL_NV_ES1_1_compatibility }, + { "glClipPlanefOES", glClipPlanefOES, extensions->has_GL_OES_single_precision }, + { "glClipPlanex", glClipPlanex, extensions->has_GL_NV_ES1_1_compatibility }, + { "glClipPlanexOES", glClipPlanexOES, extensions->has_GL_OES_fixed_point }, + { "glColor3fVertex3fSUN", glColor3fVertex3fSUN, extensions->has_GL_SUN_vertex }, + { "glColor3fVertex3fvSUN", glColor3fVertex3fvSUN, extensions->has_GL_SUN_vertex }, + { "glColor3hNV", glColor3hNV, extensions->has_GL_NV_half_float }, + { "glColor3hvNV", glColor3hvNV, extensions->has_GL_NV_half_float }, + { "glColor3xOES", glColor3xOES, extensions->has_GL_OES_fixed_point }, + { "glColor3xvOES", glColor3xvOES, extensions->has_GL_OES_fixed_point }, + { "glColor4fNormal3fVertex3fSUN", glColor4fNormal3fVertex3fSUN, extensions->has_GL_SUN_vertex }, + { "glColor4fNormal3fVertex3fvSUN", glColor4fNormal3fVertex3fvSUN, extensions->has_GL_SUN_vertex }, + { "glColor4hNV", glColor4hNV, extensions->has_GL_NV_half_float }, + { "glColor4hvNV", glColor4hvNV, extensions->has_GL_NV_half_float }, + { "glColor4ubVertex2fSUN", glColor4ubVertex2fSUN, extensions->has_GL_SUN_vertex }, + { "glColor4ubVertex2fvSUN", glColor4ubVertex2fvSUN, extensions->has_GL_SUN_vertex }, + { "glColor4ubVertex3fSUN", glColor4ubVertex3fSUN, extensions->has_GL_SUN_vertex }, + { "glColor4ubVertex3fvSUN", glColor4ubVertex3fvSUN, extensions->has_GL_SUN_vertex }, + { "glColor4x", glColor4x, extensions->has_GL_NV_ES1_1_compatibility }, + { "glColor4xOES", glColor4xOES, extensions->has_GL_OES_fixed_point }, + { "glColor4xvOES", glColor4xvOES, extensions->has_GL_OES_fixed_point }, + { "glColorFormatNV", glColorFormatNV, extensions->has_GL_NV_vertex_buffer_unified_memory }, + { "glColorFragmentOp1ATI", glColorFragmentOp1ATI, extensions->has_GL_ATI_fragment_shader }, + { "glColorFragmentOp2ATI", glColorFragmentOp2ATI, extensions->has_GL_ATI_fragment_shader }, + { "glColorFragmentOp3ATI", glColorFragmentOp3ATI, extensions->has_GL_ATI_fragment_shader }, + { "glColorMaskIndexedEXT", glColorMaskIndexedEXT, extensions->has_GL_EXT_draw_buffers2 }, + { "glColorMaski", glColorMaski, (major > 3 || (major == 3 && minor >= 0)) }, + { "glColorP3ui", glColorP3ui, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glColorP3uiv", glColorP3uiv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glColorP4ui", glColorP4ui, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glColorP4uiv", glColorP4uiv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glColorPointerEXT", glColorPointerEXT, extensions->has_GL_EXT_vertex_array }, + { "glColorPointerListIBM", glColorPointerListIBM, extensions->has_GL_IBM_vertex_array_lists }, + { "glColorPointervINTEL", glColorPointervINTEL, extensions->has_GL_INTEL_parallel_arrays }, + { "glColorSubTable", glColorSubTable, extensions->has_GL_ARB_imaging }, + { "glColorSubTableEXT", glColorSubTableEXT, extensions->has_GL_EXT_color_subtable }, + { "glColorTable", glColorTable, extensions->has_GL_ARB_imaging }, + { "glColorTableEXT", glColorTableEXT, extensions->has_GL_EXT_paletted_texture }, + { "glColorTableParameterfv", glColorTableParameterfv, extensions->has_GL_ARB_imaging }, + { "glColorTableParameterfvSGI", glColorTableParameterfvSGI, extensions->has_GL_SGI_color_table }, + { "glColorTableParameteriv", glColorTableParameteriv, extensions->has_GL_ARB_imaging }, + { "glColorTableParameterivSGI", glColorTableParameterivSGI, extensions->has_GL_SGI_color_table }, + { "glColorTableSGI", glColorTableSGI, extensions->has_GL_SGI_color_table }, + { "glCombinerInputNV", glCombinerInputNV, extensions->has_GL_NV_register_combiners }, + { "glCombinerOutputNV", glCombinerOutputNV, extensions->has_GL_NV_register_combiners }, + { "glCombinerParameterfNV", glCombinerParameterfNV, extensions->has_GL_NV_register_combiners }, + { "glCombinerParameterfvNV", glCombinerParameterfvNV, extensions->has_GL_NV_register_combiners }, + { "glCombinerParameteriNV", glCombinerParameteriNV, extensions->has_GL_NV_register_combiners }, + { "glCombinerParameterivNV", glCombinerParameterivNV, extensions->has_GL_NV_register_combiners }, + { "glCombinerStageParameterfvNV", glCombinerStageParameterfvNV, extensions->has_GL_NV_register_combiners2 }, + { "glCommandListSegmentsNV", glCommandListSegmentsNV, extensions->has_GL_NV_command_list }, + { "glCompileCommandListNV", glCompileCommandListNV, extensions->has_GL_NV_command_list }, + { "glCompileShader", glCompileShader, (major > 2 || (major == 2 && minor >= 0)) }, + { "glCompileShaderARB", glCompileShaderARB, extensions->has_GL_ARB_shader_objects }, + { "glCompileShaderIncludeARB", glCompileShaderIncludeARB, extensions->has_GL_ARB_shading_language_include }, + { "glCompressedMultiTexImage1DEXT", glCompressedMultiTexImage1DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glCompressedMultiTexImage2DEXT", glCompressedMultiTexImage2DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glCompressedMultiTexImage3DEXT", glCompressedMultiTexImage3DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glCompressedMultiTexSubImage1DEXT", glCompressedMultiTexSubImage1DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glCompressedMultiTexSubImage2DEXT", glCompressedMultiTexSubImage2DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glCompressedMultiTexSubImage3DEXT", glCompressedMultiTexSubImage3DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glCompressedTexImage1D", glCompressedTexImage1D, (major > 1 || (major == 1 && minor >= 3)) }, + { "glCompressedTexImage1DARB", glCompressedTexImage1DARB, (major > 1 || (major == 1 && minor >= 3)) || extensions->has_GL_ARB_texture_compression }, + { "glCompressedTexImage2D", glCompressedTexImage2D, (major > 1 || (major == 1 && minor >= 3)) }, + { "glCompressedTexImage2DARB", glCompressedTexImage2DARB, (major > 1 || (major == 1 && minor >= 3)) || extensions->has_GL_ARB_texture_compression }, + { "glCompressedTexImage3D", glCompressedTexImage3D, (major > 1 || (major == 1 && minor >= 3)) }, + { "glCompressedTexImage3DARB", glCompressedTexImage3DARB, (major > 1 || (major == 1 && minor >= 3)) || extensions->has_GL_ARB_texture_compression }, + { "glCompressedTexSubImage1D", glCompressedTexSubImage1D, (major > 1 || (major == 1 && minor >= 3)) }, + { "glCompressedTexSubImage1DARB", glCompressedTexSubImage1DARB, (major > 1 || (major == 1 && minor >= 3)) || extensions->has_GL_ARB_texture_compression }, + { "glCompressedTexSubImage2D", glCompressedTexSubImage2D, (major > 1 || (major == 1 && minor >= 3)) }, + { "glCompressedTexSubImage2DARB", glCompressedTexSubImage2DARB, (major > 1 || (major == 1 && minor >= 3)) || extensions->has_GL_ARB_texture_compression }, + { "glCompressedTexSubImage3D", glCompressedTexSubImage3D, (major > 1 || (major == 1 && minor >= 3)) }, + { "glCompressedTexSubImage3DARB", glCompressedTexSubImage3DARB, (major > 1 || (major == 1 && minor >= 3)) || extensions->has_GL_ARB_texture_compression }, + { "glCompressedTextureImage1DEXT", glCompressedTextureImage1DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glCompressedTextureImage2DEXT", glCompressedTextureImage2DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glCompressedTextureImage3DEXT", glCompressedTextureImage3DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glCompressedTextureSubImage1D", glCompressedTextureSubImage1D, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glCompressedTextureSubImage1DEXT", glCompressedTextureSubImage1DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glCompressedTextureSubImage2D", glCompressedTextureSubImage2D, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glCompressedTextureSubImage2DEXT", glCompressedTextureSubImage2DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glCompressedTextureSubImage3D", glCompressedTextureSubImage3D, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glCompressedTextureSubImage3DEXT", glCompressedTextureSubImage3DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glConservativeRasterParameterfNV", glConservativeRasterParameterfNV, extensions->has_GL_NV_conservative_raster_dilate }, + { "glConservativeRasterParameteriNV", glConservativeRasterParameteriNV, extensions->has_GL_NV_conservative_raster_pre_snap_triangles }, + { "glConvolutionFilter1D", glConvolutionFilter1D, extensions->has_GL_ARB_imaging }, + { "glConvolutionFilter1DEXT", glConvolutionFilter1DEXT, extensions->has_GL_EXT_convolution }, + { "glConvolutionFilter2D", glConvolutionFilter2D, extensions->has_GL_ARB_imaging }, + { "glConvolutionFilter2DEXT", glConvolutionFilter2DEXT, extensions->has_GL_EXT_convolution }, + { "glConvolutionParameterf", glConvolutionParameterf, extensions->has_GL_ARB_imaging }, + { "glConvolutionParameterfEXT", glConvolutionParameterfEXT, extensions->has_GL_EXT_convolution }, + { "glConvolutionParameterfv", glConvolutionParameterfv, extensions->has_GL_ARB_imaging }, + { "glConvolutionParameterfvEXT", glConvolutionParameterfvEXT, extensions->has_GL_EXT_convolution }, + { "glConvolutionParameteri", glConvolutionParameteri, extensions->has_GL_ARB_imaging }, + { "glConvolutionParameteriEXT", glConvolutionParameteriEXT, extensions->has_GL_EXT_convolution }, + { "glConvolutionParameteriv", glConvolutionParameteriv, extensions->has_GL_ARB_imaging }, + { "glConvolutionParameterivEXT", glConvolutionParameterivEXT, extensions->has_GL_EXT_convolution }, + { "glConvolutionParameterxOES", glConvolutionParameterxOES, extensions->has_GL_OES_fixed_point }, + { "glConvolutionParameterxvOES", glConvolutionParameterxvOES, extensions->has_GL_OES_fixed_point }, + { "glCopyBufferSubData", glCopyBufferSubData, (major > 3 || (major == 3 && minor >= 1)) || extensions->has_GL_ARB_copy_buffer || extensions->has_GL_EXT_copy_buffer }, + { "glCopyColorSubTable", glCopyColorSubTable, extensions->has_GL_ARB_imaging }, + { "glCopyColorSubTableEXT", glCopyColorSubTableEXT, extensions->has_GL_EXT_color_subtable }, + { "glCopyColorTable", glCopyColorTable, extensions->has_GL_ARB_imaging }, + { "glCopyColorTableSGI", glCopyColorTableSGI, extensions->has_GL_SGI_color_table }, + { "glCopyConvolutionFilter1D", glCopyConvolutionFilter1D, extensions->has_GL_ARB_imaging }, + { "glCopyConvolutionFilter1DEXT", glCopyConvolutionFilter1DEXT, extensions->has_GL_EXT_convolution }, + { "glCopyConvolutionFilter2D", glCopyConvolutionFilter2D, extensions->has_GL_ARB_imaging }, + { "glCopyConvolutionFilter2DEXT", glCopyConvolutionFilter2DEXT, extensions->has_GL_EXT_convolution }, + { "glCopyImageSubData", glCopyImageSubData, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_copy_image }, + { "glCopyImageSubDataNV", glCopyImageSubDataNV, extensions->has_GL_NV_copy_image }, + { "glCopyMultiTexImage1DEXT", glCopyMultiTexImage1DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glCopyMultiTexImage2DEXT", glCopyMultiTexImage2DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glCopyMultiTexSubImage1DEXT", glCopyMultiTexSubImage1DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glCopyMultiTexSubImage2DEXT", glCopyMultiTexSubImage2DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glCopyMultiTexSubImage3DEXT", glCopyMultiTexSubImage3DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glCopyNamedBufferSubData", glCopyNamedBufferSubData, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glCopyPathNV", glCopyPathNV, extensions->has_GL_NV_path_rendering }, + { "glCopyTexImage1DEXT", glCopyTexImage1DEXT, (major > 1 || (major == 1 && minor >= 2)) || extensions->has_GL_EXT_copy_texture }, + { "glCopyTexImage2DEXT", glCopyTexImage2DEXT, (major > 1 || (major == 1 && minor >= 2)) || extensions->has_GL_EXT_copy_texture }, + { "glCopyTexSubImage1DEXT", glCopyTexSubImage1DEXT, (major > 1 || (major == 1 && minor >= 2)) || extensions->has_GL_EXT_copy_texture }, + { "glCopyTexSubImage2DEXT", glCopyTexSubImage2DEXT, (major > 1 || (major == 1 && minor >= 2)) || extensions->has_GL_EXT_copy_texture }, + { "glCopyTexSubImage3D", glCopyTexSubImage3D, (major > 1 || (major == 1 && minor >= 2)) }, + { "glCopyTexSubImage3DEXT", glCopyTexSubImage3DEXT, (major > 1 || (major == 1 && minor >= 2)) || extensions->has_GL_EXT_copy_texture }, + { "glCopyTextureImage1DEXT", glCopyTextureImage1DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glCopyTextureImage2DEXT", glCopyTextureImage2DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glCopyTextureSubImage1D", glCopyTextureSubImage1D, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glCopyTextureSubImage1DEXT", glCopyTextureSubImage1DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glCopyTextureSubImage2D", glCopyTextureSubImage2D, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glCopyTextureSubImage2DEXT", glCopyTextureSubImage2DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glCopyTextureSubImage3D", glCopyTextureSubImage3D, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glCopyTextureSubImage3DEXT", glCopyTextureSubImage3DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glCoverFillPathInstancedNV", glCoverFillPathInstancedNV, extensions->has_GL_NV_path_rendering }, + { "glCoverFillPathNV", glCoverFillPathNV, extensions->has_GL_NV_path_rendering }, + { "glCoverStrokePathInstancedNV", glCoverStrokePathInstancedNV, extensions->has_GL_NV_path_rendering }, + { "glCoverStrokePathNV", glCoverStrokePathNV, extensions->has_GL_NV_path_rendering }, + { "glCoverageModulationNV", glCoverageModulationNV, extensions->has_GL_NV_framebuffer_mixed_samples }, + { "glCoverageModulationTableNV", glCoverageModulationTableNV, extensions->has_GL_NV_framebuffer_mixed_samples }, + { "glCreateBuffers", glCreateBuffers, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glCreateCommandListsNV", glCreateCommandListsNV, extensions->has_GL_NV_command_list }, + { "glCreateFramebuffers", glCreateFramebuffers, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glCreateMemoryObjectsEXT", glCreateMemoryObjectsEXT, extensions->has_GL_EXT_memory_object }, + { "glCreatePerfQueryINTEL", glCreatePerfQueryINTEL, extensions->has_GL_INTEL_performance_query }, + { "glCreateProgram", glCreateProgram, (major > 2 || (major == 2 && minor >= 0)) }, + { "glCreateProgramObjectARB", glCreateProgramObjectARB, extensions->has_GL_ARB_shader_objects }, + { "glCreateProgramPipelines", glCreateProgramPipelines, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glCreateProgressFenceNVX", glCreateProgressFenceNVX, extensions->has_GL_NVX_progress_fence }, + { "glCreateQueries", glCreateQueries, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glCreateRenderbuffers", glCreateRenderbuffers, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glCreateSamplers", glCreateSamplers, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glCreateSemaphoresNV", glCreateSemaphoresNV, extensions->has_GL_NV_timeline_semaphore }, + { "glCreateShader", glCreateShader, (major > 2 || (major == 2 && minor >= 0)) }, + { "glCreateShaderObjectARB", glCreateShaderObjectARB, extensions->has_GL_ARB_shader_objects }, + { "glCreateShaderProgramEXT", glCreateShaderProgramEXT, extensions->has_GL_EXT_separate_shader_objects }, + { "glCreateShaderProgramv", glCreateShaderProgramv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glCreateStatesNV", glCreateStatesNV, extensions->has_GL_NV_command_list }, + { "glCreateSyncFromCLeventARB", glCreateSyncFromCLeventARB, extensions->has_GL_ARB_cl_event }, + { "glCreateTextures", glCreateTextures, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glCreateTransformFeedbacks", glCreateTransformFeedbacks, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glCreateVertexArrays", glCreateVertexArrays, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glCullParameterdvEXT", glCullParameterdvEXT, extensions->has_GL_EXT_cull_vertex }, + { "glCullParameterfvEXT", glCullParameterfvEXT, extensions->has_GL_EXT_cull_vertex }, + { "glCurrentPaletteMatrixARB", glCurrentPaletteMatrixARB, extensions->has_GL_ARB_matrix_palette }, + { "glDebugMessageCallback", glDebugMessageCallback, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_KHR_debug }, + { "glDebugMessageCallbackAMD", glDebugMessageCallbackAMD, extensions->has_GL_AMDX_debug_output || extensions->has_GL_AMD_debug_output }, + { "glDebugMessageCallbackARB", glDebugMessageCallbackARB, extensions->has_GL_ARB_debug_output }, + { "glDebugMessageControl", glDebugMessageControl, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_KHR_debug }, + { "glDebugMessageControlARB", glDebugMessageControlARB, extensions->has_GL_ARB_debug_output }, + { "glDebugMessageEnableAMD", glDebugMessageEnableAMD, extensions->has_GL_AMDX_debug_output || extensions->has_GL_AMD_debug_output }, + { "glDebugMessageInsert", glDebugMessageInsert, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_KHR_debug }, + { "glDebugMessageInsertAMD", glDebugMessageInsertAMD, extensions->has_GL_AMDX_debug_output || extensions->has_GL_AMD_debug_output }, + { "glDebugMessageInsertARB", glDebugMessageInsertARB, extensions->has_GL_ARB_debug_output }, + { "glDeformSGIX", glDeformSGIX, extensions->has_GL_SGIX_polynomial_ffd }, + { "glDeformationMap3dSGIX", glDeformationMap3dSGIX, extensions->has_GL_SGIX_polynomial_ffd }, + { "glDeformationMap3fSGIX", glDeformationMap3fSGIX, extensions->has_GL_SGIX_polynomial_ffd }, + { "glDeleteAsyncMarkersSGIX", glDeleteAsyncMarkersSGIX, extensions->has_GL_SGIX_async }, + { "glDeleteBufferRegion", glDeleteBufferRegion, extensions->has_GL_KTX_buffer_region }, + { "glDeleteBuffers", glDeleteBuffers, (major > 1 || (major == 1 && minor >= 5)) }, + { "glDeleteBuffersARB", glDeleteBuffersARB, extensions->has_GL_ARB_vertex_buffer_object }, + { "glDeleteCommandListsNV", glDeleteCommandListsNV, extensions->has_GL_NV_command_list }, + { "glDeleteFencesAPPLE", glDeleteFencesAPPLE, extensions->has_GL_APPLE_fence }, + { "glDeleteFencesNV", glDeleteFencesNV, extensions->has_GL_NV_fence }, + { "glDeleteFragmentShaderATI", glDeleteFragmentShaderATI, extensions->has_GL_ATI_fragment_shader }, + { "glDeleteFramebuffers", glDeleteFramebuffers, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_framebuffer_object }, + { "glDeleteFramebuffersEXT", glDeleteFramebuffersEXT, extensions->has_GL_EXT_framebuffer_object }, + { "glDeleteMemoryObjectsEXT", glDeleteMemoryObjectsEXT, extensions->has_GL_EXT_memory_object }, + { "glDeleteNamedStringARB", glDeleteNamedStringARB, extensions->has_GL_ARB_shading_language_include }, + { "glDeleteNamesAMD", glDeleteNamesAMD, extensions->has_GL_AMD_name_gen_delete }, + { "glDeleteObjectARB", glDeleteObjectARB, extensions->has_GL_ARB_shader_objects }, + { "glDeleteObjectBufferATI", glDeleteObjectBufferATI, extensions->has_GL_ATI_vertex_array_object }, + { "glDeleteOcclusionQueriesNV", glDeleteOcclusionQueriesNV, extensions->has_GL_NV_occlusion_query }, + { "glDeletePathsNV", glDeletePathsNV, extensions->has_GL_NV_path_rendering }, + { "glDeletePerfMonitorsAMD", glDeletePerfMonitorsAMD, extensions->has_GL_AMD_performance_monitor }, + { "glDeletePerfQueryINTEL", glDeletePerfQueryINTEL, extensions->has_GL_INTEL_performance_query }, + { "glDeleteProgram", glDeleteProgram, (major > 2 || (major == 2 && minor >= 0)) }, + { "glDeleteProgramPipelines", glDeleteProgramPipelines, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glDeleteProgramsARB", glDeleteProgramsARB, extensions->has_GL_ARB_fragment_program || extensions->has_GL_ARB_vertex_program }, + { "glDeleteProgramsNV", glDeleteProgramsNV, extensions->has_GL_NV_vertex_program }, + { "glDeleteQueries", glDeleteQueries, (major > 1 || (major == 1 && minor >= 5)) }, + { "glDeleteQueriesARB", glDeleteQueriesARB, extensions->has_GL_ARB_occlusion_query }, + { "glDeleteQueryResourceTagNV", glDeleteQueryResourceTagNV, extensions->has_GL_NV_query_resource_tag }, + { "glDeleteRenderbuffers", glDeleteRenderbuffers, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_framebuffer_object }, + { "glDeleteRenderbuffersEXT", glDeleteRenderbuffersEXT, extensions->has_GL_EXT_framebuffer_object }, + { "glDeleteSamplers", glDeleteSamplers, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_sampler_objects }, + { "glDeleteSemaphoresEXT", glDeleteSemaphoresEXT, extensions->has_GL_EXT_semaphore }, + { "glDeleteShader", glDeleteShader, (major > 2 || (major == 2 && minor >= 0)) }, + { "glDeleteStatesNV", glDeleteStatesNV, extensions->has_GL_NV_command_list }, + { "glDeleteSync", glDeleteSync, (major > 3 || (major == 3 && minor >= 2)) || extensions->has_GL_ARB_sync }, + { "glDeleteTexturesEXT", glDeleteTexturesEXT, extensions->has_GL_EXT_texture_object }, + { "glDeleteTransformFeedbacks", glDeleteTransformFeedbacks, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_transform_feedback2 }, + { "glDeleteTransformFeedbacksNV", glDeleteTransformFeedbacksNV, extensions->has_GL_NV_transform_feedback2 }, + { "glDeleteVertexArrays", glDeleteVertexArrays, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_vertex_array_object }, + { "glDeleteVertexArraysAPPLE", glDeleteVertexArraysAPPLE, extensions->has_GL_APPLE_vertex_array_object }, + { "glDeleteVertexShaderEXT", glDeleteVertexShaderEXT, extensions->has_GL_EXT_vertex_shader }, + { "glDepthBoundsEXT", glDepthBoundsEXT, extensions->has_GL_EXT_depth_bounds_test }, + { "glDepthBoundsdNV", glDepthBoundsdNV, extensions->has_GL_NV_depth_buffer_float }, + { "glDepthRangeArraydvNV", glDepthRangeArraydvNV, extensions->has_GL_ARB_viewport_array }, + { "glDepthRangeArrayv", glDepthRangeArrayv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_viewport_array }, + { "glDepthRangeIndexed", glDepthRangeIndexed, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_viewport_array }, + { "glDepthRangeIndexeddNV", glDepthRangeIndexeddNV, extensions->has_GL_ARB_viewport_array }, + { "glDepthRangedNV", glDepthRangedNV, extensions->has_GL_NV_depth_buffer_float }, + { "glDepthRangef", glDepthRangef, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_ES2_compatibility }, + { "glDepthRangefOES", glDepthRangefOES, extensions->has_GL_OES_single_precision }, + { "glDepthRangex", glDepthRangex, extensions->has_GL_NV_ES1_1_compatibility }, + { "glDepthRangexOES", glDepthRangexOES, extensions->has_GL_OES_fixed_point }, + { "glDetachObjectARB", glDetachObjectARB, extensions->has_GL_ARB_shader_objects }, + { "glDetachShader", glDetachShader, (major > 2 || (major == 2 && minor >= 0)) }, + { "glDetailTexFuncSGIS", glDetailTexFuncSGIS, extensions->has_GL_SGIS_detail_texture }, + { "glDisableClientStateIndexedEXT", glDisableClientStateIndexedEXT, extensions->has_GL_EXT_direct_state_access }, + { "glDisableClientStateiEXT", glDisableClientStateiEXT, extensions->has_GL_EXT_direct_state_access }, + { "glDisableIndexedEXT", glDisableIndexedEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_EXT_draw_buffers2 }, + { "glDisableVariantClientStateEXT", glDisableVariantClientStateEXT, extensions->has_GL_EXT_vertex_shader }, + { "glDisableVertexArrayAttrib", glDisableVertexArrayAttrib, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glDisableVertexArrayAttribEXT", glDisableVertexArrayAttribEXT, extensions->has_GL_EXT_direct_state_access }, + { "glDisableVertexArrayEXT", glDisableVertexArrayEXT, extensions->has_GL_EXT_direct_state_access }, + { "glDisableVertexAttribAPPLE", glDisableVertexAttribAPPLE, extensions->has_GL_APPLE_vertex_program_evaluators }, + { "glDisableVertexAttribArray", glDisableVertexAttribArray, (major > 2 || (major == 2 && minor >= 0)) }, + { "glDisableVertexAttribArrayARB", glDisableVertexAttribArrayARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glDisablei", glDisablei, (major > 3 || (major == 3 && minor >= 0)) }, + { "glDispatchCompute", glDispatchCompute, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_compute_shader }, + { "glDispatchComputeGroupSizeARB", glDispatchComputeGroupSizeARB, extensions->has_GL_ARB_compute_variable_group_size }, + { "glDispatchComputeIndirect", glDispatchComputeIndirect, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_compute_shader }, + { "glDrawArraysEXT", glDrawArraysEXT, extensions->has_GL_EXT_vertex_array }, + { "glDrawArraysIndirect", glDrawArraysIndirect, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_draw_indirect }, + { "glDrawArraysInstanced", glDrawArraysInstanced, (major > 3 || (major == 3 && minor >= 1)) }, + { "glDrawArraysInstancedARB", glDrawArraysInstancedARB, extensions->has_GL_ARB_draw_instanced }, + { "glDrawArraysInstancedBaseInstance", glDrawArraysInstancedBaseInstance, (major > 4 || (major == 4 && minor >= 2)) || extensions->has_GL_ARB_base_instance }, + { "glDrawArraysInstancedEXT", glDrawArraysInstancedEXT, extensions->has_GL_EXT_draw_instanced }, + { "glDrawBufferRegion", glDrawBufferRegion, extensions->has_GL_KTX_buffer_region }, + { "glDrawBuffers", glDrawBuffers, (major > 2 || (major == 2 && minor >= 0)) }, + { "glDrawBuffersARB", glDrawBuffersARB, extensions->has_GL_ARB_draw_buffers }, + { "glDrawBuffersATI", glDrawBuffersATI, extensions->has_GL_ATI_draw_buffers }, + { "glDrawCommandsAddressNV", glDrawCommandsAddressNV, extensions->has_GL_NV_command_list }, + { "glDrawCommandsNV", glDrawCommandsNV, extensions->has_GL_NV_command_list }, + { "glDrawCommandsStatesAddressNV", glDrawCommandsStatesAddressNV, extensions->has_GL_NV_command_list }, + { "glDrawCommandsStatesNV", glDrawCommandsStatesNV, extensions->has_GL_NV_command_list }, + { "glDrawElementArrayAPPLE", glDrawElementArrayAPPLE, extensions->has_GL_APPLE_element_array }, + { "glDrawElementArrayATI", glDrawElementArrayATI, extensions->has_GL_ATI_element_array }, + { "glDrawElementsBaseVertex", glDrawElementsBaseVertex, (major > 3 || (major == 3 && minor >= 2)) || extensions->has_GL_ARB_draw_elements_base_vertex }, + { "glDrawElementsIndirect", glDrawElementsIndirect, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_draw_indirect }, + { "glDrawElementsInstanced", glDrawElementsInstanced, (major > 3 || (major == 3 && minor >= 1)) }, + { "glDrawElementsInstancedARB", glDrawElementsInstancedARB, extensions->has_GL_ARB_draw_instanced }, + { "glDrawElementsInstancedBaseInstance", glDrawElementsInstancedBaseInstance, (major > 4 || (major == 4 && minor >= 2)) || extensions->has_GL_ARB_base_instance }, + { "glDrawElementsInstancedBaseVertex", glDrawElementsInstancedBaseVertex, (major > 3 || (major == 3 && minor >= 2)) || extensions->has_GL_ARB_draw_elements_base_vertex }, + { "glDrawElementsInstancedBaseVertexBaseInstance", glDrawElementsInstancedBaseVertexBaseInstance, (major > 4 || (major == 4 && minor >= 2)) || extensions->has_GL_ARB_base_instance }, + { "glDrawElementsInstancedEXT", glDrawElementsInstancedEXT, extensions->has_GL_EXT_draw_instanced }, + { "glDrawMeshArraysSUN", glDrawMeshArraysSUN, extensions->has_GL_SUN_mesh_array }, + { "glDrawMeshTasksEXT", glDrawMeshTasksEXT, extensions->has_GL_EXT_mesh_shader }, + { "glDrawMeshTasksIndirectEXT", glDrawMeshTasksIndirectEXT, extensions->has_GL_EXT_mesh_shader }, + { "glDrawMeshTasksIndirectNV", glDrawMeshTasksIndirectNV, extensions->has_GL_NV_mesh_shader }, + { "glDrawMeshTasksNV", glDrawMeshTasksNV, extensions->has_GL_NV_mesh_shader }, + { "glDrawRangeElementArrayAPPLE", glDrawRangeElementArrayAPPLE, extensions->has_GL_APPLE_element_array }, + { "glDrawRangeElementArrayATI", glDrawRangeElementArrayATI, extensions->has_GL_ATI_element_array }, + { "glDrawRangeElements", glDrawRangeElements, (major > 1 || (major == 1 && minor >= 2)) }, + { "glDrawRangeElementsBaseVertex", glDrawRangeElementsBaseVertex, (major > 3 || (major == 3 && minor >= 2)) || extensions->has_GL_ARB_draw_elements_base_vertex }, + { "glDrawRangeElementsEXT", glDrawRangeElementsEXT, extensions->has_GL_EXT_draw_range_elements }, + { "glDrawTextureNV", glDrawTextureNV, extensions->has_GL_NV_draw_texture }, + { "glDrawTransformFeedback", glDrawTransformFeedback, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_transform_feedback2 }, + { "glDrawTransformFeedbackInstanced", glDrawTransformFeedbackInstanced, (major > 4 || (major == 4 && minor >= 2)) || extensions->has_GL_ARB_transform_feedback_instanced }, + { "glDrawTransformFeedbackNV", glDrawTransformFeedbackNV, extensions->has_GL_NV_transform_feedback2 }, + { "glDrawTransformFeedbackStream", glDrawTransformFeedbackStream, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_transform_feedback3 }, + { "glDrawTransformFeedbackStreamInstanced", glDrawTransformFeedbackStreamInstanced, (major > 4 || (major == 4 && minor >= 2)) || extensions->has_GL_ARB_transform_feedback_instanced }, + { "glDrawVkImageNV", glDrawVkImageNV, extensions->has_GL_NV_draw_vulkan_image }, + { "glEGLImageTargetTexStorageEXT", glEGLImageTargetTexStorageEXT, extensions->has_GL_EXT_EGL_image_storage }, + { "glEGLImageTargetTextureStorageEXT", glEGLImageTargetTextureStorageEXT, extensions->has_GL_EXT_EGL_image_storage }, + { "glEdgeFlagFormatNV", glEdgeFlagFormatNV, extensions->has_GL_NV_vertex_buffer_unified_memory }, + { "glEdgeFlagPointerEXT", glEdgeFlagPointerEXT, extensions->has_GL_EXT_vertex_array }, + { "glEdgeFlagPointerListIBM", glEdgeFlagPointerListIBM, extensions->has_GL_IBM_vertex_array_lists }, + { "glElementPointerAPPLE", glElementPointerAPPLE, extensions->has_GL_APPLE_element_array }, + { "glElementPointerATI", glElementPointerATI, extensions->has_GL_ATI_element_array }, + { "glEnableClientStateIndexedEXT", glEnableClientStateIndexedEXT, extensions->has_GL_EXT_direct_state_access }, + { "glEnableClientStateiEXT", glEnableClientStateiEXT, extensions->has_GL_EXT_direct_state_access }, + { "glEnableIndexedEXT", glEnableIndexedEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_EXT_draw_buffers2 }, + { "glEnableVariantClientStateEXT", glEnableVariantClientStateEXT, extensions->has_GL_EXT_vertex_shader }, + { "glEnableVertexArrayAttrib", glEnableVertexArrayAttrib, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glEnableVertexArrayAttribEXT", glEnableVertexArrayAttribEXT, extensions->has_GL_EXT_direct_state_access }, + { "glEnableVertexArrayEXT", glEnableVertexArrayEXT, extensions->has_GL_EXT_direct_state_access }, + { "glEnableVertexAttribAPPLE", glEnableVertexAttribAPPLE, extensions->has_GL_APPLE_vertex_program_evaluators }, + { "glEnableVertexAttribArray", glEnableVertexAttribArray, (major > 2 || (major == 2 && minor >= 0)) }, + { "glEnableVertexAttribArrayARB", glEnableVertexAttribArrayARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glEnablei", glEnablei, (major > 3 || (major == 3 && minor >= 0)) }, + { "glEndConditionalRender", glEndConditionalRender, (major > 3 || (major == 3 && minor >= 0)) }, + { "glEndConditionalRenderNV", glEndConditionalRenderNV, extensions->has_GL_NV_conditional_render }, + { "glEndConditionalRenderNVX", glEndConditionalRenderNVX, extensions->has_GL_NVX_conditional_render }, + { "glEndFragmentShaderATI", glEndFragmentShaderATI, extensions->has_GL_ATI_fragment_shader }, + { "glEndOcclusionQueryNV", glEndOcclusionQueryNV, extensions->has_GL_NV_occlusion_query }, + { "glEndPerfMonitorAMD", glEndPerfMonitorAMD, extensions->has_GL_AMD_performance_monitor }, + { "glEndPerfQueryINTEL", glEndPerfQueryINTEL, extensions->has_GL_INTEL_performance_query }, + { "glEndQuery", glEndQuery, (major > 1 || (major == 1 && minor >= 5)) }, + { "glEndQueryARB", glEndQueryARB, extensions->has_GL_ARB_occlusion_query }, + { "glEndQueryIndexed", glEndQueryIndexed, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_transform_feedback3 }, + { "glEndTransformFeedback", glEndTransformFeedback, (major > 3 || (major == 3 && minor >= 0)) }, + { "glEndTransformFeedbackEXT", glEndTransformFeedbackEXT, extensions->has_GL_EXT_transform_feedback }, + { "glEndTransformFeedbackNV", glEndTransformFeedbackNV, extensions->has_GL_NV_transform_feedback }, + { "glEndVertexShaderEXT", glEndVertexShaderEXT, extensions->has_GL_EXT_vertex_shader }, + { "glEndVideoCaptureNV", glEndVideoCaptureNV, extensions->has_GL_NV_video_capture }, + { "glEvalCoord1xOES", glEvalCoord1xOES, extensions->has_GL_OES_fixed_point }, + { "glEvalCoord1xvOES", glEvalCoord1xvOES, extensions->has_GL_OES_fixed_point }, + { "glEvalCoord2xOES", glEvalCoord2xOES, extensions->has_GL_OES_fixed_point }, + { "glEvalCoord2xvOES", glEvalCoord2xvOES, extensions->has_GL_OES_fixed_point }, + { "glEvalMapsNV", glEvalMapsNV, extensions->has_GL_NV_evaluators }, + { "glEvaluateDepthValuesARB", glEvaluateDepthValuesARB, extensions->has_GL_ARB_sample_locations }, + { "glExecuteProgramNV", glExecuteProgramNV, extensions->has_GL_NV_vertex_program }, + { "glExtractComponentEXT", glExtractComponentEXT, extensions->has_GL_EXT_vertex_shader }, + { "glFeedbackBufferxOES", glFeedbackBufferxOES, extensions->has_GL_OES_fixed_point }, + { "glFenceSync", glFenceSync, (major > 3 || (major == 3 && minor >= 2)) || extensions->has_GL_ARB_sync }, + { "glFinalCombinerInputNV", glFinalCombinerInputNV, extensions->has_GL_NV_register_combiners }, + { "glFinishAsyncSGIX", glFinishAsyncSGIX, extensions->has_GL_SGIX_async }, + { "glFinishFenceAPPLE", glFinishFenceAPPLE, extensions->has_GL_APPLE_fence }, + { "glFinishFenceNV", glFinishFenceNV, extensions->has_GL_NV_fence }, + { "glFinishObjectAPPLE", glFinishObjectAPPLE, extensions->has_GL_APPLE_fence }, + { "glFinishTextureSUNX", glFinishTextureSUNX, extensions->has_GL_SUNX_constant_data }, + { "glFlushMappedBufferRange", glFlushMappedBufferRange, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_map_buffer_range }, + { "glFlushMappedBufferRangeAPPLE", glFlushMappedBufferRangeAPPLE, extensions->has_GL_APPLE_flush_buffer_range }, + { "glFlushMappedNamedBufferRange", glFlushMappedNamedBufferRange, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glFlushMappedNamedBufferRangeEXT", glFlushMappedNamedBufferRangeEXT, extensions->has_GL_EXT_direct_state_access }, + { "glFlushPixelDataRangeNV", glFlushPixelDataRangeNV, extensions->has_GL_NV_pixel_data_range }, + { "glFlushRasterSGIX", glFlushRasterSGIX, extensions->has_GL_SGIX_flush_raster }, + { "glFlushStaticDataIBM", glFlushStaticDataIBM, extensions->has_GL_IBM_static_data }, + { "glFlushVertexArrayRangeAPPLE", glFlushVertexArrayRangeAPPLE, extensions->has_GL_APPLE_vertex_array_range }, + { "glFlushVertexArrayRangeNV", glFlushVertexArrayRangeNV, extensions->has_GL_NV_vertex_array_range }, + { "glFogCoordFormatNV", glFogCoordFormatNV, extensions->has_GL_NV_vertex_buffer_unified_memory }, + { "glFogCoordPointer", glFogCoordPointer, (major > 1 || (major == 1 && minor >= 4)) }, + { "glFogCoordPointerEXT", glFogCoordPointerEXT, extensions->has_GL_EXT_fog_coord }, + { "glFogCoordPointerListIBM", glFogCoordPointerListIBM, extensions->has_GL_IBM_vertex_array_lists }, + { "glFogCoordd", glFogCoordd, (major > 1 || (major == 1 && minor >= 4)) }, + { "glFogCoorddEXT", glFogCoorddEXT, extensions->has_GL_EXT_fog_coord }, + { "glFogCoorddv", glFogCoorddv, (major > 1 || (major == 1 && minor >= 4)) }, + { "glFogCoorddvEXT", glFogCoorddvEXT, extensions->has_GL_EXT_fog_coord }, + { "glFogCoordf", glFogCoordf, (major > 1 || (major == 1 && minor >= 4)) }, + { "glFogCoordfEXT", glFogCoordfEXT, extensions->has_GL_EXT_fog_coord }, + { "glFogCoordfv", glFogCoordfv, (major > 1 || (major == 1 && minor >= 4)) }, + { "glFogCoordfvEXT", glFogCoordfvEXT, extensions->has_GL_EXT_fog_coord }, + { "glFogCoordhNV", glFogCoordhNV, extensions->has_GL_NV_half_float }, + { "glFogCoordhvNV", glFogCoordhvNV, extensions->has_GL_NV_half_float }, + { "glFogFuncSGIS", glFogFuncSGIS, extensions->has_GL_SGIS_fog_function }, + { "glFogx", glFogx, extensions->has_GL_NV_ES1_1_compatibility }, + { "glFogxOES", glFogxOES, extensions->has_GL_OES_fixed_point }, + { "glFogxv", glFogxv, extensions->has_GL_NV_ES1_1_compatibility }, + { "glFogxvOES", glFogxvOES, extensions->has_GL_OES_fixed_point }, + { "glFragmentColorMaterialSGIX", glFragmentColorMaterialSGIX, extensions->has_GL_SGIX_fragment_lighting }, + { "glFragmentCoverageColorNV", glFragmentCoverageColorNV, extensions->has_GL_NV_fragment_coverage_to_color }, + { "glFragmentLightModelfSGIX", glFragmentLightModelfSGIX, extensions->has_GL_SGIX_fragment_lighting }, + { "glFragmentLightModelfvSGIX", glFragmentLightModelfvSGIX, extensions->has_GL_SGIX_fragment_lighting }, + { "glFragmentLightModeliSGIX", glFragmentLightModeliSGIX, extensions->has_GL_SGIX_fragment_lighting }, + { "glFragmentLightModelivSGIX", glFragmentLightModelivSGIX, extensions->has_GL_SGIX_fragment_lighting }, + { "glFragmentLightfSGIX", glFragmentLightfSGIX, extensions->has_GL_SGIX_fragment_lighting }, + { "glFragmentLightfvSGIX", glFragmentLightfvSGIX, extensions->has_GL_SGIX_fragment_lighting }, + { "glFragmentLightiSGIX", glFragmentLightiSGIX, extensions->has_GL_SGIX_fragment_lighting }, + { "glFragmentLightivSGIX", glFragmentLightivSGIX, extensions->has_GL_SGIX_fragment_lighting }, + { "glFragmentMaterialfSGIX", glFragmentMaterialfSGIX, extensions->has_GL_SGIX_fragment_lighting }, + { "glFragmentMaterialfvSGIX", glFragmentMaterialfvSGIX, extensions->has_GL_SGIX_fragment_lighting }, + { "glFragmentMaterialiSGIX", glFragmentMaterialiSGIX, extensions->has_GL_SGIX_fragment_lighting }, + { "glFragmentMaterialivSGIX", glFragmentMaterialivSGIX, extensions->has_GL_SGIX_fragment_lighting }, + { "glFrameTerminatorGREMEDY", glFrameTerminatorGREMEDY, extensions->has_GL_GREMEDY_frame_terminator }, + { "glFrameZoomSGIX", glFrameZoomSGIX, extensions->has_GL_SGIX_framezoom }, + { "glFramebufferDrawBufferEXT", glFramebufferDrawBufferEXT, extensions->has_GL_EXT_direct_state_access }, + { "glFramebufferDrawBuffersEXT", glFramebufferDrawBuffersEXT, extensions->has_GL_EXT_direct_state_access }, + { "glFramebufferFetchBarrierEXT", glFramebufferFetchBarrierEXT, extensions->has_GL_EXT_shader_framebuffer_fetch_non_coherent }, + { "glFramebufferParameteri", glFramebufferParameteri, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_framebuffer_no_attachments }, + { "glFramebufferParameteriMESA", glFramebufferParameteriMESA, extensions->has_GL_MESA_framebuffer_flip_y }, + { "glFramebufferReadBufferEXT", glFramebufferReadBufferEXT, extensions->has_GL_EXT_direct_state_access }, + { "glFramebufferRenderbuffer", glFramebufferRenderbuffer, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_framebuffer_object }, + { "glFramebufferRenderbufferEXT", glFramebufferRenderbufferEXT, extensions->has_GL_EXT_framebuffer_object }, + { "glFramebufferSampleLocationsfvARB", glFramebufferSampleLocationsfvARB, extensions->has_GL_ARB_sample_locations }, + { "glFramebufferSampleLocationsfvNV", glFramebufferSampleLocationsfvNV, extensions->has_GL_NV_sample_locations }, + { "glFramebufferSamplePositionsfvAMD", glFramebufferSamplePositionsfvAMD, extensions->has_GL_AMD_framebuffer_sample_positions }, + { "glFramebufferShadingRateEXT", glFramebufferShadingRateEXT, extensions->has_GL_EXT_fragment_shading_rate || extensions->has_GL_EXT_fragment_shading_rate_attachment || extensions->has_GL_EXT_fragment_shading_rate_primitive }, + { "glFramebufferTexture", glFramebufferTexture, (major > 3 || (major == 3 && minor >= 2)) }, + { "glFramebufferTexture1D", glFramebufferTexture1D, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_framebuffer_object }, + { "glFramebufferTexture1DEXT", glFramebufferTexture1DEXT, extensions->has_GL_EXT_framebuffer_object }, + { "glFramebufferTexture2D", glFramebufferTexture2D, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_framebuffer_object }, + { "glFramebufferTexture2DEXT", glFramebufferTexture2DEXT, extensions->has_GL_EXT_framebuffer_object }, + { "glFramebufferTexture3D", glFramebufferTexture3D, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_framebuffer_object }, + { "glFramebufferTexture3DEXT", glFramebufferTexture3DEXT, extensions->has_GL_EXT_framebuffer_object }, + { "glFramebufferTextureARB", glFramebufferTextureARB, extensions->has_GL_ARB_geometry_shader4 }, + { "glFramebufferTextureEXT", glFramebufferTextureEXT, extensions->has_GL_NV_geometry_program4 }, + { "glFramebufferTextureFaceARB", glFramebufferTextureFaceARB, extensions->has_GL_ARB_geometry_shader4 }, + { "glFramebufferTextureFaceEXT", glFramebufferTextureFaceEXT, extensions->has_GL_NV_geometry_program4 }, + { "glFramebufferTextureLayer", glFramebufferTextureLayer, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_framebuffer_object }, + { "glFramebufferTextureLayerARB", glFramebufferTextureLayerARB, extensions->has_GL_ARB_geometry_shader4 }, + { "glFramebufferTextureLayerEXT", glFramebufferTextureLayerEXT, extensions->has_GL_EXT_texture_array || extensions->has_GL_NV_geometry_program4 }, + { "glFramebufferTextureMultiviewOVR", glFramebufferTextureMultiviewOVR, extensions->has_GL_OVR_multiview }, + { "glFreeObjectBufferATI", glFreeObjectBufferATI, extensions->has_GL_ATI_vertex_array_object }, + { "glFrustumf", glFrustumf, extensions->has_GL_NV_ES1_1_compatibility }, + { "glFrustumfOES", glFrustumfOES, extensions->has_GL_OES_single_precision }, + { "glFrustumx", glFrustumx, extensions->has_GL_NV_ES1_1_compatibility }, + { "glFrustumxOES", glFrustumxOES, extensions->has_GL_OES_fixed_point }, + { "glGenAsyncMarkersSGIX", glGenAsyncMarkersSGIX, extensions->has_GL_SGIX_async }, + { "glGenBuffers", glGenBuffers, (major > 1 || (major == 1 && minor >= 5)) }, + { "glGenBuffersARB", glGenBuffersARB, extensions->has_GL_ARB_vertex_buffer_object }, + { "glGenFencesAPPLE", glGenFencesAPPLE, extensions->has_GL_APPLE_fence }, + { "glGenFencesNV", glGenFencesNV, extensions->has_GL_NV_fence }, + { "glGenFragmentShadersATI", glGenFragmentShadersATI, extensions->has_GL_ATI_fragment_shader }, + { "glGenFramebuffers", glGenFramebuffers, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_framebuffer_object }, + { "glGenFramebuffersEXT", glGenFramebuffersEXT, extensions->has_GL_EXT_framebuffer_object }, + { "glGenNamesAMD", glGenNamesAMD, extensions->has_GL_AMD_name_gen_delete }, + { "glGenOcclusionQueriesNV", glGenOcclusionQueriesNV, extensions->has_GL_NV_occlusion_query }, + { "glGenPathsNV", glGenPathsNV, extensions->has_GL_NV_path_rendering }, + { "glGenPerfMonitorsAMD", glGenPerfMonitorsAMD, extensions->has_GL_AMD_performance_monitor }, + { "glGenProgramPipelines", glGenProgramPipelines, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glGenProgramsARB", glGenProgramsARB, extensions->has_GL_ARB_fragment_program || extensions->has_GL_ARB_vertex_program }, + { "glGenProgramsNV", glGenProgramsNV, extensions->has_GL_NV_vertex_program }, + { "glGenQueries", glGenQueries, (major > 1 || (major == 1 && minor >= 5)) }, + { "glGenQueriesARB", glGenQueriesARB, extensions->has_GL_ARB_occlusion_query }, + { "glGenQueryResourceTagNV", glGenQueryResourceTagNV, extensions->has_GL_NV_query_resource_tag }, + { "glGenRenderbuffers", glGenRenderbuffers, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_framebuffer_object }, + { "glGenRenderbuffersEXT", glGenRenderbuffersEXT, extensions->has_GL_EXT_framebuffer_object }, + { "glGenSamplers", glGenSamplers, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_sampler_objects }, + { "glGenSemaphoresEXT", glGenSemaphoresEXT, extensions->has_GL_EXT_semaphore }, + { "glGenSymbolsEXT", glGenSymbolsEXT, extensions->has_GL_EXT_vertex_shader }, + { "glGenTexturesEXT", glGenTexturesEXT, extensions->has_GL_EXT_texture_object }, + { "glGenTransformFeedbacks", glGenTransformFeedbacks, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_transform_feedback2 }, + { "glGenTransformFeedbacksNV", glGenTransformFeedbacksNV, extensions->has_GL_NV_transform_feedback2 }, + { "glGenVertexArrays", glGenVertexArrays, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_vertex_array_object }, + { "glGenVertexArraysAPPLE", glGenVertexArraysAPPLE, extensions->has_GL_APPLE_vertex_array_object }, + { "glGenVertexShadersEXT", glGenVertexShadersEXT, extensions->has_GL_EXT_vertex_shader }, + { "glGenerateMipmap", glGenerateMipmap, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_framebuffer_object }, + { "glGenerateMipmapEXT", glGenerateMipmapEXT, extensions->has_GL_EXT_framebuffer_object }, + { "glGenerateMultiTexMipmapEXT", glGenerateMultiTexMipmapEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGenerateTextureMipmap", glGenerateTextureMipmap, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glGenerateTextureMipmapEXT", glGenerateTextureMipmapEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetActiveAtomicCounterBufferiv", glGetActiveAtomicCounterBufferiv, (major > 4 || (major == 4 && minor >= 2)) || extensions->has_GL_ARB_shader_atomic_counters }, + { "glGetActiveAttrib", glGetActiveAttrib, (major > 2 || (major == 2 && minor >= 0)) }, + { "glGetActiveAttribARB", glGetActiveAttribARB, extensions->has_GL_ARB_vertex_shader }, + { "glGetActiveSubroutineName", glGetActiveSubroutineName, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_shader_subroutine }, + { "glGetActiveSubroutineUniformName", glGetActiveSubroutineUniformName, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_shader_subroutine }, + { "glGetActiveSubroutineUniformiv", glGetActiveSubroutineUniformiv, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_shader_subroutine }, + { "glGetActiveUniform", glGetActiveUniform, (major > 2 || (major == 2 && minor >= 0)) }, + { "glGetActiveUniformARB", glGetActiveUniformARB, extensions->has_GL_ARB_shader_objects }, + { "glGetActiveUniformBlockName", glGetActiveUniformBlockName, (major > 3 || (major == 3 && minor >= 1)) || extensions->has_GL_ARB_uniform_buffer_object }, + { "glGetActiveUniformBlockiv", glGetActiveUniformBlockiv, (major > 3 || (major == 3 && minor >= 1)) || extensions->has_GL_ARB_uniform_buffer_object }, + { "glGetActiveUniformName", glGetActiveUniformName, (major > 3 || (major == 3 && minor >= 1)) || extensions->has_GL_ARB_uniform_buffer_object }, + { "glGetActiveUniformsiv", glGetActiveUniformsiv, (major > 3 || (major == 3 && minor >= 1)) || extensions->has_GL_ARB_uniform_buffer_object }, + { "glGetActiveVaryingNV", glGetActiveVaryingNV, extensions->has_GL_NV_transform_feedback }, + { "glGetArrayObjectfvATI", glGetArrayObjectfvATI, extensions->has_GL_ATI_vertex_array_object }, + { "glGetArrayObjectivATI", glGetArrayObjectivATI, extensions->has_GL_ATI_vertex_array_object }, + { "glGetAttachedObjectsARB", glGetAttachedObjectsARB, extensions->has_GL_ARB_shader_objects }, + { "glGetAttachedShaders", glGetAttachedShaders, (major > 2 || (major == 2 && minor >= 0)) }, + { "glGetAttribLocation", glGetAttribLocation, (major > 2 || (major == 2 && minor >= 0)) }, + { "glGetAttribLocationARB", glGetAttribLocationARB, extensions->has_GL_ARB_vertex_shader }, + { "glGetBooleanIndexedvEXT", glGetBooleanIndexedvEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_EXT_draw_buffers2 }, + { "glGetBooleani_v", glGetBooleani_v, (major > 3 || (major == 3 && minor >= 0)) }, + { "glGetBufferParameteri64v", glGetBufferParameteri64v, (major > 3 || (major == 3 && minor >= 2)) }, + { "glGetBufferParameteriv", glGetBufferParameteriv, (major > 1 || (major == 1 && minor >= 5)) }, + { "glGetBufferParameterivARB", glGetBufferParameterivARB, extensions->has_GL_ARB_vertex_buffer_object }, + { "glGetBufferParameterui64vNV", glGetBufferParameterui64vNV, extensions->has_GL_NV_shader_buffer_load }, + { "glGetBufferPointerv", glGetBufferPointerv, (major > 1 || (major == 1 && minor >= 5)) }, + { "glGetBufferPointervARB", glGetBufferPointervARB, extensions->has_GL_ARB_vertex_buffer_object }, + { "glGetBufferSubData", glGetBufferSubData, (major > 1 || (major == 1 && minor >= 5)) }, + { "glGetBufferSubDataARB", glGetBufferSubDataARB, extensions->has_GL_ARB_vertex_buffer_object }, + { "glGetClipPlanef", glGetClipPlanef, extensions->has_GL_NV_ES1_1_compatibility }, + { "glGetClipPlanefOES", glGetClipPlanefOES, extensions->has_GL_OES_single_precision }, + { "glGetClipPlanex", glGetClipPlanex, extensions->has_GL_NV_ES1_1_compatibility }, + { "glGetClipPlanexOES", glGetClipPlanexOES, extensions->has_GL_OES_fixed_point }, + { "glGetColorTable", glGetColorTable, extensions->has_GL_ARB_imaging }, + { "glGetColorTableEXT", glGetColorTableEXT, extensions->has_GL_EXT_paletted_texture }, + { "glGetColorTableParameterfv", glGetColorTableParameterfv, extensions->has_GL_ARB_imaging }, + { "glGetColorTableParameterfvEXT", glGetColorTableParameterfvEXT, extensions->has_GL_EXT_paletted_texture }, + { "glGetColorTableParameterfvSGI", glGetColorTableParameterfvSGI, extensions->has_GL_SGI_color_table }, + { "glGetColorTableParameteriv", glGetColorTableParameteriv, extensions->has_GL_ARB_imaging }, + { "glGetColorTableParameterivEXT", glGetColorTableParameterivEXT, extensions->has_GL_EXT_paletted_texture }, + { "glGetColorTableParameterivSGI", glGetColorTableParameterivSGI, extensions->has_GL_SGI_color_table }, + { "glGetColorTableSGI", glGetColorTableSGI, extensions->has_GL_SGI_color_table }, + { "glGetCombinerInputParameterfvNV", glGetCombinerInputParameterfvNV, extensions->has_GL_NV_register_combiners }, + { "glGetCombinerInputParameterivNV", glGetCombinerInputParameterivNV, extensions->has_GL_NV_register_combiners }, + { "glGetCombinerOutputParameterfvNV", glGetCombinerOutputParameterfvNV, extensions->has_GL_NV_register_combiners }, + { "glGetCombinerOutputParameterivNV", glGetCombinerOutputParameterivNV, extensions->has_GL_NV_register_combiners }, + { "glGetCombinerStageParameterfvNV", glGetCombinerStageParameterfvNV, extensions->has_GL_NV_register_combiners2 }, + { "glGetCommandHeaderNV", glGetCommandHeaderNV, extensions->has_GL_NV_command_list }, + { "glGetCompressedMultiTexImageEXT", glGetCompressedMultiTexImageEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetCompressedTexImage", glGetCompressedTexImage, (major > 1 || (major == 1 && minor >= 3)) }, + { "glGetCompressedTexImageARB", glGetCompressedTexImageARB, (major > 1 || (major == 1 && minor >= 3)) || extensions->has_GL_ARB_texture_compression }, + { "glGetCompressedTextureImage", glGetCompressedTextureImage, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glGetCompressedTextureImageEXT", glGetCompressedTextureImageEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetCompressedTextureSubImage", glGetCompressedTextureSubImage, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_get_texture_sub_image }, + { "glGetConvolutionFilter", glGetConvolutionFilter, extensions->has_GL_ARB_imaging }, + { "glGetConvolutionFilterEXT", glGetConvolutionFilterEXT, extensions->has_GL_EXT_convolution }, + { "glGetConvolutionParameterfv", glGetConvolutionParameterfv, extensions->has_GL_ARB_imaging }, + { "glGetConvolutionParameterfvEXT", glGetConvolutionParameterfvEXT, extensions->has_GL_EXT_convolution }, + { "glGetConvolutionParameteriv", glGetConvolutionParameteriv, extensions->has_GL_ARB_imaging }, + { "glGetConvolutionParameterivEXT", glGetConvolutionParameterivEXT, extensions->has_GL_EXT_convolution }, + { "glGetConvolutionParameterxvOES", glGetConvolutionParameterxvOES, extensions->has_GL_OES_fixed_point }, + { "glGetCoverageModulationTableNV", glGetCoverageModulationTableNV, extensions->has_GL_NV_framebuffer_mixed_samples }, + { "glGetDebugMessageLog", glGetDebugMessageLog, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_KHR_debug }, + { "glGetDebugMessageLogAMD", glGetDebugMessageLogAMD, extensions->has_GL_AMDX_debug_output || extensions->has_GL_AMD_debug_output }, + { "glGetDebugMessageLogARB", glGetDebugMessageLogARB, extensions->has_GL_ARB_debug_output }, + { "glGetDetailTexFuncSGIS", glGetDetailTexFuncSGIS, extensions->has_GL_SGIS_detail_texture }, + { "glGetDoubleIndexedvEXT", glGetDoubleIndexedvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetDoublei_v", glGetDoublei_v, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_viewport_array }, + { "glGetDoublei_vEXT", glGetDoublei_vEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetFenceivNV", glGetFenceivNV, extensions->has_GL_NV_fence }, + { "glGetFinalCombinerInputParameterfvNV", glGetFinalCombinerInputParameterfvNV, extensions->has_GL_NV_register_combiners }, + { "glGetFinalCombinerInputParameterivNV", glGetFinalCombinerInputParameterivNV, extensions->has_GL_NV_register_combiners }, + { "glGetFirstPerfQueryIdINTEL", glGetFirstPerfQueryIdINTEL, extensions->has_GL_INTEL_performance_query }, + { "glGetFixedv", glGetFixedv, extensions->has_GL_NV_ES1_1_compatibility }, + { "glGetFixedvOES", glGetFixedvOES, extensions->has_GL_OES_fixed_point }, + { "glGetFloatIndexedvEXT", glGetFloatIndexedvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetFloati_v", glGetFloati_v, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_viewport_array }, + { "glGetFloati_vEXT", glGetFloati_vEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetFogFuncSGIS", glGetFogFuncSGIS, extensions->has_GL_SGIS_fog_function }, + { "glGetFragDataIndex", glGetFragDataIndex, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_blend_func_extended }, + { "glGetFragDataLocation", glGetFragDataLocation, (major > 3 || (major == 3 && minor >= 0)) }, + { "glGetFragDataLocationEXT", glGetFragDataLocationEXT, extensions->has_GL_EXT_gpu_shader4 }, + { "glGetFragmentLightfvSGIX", glGetFragmentLightfvSGIX, extensions->has_GL_SGIX_fragment_lighting }, + { "glGetFragmentLightivSGIX", glGetFragmentLightivSGIX, extensions->has_GL_SGIX_fragment_lighting }, + { "glGetFragmentMaterialfvSGIX", glGetFragmentMaterialfvSGIX, extensions->has_GL_SGIX_fragment_lighting }, + { "glGetFragmentMaterialivSGIX", glGetFragmentMaterialivSGIX, extensions->has_GL_SGIX_fragment_lighting }, + { "glGetFragmentShadingRatesEXT", glGetFragmentShadingRatesEXT, extensions->has_GL_EXT_fragment_shading_rate || extensions->has_GL_EXT_fragment_shading_rate_attachment || extensions->has_GL_EXT_fragment_shading_rate_primitive }, + { "glGetFramebufferAttachmentParameteriv", glGetFramebufferAttachmentParameteriv, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_framebuffer_object }, + { "glGetFramebufferAttachmentParameterivEXT", glGetFramebufferAttachmentParameterivEXT, extensions->has_GL_EXT_framebuffer_object }, + { "glGetFramebufferParameterfvAMD", glGetFramebufferParameterfvAMD, extensions->has_GL_AMD_framebuffer_sample_positions }, + { "glGetFramebufferParameteriv", glGetFramebufferParameteriv, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_framebuffer_no_attachments }, + { "glGetFramebufferParameterivEXT", glGetFramebufferParameterivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetFramebufferParameterivMESA", glGetFramebufferParameterivMESA, extensions->has_GL_MESA_framebuffer_flip_y }, + { "glGetGraphicsResetStatus", glGetGraphicsResetStatus, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_KHR_robustness }, + { "glGetGraphicsResetStatusARB", glGetGraphicsResetStatusARB, extensions->has_GL_ARB_robustness }, + { "glGetHandleARB", glGetHandleARB, extensions->has_GL_ARB_shader_objects }, + { "glGetHistogram", glGetHistogram, extensions->has_GL_ARB_imaging }, + { "glGetHistogramEXT", glGetHistogramEXT, extensions->has_GL_EXT_histogram }, + { "glGetHistogramParameterfv", glGetHistogramParameterfv, extensions->has_GL_ARB_imaging }, + { "glGetHistogramParameterfvEXT", glGetHistogramParameterfvEXT, extensions->has_GL_EXT_histogram }, + { "glGetHistogramParameteriv", glGetHistogramParameteriv, extensions->has_GL_ARB_imaging }, + { "glGetHistogramParameterivEXT", glGetHistogramParameterivEXT, extensions->has_GL_EXT_histogram }, + { "glGetHistogramParameterxvOES", glGetHistogramParameterxvOES, extensions->has_GL_OES_fixed_point }, + { "glGetImageHandleARB", glGetImageHandleARB, extensions->has_GL_ARB_bindless_texture }, + { "glGetImageHandleNV", glGetImageHandleNV, extensions->has_GL_NV_bindless_texture }, + { "glGetImageTransformParameterfvHP", glGetImageTransformParameterfvHP, extensions->has_GL_HP_image_transform }, + { "glGetImageTransformParameterivHP", glGetImageTransformParameterivHP, extensions->has_GL_HP_image_transform }, + { "glGetInfoLogARB", glGetInfoLogARB, extensions->has_GL_ARB_shader_objects }, + { "glGetInstrumentsSGIX", glGetInstrumentsSGIX, extensions->has_GL_SGIX_instruments }, + { "glGetInteger64i_v", glGetInteger64i_v, (major > 3 || (major == 3 && minor >= 2)) }, + { "glGetInteger64v", glGetInteger64v, (major > 3 || (major == 3 && minor >= 2)) || extensions->has_GL_ARB_sync }, + { "glGetIntegerIndexedvEXT", glGetIntegerIndexedvEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_EXT_draw_buffers2 }, + { "glGetIntegeri_v", glGetIntegeri_v, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_uniform_buffer_object }, + { "glGetIntegerui64i_vNV", glGetIntegerui64i_vNV, extensions->has_GL_NV_vertex_buffer_unified_memory }, + { "glGetIntegerui64vNV", glGetIntegerui64vNV, extensions->has_GL_NV_shader_buffer_load }, + { "glGetInternalformatSampleivNV", glGetInternalformatSampleivNV, extensions->has_GL_NV_internalformat_sample_query }, + { "glGetInternalformati64v", glGetInternalformati64v, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_internalformat_query2 }, + { "glGetInternalformativ", glGetInternalformativ, (major > 4 || (major == 4 && minor >= 2)) || extensions->has_GL_ARB_internalformat_query }, + { "glGetInvariantBooleanvEXT", glGetInvariantBooleanvEXT, extensions->has_GL_EXT_vertex_shader }, + { "glGetInvariantFloatvEXT", glGetInvariantFloatvEXT, extensions->has_GL_EXT_vertex_shader }, + { "glGetInvariantIntegervEXT", glGetInvariantIntegervEXT, extensions->has_GL_EXT_vertex_shader }, + { "glGetLightxOES", glGetLightxOES, extensions->has_GL_OES_fixed_point }, + { "glGetLightxv", glGetLightxv, extensions->has_GL_NV_ES1_1_compatibility }, + { "glGetListParameterfvSGIX", glGetListParameterfvSGIX, extensions->has_GL_SGIX_list_priority }, + { "glGetListParameterivSGIX", glGetListParameterivSGIX, extensions->has_GL_SGIX_list_priority }, + { "glGetLocalConstantBooleanvEXT", glGetLocalConstantBooleanvEXT, extensions->has_GL_EXT_vertex_shader }, + { "glGetLocalConstantFloatvEXT", glGetLocalConstantFloatvEXT, extensions->has_GL_EXT_vertex_shader }, + { "glGetLocalConstantIntegervEXT", glGetLocalConstantIntegervEXT, extensions->has_GL_EXT_vertex_shader }, + { "glGetMapAttribParameterfvNV", glGetMapAttribParameterfvNV, extensions->has_GL_NV_evaluators }, + { "glGetMapAttribParameterivNV", glGetMapAttribParameterivNV, extensions->has_GL_NV_evaluators }, + { "glGetMapControlPointsNV", glGetMapControlPointsNV, extensions->has_GL_NV_evaluators }, + { "glGetMapParameterfvNV", glGetMapParameterfvNV, extensions->has_GL_NV_evaluators }, + { "glGetMapParameterivNV", glGetMapParameterivNV, extensions->has_GL_NV_evaluators }, + { "glGetMapxvOES", glGetMapxvOES, extensions->has_GL_OES_fixed_point }, + { "glGetMaterialxOES", glGetMaterialxOES, extensions->has_GL_OES_fixed_point }, + { "glGetMaterialxv", glGetMaterialxv, extensions->has_GL_NV_ES1_1_compatibility }, + { "glGetMemoryObjectDetachedResourcesuivNV", glGetMemoryObjectDetachedResourcesuivNV, extensions->has_GL_NV_memory_attachment }, + { "glGetMemoryObjectParameterivEXT", glGetMemoryObjectParameterivEXT, extensions->has_GL_EXT_memory_object }, + { "glGetMinmax", glGetMinmax, extensions->has_GL_ARB_imaging }, + { "glGetMinmaxEXT", glGetMinmaxEXT, extensions->has_GL_EXT_histogram }, + { "glGetMinmaxParameterfv", glGetMinmaxParameterfv, extensions->has_GL_ARB_imaging }, + { "glGetMinmaxParameterfvEXT", glGetMinmaxParameterfvEXT, extensions->has_GL_EXT_histogram }, + { "glGetMinmaxParameteriv", glGetMinmaxParameteriv, extensions->has_GL_ARB_imaging }, + { "glGetMinmaxParameterivEXT", glGetMinmaxParameterivEXT, extensions->has_GL_EXT_histogram }, + { "glGetMultiTexEnvfvEXT", glGetMultiTexEnvfvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetMultiTexEnvivEXT", glGetMultiTexEnvivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetMultiTexGendvEXT", glGetMultiTexGendvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetMultiTexGenfvEXT", glGetMultiTexGenfvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetMultiTexGenivEXT", glGetMultiTexGenivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetMultiTexImageEXT", glGetMultiTexImageEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetMultiTexLevelParameterfvEXT", glGetMultiTexLevelParameterfvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetMultiTexLevelParameterivEXT", glGetMultiTexLevelParameterivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetMultiTexParameterIivEXT", glGetMultiTexParameterIivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetMultiTexParameterIuivEXT", glGetMultiTexParameterIuivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetMultiTexParameterfvEXT", glGetMultiTexParameterfvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetMultiTexParameterivEXT", glGetMultiTexParameterivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetMultisamplefv", glGetMultisamplefv, (major > 3 || (major == 3 && minor >= 2)) || extensions->has_GL_ARB_texture_multisample }, + { "glGetMultisamplefvNV", glGetMultisamplefvNV, extensions->has_GL_NV_explicit_multisample }, + { "glGetNamedBufferParameteri64v", glGetNamedBufferParameteri64v, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glGetNamedBufferParameteriv", glGetNamedBufferParameteriv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glGetNamedBufferParameterivEXT", glGetNamedBufferParameterivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetNamedBufferParameterui64vNV", glGetNamedBufferParameterui64vNV, extensions->has_GL_NV_shader_buffer_load }, + { "glGetNamedBufferPointerv", glGetNamedBufferPointerv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glGetNamedBufferPointervEXT", glGetNamedBufferPointervEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetNamedBufferSubData", glGetNamedBufferSubData, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glGetNamedBufferSubDataEXT", glGetNamedBufferSubDataEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetNamedFramebufferAttachmentParameteriv", glGetNamedFramebufferAttachmentParameteriv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glGetNamedFramebufferAttachmentParameterivEXT", glGetNamedFramebufferAttachmentParameterivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetNamedFramebufferParameterfvAMD", glGetNamedFramebufferParameterfvAMD, extensions->has_GL_AMD_framebuffer_sample_positions }, + { "glGetNamedFramebufferParameteriv", glGetNamedFramebufferParameteriv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glGetNamedFramebufferParameterivEXT", glGetNamedFramebufferParameterivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetNamedProgramLocalParameterIivEXT", glGetNamedProgramLocalParameterIivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetNamedProgramLocalParameterIuivEXT", glGetNamedProgramLocalParameterIuivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetNamedProgramLocalParameterdvEXT", glGetNamedProgramLocalParameterdvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetNamedProgramLocalParameterfvEXT", glGetNamedProgramLocalParameterfvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetNamedProgramStringEXT", glGetNamedProgramStringEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetNamedProgramivEXT", glGetNamedProgramivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetNamedRenderbufferParameteriv", glGetNamedRenderbufferParameteriv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glGetNamedRenderbufferParameterivEXT", glGetNamedRenderbufferParameterivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetNamedStringARB", glGetNamedStringARB, extensions->has_GL_ARB_shading_language_include }, + { "glGetNamedStringivARB", glGetNamedStringivARB, extensions->has_GL_ARB_shading_language_include }, + { "glGetNextPerfQueryIdINTEL", glGetNextPerfQueryIdINTEL, extensions->has_GL_INTEL_performance_query }, + { "glGetObjectBufferfvATI", glGetObjectBufferfvATI, extensions->has_GL_ATI_vertex_array_object }, + { "glGetObjectBufferivATI", glGetObjectBufferivATI, extensions->has_GL_ATI_vertex_array_object }, + { "glGetObjectLabel", glGetObjectLabel, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_KHR_debug }, + { "glGetObjectLabelEXT", glGetObjectLabelEXT, extensions->has_GL_EXT_debug_label }, + { "glGetObjectParameterfvARB", glGetObjectParameterfvARB, extensions->has_GL_ARB_shader_objects }, + { "glGetObjectParameterivAPPLE", glGetObjectParameterivAPPLE, extensions->has_GL_APPLE_object_purgeable }, + { "glGetObjectParameterivARB", glGetObjectParameterivARB, extensions->has_GL_ARB_shader_objects }, + { "glGetObjectPtrLabel", glGetObjectPtrLabel, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_KHR_debug }, + { "glGetOcclusionQueryivNV", glGetOcclusionQueryivNV, extensions->has_GL_NV_occlusion_query }, + { "glGetOcclusionQueryuivNV", glGetOcclusionQueryuivNV, extensions->has_GL_NV_occlusion_query }, + { "glGetPathColorGenfvNV", glGetPathColorGenfvNV, extensions->has_GL_NV_path_rendering }, + { "glGetPathColorGenivNV", glGetPathColorGenivNV, extensions->has_GL_NV_path_rendering }, + { "glGetPathCommandsNV", glGetPathCommandsNV, extensions->has_GL_NV_path_rendering }, + { "glGetPathCoordsNV", glGetPathCoordsNV, extensions->has_GL_NV_path_rendering }, + { "glGetPathDashArrayNV", glGetPathDashArrayNV, extensions->has_GL_NV_path_rendering }, + { "glGetPathLengthNV", glGetPathLengthNV, extensions->has_GL_NV_path_rendering }, + { "glGetPathMetricRangeNV", glGetPathMetricRangeNV, extensions->has_GL_NV_path_rendering }, + { "glGetPathMetricsNV", glGetPathMetricsNV, extensions->has_GL_NV_path_rendering }, + { "glGetPathParameterfvNV", glGetPathParameterfvNV, extensions->has_GL_NV_path_rendering }, + { "glGetPathParameterivNV", glGetPathParameterivNV, extensions->has_GL_NV_path_rendering }, + { "glGetPathSpacingNV", glGetPathSpacingNV, extensions->has_GL_NV_path_rendering }, + { "glGetPathTexGenfvNV", glGetPathTexGenfvNV, extensions->has_GL_NV_path_rendering }, + { "glGetPathTexGenivNV", glGetPathTexGenivNV, extensions->has_GL_NV_path_rendering }, + { "glGetPerfCounterInfoINTEL", glGetPerfCounterInfoINTEL, extensions->has_GL_INTEL_performance_query }, + { "glGetPerfMonitorCounterDataAMD", glGetPerfMonitorCounterDataAMD, extensions->has_GL_AMD_performance_monitor }, + { "glGetPerfMonitorCounterInfoAMD", glGetPerfMonitorCounterInfoAMD, extensions->has_GL_AMD_performance_monitor }, + { "glGetPerfMonitorCounterStringAMD", glGetPerfMonitorCounterStringAMD, extensions->has_GL_AMD_performance_monitor }, + { "glGetPerfMonitorCountersAMD", glGetPerfMonitorCountersAMD, extensions->has_GL_AMD_performance_monitor }, + { "glGetPerfMonitorGroupStringAMD", glGetPerfMonitorGroupStringAMD, extensions->has_GL_AMD_performance_monitor }, + { "glGetPerfMonitorGroupsAMD", glGetPerfMonitorGroupsAMD, extensions->has_GL_AMD_performance_monitor }, + { "glGetPerfQueryDataINTEL", glGetPerfQueryDataINTEL, extensions->has_GL_INTEL_performance_query }, + { "glGetPerfQueryIdByNameINTEL", glGetPerfQueryIdByNameINTEL, extensions->has_GL_INTEL_performance_query }, + { "glGetPerfQueryInfoINTEL", glGetPerfQueryInfoINTEL, extensions->has_GL_INTEL_performance_query }, + { "glGetPixelMapxv", glGetPixelMapxv, extensions->has_GL_OES_fixed_point }, + { "glGetPixelTexGenParameterfvSGIS", glGetPixelTexGenParameterfvSGIS, extensions->has_GL_SGIS_pixel_texture }, + { "glGetPixelTexGenParameterivSGIS", glGetPixelTexGenParameterivSGIS, extensions->has_GL_SGIS_pixel_texture }, + { "glGetPixelTransformParameterfvEXT", glGetPixelTransformParameterfvEXT, extensions->has_GL_EXT_pixel_transform }, + { "glGetPixelTransformParameterivEXT", glGetPixelTransformParameterivEXT, extensions->has_GL_EXT_pixel_transform }, + { "glGetPointerIndexedvEXT", glGetPointerIndexedvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetPointeri_vEXT", glGetPointeri_vEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetPointervEXT", glGetPointervEXT, extensions->has_GL_EXT_vertex_array }, + { "glGetProgramBinary", glGetProgramBinary, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_get_program_binary }, + { "glGetProgramEnvParameterIivNV", glGetProgramEnvParameterIivNV, extensions->has_GL_NV_gpu_program4 }, + { "glGetProgramEnvParameterIuivNV", glGetProgramEnvParameterIuivNV, extensions->has_GL_NV_gpu_program4 }, + { "glGetProgramEnvParameterdvARB", glGetProgramEnvParameterdvARB, extensions->has_GL_ARB_fragment_program || extensions->has_GL_ARB_vertex_program }, + { "glGetProgramEnvParameterfvARB", glGetProgramEnvParameterfvARB, extensions->has_GL_ARB_fragment_program || extensions->has_GL_ARB_vertex_program }, + { "glGetProgramInfoLog", glGetProgramInfoLog, (major > 2 || (major == 2 && minor >= 0)) }, + { "glGetProgramInterfaceiv", glGetProgramInterfaceiv, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_program_interface_query }, + { "glGetProgramLocalParameterIivNV", glGetProgramLocalParameterIivNV, extensions->has_GL_NV_gpu_program4 }, + { "glGetProgramLocalParameterIuivNV", glGetProgramLocalParameterIuivNV, extensions->has_GL_NV_gpu_program4 }, + { "glGetProgramLocalParameterdvARB", glGetProgramLocalParameterdvARB, extensions->has_GL_ARB_fragment_program || extensions->has_GL_ARB_vertex_program }, + { "glGetProgramLocalParameterfvARB", glGetProgramLocalParameterfvARB, extensions->has_GL_ARB_fragment_program || extensions->has_GL_ARB_vertex_program }, + { "glGetProgramNamedParameterdvNV", glGetProgramNamedParameterdvNV, extensions->has_GL_NV_fragment_program }, + { "glGetProgramNamedParameterfvNV", glGetProgramNamedParameterfvNV, extensions->has_GL_NV_fragment_program }, + { "glGetProgramParameterdvNV", glGetProgramParameterdvNV, extensions->has_GL_NV_vertex_program }, + { "glGetProgramParameterfvNV", glGetProgramParameterfvNV, extensions->has_GL_NV_vertex_program }, + { "glGetProgramPipelineInfoLog", glGetProgramPipelineInfoLog, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glGetProgramPipelineiv", glGetProgramPipelineiv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glGetProgramResourceIndex", glGetProgramResourceIndex, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_program_interface_query }, + { "glGetProgramResourceLocation", glGetProgramResourceLocation, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_program_interface_query }, + { "glGetProgramResourceLocationIndex", glGetProgramResourceLocationIndex, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_program_interface_query }, + { "glGetProgramResourceName", glGetProgramResourceName, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_program_interface_query }, + { "glGetProgramResourcefvNV", glGetProgramResourcefvNV, extensions->has_GL_NV_path_rendering }, + { "glGetProgramResourceiv", glGetProgramResourceiv, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_program_interface_query }, + { "glGetProgramStageiv", glGetProgramStageiv, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_shader_subroutine }, + { "glGetProgramStringARB", glGetProgramStringARB, extensions->has_GL_ARB_fragment_program || extensions->has_GL_ARB_vertex_program }, + { "glGetProgramStringNV", glGetProgramStringNV, extensions->has_GL_NV_vertex_program }, + { "glGetProgramSubroutineParameteruivNV", glGetProgramSubroutineParameteruivNV, extensions->has_GL_NV_gpu_program5 || extensions->has_GL_NV_gpu_program_fp64 }, + { "glGetProgramiv", glGetProgramiv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glGetProgramivARB", glGetProgramivARB, extensions->has_GL_ARB_fragment_program || extensions->has_GL_ARB_vertex_program }, + { "glGetProgramivNV", glGetProgramivNV, extensions->has_GL_NV_vertex_program }, + { "glGetQueryBufferObjecti64v", glGetQueryBufferObjecti64v, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glGetQueryBufferObjectiv", glGetQueryBufferObjectiv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glGetQueryBufferObjectui64v", glGetQueryBufferObjectui64v, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glGetQueryBufferObjectuiv", glGetQueryBufferObjectuiv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glGetQueryIndexediv", glGetQueryIndexediv, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_transform_feedback3 }, + { "glGetQueryObjecti64v", glGetQueryObjecti64v, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_timer_query }, + { "glGetQueryObjecti64vEXT", glGetQueryObjecti64vEXT, extensions->has_GL_EXT_timer_query }, + { "glGetQueryObjectiv", glGetQueryObjectiv, (major > 1 || (major == 1 && minor >= 5)) }, + { "glGetQueryObjectivARB", glGetQueryObjectivARB, extensions->has_GL_ARB_occlusion_query }, + { "glGetQueryObjectui64v", glGetQueryObjectui64v, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_timer_query }, + { "glGetQueryObjectui64vEXT", glGetQueryObjectui64vEXT, extensions->has_GL_EXT_timer_query }, + { "glGetQueryObjectuiv", glGetQueryObjectuiv, (major > 1 || (major == 1 && minor >= 5)) }, + { "glGetQueryObjectuivARB", glGetQueryObjectuivARB, extensions->has_GL_ARB_occlusion_query }, + { "glGetQueryiv", glGetQueryiv, (major > 1 || (major == 1 && minor >= 5)) }, + { "glGetQueryivARB", glGetQueryivARB, extensions->has_GL_ARB_occlusion_query }, + { "glGetRenderbufferParameteriv", glGetRenderbufferParameteriv, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_framebuffer_object }, + { "glGetRenderbufferParameterivEXT", glGetRenderbufferParameterivEXT, extensions->has_GL_EXT_framebuffer_object }, + { "glGetSamplerParameterIiv", glGetSamplerParameterIiv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_sampler_objects }, + { "glGetSamplerParameterIuiv", glGetSamplerParameterIuiv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_sampler_objects }, + { "glGetSamplerParameterfv", glGetSamplerParameterfv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_sampler_objects }, + { "glGetSamplerParameteriv", glGetSamplerParameteriv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_sampler_objects }, + { "glGetSemaphoreParameterivNV", glGetSemaphoreParameterivNV, extensions->has_GL_NV_timeline_semaphore }, + { "glGetSemaphoreParameterui64vEXT", glGetSemaphoreParameterui64vEXT, extensions->has_GL_EXT_semaphore }, + { "glGetSeparableFilter", glGetSeparableFilter, extensions->has_GL_ARB_imaging }, + { "glGetSeparableFilterEXT", glGetSeparableFilterEXT, extensions->has_GL_EXT_convolution }, + { "glGetShaderInfoLog", glGetShaderInfoLog, (major > 2 || (major == 2 && minor >= 0)) }, + { "glGetShaderPrecisionFormat", glGetShaderPrecisionFormat, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_ES2_compatibility }, + { "glGetShaderSource", glGetShaderSource, (major > 2 || (major == 2 && minor >= 0)) }, + { "glGetShaderSourceARB", glGetShaderSourceARB, extensions->has_GL_ARB_shader_objects }, + { "glGetShaderiv", glGetShaderiv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glGetShadingRateImagePaletteNV", glGetShadingRateImagePaletteNV, extensions->has_GL_NV_shading_rate_image }, + { "glGetShadingRateSampleLocationivNV", glGetShadingRateSampleLocationivNV, extensions->has_GL_NV_shading_rate_image }, + { "glGetSharpenTexFuncSGIS", glGetSharpenTexFuncSGIS, extensions->has_GL_SGIS_sharpen_texture }, + { "glGetStageIndexNV", glGetStageIndexNV, extensions->has_GL_NV_command_list }, + { "glGetStringi", glGetStringi, (major > 3 || (major == 3 && minor >= 0)) }, + { "glGetSubroutineIndex", glGetSubroutineIndex, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_shader_subroutine }, + { "glGetSubroutineUniformLocation", glGetSubroutineUniformLocation, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_shader_subroutine }, + { "glGetSynciv", glGetSynciv, (major > 3 || (major == 3 && minor >= 2)) || extensions->has_GL_ARB_sync }, + { "glGetTexBumpParameterfvATI", glGetTexBumpParameterfvATI, extensions->has_GL_ATI_envmap_bumpmap }, + { "glGetTexBumpParameterivATI", glGetTexBumpParameterivATI, extensions->has_GL_ATI_envmap_bumpmap }, + { "glGetTexEnvxv", glGetTexEnvxv, extensions->has_GL_NV_ES1_1_compatibility }, + { "glGetTexEnvxvOES", glGetTexEnvxvOES, extensions->has_GL_OES_fixed_point }, + { "glGetTexFilterFuncSGIS", glGetTexFilterFuncSGIS, extensions->has_GL_SGIS_texture_filter4 }, + { "glGetTexGenxvOES", glGetTexGenxvOES, extensions->has_GL_OES_fixed_point }, + { "glGetTexLevelParameterxvOES", glGetTexLevelParameterxvOES, extensions->has_GL_OES_fixed_point }, + { "glGetTexParameterIiv", glGetTexParameterIiv, (major > 3 || (major == 3 && minor >= 0)) }, + { "glGetTexParameterIivEXT", glGetTexParameterIivEXT, extensions->has_GL_EXT_texture_integer }, + { "glGetTexParameterIuiv", glGetTexParameterIuiv, (major > 3 || (major == 3 && minor >= 0)) }, + { "glGetTexParameterIuivEXT", glGetTexParameterIuivEXT, extensions->has_GL_EXT_texture_integer }, + { "glGetTexParameterPointervAPPLE", glGetTexParameterPointervAPPLE, extensions->has_GL_APPLE_texture_range }, + { "glGetTexParameterxv", glGetTexParameterxv, extensions->has_GL_NV_ES1_1_compatibility }, + { "glGetTexParameterxvOES", glGetTexParameterxvOES, extensions->has_GL_OES_fixed_point }, + { "glGetTextureHandleARB", glGetTextureHandleARB, extensions->has_GL_ARB_bindless_texture }, + { "glGetTextureHandleNV", glGetTextureHandleNV, extensions->has_GL_NV_bindless_texture }, + { "glGetTextureImage", glGetTextureImage, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glGetTextureImageEXT", glGetTextureImageEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetTextureLevelParameterfv", glGetTextureLevelParameterfv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glGetTextureLevelParameterfvEXT", glGetTextureLevelParameterfvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetTextureLevelParameteriv", glGetTextureLevelParameteriv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glGetTextureLevelParameterivEXT", glGetTextureLevelParameterivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetTextureParameterIiv", glGetTextureParameterIiv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glGetTextureParameterIivEXT", glGetTextureParameterIivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetTextureParameterIuiv", glGetTextureParameterIuiv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glGetTextureParameterIuivEXT", glGetTextureParameterIuivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetTextureParameterfv", glGetTextureParameterfv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glGetTextureParameterfvEXT", glGetTextureParameterfvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetTextureParameteriv", glGetTextureParameteriv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glGetTextureParameterivEXT", glGetTextureParameterivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetTextureSamplerHandleARB", glGetTextureSamplerHandleARB, extensions->has_GL_ARB_bindless_texture }, + { "glGetTextureSamplerHandleNV", glGetTextureSamplerHandleNV, extensions->has_GL_NV_bindless_texture }, + { "glGetTextureSubImage", glGetTextureSubImage, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_get_texture_sub_image }, + { "glGetTrackMatrixivNV", glGetTrackMatrixivNV, extensions->has_GL_NV_vertex_program }, + { "glGetTransformFeedbackVarying", glGetTransformFeedbackVarying, (major > 3 || (major == 3 && minor >= 0)) }, + { "glGetTransformFeedbackVaryingEXT", glGetTransformFeedbackVaryingEXT, extensions->has_GL_EXT_transform_feedback }, + { "glGetTransformFeedbackVaryingNV", glGetTransformFeedbackVaryingNV, extensions->has_GL_NV_transform_feedback }, + { "glGetTransformFeedbacki64_v", glGetTransformFeedbacki64_v, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glGetTransformFeedbacki_v", glGetTransformFeedbacki_v, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glGetTransformFeedbackiv", glGetTransformFeedbackiv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glGetUniformBlockIndex", glGetUniformBlockIndex, (major > 3 || (major == 3 && minor >= 1)) || extensions->has_GL_ARB_uniform_buffer_object }, + { "glGetUniformBufferSizeEXT", glGetUniformBufferSizeEXT, extensions->has_GL_EXT_bindable_uniform }, + { "glGetUniformIndices", glGetUniformIndices, (major > 3 || (major == 3 && minor >= 1)) || extensions->has_GL_ARB_uniform_buffer_object }, + { "glGetUniformLocation", glGetUniformLocation, (major > 2 || (major == 2 && minor >= 0)) }, + { "glGetUniformLocationARB", glGetUniformLocationARB, extensions->has_GL_ARB_shader_objects }, + { "glGetUniformOffsetEXT", glGetUniformOffsetEXT, extensions->has_GL_EXT_bindable_uniform }, + { "glGetUniformSubroutineuiv", glGetUniformSubroutineuiv, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_shader_subroutine }, + { "glGetUniformdv", glGetUniformdv, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_gpu_shader_fp64 }, + { "glGetUniformfv", glGetUniformfv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glGetUniformfvARB", glGetUniformfvARB, extensions->has_GL_ARB_shader_objects }, + { "glGetUniformi64vARB", glGetUniformi64vARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glGetUniformi64vNV", glGetUniformi64vNV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glGetUniformiv", glGetUniformiv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glGetUniformivARB", glGetUniformivARB, extensions->has_GL_ARB_shader_objects }, + { "glGetUniformui64vARB", glGetUniformui64vARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glGetUniformui64vNV", glGetUniformui64vNV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_shader_buffer_load }, + { "glGetUniformuiv", glGetUniformuiv, (major > 3 || (major == 3 && minor >= 0)) }, + { "glGetUniformuivEXT", glGetUniformuivEXT, extensions->has_GL_EXT_gpu_shader4 }, + { "glGetUnsignedBytei_vEXT", glGetUnsignedBytei_vEXT, extensions->has_GL_EXT_memory_object || extensions->has_GL_EXT_semaphore }, + { "glGetUnsignedBytevEXT", glGetUnsignedBytevEXT, extensions->has_GL_EXT_memory_object || extensions->has_GL_EXT_semaphore }, + { "glGetVariantArrayObjectfvATI", glGetVariantArrayObjectfvATI, extensions->has_GL_ATI_vertex_array_object }, + { "glGetVariantArrayObjectivATI", glGetVariantArrayObjectivATI, extensions->has_GL_ATI_vertex_array_object }, + { "glGetVariantBooleanvEXT", glGetVariantBooleanvEXT, extensions->has_GL_EXT_vertex_shader }, + { "glGetVariantFloatvEXT", glGetVariantFloatvEXT, extensions->has_GL_EXT_vertex_shader }, + { "glGetVariantIntegervEXT", glGetVariantIntegervEXT, extensions->has_GL_EXT_vertex_shader }, + { "glGetVariantPointervEXT", glGetVariantPointervEXT, extensions->has_GL_EXT_vertex_shader }, + { "glGetVaryingLocationNV", glGetVaryingLocationNV, extensions->has_GL_NV_transform_feedback }, + { "glGetVertexArrayIndexed64iv", glGetVertexArrayIndexed64iv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glGetVertexArrayIndexediv", glGetVertexArrayIndexediv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glGetVertexArrayIntegeri_vEXT", glGetVertexArrayIntegeri_vEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetVertexArrayIntegervEXT", glGetVertexArrayIntegervEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetVertexArrayPointeri_vEXT", glGetVertexArrayPointeri_vEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetVertexArrayPointervEXT", glGetVertexArrayPointervEXT, extensions->has_GL_EXT_direct_state_access }, + { "glGetVertexArrayiv", glGetVertexArrayiv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glGetVertexAttribArrayObjectfvATI", glGetVertexAttribArrayObjectfvATI, extensions->has_GL_ATI_vertex_attrib_array_object }, + { "glGetVertexAttribArrayObjectivATI", glGetVertexAttribArrayObjectivATI, extensions->has_GL_ATI_vertex_attrib_array_object }, + { "glGetVertexAttribIiv", glGetVertexAttribIiv, (major > 3 || (major == 3 && minor >= 0)) }, + { "glGetVertexAttribIivEXT", glGetVertexAttribIivEXT, extensions->has_GL_EXT_gpu_shader4 || extensions->has_GL_NV_vertex_program4 }, + { "glGetVertexAttribIuiv", glGetVertexAttribIuiv, (major > 3 || (major == 3 && minor >= 0)) }, + { "glGetVertexAttribIuivEXT", glGetVertexAttribIuivEXT, extensions->has_GL_EXT_gpu_shader4 || extensions->has_GL_NV_vertex_program4 }, + { "glGetVertexAttribLdv", glGetVertexAttribLdv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_vertex_attrib_64bit }, + { "glGetVertexAttribLdvEXT", glGetVertexAttribLdvEXT, extensions->has_GL_EXT_vertex_attrib_64bit }, + { "glGetVertexAttribLi64vNV", glGetVertexAttribLi64vNV, extensions->has_GL_NV_vertex_attrib_integer_64bit }, + { "glGetVertexAttribLui64vARB", glGetVertexAttribLui64vARB, extensions->has_GL_ARB_bindless_texture }, + { "glGetVertexAttribLui64vNV", glGetVertexAttribLui64vNV, extensions->has_GL_NV_vertex_attrib_integer_64bit }, + { "glGetVertexAttribPointerv", glGetVertexAttribPointerv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glGetVertexAttribPointervARB", glGetVertexAttribPointervARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glGetVertexAttribPointervNV", glGetVertexAttribPointervNV, extensions->has_GL_NV_vertex_program }, + { "glGetVertexAttribdv", glGetVertexAttribdv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glGetVertexAttribdvARB", glGetVertexAttribdvARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glGetVertexAttribdvNV", glGetVertexAttribdvNV, extensions->has_GL_NV_vertex_program }, + { "glGetVertexAttribfv", glGetVertexAttribfv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glGetVertexAttribfvARB", glGetVertexAttribfvARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glGetVertexAttribfvNV", glGetVertexAttribfvNV, extensions->has_GL_NV_vertex_program }, + { "glGetVertexAttribiv", glGetVertexAttribiv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glGetVertexAttribivARB", glGetVertexAttribivARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glGetVertexAttribivNV", glGetVertexAttribivNV, extensions->has_GL_NV_vertex_program }, + { "glGetVideoCaptureStreamdvNV", glGetVideoCaptureStreamdvNV, extensions->has_GL_NV_video_capture }, + { "glGetVideoCaptureStreamfvNV", glGetVideoCaptureStreamfvNV, extensions->has_GL_NV_video_capture }, + { "glGetVideoCaptureStreamivNV", glGetVideoCaptureStreamivNV, extensions->has_GL_NV_video_capture }, + { "glGetVideoCaptureivNV", glGetVideoCaptureivNV, extensions->has_GL_NV_video_capture }, + { "glGetVideoi64vNV", glGetVideoi64vNV, extensions->has_GL_NV_present_video }, + { "glGetVideoivNV", glGetVideoivNV, extensions->has_GL_NV_present_video }, + { "glGetVideoui64vNV", glGetVideoui64vNV, extensions->has_GL_NV_present_video }, + { "glGetVideouivNV", glGetVideouivNV, extensions->has_GL_NV_present_video }, + { "glGetVkProcAddrNV", glGetVkProcAddrNV, extensions->has_GL_NV_draw_vulkan_image }, + { "glGetnColorTable", glGetnColorTable, (major > 4 || (major == 4 && minor >= 5)) }, + { "glGetnColorTableARB", glGetnColorTableARB, extensions->has_GL_ARB_robustness }, + { "glGetnCompressedTexImage", glGetnCompressedTexImage, (major > 4 || (major == 4 && minor >= 5)) }, + { "glGetnCompressedTexImageARB", glGetnCompressedTexImageARB, extensions->has_GL_ARB_robustness }, + { "glGetnConvolutionFilter", glGetnConvolutionFilter, (major > 4 || (major == 4 && minor >= 5)) }, + { "glGetnConvolutionFilterARB", glGetnConvolutionFilterARB, extensions->has_GL_ARB_robustness }, + { "glGetnHistogram", glGetnHistogram, (major > 4 || (major == 4 && minor >= 5)) }, + { "glGetnHistogramARB", glGetnHistogramARB, extensions->has_GL_ARB_robustness }, + { "glGetnMapdv", glGetnMapdv, (major > 4 || (major == 4 && minor >= 5)) }, + { "glGetnMapdvARB", glGetnMapdvARB, extensions->has_GL_ARB_robustness }, + { "glGetnMapfv", glGetnMapfv, (major > 4 || (major == 4 && minor >= 5)) }, + { "glGetnMapfvARB", glGetnMapfvARB, extensions->has_GL_ARB_robustness }, + { "glGetnMapiv", glGetnMapiv, (major > 4 || (major == 4 && minor >= 5)) }, + { "glGetnMapivARB", glGetnMapivARB, extensions->has_GL_ARB_robustness }, + { "glGetnMinmax", glGetnMinmax, (major > 4 || (major == 4 && minor >= 5)) }, + { "glGetnMinmaxARB", glGetnMinmaxARB, extensions->has_GL_ARB_robustness }, + { "glGetnPixelMapfv", glGetnPixelMapfv, (major > 4 || (major == 4 && minor >= 5)) }, + { "glGetnPixelMapfvARB", glGetnPixelMapfvARB, extensions->has_GL_ARB_robustness }, + { "glGetnPixelMapuiv", glGetnPixelMapuiv, (major > 4 || (major == 4 && minor >= 5)) }, + { "glGetnPixelMapuivARB", glGetnPixelMapuivARB, extensions->has_GL_ARB_robustness }, + { "glGetnPixelMapusv", glGetnPixelMapusv, (major > 4 || (major == 4 && minor >= 5)) }, + { "glGetnPixelMapusvARB", glGetnPixelMapusvARB, extensions->has_GL_ARB_robustness }, + { "glGetnPolygonStipple", glGetnPolygonStipple, (major > 4 || (major == 4 && minor >= 5)) }, + { "glGetnPolygonStippleARB", glGetnPolygonStippleARB, extensions->has_GL_ARB_robustness }, + { "glGetnSeparableFilter", glGetnSeparableFilter, (major > 4 || (major == 4 && minor >= 5)) }, + { "glGetnSeparableFilterARB", glGetnSeparableFilterARB, extensions->has_GL_ARB_robustness }, + { "glGetnTexImage", glGetnTexImage, (major > 4 || (major == 4 && minor >= 5)) }, + { "glGetnTexImageARB", glGetnTexImageARB, extensions->has_GL_ARB_robustness }, + { "glGetnUniformdv", glGetnUniformdv, (major > 4 || (major == 4 && minor >= 5)) }, + { "glGetnUniformdvARB", glGetnUniformdvARB, extensions->has_GL_ARB_robustness }, + { "glGetnUniformfv", glGetnUniformfv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_KHR_robustness }, + { "glGetnUniformfvARB", glGetnUniformfvARB, extensions->has_GL_ARB_robustness }, + { "glGetnUniformi64vARB", glGetnUniformi64vARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glGetnUniformiv", glGetnUniformiv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_KHR_robustness }, + { "glGetnUniformivARB", glGetnUniformivARB, extensions->has_GL_ARB_robustness }, + { "glGetnUniformui64vARB", glGetnUniformui64vARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glGetnUniformuiv", glGetnUniformuiv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_KHR_robustness }, + { "glGetnUniformuivARB", glGetnUniformuivARB, extensions->has_GL_ARB_robustness }, + { "glGlobalAlphaFactorbSUN", glGlobalAlphaFactorbSUN, extensions->has_GL_SUN_global_alpha }, + { "glGlobalAlphaFactordSUN", glGlobalAlphaFactordSUN, extensions->has_GL_SUN_global_alpha }, + { "glGlobalAlphaFactorfSUN", glGlobalAlphaFactorfSUN, extensions->has_GL_SUN_global_alpha }, + { "glGlobalAlphaFactoriSUN", glGlobalAlphaFactoriSUN, extensions->has_GL_SUN_global_alpha }, + { "glGlobalAlphaFactorsSUN", glGlobalAlphaFactorsSUN, extensions->has_GL_SUN_global_alpha }, + { "glGlobalAlphaFactorubSUN", glGlobalAlphaFactorubSUN, extensions->has_GL_SUN_global_alpha }, + { "glGlobalAlphaFactoruiSUN", glGlobalAlphaFactoruiSUN, extensions->has_GL_SUN_global_alpha }, + { "glGlobalAlphaFactorusSUN", glGlobalAlphaFactorusSUN, extensions->has_GL_SUN_global_alpha }, + { "glHintPGI", glHintPGI, extensions->has_GL_PGI_misc_hints }, + { "glHistogram", glHistogram, extensions->has_GL_ARB_imaging }, + { "glHistogramEXT", glHistogramEXT, extensions->has_GL_EXT_histogram }, + { "glIglooInterfaceSGIX", glIglooInterfaceSGIX, extensions->has_GL_SGIX_igloo_interface }, + { "glImageTransformParameterfHP", glImageTransformParameterfHP, extensions->has_GL_HP_image_transform }, + { "glImageTransformParameterfvHP", glImageTransformParameterfvHP, extensions->has_GL_HP_image_transform }, + { "glImageTransformParameteriHP", glImageTransformParameteriHP, extensions->has_GL_HP_image_transform }, + { "glImageTransformParameterivHP", glImageTransformParameterivHP, extensions->has_GL_HP_image_transform }, + { "glImportMemoryWin32HandleEXT", glImportMemoryWin32HandleEXT, extensions->has_GL_EXT_memory_object_win32 }, + { "glImportMemoryWin32NameEXT", glImportMemoryWin32NameEXT, extensions->has_GL_EXT_memory_object_win32 }, + { "glImportSemaphoreWin32HandleEXT", glImportSemaphoreWin32HandleEXT, extensions->has_GL_EXT_semaphore_win32 }, + { "glImportSemaphoreWin32NameEXT", glImportSemaphoreWin32NameEXT, extensions->has_GL_EXT_semaphore_win32 }, + { "glImportSyncEXT", glImportSyncEXT, extensions->has_GL_EXT_x11_sync_object }, + { "glIndexFormatNV", glIndexFormatNV, extensions->has_GL_NV_vertex_buffer_unified_memory }, + { "glIndexFuncEXT", glIndexFuncEXT, extensions->has_GL_EXT_index_func }, + { "glIndexMaterialEXT", glIndexMaterialEXT, extensions->has_GL_EXT_index_material }, + { "glIndexPointerEXT", glIndexPointerEXT, extensions->has_GL_EXT_vertex_array }, + { "glIndexPointerListIBM", glIndexPointerListIBM, extensions->has_GL_IBM_vertex_array_lists }, + { "glIndexxOES", glIndexxOES, extensions->has_GL_OES_fixed_point }, + { "glIndexxvOES", glIndexxvOES, extensions->has_GL_OES_fixed_point }, + { "glInsertComponentEXT", glInsertComponentEXT, extensions->has_GL_EXT_vertex_shader }, + { "glInsertEventMarkerEXT", glInsertEventMarkerEXT, extensions->has_GL_EXT_debug_marker }, + { "glInstrumentsBufferSGIX", glInstrumentsBufferSGIX, extensions->has_GL_SGIX_instruments }, + { "glInterpolatePathsNV", glInterpolatePathsNV, extensions->has_GL_NV_path_rendering }, + { "glInvalidateBufferData", glInvalidateBufferData, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_invalidate_subdata }, + { "glInvalidateBufferSubData", glInvalidateBufferSubData, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_invalidate_subdata }, + { "glInvalidateFramebuffer", glInvalidateFramebuffer, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_invalidate_subdata }, + { "glInvalidateNamedFramebufferData", glInvalidateNamedFramebufferData, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glInvalidateNamedFramebufferSubData", glInvalidateNamedFramebufferSubData, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glInvalidateSubFramebuffer", glInvalidateSubFramebuffer, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_invalidate_subdata }, + { "glInvalidateTexImage", glInvalidateTexImage, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_invalidate_subdata }, + { "glInvalidateTexSubImage", glInvalidateTexSubImage, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_invalidate_subdata }, + { "glIsAsyncMarkerSGIX", glIsAsyncMarkerSGIX, extensions->has_GL_SGIX_async }, + { "glIsBuffer", glIsBuffer, (major > 1 || (major == 1 && minor >= 5)) }, + { "glIsBufferARB", glIsBufferARB, extensions->has_GL_ARB_vertex_buffer_object }, + { "glIsBufferResidentNV", glIsBufferResidentNV, extensions->has_GL_NV_shader_buffer_load }, + { "glIsCommandListNV", glIsCommandListNV, extensions->has_GL_NV_command_list }, + { "glIsEnabledIndexedEXT", glIsEnabledIndexedEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_EXT_draw_buffers2 }, + { "glIsEnabledi", glIsEnabledi, (major > 3 || (major == 3 && minor >= 0)) }, + { "glIsFenceAPPLE", glIsFenceAPPLE, extensions->has_GL_APPLE_fence }, + { "glIsFenceNV", glIsFenceNV, extensions->has_GL_NV_fence }, + { "glIsFramebuffer", glIsFramebuffer, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_framebuffer_object }, + { "glIsFramebufferEXT", glIsFramebufferEXT, extensions->has_GL_EXT_framebuffer_object }, + { "glIsImageHandleResidentARB", glIsImageHandleResidentARB, extensions->has_GL_ARB_bindless_texture }, + { "glIsImageHandleResidentNV", glIsImageHandleResidentNV, extensions->has_GL_NV_bindless_texture }, + { "glIsMemoryObjectEXT", glIsMemoryObjectEXT, extensions->has_GL_EXT_memory_object }, + { "glIsNameAMD", glIsNameAMD, extensions->has_GL_AMD_name_gen_delete }, + { "glIsNamedBufferResidentNV", glIsNamedBufferResidentNV, extensions->has_GL_NV_shader_buffer_load }, + { "glIsNamedStringARB", glIsNamedStringARB, extensions->has_GL_ARB_shading_language_include }, + { "glIsObjectBufferATI", glIsObjectBufferATI, extensions->has_GL_ATI_vertex_array_object }, + { "glIsOcclusionQueryNV", glIsOcclusionQueryNV, extensions->has_GL_NV_occlusion_query }, + { "glIsPathNV", glIsPathNV, extensions->has_GL_NV_path_rendering }, + { "glIsPointInFillPathNV", glIsPointInFillPathNV, extensions->has_GL_NV_path_rendering }, + { "glIsPointInStrokePathNV", glIsPointInStrokePathNV, extensions->has_GL_NV_path_rendering }, + { "glIsProgram", glIsProgram, (major > 2 || (major == 2 && minor >= 0)) }, + { "glIsProgramARB", glIsProgramARB, extensions->has_GL_ARB_fragment_program || extensions->has_GL_ARB_vertex_program }, + { "glIsProgramNV", glIsProgramNV, extensions->has_GL_NV_vertex_program }, + { "glIsProgramPipeline", glIsProgramPipeline, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glIsQuery", glIsQuery, (major > 1 || (major == 1 && minor >= 5)) }, + { "glIsQueryARB", glIsQueryARB, extensions->has_GL_ARB_occlusion_query }, + { "glIsRenderbuffer", glIsRenderbuffer, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_framebuffer_object }, + { "glIsRenderbufferEXT", glIsRenderbufferEXT, extensions->has_GL_EXT_framebuffer_object }, + { "glIsSampler", glIsSampler, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_sampler_objects }, + { "glIsSemaphoreEXT", glIsSemaphoreEXT, extensions->has_GL_EXT_semaphore }, + { "glIsShader", glIsShader, (major > 2 || (major == 2 && minor >= 0)) }, + { "glIsStateNV", glIsStateNV, extensions->has_GL_NV_command_list }, + { "glIsSync", glIsSync, (major > 3 || (major == 3 && minor >= 2)) || extensions->has_GL_ARB_sync }, + { "glIsTextureEXT", glIsTextureEXT, extensions->has_GL_EXT_texture_object }, + { "glIsTextureHandleResidentARB", glIsTextureHandleResidentARB, extensions->has_GL_ARB_bindless_texture }, + { "glIsTextureHandleResidentNV", glIsTextureHandleResidentNV, extensions->has_GL_NV_bindless_texture }, + { "glIsTransformFeedback", glIsTransformFeedback, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_transform_feedback2 }, + { "glIsTransformFeedbackNV", glIsTransformFeedbackNV, extensions->has_GL_NV_transform_feedback2 }, + { "glIsVariantEnabledEXT", glIsVariantEnabledEXT, extensions->has_GL_EXT_vertex_shader }, + { "glIsVertexArray", glIsVertexArray, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_vertex_array_object }, + { "glIsVertexArrayAPPLE", glIsVertexArrayAPPLE, extensions->has_GL_APPLE_vertex_array_object }, + { "glIsVertexAttribEnabledAPPLE", glIsVertexAttribEnabledAPPLE, extensions->has_GL_APPLE_vertex_program_evaluators }, + { "glLGPUCopyImageSubDataNVX", glLGPUCopyImageSubDataNVX, extensions->has_GL_NVX_linked_gpu_multicast }, + { "glLGPUInterlockNVX", glLGPUInterlockNVX, extensions->has_GL_NVX_linked_gpu_multicast }, + { "glLGPUNamedBufferSubDataNVX", glLGPUNamedBufferSubDataNVX, extensions->has_GL_NVX_linked_gpu_multicast }, + { "glLabelObjectEXT", glLabelObjectEXT, extensions->has_GL_EXT_debug_label }, + { "glLightEnviSGIX", glLightEnviSGIX, extensions->has_GL_SGIX_fragment_lighting }, + { "glLightModelx", glLightModelx, extensions->has_GL_NV_ES1_1_compatibility }, + { "glLightModelxOES", glLightModelxOES, extensions->has_GL_OES_fixed_point }, + { "glLightModelxv", glLightModelxv, extensions->has_GL_NV_ES1_1_compatibility }, + { "glLightModelxvOES", glLightModelxvOES, extensions->has_GL_OES_fixed_point }, + { "glLightx", glLightx, extensions->has_GL_NV_ES1_1_compatibility }, + { "glLightxOES", glLightxOES, extensions->has_GL_OES_fixed_point }, + { "glLightxv", glLightxv, extensions->has_GL_NV_ES1_1_compatibility }, + { "glLightxvOES", glLightxvOES, extensions->has_GL_OES_fixed_point }, + { "glLineWidthx", glLineWidthx, extensions->has_GL_NV_ES1_1_compatibility }, + { "glLineWidthxOES", glLineWidthxOES, extensions->has_GL_OES_fixed_point }, + { "glLinkProgram", glLinkProgram, (major > 2 || (major == 2 && minor >= 0)) }, + { "glLinkProgramARB", glLinkProgramARB, extensions->has_GL_ARB_shader_objects }, + { "glListDrawCommandsStatesClientNV", glListDrawCommandsStatesClientNV, extensions->has_GL_NV_command_list }, + { "glListParameterfSGIX", glListParameterfSGIX, extensions->has_GL_SGIX_list_priority }, + { "glListParameterfvSGIX", glListParameterfvSGIX, extensions->has_GL_SGIX_list_priority }, + { "glListParameteriSGIX", glListParameteriSGIX, extensions->has_GL_SGIX_list_priority }, + { "glListParameterivSGIX", glListParameterivSGIX, extensions->has_GL_SGIX_list_priority }, + { "glLoadIdentityDeformationMapSGIX", glLoadIdentityDeformationMapSGIX, extensions->has_GL_SGIX_polynomial_ffd }, + { "glLoadMatrixx", glLoadMatrixx, extensions->has_GL_NV_ES1_1_compatibility }, + { "glLoadMatrixxOES", glLoadMatrixxOES, extensions->has_GL_OES_fixed_point }, + { "glLoadProgramNV", glLoadProgramNV, extensions->has_GL_NV_vertex_program }, + { "glLoadTransposeMatrixd", glLoadTransposeMatrixd, (major > 1 || (major == 1 && minor >= 3)) }, + { "glLoadTransposeMatrixdARB", glLoadTransposeMatrixdARB, extensions->has_GL_ARB_transpose_matrix }, + { "glLoadTransposeMatrixf", glLoadTransposeMatrixf, (major > 1 || (major == 1 && minor >= 3)) }, + { "glLoadTransposeMatrixfARB", glLoadTransposeMatrixfARB, extensions->has_GL_ARB_transpose_matrix }, + { "glLoadTransposeMatrixxOES", glLoadTransposeMatrixxOES, extensions->has_GL_OES_fixed_point }, + { "glLockArraysEXT", glLockArraysEXT, extensions->has_GL_EXT_compiled_vertex_array }, + { "glMTexCoord2fSGIS", glMTexCoord2fSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMTexCoord2fvSGIS", glMTexCoord2fvSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMakeBufferNonResidentNV", glMakeBufferNonResidentNV, extensions->has_GL_NV_shader_buffer_load }, + { "glMakeBufferResidentNV", glMakeBufferResidentNV, extensions->has_GL_NV_shader_buffer_load }, + { "glMakeImageHandleNonResidentARB", glMakeImageHandleNonResidentARB, extensions->has_GL_ARB_bindless_texture }, + { "glMakeImageHandleNonResidentNV", glMakeImageHandleNonResidentNV, extensions->has_GL_NV_bindless_texture }, + { "glMakeImageHandleResidentARB", glMakeImageHandleResidentARB, extensions->has_GL_ARB_bindless_texture }, + { "glMakeImageHandleResidentNV", glMakeImageHandleResidentNV, extensions->has_GL_NV_bindless_texture }, + { "glMakeNamedBufferNonResidentNV", glMakeNamedBufferNonResidentNV, extensions->has_GL_NV_shader_buffer_load }, + { "glMakeNamedBufferResidentNV", glMakeNamedBufferResidentNV, extensions->has_GL_NV_shader_buffer_load }, + { "glMakeTextureHandleNonResidentARB", glMakeTextureHandleNonResidentARB, extensions->has_GL_ARB_bindless_texture }, + { "glMakeTextureHandleNonResidentNV", glMakeTextureHandleNonResidentNV, extensions->has_GL_NV_bindless_texture }, + { "glMakeTextureHandleResidentARB", glMakeTextureHandleResidentARB, extensions->has_GL_ARB_bindless_texture }, + { "glMakeTextureHandleResidentNV", glMakeTextureHandleResidentNV, extensions->has_GL_NV_bindless_texture }, + { "glMap1xOES", glMap1xOES, extensions->has_GL_OES_fixed_point }, + { "glMap2xOES", glMap2xOES, extensions->has_GL_OES_fixed_point }, + { "glMapBuffer", glMapBuffer, (major > 1 || (major == 1 && minor >= 5)) }, + { "glMapBufferARB", glMapBufferARB, extensions->has_GL_ARB_vertex_buffer_object }, + { "glMapBufferRange", glMapBufferRange, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_map_buffer_range }, + { "glMapControlPointsNV", glMapControlPointsNV, extensions->has_GL_NV_evaluators }, + { "glMapGrid1xOES", glMapGrid1xOES, extensions->has_GL_OES_fixed_point }, + { "glMapGrid2xOES", glMapGrid2xOES, extensions->has_GL_OES_fixed_point }, + { "glMapNamedBuffer", glMapNamedBuffer, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glMapNamedBufferEXT", glMapNamedBufferEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMapNamedBufferRange", glMapNamedBufferRange, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glMapNamedBufferRangeEXT", glMapNamedBufferRangeEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMapObjectBufferATI", glMapObjectBufferATI, extensions->has_GL_ATI_map_object_buffer }, + { "glMapParameterfvNV", glMapParameterfvNV, extensions->has_GL_NV_evaluators }, + { "glMapParameterivNV", glMapParameterivNV, extensions->has_GL_NV_evaluators }, + { "glMapTexture2DINTEL", glMapTexture2DINTEL, extensions->has_GL_INTEL_map_texture }, + { "glMapVertexAttrib1dAPPLE", glMapVertexAttrib1dAPPLE, extensions->has_GL_APPLE_vertex_program_evaluators }, + { "glMapVertexAttrib1fAPPLE", glMapVertexAttrib1fAPPLE, extensions->has_GL_APPLE_vertex_program_evaluators }, + { "glMapVertexAttrib2dAPPLE", glMapVertexAttrib2dAPPLE, extensions->has_GL_APPLE_vertex_program_evaluators }, + { "glMapVertexAttrib2fAPPLE", glMapVertexAttrib2fAPPLE, extensions->has_GL_APPLE_vertex_program_evaluators }, + { "glMaterialx", glMaterialx, extensions->has_GL_NV_ES1_1_compatibility }, + { "glMaterialxOES", glMaterialxOES, extensions->has_GL_OES_fixed_point }, + { "glMaterialxv", glMaterialxv, extensions->has_GL_NV_ES1_1_compatibility }, + { "glMaterialxvOES", glMaterialxvOES, extensions->has_GL_OES_fixed_point }, + { "glMatrixFrustumEXT", glMatrixFrustumEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_NV_path_rendering }, + { "glMatrixIndexPointerARB", glMatrixIndexPointerARB, extensions->has_GL_ARB_matrix_palette }, + { "glMatrixIndexubvARB", glMatrixIndexubvARB, extensions->has_GL_ARB_matrix_palette }, + { "glMatrixIndexuivARB", glMatrixIndexuivARB, extensions->has_GL_ARB_matrix_palette }, + { "glMatrixIndexusvARB", glMatrixIndexusvARB, extensions->has_GL_ARB_matrix_palette }, + { "glMatrixLoad3x2fNV", glMatrixLoad3x2fNV, extensions->has_GL_NV_path_rendering }, + { "glMatrixLoad3x3fNV", glMatrixLoad3x3fNV, extensions->has_GL_NV_path_rendering }, + { "glMatrixLoadIdentityEXT", glMatrixLoadIdentityEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_NV_path_rendering }, + { "glMatrixLoadTranspose3x3fNV", glMatrixLoadTranspose3x3fNV, extensions->has_GL_NV_path_rendering }, + { "glMatrixLoadTransposedEXT", glMatrixLoadTransposedEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_NV_path_rendering }, + { "glMatrixLoadTransposefEXT", glMatrixLoadTransposefEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_NV_path_rendering }, + { "glMatrixLoaddEXT", glMatrixLoaddEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_NV_path_rendering }, + { "glMatrixLoadfEXT", glMatrixLoadfEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_NV_path_rendering }, + { "glMatrixMult3x2fNV", glMatrixMult3x2fNV, extensions->has_GL_NV_path_rendering }, + { "glMatrixMult3x3fNV", glMatrixMult3x3fNV, extensions->has_GL_NV_path_rendering }, + { "glMatrixMultTranspose3x3fNV", glMatrixMultTranspose3x3fNV, extensions->has_GL_NV_path_rendering }, + { "glMatrixMultTransposedEXT", glMatrixMultTransposedEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_NV_path_rendering }, + { "glMatrixMultTransposefEXT", glMatrixMultTransposefEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_NV_path_rendering }, + { "glMatrixMultdEXT", glMatrixMultdEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_NV_path_rendering }, + { "glMatrixMultfEXT", glMatrixMultfEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_NV_path_rendering }, + { "glMatrixOrthoEXT", glMatrixOrthoEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_NV_path_rendering }, + { "glMatrixPopEXT", glMatrixPopEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_NV_path_rendering }, + { "glMatrixPushEXT", glMatrixPushEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_NV_path_rendering }, + { "glMatrixRotatedEXT", glMatrixRotatedEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_NV_path_rendering }, + { "glMatrixRotatefEXT", glMatrixRotatefEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_NV_path_rendering }, + { "glMatrixScaledEXT", glMatrixScaledEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_NV_path_rendering }, + { "glMatrixScalefEXT", glMatrixScalefEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_NV_path_rendering }, + { "glMatrixTranslatedEXT", glMatrixTranslatedEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_NV_path_rendering }, + { "glMatrixTranslatefEXT", glMatrixTranslatefEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_NV_path_rendering }, + { "glMaxShaderCompilerThreadsARB", glMaxShaderCompilerThreadsARB, extensions->has_GL_ARB_parallel_shader_compile }, + { "glMaxShaderCompilerThreadsKHR", glMaxShaderCompilerThreadsKHR, extensions->has_GL_KHR_parallel_shader_compile }, + { "glMemoryBarrier", glMemoryBarrier, (major > 4 || (major == 4 && minor >= 2)) || extensions->has_GL_ARB_shader_image_load_store }, + { "glMemoryBarrierByRegion", glMemoryBarrierByRegion, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_ES3_1_compatibility || extensions->has_GL_NV_ES3_1_compatibility }, + { "glMemoryBarrierEXT", glMemoryBarrierEXT, extensions->has_GL_EXT_shader_image_load_store }, + { "glMemoryObjectParameterivEXT", glMemoryObjectParameterivEXT, extensions->has_GL_EXT_memory_object }, + { "glMinSampleShading", glMinSampleShading, (major > 4 || (major == 4 && minor >= 0)) }, + { "glMinSampleShadingARB", glMinSampleShadingARB, extensions->has_GL_ARB_sample_shading }, + { "glMinmax", glMinmax, extensions->has_GL_ARB_imaging }, + { "glMinmaxEXT", glMinmaxEXT, extensions->has_GL_EXT_histogram }, + { "glMultMatrixx", glMultMatrixx, extensions->has_GL_NV_ES1_1_compatibility }, + { "glMultMatrixxOES", glMultMatrixxOES, extensions->has_GL_OES_fixed_point }, + { "glMultTransposeMatrixd", glMultTransposeMatrixd, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultTransposeMatrixdARB", glMultTransposeMatrixdARB, extensions->has_GL_ARB_transpose_matrix }, + { "glMultTransposeMatrixf", glMultTransposeMatrixf, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultTransposeMatrixfARB", glMultTransposeMatrixfARB, extensions->has_GL_ARB_transpose_matrix }, + { "glMultTransposeMatrixxOES", glMultTransposeMatrixxOES, extensions->has_GL_OES_fixed_point }, + { "glMultiDrawArrays", glMultiDrawArrays, (major > 1 || (major == 1 && minor >= 4)) }, + { "glMultiDrawArraysEXT", glMultiDrawArraysEXT, extensions->has_GL_EXT_multi_draw_arrays || extensions->has_GL_SUN_multi_draw_arrays }, + { "glMultiDrawArraysIndirect", glMultiDrawArraysIndirect, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_multi_draw_indirect }, + { "glMultiDrawArraysIndirectAMD", glMultiDrawArraysIndirectAMD, extensions->has_GL_AMD_multi_draw_indirect }, + { "glMultiDrawArraysIndirectBindlessCountNV", glMultiDrawArraysIndirectBindlessCountNV, extensions->has_GL_NV_bindless_multi_draw_indirect_count }, + { "glMultiDrawArraysIndirectBindlessNV", glMultiDrawArraysIndirectBindlessNV, extensions->has_GL_NV_bindless_multi_draw_indirect }, + { "glMultiDrawArraysIndirectCount", glMultiDrawArraysIndirectCount, (major > 4 || (major == 4 && minor >= 6)) }, + { "glMultiDrawArraysIndirectCountARB", glMultiDrawArraysIndirectCountARB, extensions->has_GL_ARB_indirect_parameters }, + { "glMultiDrawElementArrayAPPLE", glMultiDrawElementArrayAPPLE, extensions->has_GL_APPLE_element_array }, + { "glMultiDrawElements", glMultiDrawElements, (major > 1 || (major == 1 && minor >= 4)) }, + { "glMultiDrawElementsBaseVertex", glMultiDrawElementsBaseVertex, (major > 3 || (major == 3 && minor >= 2)) || extensions->has_GL_ARB_draw_elements_base_vertex }, + { "glMultiDrawElementsEXT", glMultiDrawElementsEXT, extensions->has_GL_EXT_multi_draw_arrays || extensions->has_GL_SUN_multi_draw_arrays }, + { "glMultiDrawElementsIndirect", glMultiDrawElementsIndirect, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_multi_draw_indirect }, + { "glMultiDrawElementsIndirectAMD", glMultiDrawElementsIndirectAMD, extensions->has_GL_AMD_multi_draw_indirect }, + { "glMultiDrawElementsIndirectBindlessCountNV", glMultiDrawElementsIndirectBindlessCountNV, extensions->has_GL_NV_bindless_multi_draw_indirect_count }, + { "glMultiDrawElementsIndirectBindlessNV", glMultiDrawElementsIndirectBindlessNV, extensions->has_GL_NV_bindless_multi_draw_indirect }, + { "glMultiDrawElementsIndirectCount", glMultiDrawElementsIndirectCount, (major > 4 || (major == 4 && minor >= 6)) }, + { "glMultiDrawElementsIndirectCountARB", glMultiDrawElementsIndirectCountARB, extensions->has_GL_ARB_indirect_parameters }, + { "glMultiDrawMeshTasksIndirectCountEXT", glMultiDrawMeshTasksIndirectCountEXT, extensions->has_GL_EXT_mesh_shader }, + { "glMultiDrawMeshTasksIndirectCountNV", glMultiDrawMeshTasksIndirectCountNV, extensions->has_GL_NV_mesh_shader }, + { "glMultiDrawMeshTasksIndirectEXT", glMultiDrawMeshTasksIndirectEXT, extensions->has_GL_EXT_mesh_shader }, + { "glMultiDrawMeshTasksIndirectNV", glMultiDrawMeshTasksIndirectNV, extensions->has_GL_NV_mesh_shader }, + { "glMultiDrawRangeElementArrayAPPLE", glMultiDrawRangeElementArrayAPPLE, extensions->has_GL_APPLE_element_array }, + { "glMultiModeDrawArraysIBM", glMultiModeDrawArraysIBM, extensions->has_GL_IBM_multimode_draw_arrays }, + { "glMultiModeDrawElementsIBM", glMultiModeDrawElementsIBM, extensions->has_GL_IBM_multimode_draw_arrays }, + { "glMultiTexBufferEXT", glMultiTexBufferEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMultiTexCoord1bOES", glMultiTexCoord1bOES, extensions->has_GL_OES_byte_coordinates }, + { "glMultiTexCoord1bvOES", glMultiTexCoord1bvOES, extensions->has_GL_OES_byte_coordinates }, + { "glMultiTexCoord1d", glMultiTexCoord1d, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord1dARB", glMultiTexCoord1dARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord1dSGIS", glMultiTexCoord1dSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord1dv", glMultiTexCoord1dv, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord1dvARB", glMultiTexCoord1dvARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord1dvSGIS", glMultiTexCoord1dvSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord1f", glMultiTexCoord1f, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord1fARB", glMultiTexCoord1fARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord1fSGIS", glMultiTexCoord1fSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord1fv", glMultiTexCoord1fv, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord1fvARB", glMultiTexCoord1fvARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord1fvSGIS", glMultiTexCoord1fvSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord1hNV", glMultiTexCoord1hNV, extensions->has_GL_NV_half_float }, + { "glMultiTexCoord1hvNV", glMultiTexCoord1hvNV, extensions->has_GL_NV_half_float }, + { "glMultiTexCoord1i", glMultiTexCoord1i, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord1iARB", glMultiTexCoord1iARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord1iSGIS", glMultiTexCoord1iSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord1iv", glMultiTexCoord1iv, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord1ivARB", glMultiTexCoord1ivARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord1ivSGIS", glMultiTexCoord1ivSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord1s", glMultiTexCoord1s, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord1sARB", glMultiTexCoord1sARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord1sSGIS", glMultiTexCoord1sSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord1sv", glMultiTexCoord1sv, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord1svARB", glMultiTexCoord1svARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord1svSGIS", glMultiTexCoord1svSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord1xOES", glMultiTexCoord1xOES, extensions->has_GL_OES_fixed_point }, + { "glMultiTexCoord1xvOES", glMultiTexCoord1xvOES, extensions->has_GL_OES_fixed_point }, + { "glMultiTexCoord2bOES", glMultiTexCoord2bOES, extensions->has_GL_OES_byte_coordinates }, + { "glMultiTexCoord2bvOES", glMultiTexCoord2bvOES, extensions->has_GL_OES_byte_coordinates }, + { "glMultiTexCoord2d", glMultiTexCoord2d, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord2dARB", glMultiTexCoord2dARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord2dSGIS", glMultiTexCoord2dSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord2dv", glMultiTexCoord2dv, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord2dvARB", glMultiTexCoord2dvARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord2dvSGIS", glMultiTexCoord2dvSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord2f", glMultiTexCoord2f, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord2fARB", glMultiTexCoord2fARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord2fSGIS", glMultiTexCoord2fSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord2fv", glMultiTexCoord2fv, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord2fvARB", glMultiTexCoord2fvARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord2fvSGIS", glMultiTexCoord2fvSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord2hNV", glMultiTexCoord2hNV, extensions->has_GL_NV_half_float }, + { "glMultiTexCoord2hvNV", glMultiTexCoord2hvNV, extensions->has_GL_NV_half_float }, + { "glMultiTexCoord2i", glMultiTexCoord2i, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord2iARB", glMultiTexCoord2iARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord2iSGIS", glMultiTexCoord2iSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord2iv", glMultiTexCoord2iv, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord2ivARB", glMultiTexCoord2ivARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord2ivSGIS", glMultiTexCoord2ivSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord2s", glMultiTexCoord2s, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord2sARB", glMultiTexCoord2sARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord2sSGIS", glMultiTexCoord2sSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord2sv", glMultiTexCoord2sv, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord2svARB", glMultiTexCoord2svARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord2svSGIS", glMultiTexCoord2svSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord2xOES", glMultiTexCoord2xOES, extensions->has_GL_OES_fixed_point }, + { "glMultiTexCoord2xvOES", glMultiTexCoord2xvOES, extensions->has_GL_OES_fixed_point }, + { "glMultiTexCoord3bOES", glMultiTexCoord3bOES, extensions->has_GL_OES_byte_coordinates }, + { "glMultiTexCoord3bvOES", glMultiTexCoord3bvOES, extensions->has_GL_OES_byte_coordinates }, + { "glMultiTexCoord3d", glMultiTexCoord3d, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord3dARB", glMultiTexCoord3dARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord3dSGIS", glMultiTexCoord3dSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord3dv", glMultiTexCoord3dv, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord3dvARB", glMultiTexCoord3dvARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord3dvSGIS", glMultiTexCoord3dvSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord3f", glMultiTexCoord3f, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord3fARB", glMultiTexCoord3fARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord3fSGIS", glMultiTexCoord3fSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord3fv", glMultiTexCoord3fv, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord3fvARB", glMultiTexCoord3fvARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord3fvSGIS", glMultiTexCoord3fvSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord3hNV", glMultiTexCoord3hNV, extensions->has_GL_NV_half_float }, + { "glMultiTexCoord3hvNV", glMultiTexCoord3hvNV, extensions->has_GL_NV_half_float }, + { "glMultiTexCoord3i", glMultiTexCoord3i, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord3iARB", glMultiTexCoord3iARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord3iSGIS", glMultiTexCoord3iSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord3iv", glMultiTexCoord3iv, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord3ivARB", glMultiTexCoord3ivARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord3ivSGIS", glMultiTexCoord3ivSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord3s", glMultiTexCoord3s, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord3sARB", glMultiTexCoord3sARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord3sSGIS", glMultiTexCoord3sSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord3sv", glMultiTexCoord3sv, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord3svARB", glMultiTexCoord3svARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord3svSGIS", glMultiTexCoord3svSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord3xOES", glMultiTexCoord3xOES, extensions->has_GL_OES_fixed_point }, + { "glMultiTexCoord3xvOES", glMultiTexCoord3xvOES, extensions->has_GL_OES_fixed_point }, + { "glMultiTexCoord4bOES", glMultiTexCoord4bOES, extensions->has_GL_OES_byte_coordinates }, + { "glMultiTexCoord4bvOES", glMultiTexCoord4bvOES, extensions->has_GL_OES_byte_coordinates }, + { "glMultiTexCoord4d", glMultiTexCoord4d, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord4dARB", glMultiTexCoord4dARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord4dSGIS", glMultiTexCoord4dSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord4dv", glMultiTexCoord4dv, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord4dvARB", glMultiTexCoord4dvARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord4dvSGIS", glMultiTexCoord4dvSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord4f", glMultiTexCoord4f, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord4fARB", glMultiTexCoord4fARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord4fSGIS", glMultiTexCoord4fSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord4fv", glMultiTexCoord4fv, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord4fvARB", glMultiTexCoord4fvARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord4fvSGIS", glMultiTexCoord4fvSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord4hNV", glMultiTexCoord4hNV, extensions->has_GL_NV_half_float }, + { "glMultiTexCoord4hvNV", glMultiTexCoord4hvNV, extensions->has_GL_NV_half_float }, + { "glMultiTexCoord4i", glMultiTexCoord4i, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord4iARB", glMultiTexCoord4iARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord4iSGIS", glMultiTexCoord4iSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord4iv", glMultiTexCoord4iv, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord4ivARB", glMultiTexCoord4ivARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord4ivSGIS", glMultiTexCoord4ivSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord4s", glMultiTexCoord4s, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord4sARB", glMultiTexCoord4sARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord4sSGIS", glMultiTexCoord4sSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord4sv", glMultiTexCoord4sv, (major > 1 || (major == 1 && minor >= 3)) }, + { "glMultiTexCoord4svARB", glMultiTexCoord4svARB, extensions->has_GL_ARB_multitexture }, + { "glMultiTexCoord4svSGIS", glMultiTexCoord4svSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexCoord4x", glMultiTexCoord4x, extensions->has_GL_NV_ES1_1_compatibility }, + { "glMultiTexCoord4xOES", glMultiTexCoord4xOES, extensions->has_GL_OES_fixed_point }, + { "glMultiTexCoord4xvOES", glMultiTexCoord4xvOES, extensions->has_GL_OES_fixed_point }, + { "glMultiTexCoordP1ui", glMultiTexCoordP1ui, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glMultiTexCoordP1uiv", glMultiTexCoordP1uiv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glMultiTexCoordP2ui", glMultiTexCoordP2ui, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glMultiTexCoordP2uiv", glMultiTexCoordP2uiv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glMultiTexCoordP3ui", glMultiTexCoordP3ui, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glMultiTexCoordP3uiv", glMultiTexCoordP3uiv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glMultiTexCoordP4ui", glMultiTexCoordP4ui, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glMultiTexCoordP4uiv", glMultiTexCoordP4uiv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glMultiTexCoordPointerEXT", glMultiTexCoordPointerEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMultiTexCoordPointerSGIS", glMultiTexCoordPointerSGIS, extensions->has_GL_SGIS_multitexture }, + { "glMultiTexEnvfEXT", glMultiTexEnvfEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMultiTexEnvfvEXT", glMultiTexEnvfvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMultiTexEnviEXT", glMultiTexEnviEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMultiTexEnvivEXT", glMultiTexEnvivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMultiTexGendEXT", glMultiTexGendEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMultiTexGendvEXT", glMultiTexGendvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMultiTexGenfEXT", glMultiTexGenfEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMultiTexGenfvEXT", glMultiTexGenfvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMultiTexGeniEXT", glMultiTexGeniEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMultiTexGenivEXT", glMultiTexGenivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMultiTexImage1DEXT", glMultiTexImage1DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMultiTexImage2DEXT", glMultiTexImage2DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMultiTexImage3DEXT", glMultiTexImage3DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMultiTexParameterIivEXT", glMultiTexParameterIivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMultiTexParameterIuivEXT", glMultiTexParameterIuivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMultiTexParameterfEXT", glMultiTexParameterfEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMultiTexParameterfvEXT", glMultiTexParameterfvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMultiTexParameteriEXT", glMultiTexParameteriEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMultiTexParameterivEXT", glMultiTexParameterivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMultiTexRenderbufferEXT", glMultiTexRenderbufferEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMultiTexSubImage1DEXT", glMultiTexSubImage1DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMultiTexSubImage2DEXT", glMultiTexSubImage2DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMultiTexSubImage3DEXT", glMultiTexSubImage3DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glMulticastBarrierNV", glMulticastBarrierNV, extensions->has_GL_NV_gpu_multicast }, + { "glMulticastBlitFramebufferNV", glMulticastBlitFramebufferNV, extensions->has_GL_NV_gpu_multicast }, + { "glMulticastBufferSubDataNV", glMulticastBufferSubDataNV, extensions->has_GL_NV_gpu_multicast }, + { "glMulticastCopyBufferSubDataNV", glMulticastCopyBufferSubDataNV, extensions->has_GL_NV_gpu_multicast }, + { "glMulticastCopyImageSubDataNV", glMulticastCopyImageSubDataNV, extensions->has_GL_NV_gpu_multicast }, + { "glMulticastFramebufferSampleLocationsfvNV", glMulticastFramebufferSampleLocationsfvNV, extensions->has_GL_NV_gpu_multicast }, + { "glMulticastGetQueryObjecti64vNV", glMulticastGetQueryObjecti64vNV, extensions->has_GL_NV_gpu_multicast }, + { "glMulticastGetQueryObjectivNV", glMulticastGetQueryObjectivNV, extensions->has_GL_NV_gpu_multicast }, + { "glMulticastGetQueryObjectui64vNV", glMulticastGetQueryObjectui64vNV, extensions->has_GL_NV_gpu_multicast }, + { "glMulticastGetQueryObjectuivNV", glMulticastGetQueryObjectuivNV, extensions->has_GL_NV_gpu_multicast }, + { "glMulticastScissorArrayvNVX", glMulticastScissorArrayvNVX, extensions->has_GL_NVX_gpu_multicast2 }, + { "glMulticastViewportArrayvNVX", glMulticastViewportArrayvNVX, extensions->has_GL_NVX_gpu_multicast2 }, + { "glMulticastViewportPositionWScaleNVX", glMulticastViewportPositionWScaleNVX, extensions->has_GL_NVX_gpu_multicast2 }, + { "glMulticastWaitSyncNV", glMulticastWaitSyncNV, extensions->has_GL_NV_gpu_multicast }, + { "glNamedBufferAttachMemoryNV", glNamedBufferAttachMemoryNV, extensions->has_GL_NV_memory_attachment }, + { "glNamedBufferData", glNamedBufferData, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glNamedBufferDataEXT", glNamedBufferDataEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedBufferPageCommitmentARB", glNamedBufferPageCommitmentARB, extensions->has_GL_ARB_sparse_buffer }, + { "glNamedBufferPageCommitmentEXT", glNamedBufferPageCommitmentEXT, extensions->has_GL_ARB_sparse_buffer }, + { "glNamedBufferPageCommitmentMemNV", glNamedBufferPageCommitmentMemNV, extensions->has_GL_NV_memory_object_sparse }, + { "glNamedBufferStorage", glNamedBufferStorage, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glNamedBufferStorageEXT", glNamedBufferStorageEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedBufferStorageExternalEXT", glNamedBufferStorageExternalEXT, extensions->has_GL_EXT_external_buffer }, + { "glNamedBufferStorageMemEXT", glNamedBufferStorageMemEXT, extensions->has_GL_EXT_memory_object }, + { "glNamedBufferSubData", glNamedBufferSubData, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glNamedBufferSubDataEXT", glNamedBufferSubDataEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedCopyBufferSubDataEXT", glNamedCopyBufferSubDataEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedFramebufferDrawBuffer", glNamedFramebufferDrawBuffer, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glNamedFramebufferDrawBuffers", glNamedFramebufferDrawBuffers, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glNamedFramebufferParameteri", glNamedFramebufferParameteri, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glNamedFramebufferParameteriEXT", glNamedFramebufferParameteriEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedFramebufferReadBuffer", glNamedFramebufferReadBuffer, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glNamedFramebufferRenderbuffer", glNamedFramebufferRenderbuffer, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glNamedFramebufferRenderbufferEXT", glNamedFramebufferRenderbufferEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedFramebufferSampleLocationsfvARB", glNamedFramebufferSampleLocationsfvARB, extensions->has_GL_ARB_sample_locations }, + { "glNamedFramebufferSampleLocationsfvNV", glNamedFramebufferSampleLocationsfvNV, extensions->has_GL_NV_sample_locations }, + { "glNamedFramebufferSamplePositionsfvAMD", glNamedFramebufferSamplePositionsfvAMD, extensions->has_GL_AMD_framebuffer_sample_positions }, + { "glNamedFramebufferTexture", glNamedFramebufferTexture, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glNamedFramebufferTexture1DEXT", glNamedFramebufferTexture1DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedFramebufferTexture2DEXT", glNamedFramebufferTexture2DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedFramebufferTexture3DEXT", glNamedFramebufferTexture3DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedFramebufferTextureEXT", glNamedFramebufferTextureEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedFramebufferTextureFaceEXT", glNamedFramebufferTextureFaceEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedFramebufferTextureLayer", glNamedFramebufferTextureLayer, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glNamedFramebufferTextureLayerEXT", glNamedFramebufferTextureLayerEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedFramebufferTextureMultiviewOVR", glNamedFramebufferTextureMultiviewOVR, extensions->has_GL_OVR_multiview }, + { "glNamedProgramLocalParameter4dEXT", glNamedProgramLocalParameter4dEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedProgramLocalParameter4dvEXT", glNamedProgramLocalParameter4dvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedProgramLocalParameter4fEXT", glNamedProgramLocalParameter4fEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedProgramLocalParameter4fvEXT", glNamedProgramLocalParameter4fvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedProgramLocalParameterI4iEXT", glNamedProgramLocalParameterI4iEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedProgramLocalParameterI4ivEXT", glNamedProgramLocalParameterI4ivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedProgramLocalParameterI4uiEXT", glNamedProgramLocalParameterI4uiEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedProgramLocalParameterI4uivEXT", glNamedProgramLocalParameterI4uivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedProgramLocalParameters4fvEXT", glNamedProgramLocalParameters4fvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedProgramLocalParametersI4ivEXT", glNamedProgramLocalParametersI4ivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedProgramLocalParametersI4uivEXT", glNamedProgramLocalParametersI4uivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedProgramStringEXT", glNamedProgramStringEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedRenderbufferStorage", glNamedRenderbufferStorage, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glNamedRenderbufferStorageEXT", glNamedRenderbufferStorageEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedRenderbufferStorageMultisample", glNamedRenderbufferStorageMultisample, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glNamedRenderbufferStorageMultisampleAdvancedAMD", glNamedRenderbufferStorageMultisampleAdvancedAMD, extensions->has_GL_AMD_framebuffer_multisample_advanced }, + { "glNamedRenderbufferStorageMultisampleCoverageEXT", glNamedRenderbufferStorageMultisampleCoverageEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedRenderbufferStorageMultisampleEXT", glNamedRenderbufferStorageMultisampleEXT, extensions->has_GL_EXT_direct_state_access }, + { "glNamedStringARB", glNamedStringARB, extensions->has_GL_ARB_shading_language_include }, + { "glNewBufferRegion", glNewBufferRegion, extensions->has_GL_KTX_buffer_region }, + { "glNewObjectBufferATI", glNewObjectBufferATI, extensions->has_GL_ATI_vertex_array_object }, + { "glNormal3fVertex3fSUN", glNormal3fVertex3fSUN, extensions->has_GL_SUN_vertex }, + { "glNormal3fVertex3fvSUN", glNormal3fVertex3fvSUN, extensions->has_GL_SUN_vertex }, + { "glNormal3hNV", glNormal3hNV, extensions->has_GL_NV_half_float }, + { "glNormal3hvNV", glNormal3hvNV, extensions->has_GL_NV_half_float }, + { "glNormal3x", glNormal3x, extensions->has_GL_NV_ES1_1_compatibility }, + { "glNormal3xOES", glNormal3xOES, extensions->has_GL_OES_fixed_point }, + { "glNormal3xvOES", glNormal3xvOES, extensions->has_GL_OES_fixed_point }, + { "glNormalFormatNV", glNormalFormatNV, extensions->has_GL_NV_vertex_buffer_unified_memory }, + { "glNormalP3ui", glNormalP3ui, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glNormalP3uiv", glNormalP3uiv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glNormalPointerEXT", glNormalPointerEXT, extensions->has_GL_EXT_vertex_array }, + { "glNormalPointerListIBM", glNormalPointerListIBM, extensions->has_GL_IBM_vertex_array_lists }, + { "glNormalPointervINTEL", glNormalPointervINTEL, extensions->has_GL_INTEL_parallel_arrays }, + { "glNormalStream3bATI", glNormalStream3bATI, extensions->has_GL_ATI_vertex_streams }, + { "glNormalStream3bvATI", glNormalStream3bvATI, extensions->has_GL_ATI_vertex_streams }, + { "glNormalStream3dATI", glNormalStream3dATI, extensions->has_GL_ATI_vertex_streams }, + { "glNormalStream3dvATI", glNormalStream3dvATI, extensions->has_GL_ATI_vertex_streams }, + { "glNormalStream3fATI", glNormalStream3fATI, extensions->has_GL_ATI_vertex_streams }, + { "glNormalStream3fvATI", glNormalStream3fvATI, extensions->has_GL_ATI_vertex_streams }, + { "glNormalStream3iATI", glNormalStream3iATI, extensions->has_GL_ATI_vertex_streams }, + { "glNormalStream3ivATI", glNormalStream3ivATI, extensions->has_GL_ATI_vertex_streams }, + { "glNormalStream3sATI", glNormalStream3sATI, extensions->has_GL_ATI_vertex_streams }, + { "glNormalStream3svATI", glNormalStream3svATI, extensions->has_GL_ATI_vertex_streams }, + { "glObjectLabel", glObjectLabel, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_KHR_debug }, + { "glObjectPtrLabel", glObjectPtrLabel, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_KHR_debug }, + { "glObjectPurgeableAPPLE", glObjectPurgeableAPPLE, extensions->has_GL_APPLE_object_purgeable }, + { "glObjectUnpurgeableAPPLE", glObjectUnpurgeableAPPLE, extensions->has_GL_APPLE_object_purgeable }, + { "glOrthof", glOrthof, extensions->has_GL_NV_ES1_1_compatibility }, + { "glOrthofOES", glOrthofOES, extensions->has_GL_OES_single_precision }, + { "glOrthox", glOrthox, extensions->has_GL_NV_ES1_1_compatibility }, + { "glOrthoxOES", glOrthoxOES, extensions->has_GL_OES_fixed_point }, + { "glPNTrianglesfATI", glPNTrianglesfATI, extensions->has_GL_ATI_pn_triangles }, + { "glPNTrianglesiATI", glPNTrianglesiATI, extensions->has_GL_ATI_pn_triangles }, + { "glPassTexCoordATI", glPassTexCoordATI, extensions->has_GL_ATI_fragment_shader }, + { "glPassThroughxOES", glPassThroughxOES, extensions->has_GL_OES_fixed_point }, + { "glPatchParameterfv", glPatchParameterfv, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_tessellation_shader }, + { "glPatchParameteri", glPatchParameteri, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_tessellation_shader }, + { "glPathColorGenNV", glPathColorGenNV, extensions->has_GL_NV_path_rendering }, + { "glPathCommandsNV", glPathCommandsNV, extensions->has_GL_NV_path_rendering }, + { "glPathCoordsNV", glPathCoordsNV, extensions->has_GL_NV_path_rendering }, + { "glPathCoverDepthFuncNV", glPathCoverDepthFuncNV, extensions->has_GL_NV_path_rendering }, + { "glPathDashArrayNV", glPathDashArrayNV, extensions->has_GL_NV_path_rendering }, + { "glPathFogGenNV", glPathFogGenNV, extensions->has_GL_NV_path_rendering }, + { "glPathGlyphIndexArrayNV", glPathGlyphIndexArrayNV, extensions->has_GL_NV_path_rendering }, + { "glPathGlyphIndexRangeNV", glPathGlyphIndexRangeNV, extensions->has_GL_NV_path_rendering }, + { "glPathGlyphRangeNV", glPathGlyphRangeNV, extensions->has_GL_NV_path_rendering }, + { "glPathGlyphsNV", glPathGlyphsNV, extensions->has_GL_NV_path_rendering }, + { "glPathMemoryGlyphIndexArrayNV", glPathMemoryGlyphIndexArrayNV, extensions->has_GL_NV_path_rendering }, + { "glPathParameterfNV", glPathParameterfNV, extensions->has_GL_NV_path_rendering }, + { "glPathParameterfvNV", glPathParameterfvNV, extensions->has_GL_NV_path_rendering }, + { "glPathParameteriNV", glPathParameteriNV, extensions->has_GL_NV_path_rendering }, + { "glPathParameterivNV", glPathParameterivNV, extensions->has_GL_NV_path_rendering }, + { "glPathStencilDepthOffsetNV", glPathStencilDepthOffsetNV, extensions->has_GL_NV_path_rendering }, + { "glPathStencilFuncNV", glPathStencilFuncNV, extensions->has_GL_NV_path_rendering }, + { "glPathStringNV", glPathStringNV, extensions->has_GL_NV_path_rendering }, + { "glPathSubCommandsNV", glPathSubCommandsNV, extensions->has_GL_NV_path_rendering }, + { "glPathSubCoordsNV", glPathSubCoordsNV, extensions->has_GL_NV_path_rendering }, + { "glPathTexGenNV", glPathTexGenNV, extensions->has_GL_NV_path_rendering }, + { "glPauseTransformFeedback", glPauseTransformFeedback, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_transform_feedback2 }, + { "glPauseTransformFeedbackNV", glPauseTransformFeedbackNV, extensions->has_GL_NV_transform_feedback2 }, + { "glPixelDataRangeNV", glPixelDataRangeNV, extensions->has_GL_NV_pixel_data_range }, + { "glPixelMapx", glPixelMapx, extensions->has_GL_OES_fixed_point }, + { "glPixelStorex", glPixelStorex, extensions->has_GL_OES_fixed_point }, + { "glPixelTexGenParameterfSGIS", glPixelTexGenParameterfSGIS, extensions->has_GL_SGIS_pixel_texture }, + { "glPixelTexGenParameterfvSGIS", glPixelTexGenParameterfvSGIS, extensions->has_GL_SGIS_pixel_texture }, + { "glPixelTexGenParameteriSGIS", glPixelTexGenParameteriSGIS, extensions->has_GL_SGIS_pixel_texture }, + { "glPixelTexGenParameterivSGIS", glPixelTexGenParameterivSGIS, extensions->has_GL_SGIS_pixel_texture }, + { "glPixelTexGenSGIX", glPixelTexGenSGIX, extensions->has_GL_SGIX_pixel_texture }, + { "glPixelTransferxOES", glPixelTransferxOES, extensions->has_GL_OES_fixed_point }, + { "glPixelTransformParameterfEXT", glPixelTransformParameterfEXT, extensions->has_GL_EXT_pixel_transform }, + { "glPixelTransformParameterfvEXT", glPixelTransformParameterfvEXT, extensions->has_GL_EXT_pixel_transform }, + { "glPixelTransformParameteriEXT", glPixelTransformParameteriEXT, extensions->has_GL_EXT_pixel_transform }, + { "glPixelTransformParameterivEXT", glPixelTransformParameterivEXT, extensions->has_GL_EXT_pixel_transform }, + { "glPixelZoomxOES", glPixelZoomxOES, extensions->has_GL_OES_fixed_point }, + { "glPointAlongPathNV", glPointAlongPathNV, extensions->has_GL_NV_path_rendering }, + { "glPointParameterf", glPointParameterf, (major > 1 || (major == 1 && minor >= 4)) }, + { "glPointParameterfARB", glPointParameterfARB, extensions->has_GL_ARB_point_parameters }, + { "glPointParameterfEXT", glPointParameterfEXT, extensions->has_GL_EXT_point_parameters }, + { "glPointParameterfSGIS", glPointParameterfSGIS, extensions->has_GL_SGIS_point_parameters }, + { "glPointParameterfv", glPointParameterfv, (major > 1 || (major == 1 && minor >= 4)) }, + { "glPointParameterfvARB", glPointParameterfvARB, extensions->has_GL_ARB_point_parameters }, + { "glPointParameterfvEXT", glPointParameterfvEXT, extensions->has_GL_EXT_point_parameters }, + { "glPointParameterfvSGIS", glPointParameterfvSGIS, extensions->has_GL_SGIS_point_parameters }, + { "glPointParameteri", glPointParameteri, (major > 1 || (major == 1 && minor >= 4)) }, + { "glPointParameteriNV", glPointParameteriNV, extensions->has_GL_NV_point_sprite }, + { "glPointParameteriv", glPointParameteriv, (major > 1 || (major == 1 && minor >= 4)) }, + { "glPointParameterivNV", glPointParameterivNV, extensions->has_GL_NV_point_sprite }, + { "glPointParameterx", glPointParameterx, extensions->has_GL_NV_ES1_1_compatibility }, + { "glPointParameterxv", glPointParameterxv, extensions->has_GL_NV_ES1_1_compatibility }, + { "glPointParameterxvOES", glPointParameterxvOES, extensions->has_GL_OES_fixed_point }, + { "glPointSizex", glPointSizex, extensions->has_GL_NV_ES1_1_compatibility }, + { "glPointSizexOES", glPointSizexOES, extensions->has_GL_OES_fixed_point }, + { "glPollAsyncSGIX", glPollAsyncSGIX, extensions->has_GL_SGIX_async }, + { "glPollInstrumentsSGIX", glPollInstrumentsSGIX, extensions->has_GL_SGIX_instruments }, + { "glPolygonOffsetClamp", glPolygonOffsetClamp, (major > 4 || (major == 4 && minor >= 6)) || extensions->has_GL_ARB_polygon_offset_clamp }, + { "glPolygonOffsetClampEXT", glPolygonOffsetClampEXT, extensions->has_GL_EXT_polygon_offset_clamp }, + { "glPolygonOffsetEXT", glPolygonOffsetEXT, extensions->has_GL_EXT_polygon_offset }, + { "glPolygonOffsetx", glPolygonOffsetx, extensions->has_GL_NV_ES1_1_compatibility }, + { "glPolygonOffsetxOES", glPolygonOffsetxOES, extensions->has_GL_OES_fixed_point }, + { "glPopDebugGroup", glPopDebugGroup, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_KHR_debug }, + { "glPopGroupMarkerEXT", glPopGroupMarkerEXT, extensions->has_GL_EXT_debug_marker }, + { "glPresentFrameDualFillNV", glPresentFrameDualFillNV, extensions->has_GL_NV_present_video }, + { "glPresentFrameKeyedNV", glPresentFrameKeyedNV, extensions->has_GL_NV_present_video }, + { "glPrimitiveBoundingBox", glPrimitiveBoundingBox, extensions->has_GL_ARB_ES3_2_compatibility }, + { "glPrimitiveBoundingBoxARB", glPrimitiveBoundingBoxARB, extensions->has_GL_ARB_ES3_2_compatibility }, + { "glPrimitiveRestartIndex", glPrimitiveRestartIndex, (major > 3 || (major == 3 && minor >= 1)) }, + { "glPrimitiveRestartIndexNV", glPrimitiveRestartIndexNV, extensions->has_GL_NV_primitive_restart }, + { "glPrimitiveRestartNV", glPrimitiveRestartNV, extensions->has_GL_NV_primitive_restart }, + { "glPrioritizeTexturesEXT", glPrioritizeTexturesEXT, extensions->has_GL_EXT_texture_object }, + { "glPrioritizeTexturesxOES", glPrioritizeTexturesxOES, extensions->has_GL_OES_fixed_point }, + { "glProgramBinary", glProgramBinary, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_get_program_binary }, + { "glProgramBufferParametersIivNV", glProgramBufferParametersIivNV, extensions->has_GL_NV_parameter_buffer_object }, + { "glProgramBufferParametersIuivNV", glProgramBufferParametersIuivNV, extensions->has_GL_NV_parameter_buffer_object }, + { "glProgramBufferParametersfvNV", glProgramBufferParametersfvNV, extensions->has_GL_NV_parameter_buffer_object }, + { "glProgramEnvParameter4dARB", glProgramEnvParameter4dARB, extensions->has_GL_ARB_fragment_program || extensions->has_GL_ARB_vertex_program }, + { "glProgramEnvParameter4dvARB", glProgramEnvParameter4dvARB, extensions->has_GL_ARB_fragment_program || extensions->has_GL_ARB_vertex_program }, + { "glProgramEnvParameter4fARB", glProgramEnvParameter4fARB, extensions->has_GL_ARB_fragment_program || extensions->has_GL_ARB_vertex_program }, + { "glProgramEnvParameter4fvARB", glProgramEnvParameter4fvARB, extensions->has_GL_ARB_fragment_program || extensions->has_GL_ARB_vertex_program }, + { "glProgramEnvParameterI4iNV", glProgramEnvParameterI4iNV, extensions->has_GL_NV_gpu_program4 }, + { "glProgramEnvParameterI4ivNV", glProgramEnvParameterI4ivNV, extensions->has_GL_NV_gpu_program4 }, + { "glProgramEnvParameterI4uiNV", glProgramEnvParameterI4uiNV, extensions->has_GL_NV_gpu_program4 }, + { "glProgramEnvParameterI4uivNV", glProgramEnvParameterI4uivNV, extensions->has_GL_NV_gpu_program4 }, + { "glProgramEnvParameters4fvEXT", glProgramEnvParameters4fvEXT, extensions->has_GL_EXT_gpu_program_parameters }, + { "glProgramEnvParametersI4ivNV", glProgramEnvParametersI4ivNV, extensions->has_GL_NV_gpu_program4 }, + { "glProgramEnvParametersI4uivNV", glProgramEnvParametersI4uivNV, extensions->has_GL_NV_gpu_program4 }, + { "glProgramLocalParameter4dARB", glProgramLocalParameter4dARB, extensions->has_GL_ARB_fragment_program || extensions->has_GL_ARB_vertex_program }, + { "glProgramLocalParameter4dvARB", glProgramLocalParameter4dvARB, extensions->has_GL_ARB_fragment_program || extensions->has_GL_ARB_vertex_program }, + { "glProgramLocalParameter4fARB", glProgramLocalParameter4fARB, extensions->has_GL_ARB_fragment_program || extensions->has_GL_ARB_vertex_program }, + { "glProgramLocalParameter4fvARB", glProgramLocalParameter4fvARB, extensions->has_GL_ARB_fragment_program || extensions->has_GL_ARB_vertex_program }, + { "glProgramLocalParameterI4iNV", glProgramLocalParameterI4iNV, extensions->has_GL_NV_gpu_program4 }, + { "glProgramLocalParameterI4ivNV", glProgramLocalParameterI4ivNV, extensions->has_GL_NV_gpu_program4 }, + { "glProgramLocalParameterI4uiNV", glProgramLocalParameterI4uiNV, extensions->has_GL_NV_gpu_program4 }, + { "glProgramLocalParameterI4uivNV", glProgramLocalParameterI4uivNV, extensions->has_GL_NV_gpu_program4 }, + { "glProgramLocalParameters4fvEXT", glProgramLocalParameters4fvEXT, extensions->has_GL_EXT_gpu_program_parameters }, + { "glProgramLocalParametersI4ivNV", glProgramLocalParametersI4ivNV, extensions->has_GL_NV_gpu_program4 }, + { "glProgramLocalParametersI4uivNV", glProgramLocalParametersI4uivNV, extensions->has_GL_NV_gpu_program4 }, + { "glProgramNamedParameter4dNV", glProgramNamedParameter4dNV, extensions->has_GL_NV_fragment_program }, + { "glProgramNamedParameter4dvNV", glProgramNamedParameter4dvNV, extensions->has_GL_NV_fragment_program }, + { "glProgramNamedParameter4fNV", glProgramNamedParameter4fNV, extensions->has_GL_NV_fragment_program }, + { "glProgramNamedParameter4fvNV", glProgramNamedParameter4fvNV, extensions->has_GL_NV_fragment_program }, + { "glProgramParameter4dNV", glProgramParameter4dNV, extensions->has_GL_NV_vertex_program }, + { "glProgramParameter4dvNV", glProgramParameter4dvNV, extensions->has_GL_NV_vertex_program }, + { "glProgramParameter4fNV", glProgramParameter4fNV, extensions->has_GL_NV_vertex_program }, + { "glProgramParameter4fvNV", glProgramParameter4fvNV, extensions->has_GL_NV_vertex_program }, + { "glProgramParameteri", glProgramParameteri, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_get_program_binary || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramParameteriARB", glProgramParameteriARB, extensions->has_GL_ARB_geometry_shader4 }, + { "glProgramParameteriEXT", glProgramParameteriEXT, extensions->has_GL_EXT_geometry_shader4 }, + { "glProgramParameters4dvNV", glProgramParameters4dvNV, extensions->has_GL_NV_vertex_program }, + { "glProgramParameters4fvNV", glProgramParameters4fvNV, extensions->has_GL_NV_vertex_program }, + { "glProgramPathFragmentInputGenNV", glProgramPathFragmentInputGenNV, extensions->has_GL_NV_path_rendering }, + { "glProgramStringARB", glProgramStringARB, extensions->has_GL_ARB_fragment_program || extensions->has_GL_ARB_vertex_program }, + { "glProgramSubroutineParametersuivNV", glProgramSubroutineParametersuivNV, extensions->has_GL_NV_gpu_program5 || extensions->has_GL_NV_gpu_program_fp64 }, + { "glProgramUniform1d", glProgramUniform1d, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform1dEXT", glProgramUniform1dEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform1dv", glProgramUniform1dv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform1dvEXT", glProgramUniform1dvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform1f", glProgramUniform1f, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform1fEXT", glProgramUniform1fEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform1fv", glProgramUniform1fv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform1fvEXT", glProgramUniform1fvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform1i", glProgramUniform1i, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform1i64ARB", glProgramUniform1i64ARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glProgramUniform1i64NV", glProgramUniform1i64NV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glProgramUniform1i64vARB", glProgramUniform1i64vARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glProgramUniform1i64vNV", glProgramUniform1i64vNV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glProgramUniform1iEXT", glProgramUniform1iEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform1iv", glProgramUniform1iv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform1ivEXT", glProgramUniform1ivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform1ui", glProgramUniform1ui, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform1ui64ARB", glProgramUniform1ui64ARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glProgramUniform1ui64NV", glProgramUniform1ui64NV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glProgramUniform1ui64vARB", glProgramUniform1ui64vARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glProgramUniform1ui64vNV", glProgramUniform1ui64vNV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glProgramUniform1uiEXT", glProgramUniform1uiEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform1uiv", glProgramUniform1uiv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform1uivEXT", glProgramUniform1uivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform2d", glProgramUniform2d, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform2dEXT", glProgramUniform2dEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform2dv", glProgramUniform2dv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform2dvEXT", glProgramUniform2dvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform2f", glProgramUniform2f, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform2fEXT", glProgramUniform2fEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform2fv", glProgramUniform2fv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform2fvEXT", glProgramUniform2fvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform2i", glProgramUniform2i, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform2i64ARB", glProgramUniform2i64ARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glProgramUniform2i64NV", glProgramUniform2i64NV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glProgramUniform2i64vARB", glProgramUniform2i64vARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glProgramUniform2i64vNV", glProgramUniform2i64vNV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glProgramUniform2iEXT", glProgramUniform2iEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform2iv", glProgramUniform2iv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform2ivEXT", glProgramUniform2ivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform2ui", glProgramUniform2ui, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform2ui64ARB", glProgramUniform2ui64ARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glProgramUniform2ui64NV", glProgramUniform2ui64NV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glProgramUniform2ui64vARB", glProgramUniform2ui64vARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glProgramUniform2ui64vNV", glProgramUniform2ui64vNV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glProgramUniform2uiEXT", glProgramUniform2uiEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform2uiv", glProgramUniform2uiv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform2uivEXT", glProgramUniform2uivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform3d", glProgramUniform3d, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform3dEXT", glProgramUniform3dEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform3dv", glProgramUniform3dv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform3dvEXT", glProgramUniform3dvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform3f", glProgramUniform3f, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform3fEXT", glProgramUniform3fEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform3fv", glProgramUniform3fv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform3fvEXT", glProgramUniform3fvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform3i", glProgramUniform3i, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform3i64ARB", glProgramUniform3i64ARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glProgramUniform3i64NV", glProgramUniform3i64NV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glProgramUniform3i64vARB", glProgramUniform3i64vARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glProgramUniform3i64vNV", glProgramUniform3i64vNV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glProgramUniform3iEXT", glProgramUniform3iEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform3iv", glProgramUniform3iv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform3ivEXT", glProgramUniform3ivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform3ui", glProgramUniform3ui, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform3ui64ARB", glProgramUniform3ui64ARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glProgramUniform3ui64NV", glProgramUniform3ui64NV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glProgramUniform3ui64vARB", glProgramUniform3ui64vARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glProgramUniform3ui64vNV", glProgramUniform3ui64vNV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glProgramUniform3uiEXT", glProgramUniform3uiEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform3uiv", glProgramUniform3uiv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform3uivEXT", glProgramUniform3uivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform4d", glProgramUniform4d, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform4dEXT", glProgramUniform4dEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform4dv", glProgramUniform4dv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform4dvEXT", glProgramUniform4dvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform4f", glProgramUniform4f, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform4fEXT", glProgramUniform4fEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform4fv", glProgramUniform4fv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform4fvEXT", glProgramUniform4fvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform4i", glProgramUniform4i, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform4i64ARB", glProgramUniform4i64ARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glProgramUniform4i64NV", glProgramUniform4i64NV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glProgramUniform4i64vARB", glProgramUniform4i64vARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glProgramUniform4i64vNV", glProgramUniform4i64vNV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glProgramUniform4iEXT", glProgramUniform4iEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform4iv", glProgramUniform4iv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform4ivEXT", glProgramUniform4ivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform4ui", glProgramUniform4ui, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform4ui64ARB", glProgramUniform4ui64ARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glProgramUniform4ui64NV", glProgramUniform4ui64NV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glProgramUniform4ui64vARB", glProgramUniform4ui64vARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glProgramUniform4ui64vNV", glProgramUniform4ui64vNV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glProgramUniform4uiEXT", glProgramUniform4uiEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniform4uiv", glProgramUniform4uiv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniform4uivEXT", glProgramUniform4uivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniformHandleui64ARB", glProgramUniformHandleui64ARB, extensions->has_GL_ARB_bindless_texture }, + { "glProgramUniformHandleui64NV", glProgramUniformHandleui64NV, extensions->has_GL_NV_bindless_texture }, + { "glProgramUniformHandleui64vARB", glProgramUniformHandleui64vARB, extensions->has_GL_ARB_bindless_texture }, + { "glProgramUniformHandleui64vNV", glProgramUniformHandleui64vNV, extensions->has_GL_NV_bindless_texture }, + { "glProgramUniformMatrix2dv", glProgramUniformMatrix2dv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniformMatrix2dvEXT", glProgramUniformMatrix2dvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniformMatrix2fv", glProgramUniformMatrix2fv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniformMatrix2fvEXT", glProgramUniformMatrix2fvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniformMatrix2x3dv", glProgramUniformMatrix2x3dv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniformMatrix2x3dvEXT", glProgramUniformMatrix2x3dvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniformMatrix2x3fv", glProgramUniformMatrix2x3fv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniformMatrix2x3fvEXT", glProgramUniformMatrix2x3fvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniformMatrix2x4dv", glProgramUniformMatrix2x4dv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniformMatrix2x4dvEXT", glProgramUniformMatrix2x4dvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniformMatrix2x4fv", glProgramUniformMatrix2x4fv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniformMatrix2x4fvEXT", glProgramUniformMatrix2x4fvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniformMatrix3dv", glProgramUniformMatrix3dv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniformMatrix3dvEXT", glProgramUniformMatrix3dvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniformMatrix3fv", glProgramUniformMatrix3fv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniformMatrix3fvEXT", glProgramUniformMatrix3fvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniformMatrix3x2dv", glProgramUniformMatrix3x2dv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniformMatrix3x2dvEXT", glProgramUniformMatrix3x2dvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniformMatrix3x2fv", glProgramUniformMatrix3x2fv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniformMatrix3x2fvEXT", glProgramUniformMatrix3x2fvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniformMatrix3x4dv", glProgramUniformMatrix3x4dv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniformMatrix3x4dvEXT", glProgramUniformMatrix3x4dvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniformMatrix3x4fv", glProgramUniformMatrix3x4fv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniformMatrix3x4fvEXT", glProgramUniformMatrix3x4fvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniformMatrix4dv", glProgramUniformMatrix4dv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniformMatrix4dvEXT", glProgramUniformMatrix4dvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniformMatrix4fv", glProgramUniformMatrix4fv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniformMatrix4fvEXT", glProgramUniformMatrix4fvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniformMatrix4x2dv", glProgramUniformMatrix4x2dv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniformMatrix4x2dvEXT", glProgramUniformMatrix4x2dvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniformMatrix4x2fv", glProgramUniformMatrix4x2fv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniformMatrix4x2fvEXT", glProgramUniformMatrix4x2fvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniformMatrix4x3dv", glProgramUniformMatrix4x3dv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniformMatrix4x3dvEXT", glProgramUniformMatrix4x3dvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniformMatrix4x3fv", glProgramUniformMatrix4x3fv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glProgramUniformMatrix4x3fvEXT", glProgramUniformMatrix4x3fvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glProgramUniformui64NV", glProgramUniformui64NV, extensions->has_GL_NV_shader_buffer_load }, + { "glProgramUniformui64vNV", glProgramUniformui64vNV, extensions->has_GL_NV_shader_buffer_load }, + { "glProgramVertexLimitNV", glProgramVertexLimitNV, extensions->has_GL_NV_geometry_program4 }, + { "glProvokingVertex", glProvokingVertex, (major > 3 || (major == 3 && minor >= 2)) || extensions->has_GL_ARB_provoking_vertex }, + { "glProvokingVertexEXT", glProvokingVertexEXT, extensions->has_GL_EXT_provoking_vertex }, + { "glPushClientAttribDefaultEXT", glPushClientAttribDefaultEXT, extensions->has_GL_EXT_direct_state_access }, + { "glPushDebugGroup", glPushDebugGroup, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_KHR_debug }, + { "glPushGroupMarkerEXT", glPushGroupMarkerEXT, extensions->has_GL_EXT_debug_marker }, + { "glQueryCounter", glQueryCounter, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_timer_query }, + { "glQueryMatrixxOES", glQueryMatrixxOES, extensions->has_GL_OES_query_matrix }, + { "glQueryObjectParameteruiAMD", glQueryObjectParameteruiAMD, extensions->has_GL_AMD_occlusion_query_event }, + { "glQueryResourceNV", glQueryResourceNV, extensions->has_GL_NV_query_resource }, + { "glQueryResourceTagNV", glQueryResourceTagNV, extensions->has_GL_NV_query_resource_tag }, + { "glRasterPos2xOES", glRasterPos2xOES, extensions->has_GL_OES_fixed_point }, + { "glRasterPos2xvOES", glRasterPos2xvOES, extensions->has_GL_OES_fixed_point }, + { "glRasterPos3xOES", glRasterPos3xOES, extensions->has_GL_OES_fixed_point }, + { "glRasterPos3xvOES", glRasterPos3xvOES, extensions->has_GL_OES_fixed_point }, + { "glRasterPos4xOES", glRasterPos4xOES, extensions->has_GL_OES_fixed_point }, + { "glRasterPos4xvOES", glRasterPos4xvOES, extensions->has_GL_OES_fixed_point }, + { "glRasterSamplesEXT", glRasterSamplesEXT, extensions->has_GL_EXT_raster_multisample || extensions->has_GL_NV_framebuffer_mixed_samples }, + { "glReadBufferRegion", glReadBufferRegion, extensions->has_GL_KTX_buffer_region }, + { "glReadInstrumentsSGIX", glReadInstrumentsSGIX, extensions->has_GL_SGIX_instruments }, + { "glReadnPixels", glReadnPixels, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_KHR_robustness }, + { "glReadnPixelsARB", glReadnPixelsARB, extensions->has_GL_ARB_robustness }, + { "glRectxOES", glRectxOES, extensions->has_GL_OES_fixed_point }, + { "glRectxvOES", glRectxvOES, extensions->has_GL_OES_fixed_point }, + { "glReferencePlaneSGIX", glReferencePlaneSGIX, extensions->has_GL_SGIX_reference_plane }, + { "glReleaseKeyedMutexWin32EXT", glReleaseKeyedMutexWin32EXT, extensions->has_GL_EXT_win32_keyed_mutex }, + { "glReleaseShaderCompiler", glReleaseShaderCompiler, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_ES2_compatibility }, + { "glRenderGpuMaskNV", glRenderGpuMaskNV, extensions->has_GL_NV_gpu_multicast }, + { "glRenderbufferStorage", glRenderbufferStorage, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_framebuffer_object }, + { "glRenderbufferStorageEXT", glRenderbufferStorageEXT, extensions->has_GL_EXT_framebuffer_object }, + { "glRenderbufferStorageMultisample", glRenderbufferStorageMultisample, (major > 3 || (major == 3 && minor >= 0)) || extensions->has_GL_ARB_framebuffer_object }, + { "glRenderbufferStorageMultisampleAdvancedAMD", glRenderbufferStorageMultisampleAdvancedAMD, extensions->has_GL_AMD_framebuffer_multisample_advanced }, + { "glRenderbufferStorageMultisampleCoverageNV", glRenderbufferStorageMultisampleCoverageNV, extensions->has_GL_NV_framebuffer_multisample_coverage }, + { "glRenderbufferStorageMultisampleEXT", glRenderbufferStorageMultisampleEXT, extensions->has_GL_EXT_framebuffer_multisample }, + { "glReplacementCodePointerSUN", glReplacementCodePointerSUN, extensions->has_GL_SUN_triangle_list }, + { "glReplacementCodeubSUN", glReplacementCodeubSUN, extensions->has_GL_SUN_triangle_list }, + { "glReplacementCodeubvSUN", glReplacementCodeubvSUN, extensions->has_GL_SUN_triangle_list }, + { "glReplacementCodeuiColor3fVertex3fSUN", glReplacementCodeuiColor3fVertex3fSUN, extensions->has_GL_SUN_vertex }, + { "glReplacementCodeuiColor3fVertex3fvSUN", glReplacementCodeuiColor3fVertex3fvSUN, extensions->has_GL_SUN_vertex }, + { "glReplacementCodeuiColor4fNormal3fVertex3fSUN", glReplacementCodeuiColor4fNormal3fVertex3fSUN, extensions->has_GL_SUN_vertex }, + { "glReplacementCodeuiColor4fNormal3fVertex3fvSUN", glReplacementCodeuiColor4fNormal3fVertex3fvSUN, extensions->has_GL_SUN_vertex }, + { "glReplacementCodeuiColor4ubVertex3fSUN", glReplacementCodeuiColor4ubVertex3fSUN, extensions->has_GL_SUN_vertex }, + { "glReplacementCodeuiColor4ubVertex3fvSUN", glReplacementCodeuiColor4ubVertex3fvSUN, extensions->has_GL_SUN_vertex }, + { "glReplacementCodeuiNormal3fVertex3fSUN", glReplacementCodeuiNormal3fVertex3fSUN, extensions->has_GL_SUN_vertex }, + { "glReplacementCodeuiNormal3fVertex3fvSUN", glReplacementCodeuiNormal3fVertex3fvSUN, extensions->has_GL_SUN_vertex }, + { "glReplacementCodeuiSUN", glReplacementCodeuiSUN, extensions->has_GL_SUN_triangle_list }, + { "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN", glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN, extensions->has_GL_SUN_vertex }, + { "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN", glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN, extensions->has_GL_SUN_vertex }, + { "glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN", glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN, extensions->has_GL_SUN_vertex }, + { "glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN", glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN, extensions->has_GL_SUN_vertex }, + { "glReplacementCodeuiTexCoord2fVertex3fSUN", glReplacementCodeuiTexCoord2fVertex3fSUN, extensions->has_GL_SUN_vertex }, + { "glReplacementCodeuiTexCoord2fVertex3fvSUN", glReplacementCodeuiTexCoord2fVertex3fvSUN, extensions->has_GL_SUN_vertex }, + { "glReplacementCodeuiVertex3fSUN", glReplacementCodeuiVertex3fSUN, extensions->has_GL_SUN_vertex }, + { "glReplacementCodeuiVertex3fvSUN", glReplacementCodeuiVertex3fvSUN, extensions->has_GL_SUN_vertex }, + { "glReplacementCodeuivSUN", glReplacementCodeuivSUN, extensions->has_GL_SUN_triangle_list }, + { "glReplacementCodeusSUN", glReplacementCodeusSUN, extensions->has_GL_SUN_triangle_list }, + { "glReplacementCodeusvSUN", glReplacementCodeusvSUN, extensions->has_GL_SUN_triangle_list }, + { "glRequestResidentProgramsNV", glRequestResidentProgramsNV, extensions->has_GL_NV_vertex_program }, + { "glResetHistogram", glResetHistogram, extensions->has_GL_ARB_imaging }, + { "glResetHistogramEXT", glResetHistogramEXT, extensions->has_GL_EXT_histogram }, + { "glResetMemoryObjectParameterNV", glResetMemoryObjectParameterNV, extensions->has_GL_NV_memory_attachment }, + { "glResetMinmax", glResetMinmax, extensions->has_GL_ARB_imaging }, + { "glResetMinmaxEXT", glResetMinmaxEXT, extensions->has_GL_EXT_histogram }, + { "glResizeBuffersMESA", glResizeBuffersMESA, extensions->has_GL_MESA_resize_buffers }, + { "glResolveDepthValuesNV", glResolveDepthValuesNV, extensions->has_GL_NV_sample_locations }, + { "glResumeTransformFeedback", glResumeTransformFeedback, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_transform_feedback2 }, + { "glResumeTransformFeedbackNV", glResumeTransformFeedbackNV, extensions->has_GL_NV_transform_feedback2 }, + { "glRotatex", glRotatex, extensions->has_GL_NV_ES1_1_compatibility }, + { "glRotatexOES", glRotatexOES, extensions->has_GL_OES_fixed_point }, + { "glSampleCoverage", glSampleCoverage, (major > 1 || (major == 1 && minor >= 3)) }, + { "glSampleCoverageARB", glSampleCoverageARB, extensions->has_GL_ARB_multisample }, + { "glSampleCoveragex", glSampleCoveragex, extensions->has_GL_NV_ES1_1_compatibility }, + { "glSampleMapATI", glSampleMapATI, extensions->has_GL_ATI_fragment_shader }, + { "glSampleMaskEXT", glSampleMaskEXT, extensions->has_GL_EXT_multisample }, + { "glSampleMaskIndexedNV", glSampleMaskIndexedNV, extensions->has_GL_NV_explicit_multisample }, + { "glSampleMaskSGIS", glSampleMaskSGIS, extensions->has_GL_SGIS_multisample }, + { "glSampleMaski", glSampleMaski, (major > 3 || (major == 3 && minor >= 2)) || extensions->has_GL_ARB_texture_multisample }, + { "glSamplePatternEXT", glSamplePatternEXT, extensions->has_GL_EXT_multisample }, + { "glSamplePatternSGIS", glSamplePatternSGIS, extensions->has_GL_SGIS_multisample }, + { "glSamplerParameterIiv", glSamplerParameterIiv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_sampler_objects }, + { "glSamplerParameterIuiv", glSamplerParameterIuiv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_sampler_objects }, + { "glSamplerParameterf", glSamplerParameterf, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_sampler_objects }, + { "glSamplerParameterfv", glSamplerParameterfv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_sampler_objects }, + { "glSamplerParameteri", glSamplerParameteri, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_sampler_objects }, + { "glSamplerParameteriv", glSamplerParameteriv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_sampler_objects }, + { "glScalex", glScalex, extensions->has_GL_NV_ES1_1_compatibility }, + { "glScalexOES", glScalexOES, extensions->has_GL_OES_fixed_point }, + { "glScissorArrayv", glScissorArrayv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_viewport_array }, + { "glScissorExclusiveArrayvNV", glScissorExclusiveArrayvNV, extensions->has_GL_NV_scissor_exclusive }, + { "glScissorExclusiveNV", glScissorExclusiveNV, extensions->has_GL_NV_scissor_exclusive }, + { "glScissorIndexed", glScissorIndexed, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_viewport_array }, + { "glScissorIndexedv", glScissorIndexedv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_viewport_array }, + { "glSecondaryColor3b", glSecondaryColor3b, (major > 1 || (major == 1 && minor >= 4)) }, + { "glSecondaryColor3bEXT", glSecondaryColor3bEXT, extensions->has_GL_EXT_secondary_color }, + { "glSecondaryColor3bv", glSecondaryColor3bv, (major > 1 || (major == 1 && minor >= 4)) }, + { "glSecondaryColor3bvEXT", glSecondaryColor3bvEXT, extensions->has_GL_EXT_secondary_color }, + { "glSecondaryColor3d", glSecondaryColor3d, (major > 1 || (major == 1 && minor >= 4)) }, + { "glSecondaryColor3dEXT", glSecondaryColor3dEXT, extensions->has_GL_EXT_secondary_color }, + { "glSecondaryColor3dv", glSecondaryColor3dv, (major > 1 || (major == 1 && minor >= 4)) }, + { "glSecondaryColor3dvEXT", glSecondaryColor3dvEXT, extensions->has_GL_EXT_secondary_color }, + { "glSecondaryColor3f", glSecondaryColor3f, (major > 1 || (major == 1 && minor >= 4)) }, + { "glSecondaryColor3fEXT", glSecondaryColor3fEXT, extensions->has_GL_EXT_secondary_color }, + { "glSecondaryColor3fv", glSecondaryColor3fv, (major > 1 || (major == 1 && minor >= 4)) }, + { "glSecondaryColor3fvEXT", glSecondaryColor3fvEXT, extensions->has_GL_EXT_secondary_color }, + { "glSecondaryColor3hNV", glSecondaryColor3hNV, extensions->has_GL_NV_half_float }, + { "glSecondaryColor3hvNV", glSecondaryColor3hvNV, extensions->has_GL_NV_half_float }, + { "glSecondaryColor3i", glSecondaryColor3i, (major > 1 || (major == 1 && minor >= 4)) }, + { "glSecondaryColor3iEXT", glSecondaryColor3iEXT, extensions->has_GL_EXT_secondary_color }, + { "glSecondaryColor3iv", glSecondaryColor3iv, (major > 1 || (major == 1 && minor >= 4)) }, + { "glSecondaryColor3ivEXT", glSecondaryColor3ivEXT, extensions->has_GL_EXT_secondary_color }, + { "glSecondaryColor3s", glSecondaryColor3s, (major > 1 || (major == 1 && minor >= 4)) }, + { "glSecondaryColor3sEXT", glSecondaryColor3sEXT, extensions->has_GL_EXT_secondary_color }, + { "glSecondaryColor3sv", glSecondaryColor3sv, (major > 1 || (major == 1 && minor >= 4)) }, + { "glSecondaryColor3svEXT", glSecondaryColor3svEXT, extensions->has_GL_EXT_secondary_color }, + { "glSecondaryColor3ub", glSecondaryColor3ub, (major > 1 || (major == 1 && minor >= 4)) }, + { "glSecondaryColor3ubEXT", glSecondaryColor3ubEXT, extensions->has_GL_EXT_secondary_color }, + { "glSecondaryColor3ubv", glSecondaryColor3ubv, (major > 1 || (major == 1 && minor >= 4)) }, + { "glSecondaryColor3ubvEXT", glSecondaryColor3ubvEXT, extensions->has_GL_EXT_secondary_color }, + { "glSecondaryColor3ui", glSecondaryColor3ui, (major > 1 || (major == 1 && minor >= 4)) }, + { "glSecondaryColor3uiEXT", glSecondaryColor3uiEXT, extensions->has_GL_EXT_secondary_color }, + { "glSecondaryColor3uiv", glSecondaryColor3uiv, (major > 1 || (major == 1 && minor >= 4)) }, + { "glSecondaryColor3uivEXT", glSecondaryColor3uivEXT, extensions->has_GL_EXT_secondary_color }, + { "glSecondaryColor3us", glSecondaryColor3us, (major > 1 || (major == 1 && minor >= 4)) }, + { "glSecondaryColor3usEXT", glSecondaryColor3usEXT, extensions->has_GL_EXT_secondary_color }, + { "glSecondaryColor3usv", glSecondaryColor3usv, (major > 1 || (major == 1 && minor >= 4)) }, + { "glSecondaryColor3usvEXT", glSecondaryColor3usvEXT, extensions->has_GL_EXT_secondary_color }, + { "glSecondaryColorFormatNV", glSecondaryColorFormatNV, extensions->has_GL_NV_vertex_buffer_unified_memory }, + { "glSecondaryColorP3ui", glSecondaryColorP3ui, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glSecondaryColorP3uiv", glSecondaryColorP3uiv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glSecondaryColorPointer", glSecondaryColorPointer, (major > 1 || (major == 1 && minor >= 4)) }, + { "glSecondaryColorPointerEXT", glSecondaryColorPointerEXT, extensions->has_GL_EXT_secondary_color }, + { "glSecondaryColorPointerListIBM", glSecondaryColorPointerListIBM, extensions->has_GL_IBM_vertex_array_lists }, + { "glSelectPerfMonitorCountersAMD", glSelectPerfMonitorCountersAMD, extensions->has_GL_AMD_performance_monitor }, + { "glSelectTextureCoordSetSGIS", glSelectTextureCoordSetSGIS, extensions->has_GL_SGIS_multitexture }, + { "glSelectTextureSGIS", glSelectTextureSGIS, extensions->has_GL_SGIS_multitexture }, + { "glSemaphoreParameterivNV", glSemaphoreParameterivNV, extensions->has_GL_NV_timeline_semaphore }, + { "glSemaphoreParameterui64vEXT", glSemaphoreParameterui64vEXT, extensions->has_GL_EXT_semaphore }, + { "glSeparableFilter2D", glSeparableFilter2D, extensions->has_GL_ARB_imaging }, + { "glSeparableFilter2DEXT", glSeparableFilter2DEXT, extensions->has_GL_EXT_convolution }, + { "glSetFenceAPPLE", glSetFenceAPPLE, extensions->has_GL_APPLE_fence }, + { "glSetFenceNV", glSetFenceNV, extensions->has_GL_NV_fence }, + { "glSetFragmentShaderConstantATI", glSetFragmentShaderConstantATI, extensions->has_GL_ATI_fragment_shader }, + { "glSetInvariantEXT", glSetInvariantEXT, extensions->has_GL_EXT_vertex_shader }, + { "glSetLocalConstantEXT", glSetLocalConstantEXT, extensions->has_GL_EXT_vertex_shader }, + { "glSetMultisamplefvAMD", glSetMultisamplefvAMD, extensions->has_GL_AMD_sample_positions }, + { "glShaderBinary", glShaderBinary, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_ES2_compatibility }, + { "glShaderOp1EXT", glShaderOp1EXT, extensions->has_GL_EXT_vertex_shader }, + { "glShaderOp2EXT", glShaderOp2EXT, extensions->has_GL_EXT_vertex_shader }, + { "glShaderOp3EXT", glShaderOp3EXT, extensions->has_GL_EXT_vertex_shader }, + { "glShaderSource", glShaderSource, (major > 2 || (major == 2 && minor >= 0)) }, + { "glShaderSourceARB", glShaderSourceARB, extensions->has_GL_ARB_shader_objects }, + { "glShaderStorageBlockBinding", glShaderStorageBlockBinding, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_shader_storage_buffer_object }, + { "glShadingRateCombinerOpsEXT", glShadingRateCombinerOpsEXT, extensions->has_GL_EXT_fragment_shading_rate || extensions->has_GL_EXT_fragment_shading_rate_attachment || extensions->has_GL_EXT_fragment_shading_rate_primitive }, + { "glShadingRateEXT", glShadingRateEXT, extensions->has_GL_EXT_fragment_shading_rate || extensions->has_GL_EXT_fragment_shading_rate_attachment || extensions->has_GL_EXT_fragment_shading_rate_primitive }, + { "glShadingRateImageBarrierNV", glShadingRateImageBarrierNV, extensions->has_GL_NV_shading_rate_image }, + { "glShadingRateImagePaletteNV", glShadingRateImagePaletteNV, extensions->has_GL_NV_shading_rate_image }, + { "glShadingRateSampleOrderCustomNV", glShadingRateSampleOrderCustomNV, extensions->has_GL_NV_shading_rate_image }, + { "glShadingRateSampleOrderNV", glShadingRateSampleOrderNV, extensions->has_GL_NV_shading_rate_image }, + { "glSharpenTexFuncSGIS", glSharpenTexFuncSGIS, extensions->has_GL_SGIS_sharpen_texture }, + { "glSignalSemaphoreEXT", glSignalSemaphoreEXT, extensions->has_GL_EXT_semaphore }, + { "glSignalSemaphoreui64NVX", glSignalSemaphoreui64NVX, extensions->has_GL_NVX_progress_fence }, + { "glSignalVkFenceNV", glSignalVkFenceNV, extensions->has_GL_NV_draw_vulkan_image }, + { "glSignalVkSemaphoreNV", glSignalVkSemaphoreNV, extensions->has_GL_NV_draw_vulkan_image }, + { "glSpecializeShader", glSpecializeShader, (major > 4 || (major == 4 && minor >= 6)) }, + { "glSpecializeShaderARB", glSpecializeShaderARB, extensions->has_GL_ARB_gl_spirv }, + { "glSpriteParameterfSGIX", glSpriteParameterfSGIX, extensions->has_GL_SGIX_sprite }, + { "glSpriteParameterfvSGIX", glSpriteParameterfvSGIX, extensions->has_GL_SGIX_sprite }, + { "glSpriteParameteriSGIX", glSpriteParameteriSGIX, extensions->has_GL_SGIX_sprite }, + { "glSpriteParameterivSGIX", glSpriteParameterivSGIX, extensions->has_GL_SGIX_sprite }, + { "glStartInstrumentsSGIX", glStartInstrumentsSGIX, extensions->has_GL_SGIX_instruments }, + { "glStateCaptureNV", glStateCaptureNV, extensions->has_GL_NV_command_list }, + { "glStencilClearTagEXT", glStencilClearTagEXT, extensions->has_GL_EXT_stencil_clear_tag }, + { "glStencilFillPathInstancedNV", glStencilFillPathInstancedNV, extensions->has_GL_NV_path_rendering }, + { "glStencilFillPathNV", glStencilFillPathNV, extensions->has_GL_NV_path_rendering }, + { "glStencilFuncSeparate", glStencilFuncSeparate, (major > 2 || (major == 2 && minor >= 0)) }, + { "glStencilFuncSeparateATI", glStencilFuncSeparateATI, extensions->has_GL_ATI_separate_stencil }, + { "glStencilMaskSeparate", glStencilMaskSeparate, (major > 2 || (major == 2 && minor >= 0)) }, + { "glStencilOpSeparate", glStencilOpSeparate, (major > 2 || (major == 2 && minor >= 0)) }, + { "glStencilOpSeparateATI", glStencilOpSeparateATI, extensions->has_GL_ATI_separate_stencil }, + { "glStencilOpValueAMD", glStencilOpValueAMD, extensions->has_GL_AMD_stencil_operation_extended }, + { "glStencilStrokePathInstancedNV", glStencilStrokePathInstancedNV, extensions->has_GL_NV_path_rendering }, + { "glStencilStrokePathNV", glStencilStrokePathNV, extensions->has_GL_NV_path_rendering }, + { "glStencilThenCoverFillPathInstancedNV", glStencilThenCoverFillPathInstancedNV, extensions->has_GL_NV_path_rendering }, + { "glStencilThenCoverFillPathNV", glStencilThenCoverFillPathNV, extensions->has_GL_NV_path_rendering }, + { "glStencilThenCoverStrokePathInstancedNV", glStencilThenCoverStrokePathInstancedNV, extensions->has_GL_NV_path_rendering }, + { "glStencilThenCoverStrokePathNV", glStencilThenCoverStrokePathNV, extensions->has_GL_NV_path_rendering }, + { "glStopInstrumentsSGIX", glStopInstrumentsSGIX, extensions->has_GL_SGIX_instruments }, + { "glStringMarkerGREMEDY", glStringMarkerGREMEDY, extensions->has_GL_GREMEDY_string_marker }, + { "glSubpixelPrecisionBiasNV", glSubpixelPrecisionBiasNV, extensions->has_GL_NV_conservative_raster }, + { "glSwizzleEXT", glSwizzleEXT, extensions->has_GL_EXT_vertex_shader }, + { "glSyncTextureINTEL", glSyncTextureINTEL, extensions->has_GL_INTEL_map_texture }, + { "glTagSampleBufferSGIX", glTagSampleBufferSGIX, extensions->has_GL_SGIX_tag_sample_buffer }, + { "glTangent3bEXT", glTangent3bEXT, extensions->has_GL_EXT_coordinate_frame }, + { "glTangent3bvEXT", glTangent3bvEXT, extensions->has_GL_EXT_coordinate_frame }, + { "glTangent3dEXT", glTangent3dEXT, extensions->has_GL_EXT_coordinate_frame }, + { "glTangent3dvEXT", glTangent3dvEXT, extensions->has_GL_EXT_coordinate_frame }, + { "glTangent3fEXT", glTangent3fEXT, extensions->has_GL_EXT_coordinate_frame }, + { "glTangent3fvEXT", glTangent3fvEXT, extensions->has_GL_EXT_coordinate_frame }, + { "glTangent3iEXT", glTangent3iEXT, extensions->has_GL_EXT_coordinate_frame }, + { "glTangent3ivEXT", glTangent3ivEXT, extensions->has_GL_EXT_coordinate_frame }, + { "glTangent3sEXT", glTangent3sEXT, extensions->has_GL_EXT_coordinate_frame }, + { "glTangent3svEXT", glTangent3svEXT, extensions->has_GL_EXT_coordinate_frame }, + { "glTangentPointerEXT", glTangentPointerEXT, extensions->has_GL_EXT_coordinate_frame }, + { "glTbufferMask3DFX", glTbufferMask3DFX, extensions->has_GL_3DFX_tbuffer }, + { "glTessellationFactorAMD", glTessellationFactorAMD, extensions->has_GL_AMD_vertex_shader_tessellator }, + { "glTessellationModeAMD", glTessellationModeAMD, extensions->has_GL_AMD_vertex_shader_tessellator }, + { "glTestFenceAPPLE", glTestFenceAPPLE, extensions->has_GL_APPLE_fence }, + { "glTestFenceNV", glTestFenceNV, extensions->has_GL_NV_fence }, + { "glTestObjectAPPLE", glTestObjectAPPLE, extensions->has_GL_APPLE_fence }, + { "glTexAttachMemoryNV", glTexAttachMemoryNV, extensions->has_GL_NV_memory_attachment }, + { "glTexBuffer", glTexBuffer, (major > 3 || (major == 3 && minor >= 1)) }, + { "glTexBufferARB", glTexBufferARB, extensions->has_GL_ARB_texture_buffer_object }, + { "glTexBufferEXT", glTexBufferEXT, extensions->has_GL_EXT_texture_buffer_object }, + { "glTexBufferRange", glTexBufferRange, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_texture_buffer_range }, + { "glTexBumpParameterfvATI", glTexBumpParameterfvATI, extensions->has_GL_ATI_envmap_bumpmap }, + { "glTexBumpParameterivATI", glTexBumpParameterivATI, extensions->has_GL_ATI_envmap_bumpmap }, + { "glTexCoord1bOES", glTexCoord1bOES, extensions->has_GL_OES_byte_coordinates }, + { "glTexCoord1bvOES", glTexCoord1bvOES, extensions->has_GL_OES_byte_coordinates }, + { "glTexCoord1hNV", glTexCoord1hNV, extensions->has_GL_NV_half_float }, + { "glTexCoord1hvNV", glTexCoord1hvNV, extensions->has_GL_NV_half_float }, + { "glTexCoord1xOES", glTexCoord1xOES, extensions->has_GL_OES_fixed_point }, + { "glTexCoord1xvOES", glTexCoord1xvOES, extensions->has_GL_OES_fixed_point }, + { "glTexCoord2bOES", glTexCoord2bOES, extensions->has_GL_OES_byte_coordinates }, + { "glTexCoord2bvOES", glTexCoord2bvOES, extensions->has_GL_OES_byte_coordinates }, + { "glTexCoord2fColor3fVertex3fSUN", glTexCoord2fColor3fVertex3fSUN, extensions->has_GL_SUN_vertex }, + { "glTexCoord2fColor3fVertex3fvSUN", glTexCoord2fColor3fVertex3fvSUN, extensions->has_GL_SUN_vertex }, + { "glTexCoord2fColor4fNormal3fVertex3fSUN", glTexCoord2fColor4fNormal3fVertex3fSUN, extensions->has_GL_SUN_vertex }, + { "glTexCoord2fColor4fNormal3fVertex3fvSUN", glTexCoord2fColor4fNormal3fVertex3fvSUN, extensions->has_GL_SUN_vertex }, + { "glTexCoord2fColor4ubVertex3fSUN", glTexCoord2fColor4ubVertex3fSUN, extensions->has_GL_SUN_vertex }, + { "glTexCoord2fColor4ubVertex3fvSUN", glTexCoord2fColor4ubVertex3fvSUN, extensions->has_GL_SUN_vertex }, + { "glTexCoord2fNormal3fVertex3fSUN", glTexCoord2fNormal3fVertex3fSUN, extensions->has_GL_SUN_vertex }, + { "glTexCoord2fNormal3fVertex3fvSUN", glTexCoord2fNormal3fVertex3fvSUN, extensions->has_GL_SUN_vertex }, + { "glTexCoord2fVertex3fSUN", glTexCoord2fVertex3fSUN, extensions->has_GL_SUN_vertex }, + { "glTexCoord2fVertex3fvSUN", glTexCoord2fVertex3fvSUN, extensions->has_GL_SUN_vertex }, + { "glTexCoord2hNV", glTexCoord2hNV, extensions->has_GL_NV_half_float }, + { "glTexCoord2hvNV", glTexCoord2hvNV, extensions->has_GL_NV_half_float }, + { "glTexCoord2xOES", glTexCoord2xOES, extensions->has_GL_OES_fixed_point }, + { "glTexCoord2xvOES", glTexCoord2xvOES, extensions->has_GL_OES_fixed_point }, + { "glTexCoord3bOES", glTexCoord3bOES, extensions->has_GL_OES_byte_coordinates }, + { "glTexCoord3bvOES", glTexCoord3bvOES, extensions->has_GL_OES_byte_coordinates }, + { "glTexCoord3hNV", glTexCoord3hNV, extensions->has_GL_NV_half_float }, + { "glTexCoord3hvNV", glTexCoord3hvNV, extensions->has_GL_NV_half_float }, + { "glTexCoord3xOES", glTexCoord3xOES, extensions->has_GL_OES_fixed_point }, + { "glTexCoord3xvOES", glTexCoord3xvOES, extensions->has_GL_OES_fixed_point }, + { "glTexCoord4bOES", glTexCoord4bOES, extensions->has_GL_OES_byte_coordinates }, + { "glTexCoord4bvOES", glTexCoord4bvOES, extensions->has_GL_OES_byte_coordinates }, + { "glTexCoord4fColor4fNormal3fVertex4fSUN", glTexCoord4fColor4fNormal3fVertex4fSUN, extensions->has_GL_SUN_vertex }, + { "glTexCoord4fColor4fNormal3fVertex4fvSUN", glTexCoord4fColor4fNormal3fVertex4fvSUN, extensions->has_GL_SUN_vertex }, + { "glTexCoord4fVertex4fSUN", glTexCoord4fVertex4fSUN, extensions->has_GL_SUN_vertex }, + { "glTexCoord4fVertex4fvSUN", glTexCoord4fVertex4fvSUN, extensions->has_GL_SUN_vertex }, + { "glTexCoord4hNV", glTexCoord4hNV, extensions->has_GL_NV_half_float }, + { "glTexCoord4hvNV", glTexCoord4hvNV, extensions->has_GL_NV_half_float }, + { "glTexCoord4xOES", glTexCoord4xOES, extensions->has_GL_OES_fixed_point }, + { "glTexCoord4xvOES", glTexCoord4xvOES, extensions->has_GL_OES_fixed_point }, + { "glTexCoordFormatNV", glTexCoordFormatNV, extensions->has_GL_NV_vertex_buffer_unified_memory }, + { "glTexCoordP1ui", glTexCoordP1ui, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glTexCoordP1uiv", glTexCoordP1uiv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glTexCoordP2ui", glTexCoordP2ui, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glTexCoordP2uiv", glTexCoordP2uiv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glTexCoordP3ui", glTexCoordP3ui, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glTexCoordP3uiv", glTexCoordP3uiv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glTexCoordP4ui", glTexCoordP4ui, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glTexCoordP4uiv", glTexCoordP4uiv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glTexCoordPointerEXT", glTexCoordPointerEXT, extensions->has_GL_EXT_vertex_array }, + { "glTexCoordPointerListIBM", glTexCoordPointerListIBM, extensions->has_GL_IBM_vertex_array_lists }, + { "glTexCoordPointervINTEL", glTexCoordPointervINTEL, extensions->has_GL_INTEL_parallel_arrays }, + { "glTexEnvx", glTexEnvx, extensions->has_GL_NV_ES1_1_compatibility }, + { "glTexEnvxOES", glTexEnvxOES, extensions->has_GL_OES_fixed_point }, + { "glTexEnvxv", glTexEnvxv, extensions->has_GL_NV_ES1_1_compatibility }, + { "glTexEnvxvOES", glTexEnvxvOES, extensions->has_GL_OES_fixed_point }, + { "glTexFilterFuncSGIS", glTexFilterFuncSGIS, extensions->has_GL_SGIS_texture_filter4 }, + { "glTexGenxOES", glTexGenxOES, extensions->has_GL_OES_fixed_point }, + { "glTexGenxvOES", glTexGenxvOES, extensions->has_GL_OES_fixed_point }, + { "glTexImage2DMultisample", glTexImage2DMultisample, (major > 3 || (major == 3 && minor >= 2)) || extensions->has_GL_ARB_texture_multisample }, + { "glTexImage2DMultisampleCoverageNV", glTexImage2DMultisampleCoverageNV, extensions->has_GL_NV_texture_multisample }, + { "glTexImage3D", glTexImage3D, (major > 1 || (major == 1 && minor >= 2)) }, + { "glTexImage3DEXT", glTexImage3DEXT, extensions->has_GL_EXT_texture3D }, + { "glTexImage3DMultisample", glTexImage3DMultisample, (major > 3 || (major == 3 && minor >= 2)) || extensions->has_GL_ARB_texture_multisample }, + { "glTexImage3DMultisampleCoverageNV", glTexImage3DMultisampleCoverageNV, extensions->has_GL_NV_texture_multisample }, + { "glTexImage4DSGIS", glTexImage4DSGIS, extensions->has_GL_SGIS_texture4D }, + { "glTexPageCommitmentARB", glTexPageCommitmentARB, extensions->has_GL_ARB_sparse_texture }, + { "glTexPageCommitmentMemNV", glTexPageCommitmentMemNV, extensions->has_GL_NV_memory_object_sparse }, + { "glTexParameterIiv", glTexParameterIiv, (major > 3 || (major == 3 && minor >= 0)) }, + { "glTexParameterIivEXT", glTexParameterIivEXT, extensions->has_GL_EXT_texture_integer }, + { "glTexParameterIuiv", glTexParameterIuiv, (major > 3 || (major == 3 && minor >= 0)) }, + { "glTexParameterIuivEXT", glTexParameterIuivEXT, extensions->has_GL_EXT_texture_integer }, + { "glTexParameterx", glTexParameterx, extensions->has_GL_NV_ES1_1_compatibility }, + { "glTexParameterxOES", glTexParameterxOES, extensions->has_GL_OES_fixed_point }, + { "glTexParameterxv", glTexParameterxv, extensions->has_GL_NV_ES1_1_compatibility }, + { "glTexParameterxvOES", glTexParameterxvOES, extensions->has_GL_OES_fixed_point }, + { "glTexRenderbufferNV", glTexRenderbufferNV, extensions->has_GL_NV_explicit_multisample }, + { "glTexStorage1D", glTexStorage1D, (major > 4 || (major == 4 && minor >= 2)) || extensions->has_GL_ARB_texture_storage }, + { "glTexStorage1DEXT", glTexStorage1DEXT, extensions->has_GL_EXT_texture_storage }, + { "glTexStorage2D", glTexStorage2D, (major > 4 || (major == 4 && minor >= 2)) || extensions->has_GL_ARB_texture_storage }, + { "glTexStorage2DEXT", glTexStorage2DEXT, extensions->has_GL_EXT_texture_storage }, + { "glTexStorage2DMultisample", glTexStorage2DMultisample, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_texture_storage_multisample }, + { "glTexStorage3D", glTexStorage3D, (major > 4 || (major == 4 && minor >= 2)) || extensions->has_GL_ARB_texture_storage }, + { "glTexStorage3DEXT", glTexStorage3DEXT, extensions->has_GL_EXT_texture_storage }, + { "glTexStorage3DMultisample", glTexStorage3DMultisample, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_texture_storage_multisample }, + { "glTexStorageMem1DEXT", glTexStorageMem1DEXT, extensions->has_GL_EXT_memory_object }, + { "glTexStorageMem2DEXT", glTexStorageMem2DEXT, extensions->has_GL_EXT_memory_object }, + { "glTexStorageMem2DMultisampleEXT", glTexStorageMem2DMultisampleEXT, extensions->has_GL_EXT_memory_object }, + { "glTexStorageMem3DEXT", glTexStorageMem3DEXT, extensions->has_GL_EXT_memory_object }, + { "glTexStorageMem3DMultisampleEXT", glTexStorageMem3DMultisampleEXT, extensions->has_GL_EXT_memory_object }, + { "glTexStorageSparseAMD", glTexStorageSparseAMD, extensions->has_GL_AMD_sparse_texture }, + { "glTexSubImage1DEXT", glTexSubImage1DEXT, extensions->has_GL_EXT_subtexture }, + { "glTexSubImage2DEXT", glTexSubImage2DEXT, extensions->has_GL_EXT_subtexture }, + { "glTexSubImage3D", glTexSubImage3D, (major > 1 || (major == 1 && minor >= 2)) }, + { "glTexSubImage3DEXT", glTexSubImage3DEXT, extensions->has_GL_EXT_texture3D }, + { "glTexSubImage4DSGIS", glTexSubImage4DSGIS, extensions->has_GL_SGIS_texture4D }, + { "glTextureAttachMemoryNV", glTextureAttachMemoryNV, extensions->has_GL_NV_memory_attachment }, + { "glTextureBarrier", glTextureBarrier, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_texture_barrier }, + { "glTextureBarrierNV", glTextureBarrierNV, extensions->has_GL_NV_texture_barrier }, + { "glTextureBuffer", glTextureBuffer, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glTextureBufferEXT", glTextureBufferEXT, extensions->has_GL_EXT_direct_state_access }, + { "glTextureBufferRange", glTextureBufferRange, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glTextureBufferRangeEXT", glTextureBufferRangeEXT, extensions->has_GL_EXT_direct_state_access }, + { "glTextureColorMaskSGIS", glTextureColorMaskSGIS, extensions->has_GL_SGIS_texture_color_mask }, + { "glTextureImage1DEXT", glTextureImage1DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glTextureImage2DEXT", glTextureImage2DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glTextureImage2DMultisampleCoverageNV", glTextureImage2DMultisampleCoverageNV, extensions->has_GL_NV_texture_multisample }, + { "glTextureImage2DMultisampleNV", glTextureImage2DMultisampleNV, extensions->has_GL_NV_texture_multisample }, + { "glTextureImage3DEXT", glTextureImage3DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glTextureImage3DMultisampleCoverageNV", glTextureImage3DMultisampleCoverageNV, extensions->has_GL_NV_texture_multisample }, + { "glTextureImage3DMultisampleNV", glTextureImage3DMultisampleNV, extensions->has_GL_NV_texture_multisample }, + { "glTextureLightEXT", glTextureLightEXT, extensions->has_GL_EXT_light_texture }, + { "glTextureMaterialEXT", glTextureMaterialEXT, extensions->has_GL_EXT_light_texture }, + { "glTextureNormalEXT", glTextureNormalEXT, extensions->has_GL_EXT_texture_perturb_normal }, + { "glTexturePageCommitmentEXT", glTexturePageCommitmentEXT, extensions->has_GL_EXT_direct_state_access }, + { "glTexturePageCommitmentMemNV", glTexturePageCommitmentMemNV, extensions->has_GL_NV_memory_object_sparse }, + { "glTextureParameterIiv", glTextureParameterIiv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glTextureParameterIivEXT", glTextureParameterIivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glTextureParameterIuiv", glTextureParameterIuiv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glTextureParameterIuivEXT", glTextureParameterIuivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glTextureParameterf", glTextureParameterf, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glTextureParameterfEXT", glTextureParameterfEXT, extensions->has_GL_EXT_direct_state_access }, + { "glTextureParameterfv", glTextureParameterfv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glTextureParameterfvEXT", glTextureParameterfvEXT, extensions->has_GL_EXT_direct_state_access }, + { "glTextureParameteri", glTextureParameteri, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glTextureParameteriEXT", glTextureParameteriEXT, extensions->has_GL_EXT_direct_state_access }, + { "glTextureParameteriv", glTextureParameteriv, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glTextureParameterivEXT", glTextureParameterivEXT, extensions->has_GL_EXT_direct_state_access }, + { "glTextureRangeAPPLE", glTextureRangeAPPLE, extensions->has_GL_APPLE_texture_range }, + { "glTextureRenderbufferEXT", glTextureRenderbufferEXT, extensions->has_GL_EXT_direct_state_access }, + { "glTextureStorage1D", glTextureStorage1D, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glTextureStorage1DEXT", glTextureStorage1DEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_EXT_texture_storage }, + { "glTextureStorage2D", glTextureStorage2D, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glTextureStorage2DEXT", glTextureStorage2DEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_EXT_texture_storage }, + { "glTextureStorage2DMultisample", glTextureStorage2DMultisample, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glTextureStorage2DMultisampleEXT", glTextureStorage2DMultisampleEXT, extensions->has_GL_EXT_direct_state_access }, + { "glTextureStorage3D", glTextureStorage3D, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glTextureStorage3DEXT", glTextureStorage3DEXT, extensions->has_GL_EXT_direct_state_access || extensions->has_GL_EXT_texture_storage }, + { "glTextureStorage3DMultisample", glTextureStorage3DMultisample, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glTextureStorage3DMultisampleEXT", glTextureStorage3DMultisampleEXT, extensions->has_GL_EXT_direct_state_access }, + { "glTextureStorageMem1DEXT", glTextureStorageMem1DEXT, extensions->has_GL_EXT_memory_object }, + { "glTextureStorageMem2DEXT", glTextureStorageMem2DEXT, extensions->has_GL_EXT_memory_object }, + { "glTextureStorageMem2DMultisampleEXT", glTextureStorageMem2DMultisampleEXT, extensions->has_GL_EXT_memory_object }, + { "glTextureStorageMem3DEXT", glTextureStorageMem3DEXT, extensions->has_GL_EXT_memory_object }, + { "glTextureStorageMem3DMultisampleEXT", glTextureStorageMem3DMultisampleEXT, extensions->has_GL_EXT_memory_object }, + { "glTextureStorageSparseAMD", glTextureStorageSparseAMD, extensions->has_GL_AMD_sparse_texture }, + { "glTextureSubImage1D", glTextureSubImage1D, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glTextureSubImage1DEXT", glTextureSubImage1DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glTextureSubImage2D", glTextureSubImage2D, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glTextureSubImage2DEXT", glTextureSubImage2DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glTextureSubImage3D", glTextureSubImage3D, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glTextureSubImage3DEXT", glTextureSubImage3DEXT, extensions->has_GL_EXT_direct_state_access }, + { "glTextureView", glTextureView, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_texture_view }, + { "glTrackMatrixNV", glTrackMatrixNV, extensions->has_GL_NV_vertex_program }, + { "glTransformFeedbackAttribsNV", glTransformFeedbackAttribsNV, extensions->has_GL_NV_transform_feedback }, + { "glTransformFeedbackBufferBase", glTransformFeedbackBufferBase, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glTransformFeedbackBufferRange", glTransformFeedbackBufferRange, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glTransformFeedbackStreamAttribsNV", glTransformFeedbackStreamAttribsNV, extensions->has_GL_NV_transform_feedback }, + { "glTransformFeedbackVaryings", glTransformFeedbackVaryings, (major > 3 || (major == 3 && minor >= 0)) }, + { "glTransformFeedbackVaryingsEXT", glTransformFeedbackVaryingsEXT, extensions->has_GL_EXT_transform_feedback }, + { "glTransformFeedbackVaryingsNV", glTransformFeedbackVaryingsNV, extensions->has_GL_NV_transform_feedback }, + { "glTransformPathNV", glTransformPathNV, extensions->has_GL_NV_path_rendering }, + { "glTranslatex", glTranslatex, extensions->has_GL_NV_ES1_1_compatibility }, + { "glTranslatexOES", glTranslatexOES, extensions->has_GL_OES_fixed_point }, + { "glUniform1d", glUniform1d, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_gpu_shader_fp64 }, + { "glUniform1dv", glUniform1dv, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_gpu_shader_fp64 }, + { "glUniform1f", glUniform1f, (major > 2 || (major == 2 && minor >= 0)) }, + { "glUniform1fARB", glUniform1fARB, extensions->has_GL_ARB_shader_objects }, + { "glUniform1fv", glUniform1fv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glUniform1fvARB", glUniform1fvARB, extensions->has_GL_ARB_shader_objects }, + { "glUniform1i", glUniform1i, (major > 2 || (major == 2 && minor >= 0)) }, + { "glUniform1i64ARB", glUniform1i64ARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glUniform1i64NV", glUniform1i64NV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glUniform1i64vARB", glUniform1i64vARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glUniform1i64vNV", glUniform1i64vNV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glUniform1iARB", glUniform1iARB, extensions->has_GL_ARB_shader_objects }, + { "glUniform1iv", glUniform1iv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glUniform1ivARB", glUniform1ivARB, extensions->has_GL_ARB_shader_objects }, + { "glUniform1ui", glUniform1ui, (major > 3 || (major == 3 && minor >= 0)) }, + { "glUniform1ui64ARB", glUniform1ui64ARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glUniform1ui64NV", glUniform1ui64NV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glUniform1ui64vARB", glUniform1ui64vARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glUniform1ui64vNV", glUniform1ui64vNV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glUniform1uiEXT", glUniform1uiEXT, extensions->has_GL_EXT_gpu_shader4 }, + { "glUniform1uiv", glUniform1uiv, (major > 3 || (major == 3 && minor >= 0)) }, + { "glUniform1uivEXT", glUniform1uivEXT, extensions->has_GL_EXT_gpu_shader4 }, + { "glUniform2d", glUniform2d, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_gpu_shader_fp64 }, + { "glUniform2dv", glUniform2dv, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_gpu_shader_fp64 }, + { "glUniform2f", glUniform2f, (major > 2 || (major == 2 && minor >= 0)) }, + { "glUniform2fARB", glUniform2fARB, extensions->has_GL_ARB_shader_objects }, + { "glUniform2fv", glUniform2fv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glUniform2fvARB", glUniform2fvARB, extensions->has_GL_ARB_shader_objects }, + { "glUniform2i", glUniform2i, (major > 2 || (major == 2 && minor >= 0)) }, + { "glUniform2i64ARB", glUniform2i64ARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glUniform2i64NV", glUniform2i64NV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glUniform2i64vARB", glUniform2i64vARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glUniform2i64vNV", glUniform2i64vNV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glUniform2iARB", glUniform2iARB, extensions->has_GL_ARB_shader_objects }, + { "glUniform2iv", glUniform2iv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glUniform2ivARB", glUniform2ivARB, extensions->has_GL_ARB_shader_objects }, + { "glUniform2ui", glUniform2ui, (major > 3 || (major == 3 && minor >= 0)) }, + { "glUniform2ui64ARB", glUniform2ui64ARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glUniform2ui64NV", glUniform2ui64NV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glUniform2ui64vARB", glUniform2ui64vARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glUniform2ui64vNV", glUniform2ui64vNV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glUniform2uiEXT", glUniform2uiEXT, extensions->has_GL_EXT_gpu_shader4 }, + { "glUniform2uiv", glUniform2uiv, (major > 3 || (major == 3 && minor >= 0)) }, + { "glUniform2uivEXT", glUniform2uivEXT, extensions->has_GL_EXT_gpu_shader4 }, + { "glUniform3d", glUniform3d, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_gpu_shader_fp64 }, + { "glUniform3dv", glUniform3dv, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_gpu_shader_fp64 }, + { "glUniform3f", glUniform3f, (major > 2 || (major == 2 && minor >= 0)) }, + { "glUniform3fARB", glUniform3fARB, extensions->has_GL_ARB_shader_objects }, + { "glUniform3fv", glUniform3fv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glUniform3fvARB", glUniform3fvARB, extensions->has_GL_ARB_shader_objects }, + { "glUniform3i", glUniform3i, (major > 2 || (major == 2 && minor >= 0)) }, + { "glUniform3i64ARB", glUniform3i64ARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glUniform3i64NV", glUniform3i64NV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glUniform3i64vARB", glUniform3i64vARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glUniform3i64vNV", glUniform3i64vNV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glUniform3iARB", glUniform3iARB, extensions->has_GL_ARB_shader_objects }, + { "glUniform3iv", glUniform3iv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glUniform3ivARB", glUniform3ivARB, extensions->has_GL_ARB_shader_objects }, + { "glUniform3ui", glUniform3ui, (major > 3 || (major == 3 && minor >= 0)) }, + { "glUniform3ui64ARB", glUniform3ui64ARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glUniform3ui64NV", glUniform3ui64NV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glUniform3ui64vARB", glUniform3ui64vARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glUniform3ui64vNV", glUniform3ui64vNV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glUniform3uiEXT", glUniform3uiEXT, extensions->has_GL_EXT_gpu_shader4 }, + { "glUniform3uiv", glUniform3uiv, (major > 3 || (major == 3 && minor >= 0)) }, + { "glUniform3uivEXT", glUniform3uivEXT, extensions->has_GL_EXT_gpu_shader4 }, + { "glUniform4d", glUniform4d, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_gpu_shader_fp64 }, + { "glUniform4dv", glUniform4dv, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_gpu_shader_fp64 }, + { "glUniform4f", glUniform4f, (major > 2 || (major == 2 && minor >= 0)) }, + { "glUniform4fARB", glUniform4fARB, extensions->has_GL_ARB_shader_objects }, + { "glUniform4fv", glUniform4fv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glUniform4fvARB", glUniform4fvARB, extensions->has_GL_ARB_shader_objects }, + { "glUniform4i", glUniform4i, (major > 2 || (major == 2 && minor >= 0)) }, + { "glUniform4i64ARB", glUniform4i64ARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glUniform4i64NV", glUniform4i64NV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glUniform4i64vARB", glUniform4i64vARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glUniform4i64vNV", glUniform4i64vNV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glUniform4iARB", glUniform4iARB, extensions->has_GL_ARB_shader_objects }, + { "glUniform4iv", glUniform4iv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glUniform4ivARB", glUniform4ivARB, extensions->has_GL_ARB_shader_objects }, + { "glUniform4ui", glUniform4ui, (major > 3 || (major == 3 && minor >= 0)) }, + { "glUniform4ui64ARB", glUniform4ui64ARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glUniform4ui64NV", glUniform4ui64NV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glUniform4ui64vARB", glUniform4ui64vARB, extensions->has_GL_ARB_gpu_shader_int64 }, + { "glUniform4ui64vNV", glUniform4ui64vNV, extensions->has_GL_AMD_gpu_shader_int64 || extensions->has_GL_NV_gpu_shader5 }, + { "glUniform4uiEXT", glUniform4uiEXT, extensions->has_GL_EXT_gpu_shader4 }, + { "glUniform4uiv", glUniform4uiv, (major > 3 || (major == 3 && minor >= 0)) }, + { "glUniform4uivEXT", glUniform4uivEXT, extensions->has_GL_EXT_gpu_shader4 }, + { "glUniformBlockBinding", glUniformBlockBinding, (major > 3 || (major == 3 && minor >= 1)) || extensions->has_GL_ARB_uniform_buffer_object }, + { "glUniformBufferEXT", glUniformBufferEXT, extensions->has_GL_EXT_bindable_uniform }, + { "glUniformHandleui64ARB", glUniformHandleui64ARB, extensions->has_GL_ARB_bindless_texture }, + { "glUniformHandleui64NV", glUniformHandleui64NV, extensions->has_GL_NV_bindless_texture }, + { "glUniformHandleui64vARB", glUniformHandleui64vARB, extensions->has_GL_ARB_bindless_texture }, + { "glUniformHandleui64vNV", glUniformHandleui64vNV, extensions->has_GL_NV_bindless_texture }, + { "glUniformMatrix2dv", glUniformMatrix2dv, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_gpu_shader_fp64 }, + { "glUniformMatrix2fv", glUniformMatrix2fv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glUniformMatrix2fvARB", glUniformMatrix2fvARB, extensions->has_GL_ARB_shader_objects }, + { "glUniformMatrix2x3dv", glUniformMatrix2x3dv, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_gpu_shader_fp64 }, + { "glUniformMatrix2x3fv", glUniformMatrix2x3fv, (major > 2 || (major == 2 && minor >= 1)) }, + { "glUniformMatrix2x4dv", glUniformMatrix2x4dv, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_gpu_shader_fp64 }, + { "glUniformMatrix2x4fv", glUniformMatrix2x4fv, (major > 2 || (major == 2 && minor >= 1)) }, + { "glUniformMatrix3dv", glUniformMatrix3dv, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_gpu_shader_fp64 }, + { "glUniformMatrix3fv", glUniformMatrix3fv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glUniformMatrix3fvARB", glUniformMatrix3fvARB, extensions->has_GL_ARB_shader_objects }, + { "glUniformMatrix3x2dv", glUniformMatrix3x2dv, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_gpu_shader_fp64 }, + { "glUniformMatrix3x2fv", glUniformMatrix3x2fv, (major > 2 || (major == 2 && minor >= 1)) }, + { "glUniformMatrix3x4dv", glUniformMatrix3x4dv, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_gpu_shader_fp64 }, + { "glUniformMatrix3x4fv", glUniformMatrix3x4fv, (major > 2 || (major == 2 && minor >= 1)) }, + { "glUniformMatrix4dv", glUniformMatrix4dv, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_gpu_shader_fp64 }, + { "glUniformMatrix4fv", glUniformMatrix4fv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glUniformMatrix4fvARB", glUniformMatrix4fvARB, extensions->has_GL_ARB_shader_objects }, + { "glUniformMatrix4x2dv", glUniformMatrix4x2dv, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_gpu_shader_fp64 }, + { "glUniformMatrix4x2fv", glUniformMatrix4x2fv, (major > 2 || (major == 2 && minor >= 1)) }, + { "glUniformMatrix4x3dv", glUniformMatrix4x3dv, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_gpu_shader_fp64 }, + { "glUniformMatrix4x3fv", glUniformMatrix4x3fv, (major > 2 || (major == 2 && minor >= 1)) }, + { "glUniformSubroutinesuiv", glUniformSubroutinesuiv, (major > 4 || (major == 4 && minor >= 0)) || extensions->has_GL_ARB_shader_subroutine }, + { "glUniformui64NV", glUniformui64NV, extensions->has_GL_NV_shader_buffer_load }, + { "glUniformui64vNV", glUniformui64vNV, extensions->has_GL_NV_shader_buffer_load }, + { "glUnlockArraysEXT", glUnlockArraysEXT, extensions->has_GL_EXT_compiled_vertex_array }, + { "glUnmapBuffer", glUnmapBuffer, (major > 1 || (major == 1 && minor >= 5)) }, + { "glUnmapBufferARB", glUnmapBufferARB, extensions->has_GL_ARB_vertex_buffer_object }, + { "glUnmapNamedBuffer", glUnmapNamedBuffer, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glUnmapNamedBufferEXT", glUnmapNamedBufferEXT, extensions->has_GL_EXT_direct_state_access }, + { "glUnmapObjectBufferATI", glUnmapObjectBufferATI, extensions->has_GL_ATI_map_object_buffer }, + { "glUnmapTexture2DINTEL", glUnmapTexture2DINTEL, extensions->has_GL_INTEL_map_texture }, + { "glUpdateObjectBufferATI", glUpdateObjectBufferATI, extensions->has_GL_ATI_vertex_array_object }, + { "glUploadGpuMaskNVX", glUploadGpuMaskNVX, extensions->has_GL_NVX_gpu_multicast2 }, + { "glUseProgram", glUseProgram, (major > 2 || (major == 2 && minor >= 0)) }, + { "glUseProgramObjectARB", glUseProgramObjectARB, extensions->has_GL_ARB_shader_objects }, + { "glUseProgramStages", glUseProgramStages, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glUseShaderProgramEXT", glUseShaderProgramEXT, extensions->has_GL_EXT_separate_shader_objects }, + { "glVDPAUFiniNV", glVDPAUFiniNV, extensions->has_GL_NV_vdpau_interop }, + { "glVDPAUGetSurfaceivNV", glVDPAUGetSurfaceivNV, extensions->has_GL_NV_vdpau_interop }, + { "glVDPAUInitNV", glVDPAUInitNV, extensions->has_GL_NV_vdpau_interop }, + { "glVDPAUIsSurfaceNV", glVDPAUIsSurfaceNV, extensions->has_GL_NV_vdpau_interop }, + { "glVDPAUMapSurfacesNV", glVDPAUMapSurfacesNV, extensions->has_GL_NV_vdpau_interop }, + { "glVDPAURegisterOutputSurfaceNV", glVDPAURegisterOutputSurfaceNV, extensions->has_GL_NV_vdpau_interop }, + { "glVDPAURegisterVideoSurfaceNV", glVDPAURegisterVideoSurfaceNV, extensions->has_GL_NV_vdpau_interop }, + { "glVDPAURegisterVideoSurfaceWithPictureStructureNV", glVDPAURegisterVideoSurfaceWithPictureStructureNV, extensions->has_GL_NV_vdpau_interop2 }, + { "glVDPAUSurfaceAccessNV", glVDPAUSurfaceAccessNV, extensions->has_GL_NV_vdpau_interop }, + { "glVDPAUUnmapSurfacesNV", glVDPAUUnmapSurfacesNV, extensions->has_GL_NV_vdpau_interop }, + { "glVDPAUUnregisterSurfaceNV", glVDPAUUnregisterSurfaceNV, extensions->has_GL_NV_vdpau_interop }, + { "glValidateProgram", glValidateProgram, (major > 2 || (major == 2 && minor >= 0)) }, + { "glValidateProgramARB", glValidateProgramARB, extensions->has_GL_ARB_shader_objects }, + { "glValidateProgramPipeline", glValidateProgramPipeline, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_separate_shader_objects }, + { "glVariantArrayObjectATI", glVariantArrayObjectATI, extensions->has_GL_ATI_vertex_array_object }, + { "glVariantPointerEXT", glVariantPointerEXT, extensions->has_GL_EXT_vertex_shader }, + { "glVariantbvEXT", glVariantbvEXT, extensions->has_GL_EXT_vertex_shader }, + { "glVariantdvEXT", glVariantdvEXT, extensions->has_GL_EXT_vertex_shader }, + { "glVariantfvEXT", glVariantfvEXT, extensions->has_GL_EXT_vertex_shader }, + { "glVariantivEXT", glVariantivEXT, extensions->has_GL_EXT_vertex_shader }, + { "glVariantsvEXT", glVariantsvEXT, extensions->has_GL_EXT_vertex_shader }, + { "glVariantubvEXT", glVariantubvEXT, extensions->has_GL_EXT_vertex_shader }, + { "glVariantuivEXT", glVariantuivEXT, extensions->has_GL_EXT_vertex_shader }, + { "glVariantusvEXT", glVariantusvEXT, extensions->has_GL_EXT_vertex_shader }, + { "glVertex2bOES", glVertex2bOES, extensions->has_GL_OES_byte_coordinates }, + { "glVertex2bvOES", glVertex2bvOES, extensions->has_GL_OES_byte_coordinates }, + { "glVertex2hNV", glVertex2hNV, extensions->has_GL_NV_half_float }, + { "glVertex2hvNV", glVertex2hvNV, extensions->has_GL_NV_half_float }, + { "glVertex2xOES", glVertex2xOES, extensions->has_GL_OES_fixed_point }, + { "glVertex2xvOES", glVertex2xvOES, extensions->has_GL_OES_fixed_point }, + { "glVertex3bOES", glVertex3bOES, extensions->has_GL_OES_byte_coordinates }, + { "glVertex3bvOES", glVertex3bvOES, extensions->has_GL_OES_byte_coordinates }, + { "glVertex3hNV", glVertex3hNV, extensions->has_GL_NV_half_float }, + { "glVertex3hvNV", glVertex3hvNV, extensions->has_GL_NV_half_float }, + { "glVertex3xOES", glVertex3xOES, extensions->has_GL_OES_fixed_point }, + { "glVertex3xvOES", glVertex3xvOES, extensions->has_GL_OES_fixed_point }, + { "glVertex4bOES", glVertex4bOES, extensions->has_GL_OES_byte_coordinates }, + { "glVertex4bvOES", glVertex4bvOES, extensions->has_GL_OES_byte_coordinates }, + { "glVertex4hNV", glVertex4hNV, extensions->has_GL_NV_half_float }, + { "glVertex4hvNV", glVertex4hvNV, extensions->has_GL_NV_half_float }, + { "glVertex4xOES", glVertex4xOES, extensions->has_GL_OES_fixed_point }, + { "glVertex4xvOES", glVertex4xvOES, extensions->has_GL_OES_fixed_point }, + { "glVertexArrayAttribBinding", glVertexArrayAttribBinding, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glVertexArrayAttribFormat", glVertexArrayAttribFormat, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glVertexArrayAttribIFormat", glVertexArrayAttribIFormat, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glVertexArrayAttribLFormat", glVertexArrayAttribLFormat, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glVertexArrayBindVertexBufferEXT", glVertexArrayBindVertexBufferEXT, extensions->has_GL_EXT_direct_state_access }, + { "glVertexArrayBindingDivisor", glVertexArrayBindingDivisor, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glVertexArrayColorOffsetEXT", glVertexArrayColorOffsetEXT, extensions->has_GL_EXT_direct_state_access }, + { "glVertexArrayEdgeFlagOffsetEXT", glVertexArrayEdgeFlagOffsetEXT, extensions->has_GL_EXT_direct_state_access }, + { "glVertexArrayElementBuffer", glVertexArrayElementBuffer, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glVertexArrayFogCoordOffsetEXT", glVertexArrayFogCoordOffsetEXT, extensions->has_GL_EXT_direct_state_access }, + { "glVertexArrayIndexOffsetEXT", glVertexArrayIndexOffsetEXT, extensions->has_GL_EXT_direct_state_access }, + { "glVertexArrayMultiTexCoordOffsetEXT", glVertexArrayMultiTexCoordOffsetEXT, extensions->has_GL_EXT_direct_state_access }, + { "glVertexArrayNormalOffsetEXT", glVertexArrayNormalOffsetEXT, extensions->has_GL_EXT_direct_state_access }, + { "glVertexArrayParameteriAPPLE", glVertexArrayParameteriAPPLE, extensions->has_GL_APPLE_vertex_array_range }, + { "glVertexArrayRangeAPPLE", glVertexArrayRangeAPPLE, extensions->has_GL_APPLE_vertex_array_range }, + { "glVertexArrayRangeNV", glVertexArrayRangeNV, extensions->has_GL_NV_vertex_array_range }, + { "glVertexArraySecondaryColorOffsetEXT", glVertexArraySecondaryColorOffsetEXT, extensions->has_GL_EXT_direct_state_access }, + { "glVertexArrayTexCoordOffsetEXT", glVertexArrayTexCoordOffsetEXT, extensions->has_GL_EXT_direct_state_access }, + { "glVertexArrayVertexAttribBindingEXT", glVertexArrayVertexAttribBindingEXT, extensions->has_GL_EXT_direct_state_access }, + { "glVertexArrayVertexAttribDivisorEXT", glVertexArrayVertexAttribDivisorEXT, extensions->has_GL_EXT_direct_state_access }, + { "glVertexArrayVertexAttribFormatEXT", glVertexArrayVertexAttribFormatEXT, extensions->has_GL_EXT_direct_state_access }, + { "glVertexArrayVertexAttribIFormatEXT", glVertexArrayVertexAttribIFormatEXT, extensions->has_GL_EXT_direct_state_access }, + { "glVertexArrayVertexAttribIOffsetEXT", glVertexArrayVertexAttribIOffsetEXT, extensions->has_GL_EXT_direct_state_access }, + { "glVertexArrayVertexAttribLFormatEXT", glVertexArrayVertexAttribLFormatEXT, extensions->has_GL_EXT_direct_state_access }, + { "glVertexArrayVertexAttribLOffsetEXT", glVertexArrayVertexAttribLOffsetEXT, extensions->has_GL_EXT_direct_state_access }, + { "glVertexArrayVertexAttribOffsetEXT", glVertexArrayVertexAttribOffsetEXT, extensions->has_GL_EXT_direct_state_access }, + { "glVertexArrayVertexBindingDivisorEXT", glVertexArrayVertexBindingDivisorEXT, extensions->has_GL_EXT_direct_state_access }, + { "glVertexArrayVertexBuffer", glVertexArrayVertexBuffer, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glVertexArrayVertexBuffers", glVertexArrayVertexBuffers, (major > 4 || (major == 4 && minor >= 5)) || extensions->has_GL_ARB_direct_state_access }, + { "glVertexArrayVertexOffsetEXT", glVertexArrayVertexOffsetEXT, extensions->has_GL_EXT_direct_state_access }, + { "glVertexAttrib1d", glVertexAttrib1d, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib1dARB", glVertexAttrib1dARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib1dNV", glVertexAttrib1dNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttrib1dv", glVertexAttrib1dv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib1dvARB", glVertexAttrib1dvARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib1dvNV", glVertexAttrib1dvNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttrib1f", glVertexAttrib1f, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib1fARB", glVertexAttrib1fARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib1fNV", glVertexAttrib1fNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttrib1fv", glVertexAttrib1fv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib1fvARB", glVertexAttrib1fvARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib1fvNV", glVertexAttrib1fvNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttrib1hNV", glVertexAttrib1hNV, extensions->has_GL_NV_half_float }, + { "glVertexAttrib1hvNV", glVertexAttrib1hvNV, extensions->has_GL_NV_half_float }, + { "glVertexAttrib1s", glVertexAttrib1s, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib1sARB", glVertexAttrib1sARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib1sNV", glVertexAttrib1sNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttrib1sv", glVertexAttrib1sv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib1svARB", glVertexAttrib1svARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib1svNV", glVertexAttrib1svNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttrib2d", glVertexAttrib2d, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib2dARB", glVertexAttrib2dARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib2dNV", glVertexAttrib2dNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttrib2dv", glVertexAttrib2dv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib2dvARB", glVertexAttrib2dvARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib2dvNV", glVertexAttrib2dvNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttrib2f", glVertexAttrib2f, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib2fARB", glVertexAttrib2fARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib2fNV", glVertexAttrib2fNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttrib2fv", glVertexAttrib2fv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib2fvARB", glVertexAttrib2fvARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib2fvNV", glVertexAttrib2fvNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttrib2hNV", glVertexAttrib2hNV, extensions->has_GL_NV_half_float }, + { "glVertexAttrib2hvNV", glVertexAttrib2hvNV, extensions->has_GL_NV_half_float }, + { "glVertexAttrib2s", glVertexAttrib2s, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib2sARB", glVertexAttrib2sARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib2sNV", glVertexAttrib2sNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttrib2sv", glVertexAttrib2sv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib2svARB", glVertexAttrib2svARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib2svNV", glVertexAttrib2svNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttrib3d", glVertexAttrib3d, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib3dARB", glVertexAttrib3dARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib3dNV", glVertexAttrib3dNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttrib3dv", glVertexAttrib3dv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib3dvARB", glVertexAttrib3dvARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib3dvNV", glVertexAttrib3dvNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttrib3f", glVertexAttrib3f, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib3fARB", glVertexAttrib3fARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib3fNV", glVertexAttrib3fNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttrib3fv", glVertexAttrib3fv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib3fvARB", glVertexAttrib3fvARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib3fvNV", glVertexAttrib3fvNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttrib3hNV", glVertexAttrib3hNV, extensions->has_GL_NV_half_float }, + { "glVertexAttrib3hvNV", glVertexAttrib3hvNV, extensions->has_GL_NV_half_float }, + { "glVertexAttrib3s", glVertexAttrib3s, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib3sARB", glVertexAttrib3sARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib3sNV", glVertexAttrib3sNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttrib3sv", glVertexAttrib3sv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib3svARB", glVertexAttrib3svARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib3svNV", glVertexAttrib3svNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttrib4Nbv", glVertexAttrib4Nbv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib4NbvARB", glVertexAttrib4NbvARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib4Niv", glVertexAttrib4Niv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib4NivARB", glVertexAttrib4NivARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib4Nsv", glVertexAttrib4Nsv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib4NsvARB", glVertexAttrib4NsvARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib4Nub", glVertexAttrib4Nub, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib4NubARB", glVertexAttrib4NubARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib4Nubv", glVertexAttrib4Nubv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib4NubvARB", glVertexAttrib4NubvARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib4Nuiv", glVertexAttrib4Nuiv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib4NuivARB", glVertexAttrib4NuivARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib4Nusv", glVertexAttrib4Nusv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib4NusvARB", glVertexAttrib4NusvARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib4bv", glVertexAttrib4bv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib4bvARB", glVertexAttrib4bvARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib4d", glVertexAttrib4d, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib4dARB", glVertexAttrib4dARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib4dNV", glVertexAttrib4dNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttrib4dv", glVertexAttrib4dv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib4dvARB", glVertexAttrib4dvARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib4dvNV", glVertexAttrib4dvNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttrib4f", glVertexAttrib4f, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib4fARB", glVertexAttrib4fARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib4fNV", glVertexAttrib4fNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttrib4fv", glVertexAttrib4fv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib4fvARB", glVertexAttrib4fvARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib4fvNV", glVertexAttrib4fvNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttrib4hNV", glVertexAttrib4hNV, extensions->has_GL_NV_half_float }, + { "glVertexAttrib4hvNV", glVertexAttrib4hvNV, extensions->has_GL_NV_half_float }, + { "glVertexAttrib4iv", glVertexAttrib4iv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib4ivARB", glVertexAttrib4ivARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib4s", glVertexAttrib4s, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib4sARB", glVertexAttrib4sARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib4sNV", glVertexAttrib4sNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttrib4sv", glVertexAttrib4sv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib4svARB", glVertexAttrib4svARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib4svNV", glVertexAttrib4svNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttrib4ubNV", glVertexAttrib4ubNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttrib4ubv", glVertexAttrib4ubv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib4ubvARB", glVertexAttrib4ubvARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib4ubvNV", glVertexAttrib4ubvNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttrib4uiv", glVertexAttrib4uiv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib4uivARB", glVertexAttrib4uivARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttrib4usv", glVertexAttrib4usv, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttrib4usvARB", glVertexAttrib4usvARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttribArrayObjectATI", glVertexAttribArrayObjectATI, extensions->has_GL_ATI_vertex_attrib_array_object }, + { "glVertexAttribBinding", glVertexAttribBinding, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_vertex_attrib_binding }, + { "glVertexAttribDivisor", glVertexAttribDivisor, (major > 3 || (major == 3 && minor >= 3)) }, + { "glVertexAttribDivisorARB", glVertexAttribDivisorARB, extensions->has_GL_ARB_instanced_arrays }, + { "glVertexAttribFormat", glVertexAttribFormat, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_vertex_attrib_binding }, + { "glVertexAttribFormatNV", glVertexAttribFormatNV, extensions->has_GL_NV_vertex_buffer_unified_memory }, + { "glVertexAttribI1i", glVertexAttribI1i, (major > 3 || (major == 3 && minor >= 0)) }, + { "glVertexAttribI1iEXT", glVertexAttribI1iEXT, extensions->has_GL_EXT_gpu_shader4 || extensions->has_GL_NV_vertex_program4 }, + { "glVertexAttribI1iv", glVertexAttribI1iv, (major > 3 || (major == 3 && minor >= 0)) }, + { "glVertexAttribI1ivEXT", glVertexAttribI1ivEXT, extensions->has_GL_EXT_gpu_shader4 || extensions->has_GL_NV_vertex_program4 }, + { "glVertexAttribI1ui", glVertexAttribI1ui, (major > 3 || (major == 3 && minor >= 0)) }, + { "glVertexAttribI1uiEXT", glVertexAttribI1uiEXT, extensions->has_GL_EXT_gpu_shader4 || extensions->has_GL_NV_vertex_program4 }, + { "glVertexAttribI1uiv", glVertexAttribI1uiv, (major > 3 || (major == 3 && minor >= 0)) }, + { "glVertexAttribI1uivEXT", glVertexAttribI1uivEXT, extensions->has_GL_EXT_gpu_shader4 || extensions->has_GL_NV_vertex_program4 }, + { "glVertexAttribI2i", glVertexAttribI2i, (major > 3 || (major == 3 && minor >= 0)) }, + { "glVertexAttribI2iEXT", glVertexAttribI2iEXT, extensions->has_GL_EXT_gpu_shader4 || extensions->has_GL_NV_vertex_program4 }, + { "glVertexAttribI2iv", glVertexAttribI2iv, (major > 3 || (major == 3 && minor >= 0)) }, + { "glVertexAttribI2ivEXT", glVertexAttribI2ivEXT, extensions->has_GL_EXT_gpu_shader4 || extensions->has_GL_NV_vertex_program4 }, + { "glVertexAttribI2ui", glVertexAttribI2ui, (major > 3 || (major == 3 && minor >= 0)) }, + { "glVertexAttribI2uiEXT", glVertexAttribI2uiEXT, extensions->has_GL_EXT_gpu_shader4 || extensions->has_GL_NV_vertex_program4 }, + { "glVertexAttribI2uiv", glVertexAttribI2uiv, (major > 3 || (major == 3 && minor >= 0)) }, + { "glVertexAttribI2uivEXT", glVertexAttribI2uivEXT, extensions->has_GL_EXT_gpu_shader4 || extensions->has_GL_NV_vertex_program4 }, + { "glVertexAttribI3i", glVertexAttribI3i, (major > 3 || (major == 3 && minor >= 0)) }, + { "glVertexAttribI3iEXT", glVertexAttribI3iEXT, extensions->has_GL_EXT_gpu_shader4 || extensions->has_GL_NV_vertex_program4 }, + { "glVertexAttribI3iv", glVertexAttribI3iv, (major > 3 || (major == 3 && minor >= 0)) }, + { "glVertexAttribI3ivEXT", glVertexAttribI3ivEXT, extensions->has_GL_EXT_gpu_shader4 || extensions->has_GL_NV_vertex_program4 }, + { "glVertexAttribI3ui", glVertexAttribI3ui, (major > 3 || (major == 3 && minor >= 0)) }, + { "glVertexAttribI3uiEXT", glVertexAttribI3uiEXT, extensions->has_GL_EXT_gpu_shader4 || extensions->has_GL_NV_vertex_program4 }, + { "glVertexAttribI3uiv", glVertexAttribI3uiv, (major > 3 || (major == 3 && minor >= 0)) }, + { "glVertexAttribI3uivEXT", glVertexAttribI3uivEXT, extensions->has_GL_EXT_gpu_shader4 || extensions->has_GL_NV_vertex_program4 }, + { "glVertexAttribI4bv", glVertexAttribI4bv, (major > 3 || (major == 3 && minor >= 0)) }, + { "glVertexAttribI4bvEXT", glVertexAttribI4bvEXT, extensions->has_GL_EXT_gpu_shader4 || extensions->has_GL_NV_vertex_program4 }, + { "glVertexAttribI4i", glVertexAttribI4i, (major > 3 || (major == 3 && minor >= 0)) }, + { "glVertexAttribI4iEXT", glVertexAttribI4iEXT, extensions->has_GL_EXT_gpu_shader4 || extensions->has_GL_NV_vertex_program4 }, + { "glVertexAttribI4iv", glVertexAttribI4iv, (major > 3 || (major == 3 && minor >= 0)) }, + { "glVertexAttribI4ivEXT", glVertexAttribI4ivEXT, extensions->has_GL_EXT_gpu_shader4 || extensions->has_GL_NV_vertex_program4 }, + { "glVertexAttribI4sv", glVertexAttribI4sv, (major > 3 || (major == 3 && minor >= 0)) }, + { "glVertexAttribI4svEXT", glVertexAttribI4svEXT, extensions->has_GL_EXT_gpu_shader4 || extensions->has_GL_NV_vertex_program4 }, + { "glVertexAttribI4ubv", glVertexAttribI4ubv, (major > 3 || (major == 3 && minor >= 0)) }, + { "glVertexAttribI4ubvEXT", glVertexAttribI4ubvEXT, extensions->has_GL_EXT_gpu_shader4 || extensions->has_GL_NV_vertex_program4 }, + { "glVertexAttribI4ui", glVertexAttribI4ui, (major > 3 || (major == 3 && minor >= 0)) }, + { "glVertexAttribI4uiEXT", glVertexAttribI4uiEXT, extensions->has_GL_EXT_gpu_shader4 || extensions->has_GL_NV_vertex_program4 }, + { "glVertexAttribI4uiv", glVertexAttribI4uiv, (major > 3 || (major == 3 && minor >= 0)) }, + { "glVertexAttribI4uivEXT", glVertexAttribI4uivEXT, extensions->has_GL_EXT_gpu_shader4 || extensions->has_GL_NV_vertex_program4 }, + { "glVertexAttribI4usv", glVertexAttribI4usv, (major > 3 || (major == 3 && minor >= 0)) }, + { "glVertexAttribI4usvEXT", glVertexAttribI4usvEXT, extensions->has_GL_EXT_gpu_shader4 || extensions->has_GL_NV_vertex_program4 }, + { "glVertexAttribIFormat", glVertexAttribIFormat, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_vertex_attrib_binding }, + { "glVertexAttribIFormatNV", glVertexAttribIFormatNV, extensions->has_GL_NV_vertex_buffer_unified_memory }, + { "glVertexAttribIPointer", glVertexAttribIPointer, (major > 3 || (major == 3 && minor >= 0)) }, + { "glVertexAttribIPointerEXT", glVertexAttribIPointerEXT, extensions->has_GL_EXT_gpu_shader4 || extensions->has_GL_NV_vertex_program4 }, + { "glVertexAttribL1d", glVertexAttribL1d, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_vertex_attrib_64bit }, + { "glVertexAttribL1dEXT", glVertexAttribL1dEXT, extensions->has_GL_EXT_vertex_attrib_64bit }, + { "glVertexAttribL1dv", glVertexAttribL1dv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_vertex_attrib_64bit }, + { "glVertexAttribL1dvEXT", glVertexAttribL1dvEXT, extensions->has_GL_EXT_vertex_attrib_64bit }, + { "glVertexAttribL1i64NV", glVertexAttribL1i64NV, extensions->has_GL_NV_vertex_attrib_integer_64bit }, + { "glVertexAttribL1i64vNV", glVertexAttribL1i64vNV, extensions->has_GL_NV_vertex_attrib_integer_64bit }, + { "glVertexAttribL1ui64ARB", glVertexAttribL1ui64ARB, extensions->has_GL_ARB_bindless_texture }, + { "glVertexAttribL1ui64NV", glVertexAttribL1ui64NV, extensions->has_GL_NV_vertex_attrib_integer_64bit }, + { "glVertexAttribL1ui64vARB", glVertexAttribL1ui64vARB, extensions->has_GL_ARB_bindless_texture }, + { "glVertexAttribL1ui64vNV", glVertexAttribL1ui64vNV, extensions->has_GL_NV_vertex_attrib_integer_64bit }, + { "glVertexAttribL2d", glVertexAttribL2d, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_vertex_attrib_64bit }, + { "glVertexAttribL2dEXT", glVertexAttribL2dEXT, extensions->has_GL_EXT_vertex_attrib_64bit }, + { "glVertexAttribL2dv", glVertexAttribL2dv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_vertex_attrib_64bit }, + { "glVertexAttribL2dvEXT", glVertexAttribL2dvEXT, extensions->has_GL_EXT_vertex_attrib_64bit }, + { "glVertexAttribL2i64NV", glVertexAttribL2i64NV, extensions->has_GL_NV_vertex_attrib_integer_64bit }, + { "glVertexAttribL2i64vNV", glVertexAttribL2i64vNV, extensions->has_GL_NV_vertex_attrib_integer_64bit }, + { "glVertexAttribL2ui64NV", glVertexAttribL2ui64NV, extensions->has_GL_NV_vertex_attrib_integer_64bit }, + { "glVertexAttribL2ui64vNV", glVertexAttribL2ui64vNV, extensions->has_GL_NV_vertex_attrib_integer_64bit }, + { "glVertexAttribL3d", glVertexAttribL3d, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_vertex_attrib_64bit }, + { "glVertexAttribL3dEXT", glVertexAttribL3dEXT, extensions->has_GL_EXT_vertex_attrib_64bit }, + { "glVertexAttribL3dv", glVertexAttribL3dv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_vertex_attrib_64bit }, + { "glVertexAttribL3dvEXT", glVertexAttribL3dvEXT, extensions->has_GL_EXT_vertex_attrib_64bit }, + { "glVertexAttribL3i64NV", glVertexAttribL3i64NV, extensions->has_GL_NV_vertex_attrib_integer_64bit }, + { "glVertexAttribL3i64vNV", glVertexAttribL3i64vNV, extensions->has_GL_NV_vertex_attrib_integer_64bit }, + { "glVertexAttribL3ui64NV", glVertexAttribL3ui64NV, extensions->has_GL_NV_vertex_attrib_integer_64bit }, + { "glVertexAttribL3ui64vNV", glVertexAttribL3ui64vNV, extensions->has_GL_NV_vertex_attrib_integer_64bit }, + { "glVertexAttribL4d", glVertexAttribL4d, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_vertex_attrib_64bit }, + { "glVertexAttribL4dEXT", glVertexAttribL4dEXT, extensions->has_GL_EXT_vertex_attrib_64bit }, + { "glVertexAttribL4dv", glVertexAttribL4dv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_vertex_attrib_64bit }, + { "glVertexAttribL4dvEXT", glVertexAttribL4dvEXT, extensions->has_GL_EXT_vertex_attrib_64bit }, + { "glVertexAttribL4i64NV", glVertexAttribL4i64NV, extensions->has_GL_NV_vertex_attrib_integer_64bit }, + { "glVertexAttribL4i64vNV", glVertexAttribL4i64vNV, extensions->has_GL_NV_vertex_attrib_integer_64bit }, + { "glVertexAttribL4ui64NV", glVertexAttribL4ui64NV, extensions->has_GL_NV_vertex_attrib_integer_64bit }, + { "glVertexAttribL4ui64vNV", glVertexAttribL4ui64vNV, extensions->has_GL_NV_vertex_attrib_integer_64bit }, + { "glVertexAttribLFormat", glVertexAttribLFormat, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_vertex_attrib_binding }, + { "glVertexAttribLFormatNV", glVertexAttribLFormatNV, extensions->has_GL_NV_vertex_attrib_integer_64bit }, + { "glVertexAttribLPointer", glVertexAttribLPointer, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_vertex_attrib_64bit }, + { "glVertexAttribLPointerEXT", glVertexAttribLPointerEXT, extensions->has_GL_EXT_vertex_attrib_64bit }, + { "glVertexAttribP1ui", glVertexAttribP1ui, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glVertexAttribP1uiv", glVertexAttribP1uiv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glVertexAttribP2ui", glVertexAttribP2ui, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glVertexAttribP2uiv", glVertexAttribP2uiv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glVertexAttribP3ui", glVertexAttribP3ui, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glVertexAttribP3uiv", glVertexAttribP3uiv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glVertexAttribP4ui", glVertexAttribP4ui, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glVertexAttribP4uiv", glVertexAttribP4uiv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glVertexAttribParameteriAMD", glVertexAttribParameteriAMD, extensions->has_GL_AMD_interleaved_elements }, + { "glVertexAttribPointer", glVertexAttribPointer, (major > 2 || (major == 2 && minor >= 0)) }, + { "glVertexAttribPointerARB", glVertexAttribPointerARB, extensions->has_GL_ARB_vertex_program || extensions->has_GL_ARB_vertex_shader }, + { "glVertexAttribPointerNV", glVertexAttribPointerNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttribs1dvNV", glVertexAttribs1dvNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttribs1fvNV", glVertexAttribs1fvNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttribs1hvNV", glVertexAttribs1hvNV, extensions->has_GL_NV_half_float }, + { "glVertexAttribs1svNV", glVertexAttribs1svNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttribs2dvNV", glVertexAttribs2dvNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttribs2fvNV", glVertexAttribs2fvNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttribs2hvNV", glVertexAttribs2hvNV, extensions->has_GL_NV_half_float }, + { "glVertexAttribs2svNV", glVertexAttribs2svNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttribs3dvNV", glVertexAttribs3dvNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttribs3fvNV", glVertexAttribs3fvNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttribs3hvNV", glVertexAttribs3hvNV, extensions->has_GL_NV_half_float }, + { "glVertexAttribs3svNV", glVertexAttribs3svNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttribs4dvNV", glVertexAttribs4dvNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttribs4fvNV", glVertexAttribs4fvNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttribs4hvNV", glVertexAttribs4hvNV, extensions->has_GL_NV_half_float }, + { "glVertexAttribs4svNV", glVertexAttribs4svNV, extensions->has_GL_NV_vertex_program }, + { "glVertexAttribs4ubvNV", glVertexAttribs4ubvNV, extensions->has_GL_NV_vertex_program }, + { "glVertexBindingDivisor", glVertexBindingDivisor, (major > 4 || (major == 4 && minor >= 3)) || extensions->has_GL_ARB_vertex_attrib_binding }, + { "glVertexBlendARB", glVertexBlendARB, extensions->has_GL_ARB_vertex_blend }, + { "glVertexBlendEnvfATI", glVertexBlendEnvfATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexBlendEnviATI", glVertexBlendEnviATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexFormatNV", glVertexFormatNV, extensions->has_GL_NV_vertex_buffer_unified_memory }, + { "glVertexP2ui", glVertexP2ui, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glVertexP2uiv", glVertexP2uiv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glVertexP3ui", glVertexP3ui, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glVertexP3uiv", glVertexP3uiv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glVertexP4ui", glVertexP4ui, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glVertexP4uiv", glVertexP4uiv, (major > 3 || (major == 3 && minor >= 3)) || extensions->has_GL_ARB_vertex_type_2_10_10_10_rev }, + { "glVertexPointerEXT", glVertexPointerEXT, extensions->has_GL_EXT_vertex_array }, + { "glVertexPointerListIBM", glVertexPointerListIBM, extensions->has_GL_IBM_vertex_array_lists }, + { "glVertexPointervINTEL", glVertexPointervINTEL, extensions->has_GL_INTEL_parallel_arrays }, + { "glVertexStream1dATI", glVertexStream1dATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream1dvATI", glVertexStream1dvATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream1fATI", glVertexStream1fATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream1fvATI", glVertexStream1fvATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream1iATI", glVertexStream1iATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream1ivATI", glVertexStream1ivATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream1sATI", glVertexStream1sATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream1svATI", glVertexStream1svATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream2dATI", glVertexStream2dATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream2dvATI", glVertexStream2dvATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream2fATI", glVertexStream2fATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream2fvATI", glVertexStream2fvATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream2iATI", glVertexStream2iATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream2ivATI", glVertexStream2ivATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream2sATI", glVertexStream2sATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream2svATI", glVertexStream2svATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream3dATI", glVertexStream3dATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream3dvATI", glVertexStream3dvATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream3fATI", glVertexStream3fATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream3fvATI", glVertexStream3fvATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream3iATI", glVertexStream3iATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream3ivATI", glVertexStream3ivATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream3sATI", glVertexStream3sATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream3svATI", glVertexStream3svATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream4dATI", glVertexStream4dATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream4dvATI", glVertexStream4dvATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream4fATI", glVertexStream4fATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream4fvATI", glVertexStream4fvATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream4iATI", glVertexStream4iATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream4ivATI", glVertexStream4ivATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream4sATI", glVertexStream4sATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexStream4svATI", glVertexStream4svATI, extensions->has_GL_ATI_vertex_streams }, + { "glVertexWeightPointerEXT", glVertexWeightPointerEXT, extensions->has_GL_EXT_vertex_weighting }, + { "glVertexWeightfEXT", glVertexWeightfEXT, extensions->has_GL_EXT_vertex_weighting }, + { "glVertexWeightfvEXT", glVertexWeightfvEXT, extensions->has_GL_EXT_vertex_weighting }, + { "glVertexWeighthNV", glVertexWeighthNV, extensions->has_GL_NV_half_float }, + { "glVertexWeighthvNV", glVertexWeighthvNV, extensions->has_GL_NV_half_float }, + { "glVideoCaptureNV", glVideoCaptureNV, extensions->has_GL_NV_video_capture }, + { "glVideoCaptureStreamParameterdvNV", glVideoCaptureStreamParameterdvNV, extensions->has_GL_NV_video_capture }, + { "glVideoCaptureStreamParameterfvNV", glVideoCaptureStreamParameterfvNV, extensions->has_GL_NV_video_capture }, + { "glVideoCaptureStreamParameterivNV", glVideoCaptureStreamParameterivNV, extensions->has_GL_NV_video_capture }, + { "glViewportArrayv", glViewportArrayv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_viewport_array }, + { "glViewportIndexedf", glViewportIndexedf, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_viewport_array }, + { "glViewportIndexedfv", glViewportIndexedfv, (major > 4 || (major == 4 && minor >= 1)) || extensions->has_GL_ARB_viewport_array }, + { "glViewportPositionWScaleNV", glViewportPositionWScaleNV, extensions->has_GL_NV_clip_space_w_scaling }, + { "glViewportSwizzleNV", glViewportSwizzleNV, extensions->has_GL_NV_viewport_swizzle }, + { "glWaitSemaphoreEXT", glWaitSemaphoreEXT, extensions->has_GL_EXT_semaphore }, + { "glWaitSemaphoreui64NVX", glWaitSemaphoreui64NVX, extensions->has_GL_NVX_progress_fence }, + { "glWaitSync", glWaitSync, (major > 3 || (major == 3 && minor >= 2)) || extensions->has_GL_ARB_sync }, + { "glWaitVkSemaphoreNV", glWaitVkSemaphoreNV, extensions->has_GL_NV_draw_vulkan_image }, + { "glWeightPathsNV", glWeightPathsNV, extensions->has_GL_NV_path_rendering }, + { "glWeightPointerARB", glWeightPointerARB, extensions->has_GL_ARB_vertex_blend }, + { "glWeightbvARB", glWeightbvARB, extensions->has_GL_ARB_vertex_blend }, + { "glWeightdvARB", glWeightdvARB, extensions->has_GL_ARB_vertex_blend }, + { "glWeightfvARB", glWeightfvARB, extensions->has_GL_ARB_vertex_blend }, + { "glWeightivARB", glWeightivARB, extensions->has_GL_ARB_vertex_blend }, + { "glWeightsvARB", glWeightsvARB, extensions->has_GL_ARB_vertex_blend }, + { "glWeightubvARB", glWeightubvARB, extensions->has_GL_ARB_vertex_blend }, + { "glWeightuivARB", glWeightuivARB, extensions->has_GL_ARB_vertex_blend }, + { "glWeightusvARB", glWeightusvARB, extensions->has_GL_ARB_vertex_blend }, + { "glWindowPos2d", glWindowPos2d, (major > 1 || (major == 1 && minor >= 4)) }, + { "glWindowPos2dARB", glWindowPos2dARB, extensions->has_GL_ARB_window_pos }, + { "glWindowPos2dMESA", glWindowPos2dMESA, extensions->has_GL_MESA_window_pos }, + { "glWindowPos2dv", glWindowPos2dv, (major > 1 || (major == 1 && minor >= 4)) }, + { "glWindowPos2dvARB", glWindowPos2dvARB, extensions->has_GL_ARB_window_pos }, + { "glWindowPos2dvMESA", glWindowPos2dvMESA, extensions->has_GL_MESA_window_pos }, + { "glWindowPos2f", glWindowPos2f, (major > 1 || (major == 1 && minor >= 4)) }, + { "glWindowPos2fARB", glWindowPos2fARB, extensions->has_GL_ARB_window_pos }, + { "glWindowPos2fMESA", glWindowPos2fMESA, extensions->has_GL_MESA_window_pos }, + { "glWindowPos2fv", glWindowPos2fv, (major > 1 || (major == 1 && minor >= 4)) }, + { "glWindowPos2fvARB", glWindowPos2fvARB, extensions->has_GL_ARB_window_pos }, + { "glWindowPos2fvMESA", glWindowPos2fvMESA, extensions->has_GL_MESA_window_pos }, + { "glWindowPos2i", glWindowPos2i, (major > 1 || (major == 1 && minor >= 4)) }, + { "glWindowPos2iARB", glWindowPos2iARB, extensions->has_GL_ARB_window_pos }, + { "glWindowPos2iMESA", glWindowPos2iMESA, extensions->has_GL_MESA_window_pos }, + { "glWindowPos2iv", glWindowPos2iv, (major > 1 || (major == 1 && minor >= 4)) }, + { "glWindowPos2ivARB", glWindowPos2ivARB, extensions->has_GL_ARB_window_pos }, + { "glWindowPos2ivMESA", glWindowPos2ivMESA, extensions->has_GL_MESA_window_pos }, + { "glWindowPos2s", glWindowPos2s, (major > 1 || (major == 1 && minor >= 4)) }, + { "glWindowPos2sARB", glWindowPos2sARB, extensions->has_GL_ARB_window_pos }, + { "glWindowPos2sMESA", glWindowPos2sMESA, extensions->has_GL_MESA_window_pos }, + { "glWindowPos2sv", glWindowPos2sv, (major > 1 || (major == 1 && minor >= 4)) }, + { "glWindowPos2svARB", glWindowPos2svARB, extensions->has_GL_ARB_window_pos }, + { "glWindowPos2svMESA", glWindowPos2svMESA, extensions->has_GL_MESA_window_pos }, + { "glWindowPos3d", glWindowPos3d, (major > 1 || (major == 1 && minor >= 4)) }, + { "glWindowPos3dARB", glWindowPos3dARB, extensions->has_GL_ARB_window_pos }, + { "glWindowPos3dMESA", glWindowPos3dMESA, extensions->has_GL_MESA_window_pos }, + { "glWindowPos3dv", glWindowPos3dv, (major > 1 || (major == 1 && minor >= 4)) }, + { "glWindowPos3dvARB", glWindowPos3dvARB, extensions->has_GL_ARB_window_pos }, + { "glWindowPos3dvMESA", glWindowPos3dvMESA, extensions->has_GL_MESA_window_pos }, + { "glWindowPos3f", glWindowPos3f, (major > 1 || (major == 1 && minor >= 4)) }, + { "glWindowPos3fARB", glWindowPos3fARB, extensions->has_GL_ARB_window_pos }, + { "glWindowPos3fMESA", glWindowPos3fMESA, extensions->has_GL_MESA_window_pos }, + { "glWindowPos3fv", glWindowPos3fv, (major > 1 || (major == 1 && minor >= 4)) }, + { "glWindowPos3fvARB", glWindowPos3fvARB, extensions->has_GL_ARB_window_pos }, + { "glWindowPos3fvMESA", glWindowPos3fvMESA, extensions->has_GL_MESA_window_pos }, + { "glWindowPos3i", glWindowPos3i, (major > 1 || (major == 1 && minor >= 4)) }, + { "glWindowPos3iARB", glWindowPos3iARB, extensions->has_GL_ARB_window_pos }, + { "glWindowPos3iMESA", glWindowPos3iMESA, extensions->has_GL_MESA_window_pos }, + { "glWindowPos3iv", glWindowPos3iv, (major > 1 || (major == 1 && minor >= 4)) }, + { "glWindowPos3ivARB", glWindowPos3ivARB, extensions->has_GL_ARB_window_pos }, + { "glWindowPos3ivMESA", glWindowPos3ivMESA, extensions->has_GL_MESA_window_pos }, + { "glWindowPos3s", glWindowPos3s, (major > 1 || (major == 1 && minor >= 4)) }, + { "glWindowPos3sARB", glWindowPos3sARB, extensions->has_GL_ARB_window_pos }, + { "glWindowPos3sMESA", glWindowPos3sMESA, extensions->has_GL_MESA_window_pos }, + { "glWindowPos3sv", glWindowPos3sv, (major > 1 || (major == 1 && minor >= 4)) }, + { "glWindowPos3svARB", glWindowPos3svARB, extensions->has_GL_ARB_window_pos }, + { "glWindowPos3svMESA", glWindowPos3svMESA, extensions->has_GL_MESA_window_pos }, + { "glWindowPos4dMESA", glWindowPos4dMESA, extensions->has_GL_MESA_window_pos }, + { "glWindowPos4dvMESA", glWindowPos4dvMESA, extensions->has_GL_MESA_window_pos }, + { "glWindowPos4fMESA", glWindowPos4fMESA, extensions->has_GL_MESA_window_pos }, + { "glWindowPos4fvMESA", glWindowPos4fvMESA, extensions->has_GL_MESA_window_pos }, + { "glWindowPos4iMESA", glWindowPos4iMESA, extensions->has_GL_MESA_window_pos }, + { "glWindowPos4ivMESA", glWindowPos4ivMESA, extensions->has_GL_MESA_window_pos }, + { "glWindowPos4sMESA", glWindowPos4sMESA, extensions->has_GL_MESA_window_pos }, + { "glWindowPos4svMESA", glWindowPos4svMESA, extensions->has_GL_MESA_window_pos }, + { "glWindowRectanglesEXT", glWindowRectanglesEXT, extensions->has_GL_EXT_window_rectangles }, + { "glWriteMaskEXT", glWriteMaskEXT, extensions->has_GL_EXT_vertex_shader }, + { "wglAllocateMemoryNV", wglAllocateMemoryNV, extensions->has_WGL_NV_vertex_array_range }, + { "wglBindTexImageARB", wglBindTexImageARB, extensions->has_WGL_ARB_render_texture }, + { "wglChoosePixelFormatARB", wglChoosePixelFormatARB, extensions->has_WGL_ARB_pixel_format }, + { "wglCreateContextAttribsARB", wglCreateContextAttribsARB, extensions->has_WGL_ARB_create_context }, + { "wglCreatePbufferARB", wglCreatePbufferARB, extensions->has_WGL_ARB_pbuffer }, + { "wglDestroyPbufferARB", wglDestroyPbufferARB, extensions->has_WGL_ARB_pbuffer }, + { "wglFreeMemoryNV", wglFreeMemoryNV, extensions->has_WGL_NV_vertex_array_range }, + { "wglGetCurrentReadDCARB", wglGetCurrentReadDCARB, extensions->has_WGL_ARB_make_current_read }, + { "wglGetExtensionsStringARB", wglGetExtensionsStringARB, extensions->has_WGL_ARB_extensions_string }, + { "wglGetExtensionsStringEXT", wglGetExtensionsStringEXT, extensions->has_WGL_EXT_extensions_string }, + { "wglGetPbufferDCARB", wglGetPbufferDCARB, extensions->has_WGL_ARB_pbuffer }, + { "wglGetPixelFormatAttribfvARB", wglGetPixelFormatAttribfvARB, extensions->has_WGL_ARB_pixel_format }, + { "wglGetPixelFormatAttribivARB", wglGetPixelFormatAttribivARB, extensions->has_WGL_ARB_pixel_format }, + { "wglGetSwapIntervalEXT", wglGetSwapIntervalEXT, extensions->has_WGL_EXT_swap_control }, + { "wglMakeContextCurrentARB", wglMakeContextCurrentARB, extensions->has_WGL_ARB_make_current_read }, + { "wglQueryCurrentRendererIntegerWINE", wglQueryCurrentRendererIntegerWINE, extensions->has_WGL_WINE_query_renderer }, + { "wglQueryCurrentRendererStringWINE", wglQueryCurrentRendererStringWINE, extensions->has_WGL_WINE_query_renderer }, + { "wglQueryPbufferARB", wglQueryPbufferARB, extensions->has_WGL_ARB_pbuffer }, + { "wglQueryRendererIntegerWINE", wglQueryRendererIntegerWINE, extensions->has_WGL_WINE_query_renderer }, + { "wglQueryRendererStringWINE", wglQueryRendererStringWINE, extensions->has_WGL_WINE_query_renderer }, + { "wglReleasePbufferDCARB", wglReleasePbufferDCARB, extensions->has_WGL_ARB_pbuffer }, + { "wglReleaseTexImageARB", wglReleaseTexImageARB, extensions->has_WGL_ARB_render_texture }, + { "wglSetPbufferAttribARB", wglSetPbufferAttribARB, extensions->has_WGL_ARB_render_texture }, + { "wglSetPixelFormatWINE", wglSetPixelFormatWINE, extensions->has_WGL_WINE_pixel_format_passthrough }, + { "wglSwapIntervalEXT", wglSwapIntervalEXT, extensions->has_WGL_EXT_swap_control }, + }; + if (!(found = bsearch( &entry, functions, ARRAY_SIZE(functions), sizeof(entry), function_entry_cmp ))) + { + WARN( "Function %s unknown\n", name ); + return NULL; + } + if (!found->supported) + { + WARN( "Function %s not supported\n", name ); + return NULL; + } + return found->function; +} diff --git a/dlls/opengl32/unix_private.h b/dlls/opengl32/unix_private.h index d5ec8cee7c4..c236c0a87b1 100644 --- a/dlls/opengl32/unix_private.h +++ b/dlls/opengl32/unix_private.h @@ -34,16 +34,6 @@ #include "wine/opengl_driver.h" #include "unix_thunks.h" -struct registry_entry -{ - const char *name; /* name of the extension */ - const char *extension; /* name of the GL/WGL extension */ - size_t offset; /* offset in the opengl_funcs table */ -}; - -extern const struct registry_entry extension_registry[]; -extern const int extension_registry_size; - extern struct opengl_funcs null_opengl_funcs; static inline const struct opengl_funcs *get_dc_funcs( HDC hdc ) diff --git a/dlls/opengl32/unix_thunks.c b/dlls/opengl32/unix_thunks.c index 73ecc42cffb..0bca65a85e7 100644 --- a/dlls/opengl32/unix_thunks.c +++ b/dlls/opengl32/unix_thunks.c @@ -62,7 +62,9 @@ static NTSTATUS wgl_wglGetPixelFormat( void *args ) static NTSTATUS wgl_wglGetProcAddress( void *args ) { struct wglGetProcAddress_params *params = args; - params->ret = wrap_wglGetProcAddress( params->teb, params->lpszProc ); + const struct opengl_funcs *funcs = params->teb->glTable; + if (!funcs->p_wglGetProcAddress) return STATUS_NOT_IMPLEMENTED; + params->ret = funcs->p_wglGetProcAddress( params->lpszProc ); return STATUS_SUCCESS; } @@ -33723,9 +33725,8 @@ static NTSTATUS wow64_wgl_wglGetProcAddress( void *args ) PTR32 lpszProc; PTR32 ret; } *params = args; - TEB *teb = get_teb64( params->teb ); - params->ret = (UINT_PTR)wrap_wglGetProcAddress( teb, ULongToPtr(params->lpszProc) ); - return STATUS_SUCCESS; + FIXME( "params %p stub!\n", params ); + return STATUS_NOT_IMPLEMENTED; } static NTSTATUS wow64_wgl_wglMakeCurrent( void *args ) @@ -91806,2766 +91807,3 @@ struct opengl_funcs null_opengl_funcs = .p_glVertexPointer = null_glVertexPointer, .p_glViewport = null_glViewport, }; - -const int extension_registry_size = 2758; -const struct registry_entry extension_registry[2758] = -{ - { "glAccumxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glAccumxOES) }, - { "glAcquireKeyedMutexWin32EXT", "GL_EXT_win32_keyed_mutex\0", offsetof(struct opengl_funcs, p_glAcquireKeyedMutexWin32EXT) }, - { "glActiveProgramEXT", "GL_EXT_separate_shader_objects\0", offsetof(struct opengl_funcs, p_glActiveProgramEXT) }, - { "glActiveShaderProgram", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glActiveShaderProgram) }, - { "glActiveStencilFaceEXT", "GL_EXT_stencil_two_side\0", offsetof(struct opengl_funcs, p_glActiveStencilFaceEXT) }, - { "glActiveTexture", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glActiveTexture) }, - { "glActiveTextureARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glActiveTextureARB) }, - { "glActiveVaryingNV", "GL_NV_transform_feedback\0", offsetof(struct opengl_funcs, p_glActiveVaryingNV) }, - { "glAlphaFragmentOp1ATI", "GL_ATI_fragment_shader\0", offsetof(struct opengl_funcs, p_glAlphaFragmentOp1ATI) }, - { "glAlphaFragmentOp2ATI", "GL_ATI_fragment_shader\0", offsetof(struct opengl_funcs, p_glAlphaFragmentOp2ATI) }, - { "glAlphaFragmentOp3ATI", "GL_ATI_fragment_shader\0", offsetof(struct opengl_funcs, p_glAlphaFragmentOp3ATI) }, - { "glAlphaFuncx", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glAlphaFuncx) }, - { "glAlphaFuncxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glAlphaFuncxOES) }, - { "glAlphaToCoverageDitherControlNV", "GL_NV_alpha_to_coverage_dither_control\0", offsetof(struct opengl_funcs, p_glAlphaToCoverageDitherControlNV) }, - { "glApplyFramebufferAttachmentCMAAINTEL", "GL_INTEL_framebuffer_CMAA\0", offsetof(struct opengl_funcs, p_glApplyFramebufferAttachmentCMAAINTEL) }, - { "glApplyTextureEXT", "GL_EXT_light_texture\0", offsetof(struct opengl_funcs, p_glApplyTextureEXT) }, - { "glAreProgramsResidentNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glAreProgramsResidentNV) }, - { "glAreTexturesResidentEXT", "GL_EXT_texture_object\0", offsetof(struct opengl_funcs, p_glAreTexturesResidentEXT) }, - { "glArrayElementEXT", "GL_EXT_vertex_array\0", offsetof(struct opengl_funcs, p_glArrayElementEXT) }, - { "glArrayObjectATI", "GL_ATI_vertex_array_object\0", offsetof(struct opengl_funcs, p_glArrayObjectATI) }, - { "glAsyncCopyBufferSubDataNVX", "GL_NVX_gpu_multicast2\0", offsetof(struct opengl_funcs, p_glAsyncCopyBufferSubDataNVX) }, - { "glAsyncCopyImageSubDataNVX", "GL_NVX_gpu_multicast2\0", offsetof(struct opengl_funcs, p_glAsyncCopyImageSubDataNVX) }, - { "glAsyncMarkerSGIX", "GL_SGIX_async\0", offsetof(struct opengl_funcs, p_glAsyncMarkerSGIX) }, - { "glAttachObjectARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glAttachObjectARB) }, - { "glAttachShader", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glAttachShader) }, - { "glBeginConditionalRender", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glBeginConditionalRender) }, - { "glBeginConditionalRenderNV", "GL_NV_conditional_render\0", offsetof(struct opengl_funcs, p_glBeginConditionalRenderNV) }, - { "glBeginConditionalRenderNVX", "GL_NVX_conditional_render\0", offsetof(struct opengl_funcs, p_glBeginConditionalRenderNVX) }, - { "glBeginFragmentShaderATI", "GL_ATI_fragment_shader\0", offsetof(struct opengl_funcs, p_glBeginFragmentShaderATI) }, - { "glBeginOcclusionQueryNV", "GL_NV_occlusion_query\0", offsetof(struct opengl_funcs, p_glBeginOcclusionQueryNV) }, - { "glBeginPerfMonitorAMD", "GL_AMD_performance_monitor\0", offsetof(struct opengl_funcs, p_glBeginPerfMonitorAMD) }, - { "glBeginPerfQueryINTEL", "GL_INTEL_performance_query\0", offsetof(struct opengl_funcs, p_glBeginPerfQueryINTEL) }, - { "glBeginQuery", "GL_VERSION_1_5\0", offsetof(struct opengl_funcs, p_glBeginQuery) }, - { "glBeginQueryARB", "GL_ARB_occlusion_query\0", offsetof(struct opengl_funcs, p_glBeginQueryARB) }, - { "glBeginQueryIndexed", "GL_ARB_transform_feedback3\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glBeginQueryIndexed) }, - { "glBeginTransformFeedback", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glBeginTransformFeedback) }, - { "glBeginTransformFeedbackEXT", "GL_EXT_transform_feedback\0", offsetof(struct opengl_funcs, p_glBeginTransformFeedbackEXT) }, - { "glBeginTransformFeedbackNV", "GL_NV_transform_feedback\0", offsetof(struct opengl_funcs, p_glBeginTransformFeedbackNV) }, - { "glBeginVertexShaderEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glBeginVertexShaderEXT) }, - { "glBeginVideoCaptureNV", "GL_NV_video_capture\0", offsetof(struct opengl_funcs, p_glBeginVideoCaptureNV) }, - { "glBindAttribLocation", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glBindAttribLocation) }, - { "glBindAttribLocationARB", "GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glBindAttribLocationARB) }, - { "glBindBuffer", "GL_VERSION_1_5\0", offsetof(struct opengl_funcs, p_glBindBuffer) }, - { "glBindBufferARB", "GL_ARB_vertex_buffer_object\0", offsetof(struct opengl_funcs, p_glBindBufferARB) }, - { "glBindBufferBase", "GL_ARB_uniform_buffer_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glBindBufferBase) }, - { "glBindBufferBaseEXT", "GL_EXT_transform_feedback\0", offsetof(struct opengl_funcs, p_glBindBufferBaseEXT) }, - { "glBindBufferBaseNV", "GL_NV_transform_feedback\0", offsetof(struct opengl_funcs, p_glBindBufferBaseNV) }, - { "glBindBufferOffsetEXT", "GL_EXT_transform_feedback\0", offsetof(struct opengl_funcs, p_glBindBufferOffsetEXT) }, - { "glBindBufferOffsetNV", "GL_NV_transform_feedback\0", offsetof(struct opengl_funcs, p_glBindBufferOffsetNV) }, - { "glBindBufferRange", "GL_ARB_uniform_buffer_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glBindBufferRange) }, - { "glBindBufferRangeEXT", "GL_EXT_transform_feedback\0", offsetof(struct opengl_funcs, p_glBindBufferRangeEXT) }, - { "glBindBufferRangeNV", "GL_NV_transform_feedback\0", offsetof(struct opengl_funcs, p_glBindBufferRangeNV) }, - { "glBindBuffersBase", "GL_ARB_multi_bind\0GL_VERSION_4_4\0", offsetof(struct opengl_funcs, p_glBindBuffersBase) }, - { "glBindBuffersRange", "GL_ARB_multi_bind\0GL_VERSION_4_4\0", offsetof(struct opengl_funcs, p_glBindBuffersRange) }, - { "glBindFragDataLocation", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glBindFragDataLocation) }, - { "glBindFragDataLocationEXT", "GL_EXT_gpu_shader4\0", offsetof(struct opengl_funcs, p_glBindFragDataLocationEXT) }, - { "glBindFragDataLocationIndexed", "GL_ARB_blend_func_extended\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glBindFragDataLocationIndexed) }, - { "glBindFragmentShaderATI", "GL_ATI_fragment_shader\0", offsetof(struct opengl_funcs, p_glBindFragmentShaderATI) }, - { "glBindFramebuffer", "GL_ARB_framebuffer_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glBindFramebuffer) }, - { "glBindFramebufferEXT", "GL_EXT_framebuffer_object\0", offsetof(struct opengl_funcs, p_glBindFramebufferEXT) }, - { "glBindImageTexture", "GL_ARB_shader_image_load_store\0GL_VERSION_4_2\0", offsetof(struct opengl_funcs, p_glBindImageTexture) }, - { "glBindImageTextureEXT", "GL_EXT_shader_image_load_store\0", offsetof(struct opengl_funcs, p_glBindImageTextureEXT) }, - { "glBindImageTextures", "GL_ARB_multi_bind\0GL_VERSION_4_4\0", offsetof(struct opengl_funcs, p_glBindImageTextures) }, - { "glBindLightParameterEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glBindLightParameterEXT) }, - { "glBindMaterialParameterEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glBindMaterialParameterEXT) }, - { "glBindMultiTextureEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glBindMultiTextureEXT) }, - { "glBindParameterEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glBindParameterEXT) }, - { "glBindProgramARB", "GL_ARB_fragment_program\0GL_ARB_vertex_program\0", offsetof(struct opengl_funcs, p_glBindProgramARB) }, - { "glBindProgramNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glBindProgramNV) }, - { "glBindProgramPipeline", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glBindProgramPipeline) }, - { "glBindRenderbuffer", "GL_ARB_framebuffer_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glBindRenderbuffer) }, - { "glBindRenderbufferEXT", "GL_EXT_framebuffer_object\0", offsetof(struct opengl_funcs, p_glBindRenderbufferEXT) }, - { "glBindSampler", "GL_ARB_sampler_objects\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glBindSampler) }, - { "glBindSamplers", "GL_ARB_multi_bind\0GL_VERSION_4_4\0", offsetof(struct opengl_funcs, p_glBindSamplers) }, - { "glBindShadingRateImageNV", "GL_NV_shading_rate_image\0", offsetof(struct opengl_funcs, p_glBindShadingRateImageNV) }, - { "glBindTexGenParameterEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glBindTexGenParameterEXT) }, - { "glBindTextureEXT", "GL_EXT_texture_object\0", offsetof(struct opengl_funcs, p_glBindTextureEXT) }, - { "glBindTextureUnit", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glBindTextureUnit) }, - { "glBindTextureUnitParameterEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glBindTextureUnitParameterEXT) }, - { "glBindTextures", "GL_ARB_multi_bind\0GL_VERSION_4_4\0", offsetof(struct opengl_funcs, p_glBindTextures) }, - { "glBindTransformFeedback", "GL_ARB_transform_feedback2\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glBindTransformFeedback) }, - { "glBindTransformFeedbackNV", "GL_NV_transform_feedback2\0", offsetof(struct opengl_funcs, p_glBindTransformFeedbackNV) }, - { "glBindVertexArray", "GL_ARB_vertex_array_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glBindVertexArray) }, - { "glBindVertexArrayAPPLE", "GL_APPLE_vertex_array_object\0", offsetof(struct opengl_funcs, p_glBindVertexArrayAPPLE) }, - { "glBindVertexBuffer", "GL_ARB_vertex_attrib_binding\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glBindVertexBuffer) }, - { "glBindVertexBuffers", "GL_ARB_multi_bind\0GL_VERSION_4_4\0", offsetof(struct opengl_funcs, p_glBindVertexBuffers) }, - { "glBindVertexShaderEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glBindVertexShaderEXT) }, - { "glBindVideoCaptureStreamBufferNV", "GL_NV_video_capture\0", offsetof(struct opengl_funcs, p_glBindVideoCaptureStreamBufferNV) }, - { "glBindVideoCaptureStreamTextureNV", "GL_NV_video_capture\0", offsetof(struct opengl_funcs, p_glBindVideoCaptureStreamTextureNV) }, - { "glBinormal3bEXT", "GL_EXT_coordinate_frame\0", offsetof(struct opengl_funcs, p_glBinormal3bEXT) }, - { "glBinormal3bvEXT", "GL_EXT_coordinate_frame\0", offsetof(struct opengl_funcs, p_glBinormal3bvEXT) }, - { "glBinormal3dEXT", "GL_EXT_coordinate_frame\0", offsetof(struct opengl_funcs, p_glBinormal3dEXT) }, - { "glBinormal3dvEXT", "GL_EXT_coordinate_frame\0", offsetof(struct opengl_funcs, p_glBinormal3dvEXT) }, - { "glBinormal3fEXT", "GL_EXT_coordinate_frame\0", offsetof(struct opengl_funcs, p_glBinormal3fEXT) }, - { "glBinormal3fvEXT", "GL_EXT_coordinate_frame\0", offsetof(struct opengl_funcs, p_glBinormal3fvEXT) }, - { "glBinormal3iEXT", "GL_EXT_coordinate_frame\0", offsetof(struct opengl_funcs, p_glBinormal3iEXT) }, - { "glBinormal3ivEXT", "GL_EXT_coordinate_frame\0", offsetof(struct opengl_funcs, p_glBinormal3ivEXT) }, - { "glBinormal3sEXT", "GL_EXT_coordinate_frame\0", offsetof(struct opengl_funcs, p_glBinormal3sEXT) }, - { "glBinormal3svEXT", "GL_EXT_coordinate_frame\0", offsetof(struct opengl_funcs, p_glBinormal3svEXT) }, - { "glBinormalPointerEXT", "GL_EXT_coordinate_frame\0", offsetof(struct opengl_funcs, p_glBinormalPointerEXT) }, - { "glBitmapxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glBitmapxOES) }, - { "glBlendBarrier", "GL_ARB_ES3_2_compatibility\0", offsetof(struct opengl_funcs, p_glBlendBarrier) }, - { "glBlendBarrierKHR", "GL_KHR_blend_equation_advanced\0", offsetof(struct opengl_funcs, p_glBlendBarrierKHR) }, - { "glBlendBarrierNV", "GL_NV_blend_equation_advanced\0", offsetof(struct opengl_funcs, p_glBlendBarrierNV) }, - { "glBlendColor", "GL_ARB_imaging\0GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glBlendColor) }, - { "glBlendColorEXT", "GL_EXT_blend_color\0", offsetof(struct opengl_funcs, p_glBlendColorEXT) }, - { "glBlendColorxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glBlendColorxOES) }, - { "glBlendEquation", "GL_ARB_imaging\0GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glBlendEquation) }, - { "glBlendEquationEXT", "GL_EXT_blend_minmax\0", offsetof(struct opengl_funcs, p_glBlendEquationEXT) }, - { "glBlendEquationIndexedAMD", "GL_AMD_draw_buffers_blend\0", offsetof(struct opengl_funcs, p_glBlendEquationIndexedAMD) }, - { "glBlendEquationSeparate", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glBlendEquationSeparate) }, - { "glBlendEquationSeparateEXT", "GL_ATI_blend_equation_separate\0GL_EXT_blend_equation_separate\0", offsetof(struct opengl_funcs, p_glBlendEquationSeparateEXT) }, - { "glBlendEquationSeparateIndexedAMD", "GL_AMD_draw_buffers_blend\0", offsetof(struct opengl_funcs, p_glBlendEquationSeparateIndexedAMD) }, - { "glBlendEquationSeparatei", "GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glBlendEquationSeparatei) }, - { "glBlendEquationSeparateiARB", "GL_ARB_draw_buffers_blend\0", offsetof(struct opengl_funcs, p_glBlendEquationSeparateiARB) }, - { "glBlendEquationi", "GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glBlendEquationi) }, - { "glBlendEquationiARB", "GL_ARB_draw_buffers_blend\0", offsetof(struct opengl_funcs, p_glBlendEquationiARB) }, - { "glBlendFuncIndexedAMD", "GL_AMD_draw_buffers_blend\0", offsetof(struct opengl_funcs, p_glBlendFuncIndexedAMD) }, - { "glBlendFuncSeparate", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glBlendFuncSeparate) }, - { "glBlendFuncSeparateEXT", "GL_EXT_blend_func_separate\0", offsetof(struct opengl_funcs, p_glBlendFuncSeparateEXT) }, - { "glBlendFuncSeparateINGR", "GL_INGR_blend_func_separate\0", offsetof(struct opengl_funcs, p_glBlendFuncSeparateINGR) }, - { "glBlendFuncSeparateIndexedAMD", "GL_AMD_draw_buffers_blend\0", offsetof(struct opengl_funcs, p_glBlendFuncSeparateIndexedAMD) }, - { "glBlendFuncSeparatei", "GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glBlendFuncSeparatei) }, - { "glBlendFuncSeparateiARB", "GL_ARB_draw_buffers_blend\0", offsetof(struct opengl_funcs, p_glBlendFuncSeparateiARB) }, - { "glBlendFunci", "GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glBlendFunci) }, - { "glBlendFunciARB", "GL_ARB_draw_buffers_blend\0", offsetof(struct opengl_funcs, p_glBlendFunciARB) }, - { "glBlendParameteriNV", "GL_NV_blend_equation_advanced\0", offsetof(struct opengl_funcs, p_glBlendParameteriNV) }, - { "glBlitFramebuffer", "GL_ARB_framebuffer_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glBlitFramebuffer) }, - { "glBlitFramebufferEXT", "GL_EXT_framebuffer_blit\0", offsetof(struct opengl_funcs, p_glBlitFramebufferEXT) }, - { "glBlitFramebufferLayerEXT", "GL_EXT_framebuffer_blit_layers\0", offsetof(struct opengl_funcs, p_glBlitFramebufferLayerEXT) }, - { "glBlitFramebufferLayersEXT", "GL_EXT_framebuffer_blit_layers\0", offsetof(struct opengl_funcs, p_glBlitFramebufferLayersEXT) }, - { "glBlitNamedFramebuffer", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glBlitNamedFramebuffer) }, - { "glBufferAddressRangeNV", "GL_NV_vertex_buffer_unified_memory\0", offsetof(struct opengl_funcs, p_glBufferAddressRangeNV) }, - { "glBufferAttachMemoryNV", "GL_NV_memory_attachment\0", offsetof(struct opengl_funcs, p_glBufferAttachMemoryNV) }, - { "glBufferData", "GL_VERSION_1_5\0", offsetof(struct opengl_funcs, p_glBufferData) }, - { "glBufferDataARB", "GL_ARB_vertex_buffer_object\0", offsetof(struct opengl_funcs, p_glBufferDataARB) }, - { "glBufferPageCommitmentARB", "GL_ARB_sparse_buffer\0", offsetof(struct opengl_funcs, p_glBufferPageCommitmentARB) }, - { "glBufferPageCommitmentMemNV", "GL_NV_memory_object_sparse\0", offsetof(struct opengl_funcs, p_glBufferPageCommitmentMemNV) }, - { "glBufferParameteriAPPLE", "GL_APPLE_flush_buffer_range\0", offsetof(struct opengl_funcs, p_glBufferParameteriAPPLE) }, - { "glBufferRegionEnabled", "GL_KTX_buffer_region\0", offsetof(struct opengl_funcs, p_glBufferRegionEnabled) }, - { "glBufferStorage", "GL_ARB_buffer_storage\0GL_VERSION_4_4\0", offsetof(struct opengl_funcs, p_glBufferStorage) }, - { "glBufferStorageExternalEXT", "GL_EXT_external_buffer\0", offsetof(struct opengl_funcs, p_glBufferStorageExternalEXT) }, - { "glBufferStorageMemEXT", "GL_EXT_memory_object\0", offsetof(struct opengl_funcs, p_glBufferStorageMemEXT) }, - { "glBufferSubData", "GL_VERSION_1_5\0", offsetof(struct opengl_funcs, p_glBufferSubData) }, - { "glBufferSubDataARB", "GL_ARB_vertex_buffer_object\0", offsetof(struct opengl_funcs, p_glBufferSubDataARB) }, - { "glCallCommandListNV", "GL_NV_command_list\0", offsetof(struct opengl_funcs, p_glCallCommandListNV) }, - { "glCheckFramebufferStatus", "GL_ARB_framebuffer_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glCheckFramebufferStatus) }, - { "glCheckFramebufferStatusEXT", "GL_EXT_framebuffer_object\0", offsetof(struct opengl_funcs, p_glCheckFramebufferStatusEXT) }, - { "glCheckNamedFramebufferStatus", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glCheckNamedFramebufferStatus) }, - { "glCheckNamedFramebufferStatusEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glCheckNamedFramebufferStatusEXT) }, - { "glClampColor", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glClampColor) }, - { "glClampColorARB", "GL_ARB_color_buffer_float\0", offsetof(struct opengl_funcs, p_glClampColorARB) }, - { "glClearAccumxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glClearAccumxOES) }, - { "glClearBufferData", "GL_ARB_clear_buffer_object\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glClearBufferData) }, - { "glClearBufferSubData", "GL_ARB_clear_buffer_object\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glClearBufferSubData) }, - { "glClearBufferfi", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glClearBufferfi) }, - { "glClearBufferfv", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glClearBufferfv) }, - { "glClearBufferiv", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glClearBufferiv) }, - { "glClearBufferuiv", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glClearBufferuiv) }, - { "glClearColorIiEXT", "GL_EXT_texture_integer\0", offsetof(struct opengl_funcs, p_glClearColorIiEXT) }, - { "glClearColorIuiEXT", "GL_EXT_texture_integer\0", offsetof(struct opengl_funcs, p_glClearColorIuiEXT) }, - { "glClearColorx", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glClearColorx) }, - { "glClearColorxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glClearColorxOES) }, - { "glClearDepthdNV", "GL_NV_depth_buffer_float\0", offsetof(struct opengl_funcs, p_glClearDepthdNV) }, - { "glClearDepthf", "GL_ARB_ES2_compatibility\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glClearDepthf) }, - { "glClearDepthfOES", "GL_OES_single_precision\0", offsetof(struct opengl_funcs, p_glClearDepthfOES) }, - { "glClearDepthx", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glClearDepthx) }, - { "glClearDepthxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glClearDepthxOES) }, - { "glClearNamedBufferData", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glClearNamedBufferData) }, - { "glClearNamedBufferDataEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glClearNamedBufferDataEXT) }, - { "glClearNamedBufferSubData", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glClearNamedBufferSubData) }, - { "glClearNamedBufferSubDataEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glClearNamedBufferSubDataEXT) }, - { "glClearNamedFramebufferfi", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glClearNamedFramebufferfi) }, - { "glClearNamedFramebufferfv", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glClearNamedFramebufferfv) }, - { "glClearNamedFramebufferiv", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glClearNamedFramebufferiv) }, - { "glClearNamedFramebufferuiv", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glClearNamedFramebufferuiv) }, - { "glClearTexImage", "GL_ARB_clear_texture\0GL_VERSION_4_4\0", offsetof(struct opengl_funcs, p_glClearTexImage) }, - { "glClearTexSubImage", "GL_ARB_clear_texture\0GL_VERSION_4_4\0", offsetof(struct opengl_funcs, p_glClearTexSubImage) }, - { "glClientActiveTexture", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glClientActiveTexture) }, - { "glClientActiveTextureARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glClientActiveTextureARB) }, - { "glClientActiveVertexStreamATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glClientActiveVertexStreamATI) }, - { "glClientAttribDefaultEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glClientAttribDefaultEXT) }, - { "glClientWaitSemaphoreui64NVX", "GL_NVX_progress_fence\0", offsetof(struct opengl_funcs, p_glClientWaitSemaphoreui64NVX) }, - { "glClientWaitSync", "GL_ARB_sync\0GL_VERSION_3_2\0", offsetof(struct opengl_funcs, p_glClientWaitSync) }, - { "glClipControl", "GL_ARB_clip_control\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glClipControl) }, - { "glClipPlanef", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glClipPlanef) }, - { "glClipPlanefOES", "GL_OES_single_precision\0", offsetof(struct opengl_funcs, p_glClipPlanefOES) }, - { "glClipPlanex", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glClipPlanex) }, - { "glClipPlanexOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glClipPlanexOES) }, - { "glColor3fVertex3fSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glColor3fVertex3fSUN) }, - { "glColor3fVertex3fvSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glColor3fVertex3fvSUN) }, - { "glColor3hNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glColor3hNV) }, - { "glColor3hvNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glColor3hvNV) }, - { "glColor3xOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glColor3xOES) }, - { "glColor3xvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glColor3xvOES) }, - { "glColor4fNormal3fVertex3fSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glColor4fNormal3fVertex3fSUN) }, - { "glColor4fNormal3fVertex3fvSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glColor4fNormal3fVertex3fvSUN) }, - { "glColor4hNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glColor4hNV) }, - { "glColor4hvNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glColor4hvNV) }, - { "glColor4ubVertex2fSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glColor4ubVertex2fSUN) }, - { "glColor4ubVertex2fvSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glColor4ubVertex2fvSUN) }, - { "glColor4ubVertex3fSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glColor4ubVertex3fSUN) }, - { "glColor4ubVertex3fvSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glColor4ubVertex3fvSUN) }, - { "glColor4x", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glColor4x) }, - { "glColor4xOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glColor4xOES) }, - { "glColor4xvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glColor4xvOES) }, - { "glColorFormatNV", "GL_NV_vertex_buffer_unified_memory\0", offsetof(struct opengl_funcs, p_glColorFormatNV) }, - { "glColorFragmentOp1ATI", "GL_ATI_fragment_shader\0", offsetof(struct opengl_funcs, p_glColorFragmentOp1ATI) }, - { "glColorFragmentOp2ATI", "GL_ATI_fragment_shader\0", offsetof(struct opengl_funcs, p_glColorFragmentOp2ATI) }, - { "glColorFragmentOp3ATI", "GL_ATI_fragment_shader\0", offsetof(struct opengl_funcs, p_glColorFragmentOp3ATI) }, - { "glColorMaskIndexedEXT", "GL_EXT_draw_buffers2\0", offsetof(struct opengl_funcs, p_glColorMaskIndexedEXT) }, - { "glColorMaski", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glColorMaski) }, - { "glColorP3ui", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glColorP3ui) }, - { "glColorP3uiv", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glColorP3uiv) }, - { "glColorP4ui", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glColorP4ui) }, - { "glColorP4uiv", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glColorP4uiv) }, - { "glColorPointerEXT", "GL_EXT_vertex_array\0", offsetof(struct opengl_funcs, p_glColorPointerEXT) }, - { "glColorPointerListIBM", "GL_IBM_vertex_array_lists\0", offsetof(struct opengl_funcs, p_glColorPointerListIBM) }, - { "glColorPointervINTEL", "GL_INTEL_parallel_arrays\0", offsetof(struct opengl_funcs, p_glColorPointervINTEL) }, - { "glColorSubTable", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glColorSubTable) }, - { "glColorSubTableEXT", "GL_EXT_color_subtable\0", offsetof(struct opengl_funcs, p_glColorSubTableEXT) }, - { "glColorTable", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glColorTable) }, - { "glColorTableEXT", "GL_EXT_paletted_texture\0", offsetof(struct opengl_funcs, p_glColorTableEXT) }, - { "glColorTableParameterfv", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glColorTableParameterfv) }, - { "glColorTableParameterfvSGI", "GL_SGI_color_table\0", offsetof(struct opengl_funcs, p_glColorTableParameterfvSGI) }, - { "glColorTableParameteriv", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glColorTableParameteriv) }, - { "glColorTableParameterivSGI", "GL_SGI_color_table\0", offsetof(struct opengl_funcs, p_glColorTableParameterivSGI) }, - { "glColorTableSGI", "GL_SGI_color_table\0", offsetof(struct opengl_funcs, p_glColorTableSGI) }, - { "glCombinerInputNV", "GL_NV_register_combiners\0", offsetof(struct opengl_funcs, p_glCombinerInputNV) }, - { "glCombinerOutputNV", "GL_NV_register_combiners\0", offsetof(struct opengl_funcs, p_glCombinerOutputNV) }, - { "glCombinerParameterfNV", "GL_NV_register_combiners\0", offsetof(struct opengl_funcs, p_glCombinerParameterfNV) }, - { "glCombinerParameterfvNV", "GL_NV_register_combiners\0", offsetof(struct opengl_funcs, p_glCombinerParameterfvNV) }, - { "glCombinerParameteriNV", "GL_NV_register_combiners\0", offsetof(struct opengl_funcs, p_glCombinerParameteriNV) }, - { "glCombinerParameterivNV", "GL_NV_register_combiners\0", offsetof(struct opengl_funcs, p_glCombinerParameterivNV) }, - { "glCombinerStageParameterfvNV", "GL_NV_register_combiners2\0", offsetof(struct opengl_funcs, p_glCombinerStageParameterfvNV) }, - { "glCommandListSegmentsNV", "GL_NV_command_list\0", offsetof(struct opengl_funcs, p_glCommandListSegmentsNV) }, - { "glCompileCommandListNV", "GL_NV_command_list\0", offsetof(struct opengl_funcs, p_glCompileCommandListNV) }, - { "glCompileShader", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glCompileShader) }, - { "glCompileShaderARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glCompileShaderARB) }, - { "glCompileShaderIncludeARB", "GL_ARB_shading_language_include\0", offsetof(struct opengl_funcs, p_glCompileShaderIncludeARB) }, - { "glCompressedMultiTexImage1DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glCompressedMultiTexImage1DEXT) }, - { "glCompressedMultiTexImage2DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glCompressedMultiTexImage2DEXT) }, - { "glCompressedMultiTexImage3DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glCompressedMultiTexImage3DEXT) }, - { "glCompressedMultiTexSubImage1DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glCompressedMultiTexSubImage1DEXT) }, - { "glCompressedMultiTexSubImage2DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glCompressedMultiTexSubImage2DEXT) }, - { "glCompressedMultiTexSubImage3DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glCompressedMultiTexSubImage3DEXT) }, - { "glCompressedTexImage1D", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glCompressedTexImage1D) }, - { "glCompressedTexImage1DARB", "GL_ARB_texture_compression\0GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glCompressedTexImage1DARB) }, - { "glCompressedTexImage2D", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glCompressedTexImage2D) }, - { "glCompressedTexImage2DARB", "GL_ARB_texture_compression\0GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glCompressedTexImage2DARB) }, - { "glCompressedTexImage3D", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glCompressedTexImage3D) }, - { "glCompressedTexImage3DARB", "GL_ARB_texture_compression\0GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glCompressedTexImage3DARB) }, - { "glCompressedTexSubImage1D", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glCompressedTexSubImage1D) }, - { "glCompressedTexSubImage1DARB", "GL_ARB_texture_compression\0GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glCompressedTexSubImage1DARB) }, - { "glCompressedTexSubImage2D", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glCompressedTexSubImage2D) }, - { "glCompressedTexSubImage2DARB", "GL_ARB_texture_compression\0GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glCompressedTexSubImage2DARB) }, - { "glCompressedTexSubImage3D", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glCompressedTexSubImage3D) }, - { "glCompressedTexSubImage3DARB", "GL_ARB_texture_compression\0GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glCompressedTexSubImage3DARB) }, - { "glCompressedTextureImage1DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glCompressedTextureImage1DEXT) }, - { "glCompressedTextureImage2DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glCompressedTextureImage2DEXT) }, - { "glCompressedTextureImage3DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glCompressedTextureImage3DEXT) }, - { "glCompressedTextureSubImage1D", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glCompressedTextureSubImage1D) }, - { "glCompressedTextureSubImage1DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glCompressedTextureSubImage1DEXT) }, - { "glCompressedTextureSubImage2D", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glCompressedTextureSubImage2D) }, - { "glCompressedTextureSubImage2DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glCompressedTextureSubImage2DEXT) }, - { "glCompressedTextureSubImage3D", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glCompressedTextureSubImage3D) }, - { "glCompressedTextureSubImage3DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glCompressedTextureSubImage3DEXT) }, - { "glConservativeRasterParameterfNV", "GL_NV_conservative_raster_dilate\0", offsetof(struct opengl_funcs, p_glConservativeRasterParameterfNV) }, - { "glConservativeRasterParameteriNV", "GL_NV_conservative_raster_pre_snap_triangles\0", offsetof(struct opengl_funcs, p_glConservativeRasterParameteriNV) }, - { "glConvolutionFilter1D", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glConvolutionFilter1D) }, - { "glConvolutionFilter1DEXT", "GL_EXT_convolution\0", offsetof(struct opengl_funcs, p_glConvolutionFilter1DEXT) }, - { "glConvolutionFilter2D", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glConvolutionFilter2D) }, - { "glConvolutionFilter2DEXT", "GL_EXT_convolution\0", offsetof(struct opengl_funcs, p_glConvolutionFilter2DEXT) }, - { "glConvolutionParameterf", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glConvolutionParameterf) }, - { "glConvolutionParameterfEXT", "GL_EXT_convolution\0", offsetof(struct opengl_funcs, p_glConvolutionParameterfEXT) }, - { "glConvolutionParameterfv", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glConvolutionParameterfv) }, - { "glConvolutionParameterfvEXT", "GL_EXT_convolution\0", offsetof(struct opengl_funcs, p_glConvolutionParameterfvEXT) }, - { "glConvolutionParameteri", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glConvolutionParameteri) }, - { "glConvolutionParameteriEXT", "GL_EXT_convolution\0", offsetof(struct opengl_funcs, p_glConvolutionParameteriEXT) }, - { "glConvolutionParameteriv", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glConvolutionParameteriv) }, - { "glConvolutionParameterivEXT", "GL_EXT_convolution\0", offsetof(struct opengl_funcs, p_glConvolutionParameterivEXT) }, - { "glConvolutionParameterxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glConvolutionParameterxOES) }, - { "glConvolutionParameterxvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glConvolutionParameterxvOES) }, - { "glCopyBufferSubData", "GL_ARB_copy_buffer\0GL_EXT_copy_buffer\0GL_VERSION_3_1\0", offsetof(struct opengl_funcs, p_glCopyBufferSubData) }, - { "glCopyColorSubTable", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glCopyColorSubTable) }, - { "glCopyColorSubTableEXT", "GL_EXT_color_subtable\0", offsetof(struct opengl_funcs, p_glCopyColorSubTableEXT) }, - { "glCopyColorTable", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glCopyColorTable) }, - { "glCopyColorTableSGI", "GL_SGI_color_table\0", offsetof(struct opengl_funcs, p_glCopyColorTableSGI) }, - { "glCopyConvolutionFilter1D", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glCopyConvolutionFilter1D) }, - { "glCopyConvolutionFilter1DEXT", "GL_EXT_convolution\0", offsetof(struct opengl_funcs, p_glCopyConvolutionFilter1DEXT) }, - { "glCopyConvolutionFilter2D", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glCopyConvolutionFilter2D) }, - { "glCopyConvolutionFilter2DEXT", "GL_EXT_convolution\0", offsetof(struct opengl_funcs, p_glCopyConvolutionFilter2DEXT) }, - { "glCopyImageSubData", "GL_ARB_copy_image\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glCopyImageSubData) }, - { "glCopyImageSubDataNV", "GL_NV_copy_image\0", offsetof(struct opengl_funcs, p_glCopyImageSubDataNV) }, - { "glCopyMultiTexImage1DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glCopyMultiTexImage1DEXT) }, - { "glCopyMultiTexImage2DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glCopyMultiTexImage2DEXT) }, - { "glCopyMultiTexSubImage1DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glCopyMultiTexSubImage1DEXT) }, - { "glCopyMultiTexSubImage2DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glCopyMultiTexSubImage2DEXT) }, - { "glCopyMultiTexSubImage3DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glCopyMultiTexSubImage3DEXT) }, - { "glCopyNamedBufferSubData", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glCopyNamedBufferSubData) }, - { "glCopyPathNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glCopyPathNV) }, - { "glCopyTexImage1DEXT", "GL_EXT_copy_texture\0GL_VERSION_1_2\0", offsetof(struct opengl_funcs, p_glCopyTexImage1DEXT) }, - { "glCopyTexImage2DEXT", "GL_EXT_copy_texture\0GL_VERSION_1_2\0", offsetof(struct opengl_funcs, p_glCopyTexImage2DEXT) }, - { "glCopyTexSubImage1DEXT", "GL_EXT_copy_texture\0GL_VERSION_1_2\0", offsetof(struct opengl_funcs, p_glCopyTexSubImage1DEXT) }, - { "glCopyTexSubImage2DEXT", "GL_EXT_copy_texture\0GL_VERSION_1_2\0", offsetof(struct opengl_funcs, p_glCopyTexSubImage2DEXT) }, - { "glCopyTexSubImage3D", "GL_VERSION_1_2\0", offsetof(struct opengl_funcs, p_glCopyTexSubImage3D) }, - { "glCopyTexSubImage3DEXT", "GL_EXT_copy_texture\0GL_VERSION_1_2\0", offsetof(struct opengl_funcs, p_glCopyTexSubImage3DEXT) }, - { "glCopyTextureImage1DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glCopyTextureImage1DEXT) }, - { "glCopyTextureImage2DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glCopyTextureImage2DEXT) }, - { "glCopyTextureSubImage1D", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glCopyTextureSubImage1D) }, - { "glCopyTextureSubImage1DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glCopyTextureSubImage1DEXT) }, - { "glCopyTextureSubImage2D", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glCopyTextureSubImage2D) }, - { "glCopyTextureSubImage2DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glCopyTextureSubImage2DEXT) }, - { "glCopyTextureSubImage3D", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glCopyTextureSubImage3D) }, - { "glCopyTextureSubImage3DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glCopyTextureSubImage3DEXT) }, - { "glCoverFillPathInstancedNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glCoverFillPathInstancedNV) }, - { "glCoverFillPathNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glCoverFillPathNV) }, - { "glCoverStrokePathInstancedNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glCoverStrokePathInstancedNV) }, - { "glCoverStrokePathNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glCoverStrokePathNV) }, - { "glCoverageModulationNV", "GL_NV_framebuffer_mixed_samples\0", offsetof(struct opengl_funcs, p_glCoverageModulationNV) }, - { "glCoverageModulationTableNV", "GL_NV_framebuffer_mixed_samples\0", offsetof(struct opengl_funcs, p_glCoverageModulationTableNV) }, - { "glCreateBuffers", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glCreateBuffers) }, - { "glCreateCommandListsNV", "GL_NV_command_list\0", offsetof(struct opengl_funcs, p_glCreateCommandListsNV) }, - { "glCreateFramebuffers", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glCreateFramebuffers) }, - { "glCreateMemoryObjectsEXT", "GL_EXT_memory_object\0", offsetof(struct opengl_funcs, p_glCreateMemoryObjectsEXT) }, - { "glCreatePerfQueryINTEL", "GL_INTEL_performance_query\0", offsetof(struct opengl_funcs, p_glCreatePerfQueryINTEL) }, - { "glCreateProgram", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glCreateProgram) }, - { "glCreateProgramObjectARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glCreateProgramObjectARB) }, - { "glCreateProgramPipelines", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glCreateProgramPipelines) }, - { "glCreateProgressFenceNVX", "GL_NVX_progress_fence\0", offsetof(struct opengl_funcs, p_glCreateProgressFenceNVX) }, - { "glCreateQueries", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glCreateQueries) }, - { "glCreateRenderbuffers", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glCreateRenderbuffers) }, - { "glCreateSamplers", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glCreateSamplers) }, - { "glCreateSemaphoresNV", "GL_NV_timeline_semaphore\0", offsetof(struct opengl_funcs, p_glCreateSemaphoresNV) }, - { "glCreateShader", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glCreateShader) }, - { "glCreateShaderObjectARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glCreateShaderObjectARB) }, - { "glCreateShaderProgramEXT", "GL_EXT_separate_shader_objects\0", offsetof(struct opengl_funcs, p_glCreateShaderProgramEXT) }, - { "glCreateShaderProgramv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glCreateShaderProgramv) }, - { "glCreateStatesNV", "GL_NV_command_list\0", offsetof(struct opengl_funcs, p_glCreateStatesNV) }, - { "glCreateSyncFromCLeventARB", "GL_ARB_cl_event\0", offsetof(struct opengl_funcs, p_glCreateSyncFromCLeventARB) }, - { "glCreateTextures", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glCreateTextures) }, - { "glCreateTransformFeedbacks", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glCreateTransformFeedbacks) }, - { "glCreateVertexArrays", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glCreateVertexArrays) }, - { "glCullParameterdvEXT", "GL_EXT_cull_vertex\0", offsetof(struct opengl_funcs, p_glCullParameterdvEXT) }, - { "glCullParameterfvEXT", "GL_EXT_cull_vertex\0", offsetof(struct opengl_funcs, p_glCullParameterfvEXT) }, - { "glCurrentPaletteMatrixARB", "GL_ARB_matrix_palette\0", offsetof(struct opengl_funcs, p_glCurrentPaletteMatrixARB) }, - { "glDebugMessageCallback", "GL_KHR_debug\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glDebugMessageCallback) }, - { "glDebugMessageCallbackAMD", "GL_AMDX_debug_output\0GL_AMD_debug_output\0", offsetof(struct opengl_funcs, p_glDebugMessageCallbackAMD) }, - { "glDebugMessageCallbackARB", "GL_ARB_debug_output\0", offsetof(struct opengl_funcs, p_glDebugMessageCallbackARB) }, - { "glDebugMessageControl", "GL_KHR_debug\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glDebugMessageControl) }, - { "glDebugMessageControlARB", "GL_ARB_debug_output\0", offsetof(struct opengl_funcs, p_glDebugMessageControlARB) }, - { "glDebugMessageEnableAMD", "GL_AMDX_debug_output\0GL_AMD_debug_output\0", offsetof(struct opengl_funcs, p_glDebugMessageEnableAMD) }, - { "glDebugMessageInsert", "GL_KHR_debug\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glDebugMessageInsert) }, - { "glDebugMessageInsertAMD", "GL_AMDX_debug_output\0GL_AMD_debug_output\0", offsetof(struct opengl_funcs, p_glDebugMessageInsertAMD) }, - { "glDebugMessageInsertARB", "GL_ARB_debug_output\0", offsetof(struct opengl_funcs, p_glDebugMessageInsertARB) }, - { "glDeformSGIX", "GL_SGIX_polynomial_ffd\0", offsetof(struct opengl_funcs, p_glDeformSGIX) }, - { "glDeformationMap3dSGIX", "GL_SGIX_polynomial_ffd\0", offsetof(struct opengl_funcs, p_glDeformationMap3dSGIX) }, - { "glDeformationMap3fSGIX", "GL_SGIX_polynomial_ffd\0", offsetof(struct opengl_funcs, p_glDeformationMap3fSGIX) }, - { "glDeleteAsyncMarkersSGIX", "GL_SGIX_async\0", offsetof(struct opengl_funcs, p_glDeleteAsyncMarkersSGIX) }, - { "glDeleteBufferRegion", "GL_KTX_buffer_region\0", offsetof(struct opengl_funcs, p_glDeleteBufferRegion) }, - { "glDeleteBuffers", "GL_VERSION_1_5\0", offsetof(struct opengl_funcs, p_glDeleteBuffers) }, - { "glDeleteBuffersARB", "GL_ARB_vertex_buffer_object\0", offsetof(struct opengl_funcs, p_glDeleteBuffersARB) }, - { "glDeleteCommandListsNV", "GL_NV_command_list\0", offsetof(struct opengl_funcs, p_glDeleteCommandListsNV) }, - { "glDeleteFencesAPPLE", "GL_APPLE_fence\0", offsetof(struct opengl_funcs, p_glDeleteFencesAPPLE) }, - { "glDeleteFencesNV", "GL_NV_fence\0", offsetof(struct opengl_funcs, p_glDeleteFencesNV) }, - { "glDeleteFragmentShaderATI", "GL_ATI_fragment_shader\0", offsetof(struct opengl_funcs, p_glDeleteFragmentShaderATI) }, - { "glDeleteFramebuffers", "GL_ARB_framebuffer_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glDeleteFramebuffers) }, - { "glDeleteFramebuffersEXT", "GL_EXT_framebuffer_object\0", offsetof(struct opengl_funcs, p_glDeleteFramebuffersEXT) }, - { "glDeleteMemoryObjectsEXT", "GL_EXT_memory_object\0", offsetof(struct opengl_funcs, p_glDeleteMemoryObjectsEXT) }, - { "glDeleteNamedStringARB", "GL_ARB_shading_language_include\0", offsetof(struct opengl_funcs, p_glDeleteNamedStringARB) }, - { "glDeleteNamesAMD", "GL_AMD_name_gen_delete\0", offsetof(struct opengl_funcs, p_glDeleteNamesAMD) }, - { "glDeleteObjectARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glDeleteObjectARB) }, - { "glDeleteObjectBufferATI", "GL_ATI_vertex_array_object\0", offsetof(struct opengl_funcs, p_glDeleteObjectBufferATI) }, - { "glDeleteOcclusionQueriesNV", "GL_NV_occlusion_query\0", offsetof(struct opengl_funcs, p_glDeleteOcclusionQueriesNV) }, - { "glDeletePathsNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glDeletePathsNV) }, - { "glDeletePerfMonitorsAMD", "GL_AMD_performance_monitor\0", offsetof(struct opengl_funcs, p_glDeletePerfMonitorsAMD) }, - { "glDeletePerfQueryINTEL", "GL_INTEL_performance_query\0", offsetof(struct opengl_funcs, p_glDeletePerfQueryINTEL) }, - { "glDeleteProgram", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glDeleteProgram) }, - { "glDeleteProgramPipelines", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glDeleteProgramPipelines) }, - { "glDeleteProgramsARB", "GL_ARB_fragment_program\0GL_ARB_vertex_program\0", offsetof(struct opengl_funcs, p_glDeleteProgramsARB) }, - { "glDeleteProgramsNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glDeleteProgramsNV) }, - { "glDeleteQueries", "GL_VERSION_1_5\0", offsetof(struct opengl_funcs, p_glDeleteQueries) }, - { "glDeleteQueriesARB", "GL_ARB_occlusion_query\0", offsetof(struct opengl_funcs, p_glDeleteQueriesARB) }, - { "glDeleteQueryResourceTagNV", "GL_NV_query_resource_tag\0", offsetof(struct opengl_funcs, p_glDeleteQueryResourceTagNV) }, - { "glDeleteRenderbuffers", "GL_ARB_framebuffer_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glDeleteRenderbuffers) }, - { "glDeleteRenderbuffersEXT", "GL_EXT_framebuffer_object\0", offsetof(struct opengl_funcs, p_glDeleteRenderbuffersEXT) }, - { "glDeleteSamplers", "GL_ARB_sampler_objects\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glDeleteSamplers) }, - { "glDeleteSemaphoresEXT", "GL_EXT_semaphore\0", offsetof(struct opengl_funcs, p_glDeleteSemaphoresEXT) }, - { "glDeleteShader", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glDeleteShader) }, - { "glDeleteStatesNV", "GL_NV_command_list\0", offsetof(struct opengl_funcs, p_glDeleteStatesNV) }, - { "glDeleteSync", "GL_ARB_sync\0GL_VERSION_3_2\0", offsetof(struct opengl_funcs, p_glDeleteSync) }, - { "glDeleteTexturesEXT", "GL_EXT_texture_object\0", offsetof(struct opengl_funcs, p_glDeleteTexturesEXT) }, - { "glDeleteTransformFeedbacks", "GL_ARB_transform_feedback2\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glDeleteTransformFeedbacks) }, - { "glDeleteTransformFeedbacksNV", "GL_NV_transform_feedback2\0", offsetof(struct opengl_funcs, p_glDeleteTransformFeedbacksNV) }, - { "glDeleteVertexArrays", "GL_ARB_vertex_array_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glDeleteVertexArrays) }, - { "glDeleteVertexArraysAPPLE", "GL_APPLE_vertex_array_object\0", offsetof(struct opengl_funcs, p_glDeleteVertexArraysAPPLE) }, - { "glDeleteVertexShaderEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glDeleteVertexShaderEXT) }, - { "glDepthBoundsEXT", "GL_EXT_depth_bounds_test\0", offsetof(struct opengl_funcs, p_glDepthBoundsEXT) }, - { "glDepthBoundsdNV", "GL_NV_depth_buffer_float\0", offsetof(struct opengl_funcs, p_glDepthBoundsdNV) }, - { "glDepthRangeArraydvNV", "GL_ARB_viewport_array\0", offsetof(struct opengl_funcs, p_glDepthRangeArraydvNV) }, - { "glDepthRangeArrayv", "GL_ARB_viewport_array\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glDepthRangeArrayv) }, - { "glDepthRangeIndexed", "GL_ARB_viewport_array\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glDepthRangeIndexed) }, - { "glDepthRangeIndexeddNV", "GL_ARB_viewport_array\0", offsetof(struct opengl_funcs, p_glDepthRangeIndexeddNV) }, - { "glDepthRangedNV", "GL_NV_depth_buffer_float\0", offsetof(struct opengl_funcs, p_glDepthRangedNV) }, - { "glDepthRangef", "GL_ARB_ES2_compatibility\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glDepthRangef) }, - { "glDepthRangefOES", "GL_OES_single_precision\0", offsetof(struct opengl_funcs, p_glDepthRangefOES) }, - { "glDepthRangex", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glDepthRangex) }, - { "glDepthRangexOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glDepthRangexOES) }, - { "glDetachObjectARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glDetachObjectARB) }, - { "glDetachShader", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glDetachShader) }, - { "glDetailTexFuncSGIS", "GL_SGIS_detail_texture\0", offsetof(struct opengl_funcs, p_glDetailTexFuncSGIS) }, - { "glDisableClientStateIndexedEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glDisableClientStateIndexedEXT) }, - { "glDisableClientStateiEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glDisableClientStateiEXT) }, - { "glDisableIndexedEXT", "GL_EXT_direct_state_access\0GL_EXT_draw_buffers2\0", offsetof(struct opengl_funcs, p_glDisableIndexedEXT) }, - { "glDisableVariantClientStateEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glDisableVariantClientStateEXT) }, - { "glDisableVertexArrayAttrib", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glDisableVertexArrayAttrib) }, - { "glDisableVertexArrayAttribEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glDisableVertexArrayAttribEXT) }, - { "glDisableVertexArrayEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glDisableVertexArrayEXT) }, - { "glDisableVertexAttribAPPLE", "GL_APPLE_vertex_program_evaluators\0", offsetof(struct opengl_funcs, p_glDisableVertexAttribAPPLE) }, - { "glDisableVertexAttribArray", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glDisableVertexAttribArray) }, - { "glDisableVertexAttribArrayARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glDisableVertexAttribArrayARB) }, - { "glDisablei", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glDisablei) }, - { "glDispatchCompute", "GL_ARB_compute_shader\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glDispatchCompute) }, - { "glDispatchComputeGroupSizeARB", "GL_ARB_compute_variable_group_size\0", offsetof(struct opengl_funcs, p_glDispatchComputeGroupSizeARB) }, - { "glDispatchComputeIndirect", "GL_ARB_compute_shader\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glDispatchComputeIndirect) }, - { "glDrawArraysEXT", "GL_EXT_vertex_array\0", offsetof(struct opengl_funcs, p_glDrawArraysEXT) }, - { "glDrawArraysIndirect", "GL_ARB_draw_indirect\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glDrawArraysIndirect) }, - { "glDrawArraysInstanced", "GL_VERSION_3_1\0", offsetof(struct opengl_funcs, p_glDrawArraysInstanced) }, - { "glDrawArraysInstancedARB", "GL_ARB_draw_instanced\0", offsetof(struct opengl_funcs, p_glDrawArraysInstancedARB) }, - { "glDrawArraysInstancedBaseInstance", "GL_ARB_base_instance\0GL_VERSION_4_2\0", offsetof(struct opengl_funcs, p_glDrawArraysInstancedBaseInstance) }, - { "glDrawArraysInstancedEXT", "GL_EXT_draw_instanced\0", offsetof(struct opengl_funcs, p_glDrawArraysInstancedEXT) }, - { "glDrawBufferRegion", "GL_KTX_buffer_region\0", offsetof(struct opengl_funcs, p_glDrawBufferRegion) }, - { "glDrawBuffers", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glDrawBuffers) }, - { "glDrawBuffersARB", "GL_ARB_draw_buffers\0", offsetof(struct opengl_funcs, p_glDrawBuffersARB) }, - { "glDrawBuffersATI", "GL_ATI_draw_buffers\0", offsetof(struct opengl_funcs, p_glDrawBuffersATI) }, - { "glDrawCommandsAddressNV", "GL_NV_command_list\0", offsetof(struct opengl_funcs, p_glDrawCommandsAddressNV) }, - { "glDrawCommandsNV", "GL_NV_command_list\0", offsetof(struct opengl_funcs, p_glDrawCommandsNV) }, - { "glDrawCommandsStatesAddressNV", "GL_NV_command_list\0", offsetof(struct opengl_funcs, p_glDrawCommandsStatesAddressNV) }, - { "glDrawCommandsStatesNV", "GL_NV_command_list\0", offsetof(struct opengl_funcs, p_glDrawCommandsStatesNV) }, - { "glDrawElementArrayAPPLE", "GL_APPLE_element_array\0", offsetof(struct opengl_funcs, p_glDrawElementArrayAPPLE) }, - { "glDrawElementArrayATI", "GL_ATI_element_array\0", offsetof(struct opengl_funcs, p_glDrawElementArrayATI) }, - { "glDrawElementsBaseVertex", "GL_ARB_draw_elements_base_vertex\0GL_VERSION_3_2\0", offsetof(struct opengl_funcs, p_glDrawElementsBaseVertex) }, - { "glDrawElementsIndirect", "GL_ARB_draw_indirect\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glDrawElementsIndirect) }, - { "glDrawElementsInstanced", "GL_VERSION_3_1\0", offsetof(struct opengl_funcs, p_glDrawElementsInstanced) }, - { "glDrawElementsInstancedARB", "GL_ARB_draw_instanced\0", offsetof(struct opengl_funcs, p_glDrawElementsInstancedARB) }, - { "glDrawElementsInstancedBaseInstance", "GL_ARB_base_instance\0GL_VERSION_4_2\0", offsetof(struct opengl_funcs, p_glDrawElementsInstancedBaseInstance) }, - { "glDrawElementsInstancedBaseVertex", "GL_ARB_draw_elements_base_vertex\0GL_VERSION_3_2\0", offsetof(struct opengl_funcs, p_glDrawElementsInstancedBaseVertex) }, - { "glDrawElementsInstancedBaseVertexBaseInstance", "GL_ARB_base_instance\0GL_VERSION_4_2\0", offsetof(struct opengl_funcs, p_glDrawElementsInstancedBaseVertexBaseInstance) }, - { "glDrawElementsInstancedEXT", "GL_EXT_draw_instanced\0", offsetof(struct opengl_funcs, p_glDrawElementsInstancedEXT) }, - { "glDrawMeshArraysSUN", "GL_SUN_mesh_array\0", offsetof(struct opengl_funcs, p_glDrawMeshArraysSUN) }, - { "glDrawMeshTasksEXT", "GL_EXT_mesh_shader\0", offsetof(struct opengl_funcs, p_glDrawMeshTasksEXT) }, - { "glDrawMeshTasksIndirectEXT", "GL_EXT_mesh_shader\0", offsetof(struct opengl_funcs, p_glDrawMeshTasksIndirectEXT) }, - { "glDrawMeshTasksIndirectNV", "GL_NV_mesh_shader\0", offsetof(struct opengl_funcs, p_glDrawMeshTasksIndirectNV) }, - { "glDrawMeshTasksNV", "GL_NV_mesh_shader\0", offsetof(struct opengl_funcs, p_glDrawMeshTasksNV) }, - { "glDrawRangeElementArrayAPPLE", "GL_APPLE_element_array\0", offsetof(struct opengl_funcs, p_glDrawRangeElementArrayAPPLE) }, - { "glDrawRangeElementArrayATI", "GL_ATI_element_array\0", offsetof(struct opengl_funcs, p_glDrawRangeElementArrayATI) }, - { "glDrawRangeElements", "GL_VERSION_1_2\0", offsetof(struct opengl_funcs, p_glDrawRangeElements) }, - { "glDrawRangeElementsBaseVertex", "GL_ARB_draw_elements_base_vertex\0GL_VERSION_3_2\0", offsetof(struct opengl_funcs, p_glDrawRangeElementsBaseVertex) }, - { "glDrawRangeElementsEXT", "GL_EXT_draw_range_elements\0", offsetof(struct opengl_funcs, p_glDrawRangeElementsEXT) }, - { "glDrawTextureNV", "GL_NV_draw_texture\0", offsetof(struct opengl_funcs, p_glDrawTextureNV) }, - { "glDrawTransformFeedback", "GL_ARB_transform_feedback2\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glDrawTransformFeedback) }, - { "glDrawTransformFeedbackInstanced", "GL_ARB_transform_feedback_instanced\0GL_VERSION_4_2\0", offsetof(struct opengl_funcs, p_glDrawTransformFeedbackInstanced) }, - { "glDrawTransformFeedbackNV", "GL_NV_transform_feedback2\0", offsetof(struct opengl_funcs, p_glDrawTransformFeedbackNV) }, - { "glDrawTransformFeedbackStream", "GL_ARB_transform_feedback3\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glDrawTransformFeedbackStream) }, - { "glDrawTransformFeedbackStreamInstanced", "GL_ARB_transform_feedback_instanced\0GL_VERSION_4_2\0", offsetof(struct opengl_funcs, p_glDrawTransformFeedbackStreamInstanced) }, - { "glDrawVkImageNV", "GL_NV_draw_vulkan_image\0", offsetof(struct opengl_funcs, p_glDrawVkImageNV) }, - { "glEGLImageTargetTexStorageEXT", "GL_EXT_EGL_image_storage\0", offsetof(struct opengl_funcs, p_glEGLImageTargetTexStorageEXT) }, - { "glEGLImageTargetTextureStorageEXT", "GL_EXT_EGL_image_storage\0", offsetof(struct opengl_funcs, p_glEGLImageTargetTextureStorageEXT) }, - { "glEdgeFlagFormatNV", "GL_NV_vertex_buffer_unified_memory\0", offsetof(struct opengl_funcs, p_glEdgeFlagFormatNV) }, - { "glEdgeFlagPointerEXT", "GL_EXT_vertex_array\0", offsetof(struct opengl_funcs, p_glEdgeFlagPointerEXT) }, - { "glEdgeFlagPointerListIBM", "GL_IBM_vertex_array_lists\0", offsetof(struct opengl_funcs, p_glEdgeFlagPointerListIBM) }, - { "glElementPointerAPPLE", "GL_APPLE_element_array\0", offsetof(struct opengl_funcs, p_glElementPointerAPPLE) }, - { "glElementPointerATI", "GL_ATI_element_array\0", offsetof(struct opengl_funcs, p_glElementPointerATI) }, - { "glEnableClientStateIndexedEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glEnableClientStateIndexedEXT) }, - { "glEnableClientStateiEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glEnableClientStateiEXT) }, - { "glEnableIndexedEXT", "GL_EXT_direct_state_access\0GL_EXT_draw_buffers2\0", offsetof(struct opengl_funcs, p_glEnableIndexedEXT) }, - { "glEnableVariantClientStateEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glEnableVariantClientStateEXT) }, - { "glEnableVertexArrayAttrib", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glEnableVertexArrayAttrib) }, - { "glEnableVertexArrayAttribEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glEnableVertexArrayAttribEXT) }, - { "glEnableVertexArrayEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glEnableVertexArrayEXT) }, - { "glEnableVertexAttribAPPLE", "GL_APPLE_vertex_program_evaluators\0", offsetof(struct opengl_funcs, p_glEnableVertexAttribAPPLE) }, - { "glEnableVertexAttribArray", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glEnableVertexAttribArray) }, - { "glEnableVertexAttribArrayARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glEnableVertexAttribArrayARB) }, - { "glEnablei", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glEnablei) }, - { "glEndConditionalRender", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glEndConditionalRender) }, - { "glEndConditionalRenderNV", "GL_NV_conditional_render\0", offsetof(struct opengl_funcs, p_glEndConditionalRenderNV) }, - { "glEndConditionalRenderNVX", "GL_NVX_conditional_render\0", offsetof(struct opengl_funcs, p_glEndConditionalRenderNVX) }, - { "glEndFragmentShaderATI", "GL_ATI_fragment_shader\0", offsetof(struct opengl_funcs, p_glEndFragmentShaderATI) }, - { "glEndOcclusionQueryNV", "GL_NV_occlusion_query\0", offsetof(struct opengl_funcs, p_glEndOcclusionQueryNV) }, - { "glEndPerfMonitorAMD", "GL_AMD_performance_monitor\0", offsetof(struct opengl_funcs, p_glEndPerfMonitorAMD) }, - { "glEndPerfQueryINTEL", "GL_INTEL_performance_query\0", offsetof(struct opengl_funcs, p_glEndPerfQueryINTEL) }, - { "glEndQuery", "GL_VERSION_1_5\0", offsetof(struct opengl_funcs, p_glEndQuery) }, - { "glEndQueryARB", "GL_ARB_occlusion_query\0", offsetof(struct opengl_funcs, p_glEndQueryARB) }, - { "glEndQueryIndexed", "GL_ARB_transform_feedback3\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glEndQueryIndexed) }, - { "glEndTransformFeedback", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glEndTransformFeedback) }, - { "glEndTransformFeedbackEXT", "GL_EXT_transform_feedback\0", offsetof(struct opengl_funcs, p_glEndTransformFeedbackEXT) }, - { "glEndTransformFeedbackNV", "GL_NV_transform_feedback\0", offsetof(struct opengl_funcs, p_glEndTransformFeedbackNV) }, - { "glEndVertexShaderEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glEndVertexShaderEXT) }, - { "glEndVideoCaptureNV", "GL_NV_video_capture\0", offsetof(struct opengl_funcs, p_glEndVideoCaptureNV) }, - { "glEvalCoord1xOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glEvalCoord1xOES) }, - { "glEvalCoord1xvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glEvalCoord1xvOES) }, - { "glEvalCoord2xOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glEvalCoord2xOES) }, - { "glEvalCoord2xvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glEvalCoord2xvOES) }, - { "glEvalMapsNV", "GL_NV_evaluators\0", offsetof(struct opengl_funcs, p_glEvalMapsNV) }, - { "glEvaluateDepthValuesARB", "GL_ARB_sample_locations\0", offsetof(struct opengl_funcs, p_glEvaluateDepthValuesARB) }, - { "glExecuteProgramNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glExecuteProgramNV) }, - { "glExtractComponentEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glExtractComponentEXT) }, - { "glFeedbackBufferxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glFeedbackBufferxOES) }, - { "glFenceSync", "GL_ARB_sync\0GL_VERSION_3_2\0", offsetof(struct opengl_funcs, p_glFenceSync) }, - { "glFinalCombinerInputNV", "GL_NV_register_combiners\0", offsetof(struct opengl_funcs, p_glFinalCombinerInputNV) }, - { "glFinishAsyncSGIX", "GL_SGIX_async\0", offsetof(struct opengl_funcs, p_glFinishAsyncSGIX) }, - { "glFinishFenceAPPLE", "GL_APPLE_fence\0", offsetof(struct opengl_funcs, p_glFinishFenceAPPLE) }, - { "glFinishFenceNV", "GL_NV_fence\0", offsetof(struct opengl_funcs, p_glFinishFenceNV) }, - { "glFinishObjectAPPLE", "GL_APPLE_fence\0", offsetof(struct opengl_funcs, p_glFinishObjectAPPLE) }, - { "glFinishTextureSUNX", "GL_SUNX_constant_data\0", offsetof(struct opengl_funcs, p_glFinishTextureSUNX) }, - { "glFlushMappedBufferRange", "GL_ARB_map_buffer_range\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glFlushMappedBufferRange) }, - { "glFlushMappedBufferRangeAPPLE", "GL_APPLE_flush_buffer_range\0", offsetof(struct opengl_funcs, p_glFlushMappedBufferRangeAPPLE) }, - { "glFlushMappedNamedBufferRange", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glFlushMappedNamedBufferRange) }, - { "glFlushMappedNamedBufferRangeEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glFlushMappedNamedBufferRangeEXT) }, - { "glFlushPixelDataRangeNV", "GL_NV_pixel_data_range\0", offsetof(struct opengl_funcs, p_glFlushPixelDataRangeNV) }, - { "glFlushRasterSGIX", "GL_SGIX_flush_raster\0", offsetof(struct opengl_funcs, p_glFlushRasterSGIX) }, - { "glFlushStaticDataIBM", "GL_IBM_static_data\0", offsetof(struct opengl_funcs, p_glFlushStaticDataIBM) }, - { "glFlushVertexArrayRangeAPPLE", "GL_APPLE_vertex_array_range\0", offsetof(struct opengl_funcs, p_glFlushVertexArrayRangeAPPLE) }, - { "glFlushVertexArrayRangeNV", "GL_NV_vertex_array_range\0", offsetof(struct opengl_funcs, p_glFlushVertexArrayRangeNV) }, - { "glFogCoordFormatNV", "GL_NV_vertex_buffer_unified_memory\0", offsetof(struct opengl_funcs, p_glFogCoordFormatNV) }, - { "glFogCoordPointer", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glFogCoordPointer) }, - { "glFogCoordPointerEXT", "GL_EXT_fog_coord\0", offsetof(struct opengl_funcs, p_glFogCoordPointerEXT) }, - { "glFogCoordPointerListIBM", "GL_IBM_vertex_array_lists\0", offsetof(struct opengl_funcs, p_glFogCoordPointerListIBM) }, - { "glFogCoordd", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glFogCoordd) }, - { "glFogCoorddEXT", "GL_EXT_fog_coord\0", offsetof(struct opengl_funcs, p_glFogCoorddEXT) }, - { "glFogCoorddv", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glFogCoorddv) }, - { "glFogCoorddvEXT", "GL_EXT_fog_coord\0", offsetof(struct opengl_funcs, p_glFogCoorddvEXT) }, - { "glFogCoordf", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glFogCoordf) }, - { "glFogCoordfEXT", "GL_EXT_fog_coord\0", offsetof(struct opengl_funcs, p_glFogCoordfEXT) }, - { "glFogCoordfv", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glFogCoordfv) }, - { "glFogCoordfvEXT", "GL_EXT_fog_coord\0", offsetof(struct opengl_funcs, p_glFogCoordfvEXT) }, - { "glFogCoordhNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glFogCoordhNV) }, - { "glFogCoordhvNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glFogCoordhvNV) }, - { "glFogFuncSGIS", "GL_SGIS_fog_function\0", offsetof(struct opengl_funcs, p_glFogFuncSGIS) }, - { "glFogx", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glFogx) }, - { "glFogxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glFogxOES) }, - { "glFogxv", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glFogxv) }, - { "glFogxvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glFogxvOES) }, - { "glFragmentColorMaterialSGIX", "GL_SGIX_fragment_lighting\0", offsetof(struct opengl_funcs, p_glFragmentColorMaterialSGIX) }, - { "glFragmentCoverageColorNV", "GL_NV_fragment_coverage_to_color\0", offsetof(struct opengl_funcs, p_glFragmentCoverageColorNV) }, - { "glFragmentLightModelfSGIX", "GL_SGIX_fragment_lighting\0", offsetof(struct opengl_funcs, p_glFragmentLightModelfSGIX) }, - { "glFragmentLightModelfvSGIX", "GL_SGIX_fragment_lighting\0", offsetof(struct opengl_funcs, p_glFragmentLightModelfvSGIX) }, - { "glFragmentLightModeliSGIX", "GL_SGIX_fragment_lighting\0", offsetof(struct opengl_funcs, p_glFragmentLightModeliSGIX) }, - { "glFragmentLightModelivSGIX", "GL_SGIX_fragment_lighting\0", offsetof(struct opengl_funcs, p_glFragmentLightModelivSGIX) }, - { "glFragmentLightfSGIX", "GL_SGIX_fragment_lighting\0", offsetof(struct opengl_funcs, p_glFragmentLightfSGIX) }, - { "glFragmentLightfvSGIX", "GL_SGIX_fragment_lighting\0", offsetof(struct opengl_funcs, p_glFragmentLightfvSGIX) }, - { "glFragmentLightiSGIX", "GL_SGIX_fragment_lighting\0", offsetof(struct opengl_funcs, p_glFragmentLightiSGIX) }, - { "glFragmentLightivSGIX", "GL_SGIX_fragment_lighting\0", offsetof(struct opengl_funcs, p_glFragmentLightivSGIX) }, - { "glFragmentMaterialfSGIX", "GL_SGIX_fragment_lighting\0", offsetof(struct opengl_funcs, p_glFragmentMaterialfSGIX) }, - { "glFragmentMaterialfvSGIX", "GL_SGIX_fragment_lighting\0", offsetof(struct opengl_funcs, p_glFragmentMaterialfvSGIX) }, - { "glFragmentMaterialiSGIX", "GL_SGIX_fragment_lighting\0", offsetof(struct opengl_funcs, p_glFragmentMaterialiSGIX) }, - { "glFragmentMaterialivSGIX", "GL_SGIX_fragment_lighting\0", offsetof(struct opengl_funcs, p_glFragmentMaterialivSGIX) }, - { "glFrameTerminatorGREMEDY", "GL_GREMEDY_frame_terminator\0", offsetof(struct opengl_funcs, p_glFrameTerminatorGREMEDY) }, - { "glFrameZoomSGIX", "GL_SGIX_framezoom\0", offsetof(struct opengl_funcs, p_glFrameZoomSGIX) }, - { "glFramebufferDrawBufferEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glFramebufferDrawBufferEXT) }, - { "glFramebufferDrawBuffersEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glFramebufferDrawBuffersEXT) }, - { "glFramebufferFetchBarrierEXT", "GL_EXT_shader_framebuffer_fetch_non_coherent\0", offsetof(struct opengl_funcs, p_glFramebufferFetchBarrierEXT) }, - { "glFramebufferParameteri", "GL_ARB_framebuffer_no_attachments\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glFramebufferParameteri) }, - { "glFramebufferParameteriMESA", "GL_MESA_framebuffer_flip_y\0", offsetof(struct opengl_funcs, p_glFramebufferParameteriMESA) }, - { "glFramebufferReadBufferEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glFramebufferReadBufferEXT) }, - { "glFramebufferRenderbuffer", "GL_ARB_framebuffer_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glFramebufferRenderbuffer) }, - { "glFramebufferRenderbufferEXT", "GL_EXT_framebuffer_object\0", offsetof(struct opengl_funcs, p_glFramebufferRenderbufferEXT) }, - { "glFramebufferSampleLocationsfvARB", "GL_ARB_sample_locations\0", offsetof(struct opengl_funcs, p_glFramebufferSampleLocationsfvARB) }, - { "glFramebufferSampleLocationsfvNV", "GL_NV_sample_locations\0", offsetof(struct opengl_funcs, p_glFramebufferSampleLocationsfvNV) }, - { "glFramebufferSamplePositionsfvAMD", "GL_AMD_framebuffer_sample_positions\0", offsetof(struct opengl_funcs, p_glFramebufferSamplePositionsfvAMD) }, - { "glFramebufferShadingRateEXT", "GL_EXT_fragment_shading_rate\0GL_EXT_fragment_shading_rate_attachment\0GL_EXT_fragment_shading_rate_primitive\0", offsetof(struct opengl_funcs, p_glFramebufferShadingRateEXT) }, - { "glFramebufferTexture", "GL_VERSION_3_2\0", offsetof(struct opengl_funcs, p_glFramebufferTexture) }, - { "glFramebufferTexture1D", "GL_ARB_framebuffer_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glFramebufferTexture1D) }, - { "glFramebufferTexture1DEXT", "GL_EXT_framebuffer_object\0", offsetof(struct opengl_funcs, p_glFramebufferTexture1DEXT) }, - { "glFramebufferTexture2D", "GL_ARB_framebuffer_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glFramebufferTexture2D) }, - { "glFramebufferTexture2DEXT", "GL_EXT_framebuffer_object\0", offsetof(struct opengl_funcs, p_glFramebufferTexture2DEXT) }, - { "glFramebufferTexture3D", "GL_ARB_framebuffer_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glFramebufferTexture3D) }, - { "glFramebufferTexture3DEXT", "GL_EXT_framebuffer_object\0", offsetof(struct opengl_funcs, p_glFramebufferTexture3DEXT) }, - { "glFramebufferTextureARB", "GL_ARB_geometry_shader4\0", offsetof(struct opengl_funcs, p_glFramebufferTextureARB) }, - { "glFramebufferTextureEXT", "GL_NV_geometry_program4\0", offsetof(struct opengl_funcs, p_glFramebufferTextureEXT) }, - { "glFramebufferTextureFaceARB", "GL_ARB_geometry_shader4\0", offsetof(struct opengl_funcs, p_glFramebufferTextureFaceARB) }, - { "glFramebufferTextureFaceEXT", "GL_NV_geometry_program4\0", offsetof(struct opengl_funcs, p_glFramebufferTextureFaceEXT) }, - { "glFramebufferTextureLayer", "GL_ARB_framebuffer_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glFramebufferTextureLayer) }, - { "glFramebufferTextureLayerARB", "GL_ARB_geometry_shader4\0", offsetof(struct opengl_funcs, p_glFramebufferTextureLayerARB) }, - { "glFramebufferTextureLayerEXT", "GL_EXT_texture_array\0GL_NV_geometry_program4\0", offsetof(struct opengl_funcs, p_glFramebufferTextureLayerEXT) }, - { "glFramebufferTextureMultiviewOVR", "GL_OVR_multiview\0", offsetof(struct opengl_funcs, p_glFramebufferTextureMultiviewOVR) }, - { "glFreeObjectBufferATI", "GL_ATI_vertex_array_object\0", offsetof(struct opengl_funcs, p_glFreeObjectBufferATI) }, - { "glFrustumf", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glFrustumf) }, - { "glFrustumfOES", "GL_OES_single_precision\0", offsetof(struct opengl_funcs, p_glFrustumfOES) }, - { "glFrustumx", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glFrustumx) }, - { "glFrustumxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glFrustumxOES) }, - { "glGenAsyncMarkersSGIX", "GL_SGIX_async\0", offsetof(struct opengl_funcs, p_glGenAsyncMarkersSGIX) }, - { "glGenBuffers", "GL_VERSION_1_5\0", offsetof(struct opengl_funcs, p_glGenBuffers) }, - { "glGenBuffersARB", "GL_ARB_vertex_buffer_object\0", offsetof(struct opengl_funcs, p_glGenBuffersARB) }, - { "glGenFencesAPPLE", "GL_APPLE_fence\0", offsetof(struct opengl_funcs, p_glGenFencesAPPLE) }, - { "glGenFencesNV", "GL_NV_fence\0", offsetof(struct opengl_funcs, p_glGenFencesNV) }, - { "glGenFragmentShadersATI", "GL_ATI_fragment_shader\0", offsetof(struct opengl_funcs, p_glGenFragmentShadersATI) }, - { "glGenFramebuffers", "GL_ARB_framebuffer_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glGenFramebuffers) }, - { "glGenFramebuffersEXT", "GL_EXT_framebuffer_object\0", offsetof(struct opengl_funcs, p_glGenFramebuffersEXT) }, - { "glGenNamesAMD", "GL_AMD_name_gen_delete\0", offsetof(struct opengl_funcs, p_glGenNamesAMD) }, - { "glGenOcclusionQueriesNV", "GL_NV_occlusion_query\0", offsetof(struct opengl_funcs, p_glGenOcclusionQueriesNV) }, - { "glGenPathsNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glGenPathsNV) }, - { "glGenPerfMonitorsAMD", "GL_AMD_performance_monitor\0", offsetof(struct opengl_funcs, p_glGenPerfMonitorsAMD) }, - { "glGenProgramPipelines", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glGenProgramPipelines) }, - { "glGenProgramsARB", "GL_ARB_fragment_program\0GL_ARB_vertex_program\0", offsetof(struct opengl_funcs, p_glGenProgramsARB) }, - { "glGenProgramsNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glGenProgramsNV) }, - { "glGenQueries", "GL_VERSION_1_5\0", offsetof(struct opengl_funcs, p_glGenQueries) }, - { "glGenQueriesARB", "GL_ARB_occlusion_query\0", offsetof(struct opengl_funcs, p_glGenQueriesARB) }, - { "glGenQueryResourceTagNV", "GL_NV_query_resource_tag\0", offsetof(struct opengl_funcs, p_glGenQueryResourceTagNV) }, - { "glGenRenderbuffers", "GL_ARB_framebuffer_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glGenRenderbuffers) }, - { "glGenRenderbuffersEXT", "GL_EXT_framebuffer_object\0", offsetof(struct opengl_funcs, p_glGenRenderbuffersEXT) }, - { "glGenSamplers", "GL_ARB_sampler_objects\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glGenSamplers) }, - { "glGenSemaphoresEXT", "GL_EXT_semaphore\0", offsetof(struct opengl_funcs, p_glGenSemaphoresEXT) }, - { "glGenSymbolsEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glGenSymbolsEXT) }, - { "glGenTexturesEXT", "GL_EXT_texture_object\0", offsetof(struct opengl_funcs, p_glGenTexturesEXT) }, - { "glGenTransformFeedbacks", "GL_ARB_transform_feedback2\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glGenTransformFeedbacks) }, - { "glGenTransformFeedbacksNV", "GL_NV_transform_feedback2\0", offsetof(struct opengl_funcs, p_glGenTransformFeedbacksNV) }, - { "glGenVertexArrays", "GL_ARB_vertex_array_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glGenVertexArrays) }, - { "glGenVertexArraysAPPLE", "GL_APPLE_vertex_array_object\0", offsetof(struct opengl_funcs, p_glGenVertexArraysAPPLE) }, - { "glGenVertexShadersEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glGenVertexShadersEXT) }, - { "glGenerateMipmap", "GL_ARB_framebuffer_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glGenerateMipmap) }, - { "glGenerateMipmapEXT", "GL_EXT_framebuffer_object\0", offsetof(struct opengl_funcs, p_glGenerateMipmapEXT) }, - { "glGenerateMultiTexMipmapEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGenerateMultiTexMipmapEXT) }, - { "glGenerateTextureMipmap", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGenerateTextureMipmap) }, - { "glGenerateTextureMipmapEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGenerateTextureMipmapEXT) }, - { "glGetActiveAtomicCounterBufferiv", "GL_ARB_shader_atomic_counters\0GL_VERSION_4_2\0", offsetof(struct opengl_funcs, p_glGetActiveAtomicCounterBufferiv) }, - { "glGetActiveAttrib", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glGetActiveAttrib) }, - { "glGetActiveAttribARB", "GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glGetActiveAttribARB) }, - { "glGetActiveSubroutineName", "GL_ARB_shader_subroutine\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glGetActiveSubroutineName) }, - { "glGetActiveSubroutineUniformName", "GL_ARB_shader_subroutine\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glGetActiveSubroutineUniformName) }, - { "glGetActiveSubroutineUniformiv", "GL_ARB_shader_subroutine\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glGetActiveSubroutineUniformiv) }, - { "glGetActiveUniform", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glGetActiveUniform) }, - { "glGetActiveUniformARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glGetActiveUniformARB) }, - { "glGetActiveUniformBlockName", "GL_ARB_uniform_buffer_object\0GL_VERSION_3_1\0", offsetof(struct opengl_funcs, p_glGetActiveUniformBlockName) }, - { "glGetActiveUniformBlockiv", "GL_ARB_uniform_buffer_object\0GL_VERSION_3_1\0", offsetof(struct opengl_funcs, p_glGetActiveUniformBlockiv) }, - { "glGetActiveUniformName", "GL_ARB_uniform_buffer_object\0GL_VERSION_3_1\0", offsetof(struct opengl_funcs, p_glGetActiveUniformName) }, - { "glGetActiveUniformsiv", "GL_ARB_uniform_buffer_object\0GL_VERSION_3_1\0", offsetof(struct opengl_funcs, p_glGetActiveUniformsiv) }, - { "glGetActiveVaryingNV", "GL_NV_transform_feedback\0", offsetof(struct opengl_funcs, p_glGetActiveVaryingNV) }, - { "glGetArrayObjectfvATI", "GL_ATI_vertex_array_object\0", offsetof(struct opengl_funcs, p_glGetArrayObjectfvATI) }, - { "glGetArrayObjectivATI", "GL_ATI_vertex_array_object\0", offsetof(struct opengl_funcs, p_glGetArrayObjectivATI) }, - { "glGetAttachedObjectsARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glGetAttachedObjectsARB) }, - { "glGetAttachedShaders", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glGetAttachedShaders) }, - { "glGetAttribLocation", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glGetAttribLocation) }, - { "glGetAttribLocationARB", "GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glGetAttribLocationARB) }, - { "glGetBooleanIndexedvEXT", "GL_EXT_direct_state_access\0GL_EXT_draw_buffers2\0", offsetof(struct opengl_funcs, p_glGetBooleanIndexedvEXT) }, - { "glGetBooleani_v", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glGetBooleani_v) }, - { "glGetBufferParameteri64v", "GL_VERSION_3_2\0", offsetof(struct opengl_funcs, p_glGetBufferParameteri64v) }, - { "glGetBufferParameteriv", "GL_VERSION_1_5\0", offsetof(struct opengl_funcs, p_glGetBufferParameteriv) }, - { "glGetBufferParameterivARB", "GL_ARB_vertex_buffer_object\0", offsetof(struct opengl_funcs, p_glGetBufferParameterivARB) }, - { "glGetBufferParameterui64vNV", "GL_NV_shader_buffer_load\0", offsetof(struct opengl_funcs, p_glGetBufferParameterui64vNV) }, - { "glGetBufferPointerv", "GL_VERSION_1_5\0", offsetof(struct opengl_funcs, p_glGetBufferPointerv) }, - { "glGetBufferPointervARB", "GL_ARB_vertex_buffer_object\0", offsetof(struct opengl_funcs, p_glGetBufferPointervARB) }, - { "glGetBufferSubData", "GL_VERSION_1_5\0", offsetof(struct opengl_funcs, p_glGetBufferSubData) }, - { "glGetBufferSubDataARB", "GL_ARB_vertex_buffer_object\0", offsetof(struct opengl_funcs, p_glGetBufferSubDataARB) }, - { "glGetClipPlanef", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glGetClipPlanef) }, - { "glGetClipPlanefOES", "GL_OES_single_precision\0", offsetof(struct opengl_funcs, p_glGetClipPlanefOES) }, - { "glGetClipPlanex", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glGetClipPlanex) }, - { "glGetClipPlanexOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glGetClipPlanexOES) }, - { "glGetColorTable", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glGetColorTable) }, - { "glGetColorTableEXT", "GL_EXT_paletted_texture\0", offsetof(struct opengl_funcs, p_glGetColorTableEXT) }, - { "glGetColorTableParameterfv", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glGetColorTableParameterfv) }, - { "glGetColorTableParameterfvEXT", "GL_EXT_paletted_texture\0", offsetof(struct opengl_funcs, p_glGetColorTableParameterfvEXT) }, - { "glGetColorTableParameterfvSGI", "GL_SGI_color_table\0", offsetof(struct opengl_funcs, p_glGetColorTableParameterfvSGI) }, - { "glGetColorTableParameteriv", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glGetColorTableParameteriv) }, - { "glGetColorTableParameterivEXT", "GL_EXT_paletted_texture\0", offsetof(struct opengl_funcs, p_glGetColorTableParameterivEXT) }, - { "glGetColorTableParameterivSGI", "GL_SGI_color_table\0", offsetof(struct opengl_funcs, p_glGetColorTableParameterivSGI) }, - { "glGetColorTableSGI", "GL_SGI_color_table\0", offsetof(struct opengl_funcs, p_glGetColorTableSGI) }, - { "glGetCombinerInputParameterfvNV", "GL_NV_register_combiners\0", offsetof(struct opengl_funcs, p_glGetCombinerInputParameterfvNV) }, - { "glGetCombinerInputParameterivNV", "GL_NV_register_combiners\0", offsetof(struct opengl_funcs, p_glGetCombinerInputParameterivNV) }, - { "glGetCombinerOutputParameterfvNV", "GL_NV_register_combiners\0", offsetof(struct opengl_funcs, p_glGetCombinerOutputParameterfvNV) }, - { "glGetCombinerOutputParameterivNV", "GL_NV_register_combiners\0", offsetof(struct opengl_funcs, p_glGetCombinerOutputParameterivNV) }, - { "glGetCombinerStageParameterfvNV", "GL_NV_register_combiners2\0", offsetof(struct opengl_funcs, p_glGetCombinerStageParameterfvNV) }, - { "glGetCommandHeaderNV", "GL_NV_command_list\0", offsetof(struct opengl_funcs, p_glGetCommandHeaderNV) }, - { "glGetCompressedMultiTexImageEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetCompressedMultiTexImageEXT) }, - { "glGetCompressedTexImage", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glGetCompressedTexImage) }, - { "glGetCompressedTexImageARB", "GL_ARB_texture_compression\0GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glGetCompressedTexImageARB) }, - { "glGetCompressedTextureImage", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetCompressedTextureImage) }, - { "glGetCompressedTextureImageEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetCompressedTextureImageEXT) }, - { "glGetCompressedTextureSubImage", "GL_ARB_get_texture_sub_image\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetCompressedTextureSubImage) }, - { "glGetConvolutionFilter", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glGetConvolutionFilter) }, - { "glGetConvolutionFilterEXT", "GL_EXT_convolution\0", offsetof(struct opengl_funcs, p_glGetConvolutionFilterEXT) }, - { "glGetConvolutionParameterfv", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glGetConvolutionParameterfv) }, - { "glGetConvolutionParameterfvEXT", "GL_EXT_convolution\0", offsetof(struct opengl_funcs, p_glGetConvolutionParameterfvEXT) }, - { "glGetConvolutionParameteriv", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glGetConvolutionParameteriv) }, - { "glGetConvolutionParameterivEXT", "GL_EXT_convolution\0", offsetof(struct opengl_funcs, p_glGetConvolutionParameterivEXT) }, - { "glGetConvolutionParameterxvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glGetConvolutionParameterxvOES) }, - { "glGetCoverageModulationTableNV", "GL_NV_framebuffer_mixed_samples\0", offsetof(struct opengl_funcs, p_glGetCoverageModulationTableNV) }, - { "glGetDebugMessageLog", "GL_KHR_debug\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glGetDebugMessageLog) }, - { "glGetDebugMessageLogAMD", "GL_AMDX_debug_output\0GL_AMD_debug_output\0", offsetof(struct opengl_funcs, p_glGetDebugMessageLogAMD) }, - { "glGetDebugMessageLogARB", "GL_ARB_debug_output\0", offsetof(struct opengl_funcs, p_glGetDebugMessageLogARB) }, - { "glGetDetailTexFuncSGIS", "GL_SGIS_detail_texture\0", offsetof(struct opengl_funcs, p_glGetDetailTexFuncSGIS) }, - { "glGetDoubleIndexedvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetDoubleIndexedvEXT) }, - { "glGetDoublei_v", "GL_ARB_viewport_array\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glGetDoublei_v) }, - { "glGetDoublei_vEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetDoublei_vEXT) }, - { "glGetFenceivNV", "GL_NV_fence\0", offsetof(struct opengl_funcs, p_glGetFenceivNV) }, - { "glGetFinalCombinerInputParameterfvNV", "GL_NV_register_combiners\0", offsetof(struct opengl_funcs, p_glGetFinalCombinerInputParameterfvNV) }, - { "glGetFinalCombinerInputParameterivNV", "GL_NV_register_combiners\0", offsetof(struct opengl_funcs, p_glGetFinalCombinerInputParameterivNV) }, - { "glGetFirstPerfQueryIdINTEL", "GL_INTEL_performance_query\0", offsetof(struct opengl_funcs, p_glGetFirstPerfQueryIdINTEL) }, - { "glGetFixedv", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glGetFixedv) }, - { "glGetFixedvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glGetFixedvOES) }, - { "glGetFloatIndexedvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetFloatIndexedvEXT) }, - { "glGetFloati_v", "GL_ARB_viewport_array\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glGetFloati_v) }, - { "glGetFloati_vEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetFloati_vEXT) }, - { "glGetFogFuncSGIS", "GL_SGIS_fog_function\0", offsetof(struct opengl_funcs, p_glGetFogFuncSGIS) }, - { "glGetFragDataIndex", "GL_ARB_blend_func_extended\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glGetFragDataIndex) }, - { "glGetFragDataLocation", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glGetFragDataLocation) }, - { "glGetFragDataLocationEXT", "GL_EXT_gpu_shader4\0", offsetof(struct opengl_funcs, p_glGetFragDataLocationEXT) }, - { "glGetFragmentLightfvSGIX", "GL_SGIX_fragment_lighting\0", offsetof(struct opengl_funcs, p_glGetFragmentLightfvSGIX) }, - { "glGetFragmentLightivSGIX", "GL_SGIX_fragment_lighting\0", offsetof(struct opengl_funcs, p_glGetFragmentLightivSGIX) }, - { "glGetFragmentMaterialfvSGIX", "GL_SGIX_fragment_lighting\0", offsetof(struct opengl_funcs, p_glGetFragmentMaterialfvSGIX) }, - { "glGetFragmentMaterialivSGIX", "GL_SGIX_fragment_lighting\0", offsetof(struct opengl_funcs, p_glGetFragmentMaterialivSGIX) }, - { "glGetFragmentShadingRatesEXT", "GL_EXT_fragment_shading_rate\0GL_EXT_fragment_shading_rate_attachment\0GL_EXT_fragment_shading_rate_primitive\0", offsetof(struct opengl_funcs, p_glGetFragmentShadingRatesEXT) }, - { "glGetFramebufferAttachmentParameteriv", "GL_ARB_framebuffer_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glGetFramebufferAttachmentParameteriv) }, - { "glGetFramebufferAttachmentParameterivEXT", "GL_EXT_framebuffer_object\0", offsetof(struct opengl_funcs, p_glGetFramebufferAttachmentParameterivEXT) }, - { "glGetFramebufferParameterfvAMD", "GL_AMD_framebuffer_sample_positions\0", offsetof(struct opengl_funcs, p_glGetFramebufferParameterfvAMD) }, - { "glGetFramebufferParameteriv", "GL_ARB_framebuffer_no_attachments\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glGetFramebufferParameteriv) }, - { "glGetFramebufferParameterivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetFramebufferParameterivEXT) }, - { "glGetFramebufferParameterivMESA", "GL_MESA_framebuffer_flip_y\0", offsetof(struct opengl_funcs, p_glGetFramebufferParameterivMESA) }, - { "glGetGraphicsResetStatus", "GL_KHR_robustness\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetGraphicsResetStatus) }, - { "glGetGraphicsResetStatusARB", "GL_ARB_robustness\0", offsetof(struct opengl_funcs, p_glGetGraphicsResetStatusARB) }, - { "glGetHandleARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glGetHandleARB) }, - { "glGetHistogram", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glGetHistogram) }, - { "glGetHistogramEXT", "GL_EXT_histogram\0", offsetof(struct opengl_funcs, p_glGetHistogramEXT) }, - { "glGetHistogramParameterfv", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glGetHistogramParameterfv) }, - { "glGetHistogramParameterfvEXT", "GL_EXT_histogram\0", offsetof(struct opengl_funcs, p_glGetHistogramParameterfvEXT) }, - { "glGetHistogramParameteriv", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glGetHistogramParameteriv) }, - { "glGetHistogramParameterivEXT", "GL_EXT_histogram\0", offsetof(struct opengl_funcs, p_glGetHistogramParameterivEXT) }, - { "glGetHistogramParameterxvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glGetHistogramParameterxvOES) }, - { "glGetImageHandleARB", "GL_ARB_bindless_texture\0", offsetof(struct opengl_funcs, p_glGetImageHandleARB) }, - { "glGetImageHandleNV", "GL_NV_bindless_texture\0", offsetof(struct opengl_funcs, p_glGetImageHandleNV) }, - { "glGetImageTransformParameterfvHP", "GL_HP_image_transform\0", offsetof(struct opengl_funcs, p_glGetImageTransformParameterfvHP) }, - { "glGetImageTransformParameterivHP", "GL_HP_image_transform\0", offsetof(struct opengl_funcs, p_glGetImageTransformParameterivHP) }, - { "glGetInfoLogARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glGetInfoLogARB) }, - { "glGetInstrumentsSGIX", "GL_SGIX_instruments\0", offsetof(struct opengl_funcs, p_glGetInstrumentsSGIX) }, - { "glGetInteger64i_v", "GL_VERSION_3_2\0", offsetof(struct opengl_funcs, p_glGetInteger64i_v) }, - { "glGetInteger64v", "GL_ARB_sync\0GL_VERSION_3_2\0", offsetof(struct opengl_funcs, p_glGetInteger64v) }, - { "glGetIntegerIndexedvEXT", "GL_EXT_direct_state_access\0GL_EXT_draw_buffers2\0", offsetof(struct opengl_funcs, p_glGetIntegerIndexedvEXT) }, - { "glGetIntegeri_v", "GL_ARB_uniform_buffer_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glGetIntegeri_v) }, - { "glGetIntegerui64i_vNV", "GL_NV_vertex_buffer_unified_memory\0", offsetof(struct opengl_funcs, p_glGetIntegerui64i_vNV) }, - { "glGetIntegerui64vNV", "GL_NV_shader_buffer_load\0", offsetof(struct opengl_funcs, p_glGetIntegerui64vNV) }, - { "glGetInternalformatSampleivNV", "GL_NV_internalformat_sample_query\0", offsetof(struct opengl_funcs, p_glGetInternalformatSampleivNV) }, - { "glGetInternalformati64v", "GL_ARB_internalformat_query2\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glGetInternalformati64v) }, - { "glGetInternalformativ", "GL_ARB_internalformat_query\0GL_VERSION_4_2\0", offsetof(struct opengl_funcs, p_glGetInternalformativ) }, - { "glGetInvariantBooleanvEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glGetInvariantBooleanvEXT) }, - { "glGetInvariantFloatvEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glGetInvariantFloatvEXT) }, - { "glGetInvariantIntegervEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glGetInvariantIntegervEXT) }, - { "glGetLightxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glGetLightxOES) }, - { "glGetLightxv", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glGetLightxv) }, - { "glGetListParameterfvSGIX", "GL_SGIX_list_priority\0", offsetof(struct opengl_funcs, p_glGetListParameterfvSGIX) }, - { "glGetListParameterivSGIX", "GL_SGIX_list_priority\0", offsetof(struct opengl_funcs, p_glGetListParameterivSGIX) }, - { "glGetLocalConstantBooleanvEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glGetLocalConstantBooleanvEXT) }, - { "glGetLocalConstantFloatvEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glGetLocalConstantFloatvEXT) }, - { "glGetLocalConstantIntegervEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glGetLocalConstantIntegervEXT) }, - { "glGetMapAttribParameterfvNV", "GL_NV_evaluators\0", offsetof(struct opengl_funcs, p_glGetMapAttribParameterfvNV) }, - { "glGetMapAttribParameterivNV", "GL_NV_evaluators\0", offsetof(struct opengl_funcs, p_glGetMapAttribParameterivNV) }, - { "glGetMapControlPointsNV", "GL_NV_evaluators\0", offsetof(struct opengl_funcs, p_glGetMapControlPointsNV) }, - { "glGetMapParameterfvNV", "GL_NV_evaluators\0", offsetof(struct opengl_funcs, p_glGetMapParameterfvNV) }, - { "glGetMapParameterivNV", "GL_NV_evaluators\0", offsetof(struct opengl_funcs, p_glGetMapParameterivNV) }, - { "glGetMapxvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glGetMapxvOES) }, - { "glGetMaterialxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glGetMaterialxOES) }, - { "glGetMaterialxv", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glGetMaterialxv) }, - { "glGetMemoryObjectDetachedResourcesuivNV", "GL_NV_memory_attachment\0", offsetof(struct opengl_funcs, p_glGetMemoryObjectDetachedResourcesuivNV) }, - { "glGetMemoryObjectParameterivEXT", "GL_EXT_memory_object\0", offsetof(struct opengl_funcs, p_glGetMemoryObjectParameterivEXT) }, - { "glGetMinmax", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glGetMinmax) }, - { "glGetMinmaxEXT", "GL_EXT_histogram\0", offsetof(struct opengl_funcs, p_glGetMinmaxEXT) }, - { "glGetMinmaxParameterfv", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glGetMinmaxParameterfv) }, - { "glGetMinmaxParameterfvEXT", "GL_EXT_histogram\0", offsetof(struct opengl_funcs, p_glGetMinmaxParameterfvEXT) }, - { "glGetMinmaxParameteriv", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glGetMinmaxParameteriv) }, - { "glGetMinmaxParameterivEXT", "GL_EXT_histogram\0", offsetof(struct opengl_funcs, p_glGetMinmaxParameterivEXT) }, - { "glGetMultiTexEnvfvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetMultiTexEnvfvEXT) }, - { "glGetMultiTexEnvivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetMultiTexEnvivEXT) }, - { "glGetMultiTexGendvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetMultiTexGendvEXT) }, - { "glGetMultiTexGenfvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetMultiTexGenfvEXT) }, - { "glGetMultiTexGenivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetMultiTexGenivEXT) }, - { "glGetMultiTexImageEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetMultiTexImageEXT) }, - { "glGetMultiTexLevelParameterfvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetMultiTexLevelParameterfvEXT) }, - { "glGetMultiTexLevelParameterivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetMultiTexLevelParameterivEXT) }, - { "glGetMultiTexParameterIivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetMultiTexParameterIivEXT) }, - { "glGetMultiTexParameterIuivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetMultiTexParameterIuivEXT) }, - { "glGetMultiTexParameterfvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetMultiTexParameterfvEXT) }, - { "glGetMultiTexParameterivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetMultiTexParameterivEXT) }, - { "glGetMultisamplefv", "GL_ARB_texture_multisample\0GL_VERSION_3_2\0", offsetof(struct opengl_funcs, p_glGetMultisamplefv) }, - { "glGetMultisamplefvNV", "GL_NV_explicit_multisample\0", offsetof(struct opengl_funcs, p_glGetMultisamplefvNV) }, - { "glGetNamedBufferParameteri64v", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetNamedBufferParameteri64v) }, - { "glGetNamedBufferParameteriv", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetNamedBufferParameteriv) }, - { "glGetNamedBufferParameterivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetNamedBufferParameterivEXT) }, - { "glGetNamedBufferParameterui64vNV", "GL_NV_shader_buffer_load\0", offsetof(struct opengl_funcs, p_glGetNamedBufferParameterui64vNV) }, - { "glGetNamedBufferPointerv", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetNamedBufferPointerv) }, - { "glGetNamedBufferPointervEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetNamedBufferPointervEXT) }, - { "glGetNamedBufferSubData", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetNamedBufferSubData) }, - { "glGetNamedBufferSubDataEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetNamedBufferSubDataEXT) }, - { "glGetNamedFramebufferAttachmentParameteriv", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetNamedFramebufferAttachmentParameteriv) }, - { "glGetNamedFramebufferAttachmentParameterivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetNamedFramebufferAttachmentParameterivEXT) }, - { "glGetNamedFramebufferParameterfvAMD", "GL_AMD_framebuffer_sample_positions\0", offsetof(struct opengl_funcs, p_glGetNamedFramebufferParameterfvAMD) }, - { "glGetNamedFramebufferParameteriv", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetNamedFramebufferParameteriv) }, - { "glGetNamedFramebufferParameterivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetNamedFramebufferParameterivEXT) }, - { "glGetNamedProgramLocalParameterIivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetNamedProgramLocalParameterIivEXT) }, - { "glGetNamedProgramLocalParameterIuivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetNamedProgramLocalParameterIuivEXT) }, - { "glGetNamedProgramLocalParameterdvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetNamedProgramLocalParameterdvEXT) }, - { "glGetNamedProgramLocalParameterfvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetNamedProgramLocalParameterfvEXT) }, - { "glGetNamedProgramStringEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetNamedProgramStringEXT) }, - { "glGetNamedProgramivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetNamedProgramivEXT) }, - { "glGetNamedRenderbufferParameteriv", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetNamedRenderbufferParameteriv) }, - { "glGetNamedRenderbufferParameterivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetNamedRenderbufferParameterivEXT) }, - { "glGetNamedStringARB", "GL_ARB_shading_language_include\0", offsetof(struct opengl_funcs, p_glGetNamedStringARB) }, - { "glGetNamedStringivARB", "GL_ARB_shading_language_include\0", offsetof(struct opengl_funcs, p_glGetNamedStringivARB) }, - { "glGetNextPerfQueryIdINTEL", "GL_INTEL_performance_query\0", offsetof(struct opengl_funcs, p_glGetNextPerfQueryIdINTEL) }, - { "glGetObjectBufferfvATI", "GL_ATI_vertex_array_object\0", offsetof(struct opengl_funcs, p_glGetObjectBufferfvATI) }, - { "glGetObjectBufferivATI", "GL_ATI_vertex_array_object\0", offsetof(struct opengl_funcs, p_glGetObjectBufferivATI) }, - { "glGetObjectLabel", "GL_KHR_debug\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glGetObjectLabel) }, - { "glGetObjectLabelEXT", "GL_EXT_debug_label\0", offsetof(struct opengl_funcs, p_glGetObjectLabelEXT) }, - { "glGetObjectParameterfvARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glGetObjectParameterfvARB) }, - { "glGetObjectParameterivAPPLE", "GL_APPLE_object_purgeable\0", offsetof(struct opengl_funcs, p_glGetObjectParameterivAPPLE) }, - { "glGetObjectParameterivARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glGetObjectParameterivARB) }, - { "glGetObjectPtrLabel", "GL_KHR_debug\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glGetObjectPtrLabel) }, - { "glGetOcclusionQueryivNV", "GL_NV_occlusion_query\0", offsetof(struct opengl_funcs, p_glGetOcclusionQueryivNV) }, - { "glGetOcclusionQueryuivNV", "GL_NV_occlusion_query\0", offsetof(struct opengl_funcs, p_glGetOcclusionQueryuivNV) }, - { "glGetPathColorGenfvNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glGetPathColorGenfvNV) }, - { "glGetPathColorGenivNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glGetPathColorGenivNV) }, - { "glGetPathCommandsNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glGetPathCommandsNV) }, - { "glGetPathCoordsNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glGetPathCoordsNV) }, - { "glGetPathDashArrayNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glGetPathDashArrayNV) }, - { "glGetPathLengthNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glGetPathLengthNV) }, - { "glGetPathMetricRangeNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glGetPathMetricRangeNV) }, - { "glGetPathMetricsNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glGetPathMetricsNV) }, - { "glGetPathParameterfvNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glGetPathParameterfvNV) }, - { "glGetPathParameterivNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glGetPathParameterivNV) }, - { "glGetPathSpacingNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glGetPathSpacingNV) }, - { "glGetPathTexGenfvNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glGetPathTexGenfvNV) }, - { "glGetPathTexGenivNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glGetPathTexGenivNV) }, - { "glGetPerfCounterInfoINTEL", "GL_INTEL_performance_query\0", offsetof(struct opengl_funcs, p_glGetPerfCounterInfoINTEL) }, - { "glGetPerfMonitorCounterDataAMD", "GL_AMD_performance_monitor\0", offsetof(struct opengl_funcs, p_glGetPerfMonitorCounterDataAMD) }, - { "glGetPerfMonitorCounterInfoAMD", "GL_AMD_performance_monitor\0", offsetof(struct opengl_funcs, p_glGetPerfMonitorCounterInfoAMD) }, - { "glGetPerfMonitorCounterStringAMD", "GL_AMD_performance_monitor\0", offsetof(struct opengl_funcs, p_glGetPerfMonitorCounterStringAMD) }, - { "glGetPerfMonitorCountersAMD", "GL_AMD_performance_monitor\0", offsetof(struct opengl_funcs, p_glGetPerfMonitorCountersAMD) }, - { "glGetPerfMonitorGroupStringAMD", "GL_AMD_performance_monitor\0", offsetof(struct opengl_funcs, p_glGetPerfMonitorGroupStringAMD) }, - { "glGetPerfMonitorGroupsAMD", "GL_AMD_performance_monitor\0", offsetof(struct opengl_funcs, p_glGetPerfMonitorGroupsAMD) }, - { "glGetPerfQueryDataINTEL", "GL_INTEL_performance_query\0", offsetof(struct opengl_funcs, p_glGetPerfQueryDataINTEL) }, - { "glGetPerfQueryIdByNameINTEL", "GL_INTEL_performance_query\0", offsetof(struct opengl_funcs, p_glGetPerfQueryIdByNameINTEL) }, - { "glGetPerfQueryInfoINTEL", "GL_INTEL_performance_query\0", offsetof(struct opengl_funcs, p_glGetPerfQueryInfoINTEL) }, - { "glGetPixelMapxv", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glGetPixelMapxv) }, - { "glGetPixelTexGenParameterfvSGIS", "GL_SGIS_pixel_texture\0", offsetof(struct opengl_funcs, p_glGetPixelTexGenParameterfvSGIS) }, - { "glGetPixelTexGenParameterivSGIS", "GL_SGIS_pixel_texture\0", offsetof(struct opengl_funcs, p_glGetPixelTexGenParameterivSGIS) }, - { "glGetPixelTransformParameterfvEXT", "GL_EXT_pixel_transform\0", offsetof(struct opengl_funcs, p_glGetPixelTransformParameterfvEXT) }, - { "glGetPixelTransformParameterivEXT", "GL_EXT_pixel_transform\0", offsetof(struct opengl_funcs, p_glGetPixelTransformParameterivEXT) }, - { "glGetPointerIndexedvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetPointerIndexedvEXT) }, - { "glGetPointeri_vEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetPointeri_vEXT) }, - { "glGetPointervEXT", "GL_EXT_vertex_array\0", offsetof(struct opengl_funcs, p_glGetPointervEXT) }, - { "glGetProgramBinary", "GL_ARB_get_program_binary\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glGetProgramBinary) }, - { "glGetProgramEnvParameterIivNV", "GL_NV_gpu_program4\0", offsetof(struct opengl_funcs, p_glGetProgramEnvParameterIivNV) }, - { "glGetProgramEnvParameterIuivNV", "GL_NV_gpu_program4\0", offsetof(struct opengl_funcs, p_glGetProgramEnvParameterIuivNV) }, - { "glGetProgramEnvParameterdvARB", "GL_ARB_fragment_program\0GL_ARB_vertex_program\0", offsetof(struct opengl_funcs, p_glGetProgramEnvParameterdvARB) }, - { "glGetProgramEnvParameterfvARB", "GL_ARB_fragment_program\0GL_ARB_vertex_program\0", offsetof(struct opengl_funcs, p_glGetProgramEnvParameterfvARB) }, - { "glGetProgramInfoLog", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glGetProgramInfoLog) }, - { "glGetProgramInterfaceiv", "GL_ARB_program_interface_query\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glGetProgramInterfaceiv) }, - { "glGetProgramLocalParameterIivNV", "GL_NV_gpu_program4\0", offsetof(struct opengl_funcs, p_glGetProgramLocalParameterIivNV) }, - { "glGetProgramLocalParameterIuivNV", "GL_NV_gpu_program4\0", offsetof(struct opengl_funcs, p_glGetProgramLocalParameterIuivNV) }, - { "glGetProgramLocalParameterdvARB", "GL_ARB_fragment_program\0GL_ARB_vertex_program\0", offsetof(struct opengl_funcs, p_glGetProgramLocalParameterdvARB) }, - { "glGetProgramLocalParameterfvARB", "GL_ARB_fragment_program\0GL_ARB_vertex_program\0", offsetof(struct opengl_funcs, p_glGetProgramLocalParameterfvARB) }, - { "glGetProgramNamedParameterdvNV", "GL_NV_fragment_program\0", offsetof(struct opengl_funcs, p_glGetProgramNamedParameterdvNV) }, - { "glGetProgramNamedParameterfvNV", "GL_NV_fragment_program\0", offsetof(struct opengl_funcs, p_glGetProgramNamedParameterfvNV) }, - { "glGetProgramParameterdvNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glGetProgramParameterdvNV) }, - { "glGetProgramParameterfvNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glGetProgramParameterfvNV) }, - { "glGetProgramPipelineInfoLog", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glGetProgramPipelineInfoLog) }, - { "glGetProgramPipelineiv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glGetProgramPipelineiv) }, - { "glGetProgramResourceIndex", "GL_ARB_program_interface_query\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glGetProgramResourceIndex) }, - { "glGetProgramResourceLocation", "GL_ARB_program_interface_query\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glGetProgramResourceLocation) }, - { "glGetProgramResourceLocationIndex", "GL_ARB_program_interface_query\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glGetProgramResourceLocationIndex) }, - { "glGetProgramResourceName", "GL_ARB_program_interface_query\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glGetProgramResourceName) }, - { "glGetProgramResourcefvNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glGetProgramResourcefvNV) }, - { "glGetProgramResourceiv", "GL_ARB_program_interface_query\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glGetProgramResourceiv) }, - { "glGetProgramStageiv", "GL_ARB_shader_subroutine\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glGetProgramStageiv) }, - { "glGetProgramStringARB", "GL_ARB_fragment_program\0GL_ARB_vertex_program\0", offsetof(struct opengl_funcs, p_glGetProgramStringARB) }, - { "glGetProgramStringNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glGetProgramStringNV) }, - { "glGetProgramSubroutineParameteruivNV", "GL_NV_gpu_program5\0GL_NV_gpu_program_fp64\0", offsetof(struct opengl_funcs, p_glGetProgramSubroutineParameteruivNV) }, - { "glGetProgramiv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glGetProgramiv) }, - { "glGetProgramivARB", "GL_ARB_fragment_program\0GL_ARB_vertex_program\0", offsetof(struct opengl_funcs, p_glGetProgramivARB) }, - { "glGetProgramivNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glGetProgramivNV) }, - { "glGetQueryBufferObjecti64v", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetQueryBufferObjecti64v) }, - { "glGetQueryBufferObjectiv", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetQueryBufferObjectiv) }, - { "glGetQueryBufferObjectui64v", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetQueryBufferObjectui64v) }, - { "glGetQueryBufferObjectuiv", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetQueryBufferObjectuiv) }, - { "glGetQueryIndexediv", "GL_ARB_transform_feedback3\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glGetQueryIndexediv) }, - { "glGetQueryObjecti64v", "GL_ARB_timer_query\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glGetQueryObjecti64v) }, - { "glGetQueryObjecti64vEXT", "GL_EXT_timer_query\0", offsetof(struct opengl_funcs, p_glGetQueryObjecti64vEXT) }, - { "glGetQueryObjectiv", "GL_VERSION_1_5\0", offsetof(struct opengl_funcs, p_glGetQueryObjectiv) }, - { "glGetQueryObjectivARB", "GL_ARB_occlusion_query\0", offsetof(struct opengl_funcs, p_glGetQueryObjectivARB) }, - { "glGetQueryObjectui64v", "GL_ARB_timer_query\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glGetQueryObjectui64v) }, - { "glGetQueryObjectui64vEXT", "GL_EXT_timer_query\0", offsetof(struct opengl_funcs, p_glGetQueryObjectui64vEXT) }, - { "glGetQueryObjectuiv", "GL_VERSION_1_5\0", offsetof(struct opengl_funcs, p_glGetQueryObjectuiv) }, - { "glGetQueryObjectuivARB", "GL_ARB_occlusion_query\0", offsetof(struct opengl_funcs, p_glGetQueryObjectuivARB) }, - { "glGetQueryiv", "GL_VERSION_1_5\0", offsetof(struct opengl_funcs, p_glGetQueryiv) }, - { "glGetQueryivARB", "GL_ARB_occlusion_query\0", offsetof(struct opengl_funcs, p_glGetQueryivARB) }, - { "glGetRenderbufferParameteriv", "GL_ARB_framebuffer_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glGetRenderbufferParameteriv) }, - { "glGetRenderbufferParameterivEXT", "GL_EXT_framebuffer_object\0", offsetof(struct opengl_funcs, p_glGetRenderbufferParameterivEXT) }, - { "glGetSamplerParameterIiv", "GL_ARB_sampler_objects\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glGetSamplerParameterIiv) }, - { "glGetSamplerParameterIuiv", "GL_ARB_sampler_objects\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glGetSamplerParameterIuiv) }, - { "glGetSamplerParameterfv", "GL_ARB_sampler_objects\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glGetSamplerParameterfv) }, - { "glGetSamplerParameteriv", "GL_ARB_sampler_objects\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glGetSamplerParameteriv) }, - { "glGetSemaphoreParameterivNV", "GL_NV_timeline_semaphore\0", offsetof(struct opengl_funcs, p_glGetSemaphoreParameterivNV) }, - { "glGetSemaphoreParameterui64vEXT", "GL_EXT_semaphore\0", offsetof(struct opengl_funcs, p_glGetSemaphoreParameterui64vEXT) }, - { "glGetSeparableFilter", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glGetSeparableFilter) }, - { "glGetSeparableFilterEXT", "GL_EXT_convolution\0", offsetof(struct opengl_funcs, p_glGetSeparableFilterEXT) }, - { "glGetShaderInfoLog", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glGetShaderInfoLog) }, - { "glGetShaderPrecisionFormat", "GL_ARB_ES2_compatibility\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glGetShaderPrecisionFormat) }, - { "glGetShaderSource", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glGetShaderSource) }, - { "glGetShaderSourceARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glGetShaderSourceARB) }, - { "glGetShaderiv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glGetShaderiv) }, - { "glGetShadingRateImagePaletteNV", "GL_NV_shading_rate_image\0", offsetof(struct opengl_funcs, p_glGetShadingRateImagePaletteNV) }, - { "glGetShadingRateSampleLocationivNV", "GL_NV_shading_rate_image\0", offsetof(struct opengl_funcs, p_glGetShadingRateSampleLocationivNV) }, - { "glGetSharpenTexFuncSGIS", "GL_SGIS_sharpen_texture\0", offsetof(struct opengl_funcs, p_glGetSharpenTexFuncSGIS) }, - { "glGetStageIndexNV", "GL_NV_command_list\0", offsetof(struct opengl_funcs, p_glGetStageIndexNV) }, - { "glGetStringi", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glGetStringi) }, - { "glGetSubroutineIndex", "GL_ARB_shader_subroutine\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glGetSubroutineIndex) }, - { "glGetSubroutineUniformLocation", "GL_ARB_shader_subroutine\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glGetSubroutineUniformLocation) }, - { "glGetSynciv", "GL_ARB_sync\0GL_VERSION_3_2\0", offsetof(struct opengl_funcs, p_glGetSynciv) }, - { "glGetTexBumpParameterfvATI", "GL_ATI_envmap_bumpmap\0", offsetof(struct opengl_funcs, p_glGetTexBumpParameterfvATI) }, - { "glGetTexBumpParameterivATI", "GL_ATI_envmap_bumpmap\0", offsetof(struct opengl_funcs, p_glGetTexBumpParameterivATI) }, - { "glGetTexEnvxv", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glGetTexEnvxv) }, - { "glGetTexEnvxvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glGetTexEnvxvOES) }, - { "glGetTexFilterFuncSGIS", "GL_SGIS_texture_filter4\0", offsetof(struct opengl_funcs, p_glGetTexFilterFuncSGIS) }, - { "glGetTexGenxvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glGetTexGenxvOES) }, - { "glGetTexLevelParameterxvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glGetTexLevelParameterxvOES) }, - { "glGetTexParameterIiv", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glGetTexParameterIiv) }, - { "glGetTexParameterIivEXT", "GL_EXT_texture_integer\0", offsetof(struct opengl_funcs, p_glGetTexParameterIivEXT) }, - { "glGetTexParameterIuiv", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glGetTexParameterIuiv) }, - { "glGetTexParameterIuivEXT", "GL_EXT_texture_integer\0", offsetof(struct opengl_funcs, p_glGetTexParameterIuivEXT) }, - { "glGetTexParameterPointervAPPLE", "GL_APPLE_texture_range\0", offsetof(struct opengl_funcs, p_glGetTexParameterPointervAPPLE) }, - { "glGetTexParameterxv", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glGetTexParameterxv) }, - { "glGetTexParameterxvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glGetTexParameterxvOES) }, - { "glGetTextureHandleARB", "GL_ARB_bindless_texture\0", offsetof(struct opengl_funcs, p_glGetTextureHandleARB) }, - { "glGetTextureHandleNV", "GL_NV_bindless_texture\0", offsetof(struct opengl_funcs, p_glGetTextureHandleNV) }, - { "glGetTextureImage", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetTextureImage) }, - { "glGetTextureImageEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetTextureImageEXT) }, - { "glGetTextureLevelParameterfv", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetTextureLevelParameterfv) }, - { "glGetTextureLevelParameterfvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetTextureLevelParameterfvEXT) }, - { "glGetTextureLevelParameteriv", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetTextureLevelParameteriv) }, - { "glGetTextureLevelParameterivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetTextureLevelParameterivEXT) }, - { "glGetTextureParameterIiv", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetTextureParameterIiv) }, - { "glGetTextureParameterIivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetTextureParameterIivEXT) }, - { "glGetTextureParameterIuiv", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetTextureParameterIuiv) }, - { "glGetTextureParameterIuivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetTextureParameterIuivEXT) }, - { "glGetTextureParameterfv", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetTextureParameterfv) }, - { "glGetTextureParameterfvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetTextureParameterfvEXT) }, - { "glGetTextureParameteriv", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetTextureParameteriv) }, - { "glGetTextureParameterivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetTextureParameterivEXT) }, - { "glGetTextureSamplerHandleARB", "GL_ARB_bindless_texture\0", offsetof(struct opengl_funcs, p_glGetTextureSamplerHandleARB) }, - { "glGetTextureSamplerHandleNV", "GL_NV_bindless_texture\0", offsetof(struct opengl_funcs, p_glGetTextureSamplerHandleNV) }, - { "glGetTextureSubImage", "GL_ARB_get_texture_sub_image\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetTextureSubImage) }, - { "glGetTrackMatrixivNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glGetTrackMatrixivNV) }, - { "glGetTransformFeedbackVarying", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glGetTransformFeedbackVarying) }, - { "glGetTransformFeedbackVaryingEXT", "GL_EXT_transform_feedback\0", offsetof(struct opengl_funcs, p_glGetTransformFeedbackVaryingEXT) }, - { "glGetTransformFeedbackVaryingNV", "GL_NV_transform_feedback\0", offsetof(struct opengl_funcs, p_glGetTransformFeedbackVaryingNV) }, - { "glGetTransformFeedbacki64_v", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetTransformFeedbacki64_v) }, - { "glGetTransformFeedbacki_v", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetTransformFeedbacki_v) }, - { "glGetTransformFeedbackiv", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetTransformFeedbackiv) }, - { "glGetUniformBlockIndex", "GL_ARB_uniform_buffer_object\0GL_VERSION_3_1\0", offsetof(struct opengl_funcs, p_glGetUniformBlockIndex) }, - { "glGetUniformBufferSizeEXT", "GL_EXT_bindable_uniform\0", offsetof(struct opengl_funcs, p_glGetUniformBufferSizeEXT) }, - { "glGetUniformIndices", "GL_ARB_uniform_buffer_object\0GL_VERSION_3_1\0", offsetof(struct opengl_funcs, p_glGetUniformIndices) }, - { "glGetUniformLocation", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glGetUniformLocation) }, - { "glGetUniformLocationARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glGetUniformLocationARB) }, - { "glGetUniformOffsetEXT", "GL_EXT_bindable_uniform\0", offsetof(struct opengl_funcs, p_glGetUniformOffsetEXT) }, - { "glGetUniformSubroutineuiv", "GL_ARB_shader_subroutine\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glGetUniformSubroutineuiv) }, - { "glGetUniformdv", "GL_ARB_gpu_shader_fp64\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glGetUniformdv) }, - { "glGetUniformfv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glGetUniformfv) }, - { "glGetUniformfvARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glGetUniformfvARB) }, - { "glGetUniformi64vARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glGetUniformi64vARB) }, - { "glGetUniformi64vNV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glGetUniformi64vNV) }, - { "glGetUniformiv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glGetUniformiv) }, - { "glGetUniformivARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glGetUniformivARB) }, - { "glGetUniformui64vARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glGetUniformui64vARB) }, - { "glGetUniformui64vNV", "GL_AMD_gpu_shader_int64\0GL_NV_shader_buffer_load\0", offsetof(struct opengl_funcs, p_glGetUniformui64vNV) }, - { "glGetUniformuiv", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glGetUniformuiv) }, - { "glGetUniformuivEXT", "GL_EXT_gpu_shader4\0", offsetof(struct opengl_funcs, p_glGetUniformuivEXT) }, - { "glGetUnsignedBytei_vEXT", "GL_EXT_memory_object\0GL_EXT_semaphore\0", offsetof(struct opengl_funcs, p_glGetUnsignedBytei_vEXT) }, - { "glGetUnsignedBytevEXT", "GL_EXT_memory_object\0GL_EXT_semaphore\0", offsetof(struct opengl_funcs, p_glGetUnsignedBytevEXT) }, - { "glGetVariantArrayObjectfvATI", "GL_ATI_vertex_array_object\0", offsetof(struct opengl_funcs, p_glGetVariantArrayObjectfvATI) }, - { "glGetVariantArrayObjectivATI", "GL_ATI_vertex_array_object\0", offsetof(struct opengl_funcs, p_glGetVariantArrayObjectivATI) }, - { "glGetVariantBooleanvEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glGetVariantBooleanvEXT) }, - { "glGetVariantFloatvEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glGetVariantFloatvEXT) }, - { "glGetVariantIntegervEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glGetVariantIntegervEXT) }, - { "glGetVariantPointervEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glGetVariantPointervEXT) }, - { "glGetVaryingLocationNV", "GL_NV_transform_feedback\0", offsetof(struct opengl_funcs, p_glGetVaryingLocationNV) }, - { "glGetVertexArrayIndexed64iv", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetVertexArrayIndexed64iv) }, - { "glGetVertexArrayIndexediv", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetVertexArrayIndexediv) }, - { "glGetVertexArrayIntegeri_vEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetVertexArrayIntegeri_vEXT) }, - { "glGetVertexArrayIntegervEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetVertexArrayIntegervEXT) }, - { "glGetVertexArrayPointeri_vEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetVertexArrayPointeri_vEXT) }, - { "glGetVertexArrayPointervEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glGetVertexArrayPointervEXT) }, - { "glGetVertexArrayiv", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetVertexArrayiv) }, - { "glGetVertexAttribArrayObjectfvATI", "GL_ATI_vertex_attrib_array_object\0", offsetof(struct opengl_funcs, p_glGetVertexAttribArrayObjectfvATI) }, - { "glGetVertexAttribArrayObjectivATI", "GL_ATI_vertex_attrib_array_object\0", offsetof(struct opengl_funcs, p_glGetVertexAttribArrayObjectivATI) }, - { "glGetVertexAttribIiv", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glGetVertexAttribIiv) }, - { "glGetVertexAttribIivEXT", "GL_EXT_gpu_shader4\0GL_NV_vertex_program4\0", offsetof(struct opengl_funcs, p_glGetVertexAttribIivEXT) }, - { "glGetVertexAttribIuiv", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glGetVertexAttribIuiv) }, - { "glGetVertexAttribIuivEXT", "GL_EXT_gpu_shader4\0GL_NV_vertex_program4\0", offsetof(struct opengl_funcs, p_glGetVertexAttribIuivEXT) }, - { "glGetVertexAttribLdv", "GL_ARB_vertex_attrib_64bit\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glGetVertexAttribLdv) }, - { "glGetVertexAttribLdvEXT", "GL_EXT_vertex_attrib_64bit\0", offsetof(struct opengl_funcs, p_glGetVertexAttribLdvEXT) }, - { "glGetVertexAttribLi64vNV", "GL_NV_vertex_attrib_integer_64bit\0", offsetof(struct opengl_funcs, p_glGetVertexAttribLi64vNV) }, - { "glGetVertexAttribLui64vARB", "GL_ARB_bindless_texture\0", offsetof(struct opengl_funcs, p_glGetVertexAttribLui64vARB) }, - { "glGetVertexAttribLui64vNV", "GL_NV_vertex_attrib_integer_64bit\0", offsetof(struct opengl_funcs, p_glGetVertexAttribLui64vNV) }, - { "glGetVertexAttribPointerv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glGetVertexAttribPointerv) }, - { "glGetVertexAttribPointervARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glGetVertexAttribPointervARB) }, - { "glGetVertexAttribPointervNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glGetVertexAttribPointervNV) }, - { "glGetVertexAttribdv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glGetVertexAttribdv) }, - { "glGetVertexAttribdvARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glGetVertexAttribdvARB) }, - { "glGetVertexAttribdvNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glGetVertexAttribdvNV) }, - { "glGetVertexAttribfv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glGetVertexAttribfv) }, - { "glGetVertexAttribfvARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glGetVertexAttribfvARB) }, - { "glGetVertexAttribfvNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glGetVertexAttribfvNV) }, - { "glGetVertexAttribiv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glGetVertexAttribiv) }, - { "glGetVertexAttribivARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glGetVertexAttribivARB) }, - { "glGetVertexAttribivNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glGetVertexAttribivNV) }, - { "glGetVideoCaptureStreamdvNV", "GL_NV_video_capture\0", offsetof(struct opengl_funcs, p_glGetVideoCaptureStreamdvNV) }, - { "glGetVideoCaptureStreamfvNV", "GL_NV_video_capture\0", offsetof(struct opengl_funcs, p_glGetVideoCaptureStreamfvNV) }, - { "glGetVideoCaptureStreamivNV", "GL_NV_video_capture\0", offsetof(struct opengl_funcs, p_glGetVideoCaptureStreamivNV) }, - { "glGetVideoCaptureivNV", "GL_NV_video_capture\0", offsetof(struct opengl_funcs, p_glGetVideoCaptureivNV) }, - { "glGetVideoi64vNV", "GL_NV_present_video\0", offsetof(struct opengl_funcs, p_glGetVideoi64vNV) }, - { "glGetVideoivNV", "GL_NV_present_video\0", offsetof(struct opengl_funcs, p_glGetVideoivNV) }, - { "glGetVideoui64vNV", "GL_NV_present_video\0", offsetof(struct opengl_funcs, p_glGetVideoui64vNV) }, - { "glGetVideouivNV", "GL_NV_present_video\0", offsetof(struct opengl_funcs, p_glGetVideouivNV) }, - { "glGetVkProcAddrNV", "GL_NV_draw_vulkan_image\0", offsetof(struct opengl_funcs, p_glGetVkProcAddrNV) }, - { "glGetnColorTable", "GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetnColorTable) }, - { "glGetnColorTableARB", "GL_ARB_robustness\0", offsetof(struct opengl_funcs, p_glGetnColorTableARB) }, - { "glGetnCompressedTexImage", "GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetnCompressedTexImage) }, - { "glGetnCompressedTexImageARB", "GL_ARB_robustness\0", offsetof(struct opengl_funcs, p_glGetnCompressedTexImageARB) }, - { "glGetnConvolutionFilter", "GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetnConvolutionFilter) }, - { "glGetnConvolutionFilterARB", "GL_ARB_robustness\0", offsetof(struct opengl_funcs, p_glGetnConvolutionFilterARB) }, - { "glGetnHistogram", "GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetnHistogram) }, - { "glGetnHistogramARB", "GL_ARB_robustness\0", offsetof(struct opengl_funcs, p_glGetnHistogramARB) }, - { "glGetnMapdv", "GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetnMapdv) }, - { "glGetnMapdvARB", "GL_ARB_robustness\0", offsetof(struct opengl_funcs, p_glGetnMapdvARB) }, - { "glGetnMapfv", "GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetnMapfv) }, - { "glGetnMapfvARB", "GL_ARB_robustness\0", offsetof(struct opengl_funcs, p_glGetnMapfvARB) }, - { "glGetnMapiv", "GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetnMapiv) }, - { "glGetnMapivARB", "GL_ARB_robustness\0", offsetof(struct opengl_funcs, p_glGetnMapivARB) }, - { "glGetnMinmax", "GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetnMinmax) }, - { "glGetnMinmaxARB", "GL_ARB_robustness\0", offsetof(struct opengl_funcs, p_glGetnMinmaxARB) }, - { "glGetnPixelMapfv", "GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetnPixelMapfv) }, - { "glGetnPixelMapfvARB", "GL_ARB_robustness\0", offsetof(struct opengl_funcs, p_glGetnPixelMapfvARB) }, - { "glGetnPixelMapuiv", "GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetnPixelMapuiv) }, - { "glGetnPixelMapuivARB", "GL_ARB_robustness\0", offsetof(struct opengl_funcs, p_glGetnPixelMapuivARB) }, - { "glGetnPixelMapusv", "GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetnPixelMapusv) }, - { "glGetnPixelMapusvARB", "GL_ARB_robustness\0", offsetof(struct opengl_funcs, p_glGetnPixelMapusvARB) }, - { "glGetnPolygonStipple", "GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetnPolygonStipple) }, - { "glGetnPolygonStippleARB", "GL_ARB_robustness\0", offsetof(struct opengl_funcs, p_glGetnPolygonStippleARB) }, - { "glGetnSeparableFilter", "GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetnSeparableFilter) }, - { "glGetnSeparableFilterARB", "GL_ARB_robustness\0", offsetof(struct opengl_funcs, p_glGetnSeparableFilterARB) }, - { "glGetnTexImage", "GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetnTexImage) }, - { "glGetnTexImageARB", "GL_ARB_robustness\0", offsetof(struct opengl_funcs, p_glGetnTexImageARB) }, - { "glGetnUniformdv", "GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetnUniformdv) }, - { "glGetnUniformdvARB", "GL_ARB_robustness\0", offsetof(struct opengl_funcs, p_glGetnUniformdvARB) }, - { "glGetnUniformfv", "GL_KHR_robustness\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetnUniformfv) }, - { "glGetnUniformfvARB", "GL_ARB_robustness\0", offsetof(struct opengl_funcs, p_glGetnUniformfvARB) }, - { "glGetnUniformi64vARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glGetnUniformi64vARB) }, - { "glGetnUniformiv", "GL_KHR_robustness\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetnUniformiv) }, - { "glGetnUniformivARB", "GL_ARB_robustness\0", offsetof(struct opengl_funcs, p_glGetnUniformivARB) }, - { "glGetnUniformui64vARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glGetnUniformui64vARB) }, - { "glGetnUniformuiv", "GL_KHR_robustness\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glGetnUniformuiv) }, - { "glGetnUniformuivARB", "GL_ARB_robustness\0", offsetof(struct opengl_funcs, p_glGetnUniformuivARB) }, - { "glGlobalAlphaFactorbSUN", "GL_SUN_global_alpha\0", offsetof(struct opengl_funcs, p_glGlobalAlphaFactorbSUN) }, - { "glGlobalAlphaFactordSUN", "GL_SUN_global_alpha\0", offsetof(struct opengl_funcs, p_glGlobalAlphaFactordSUN) }, - { "glGlobalAlphaFactorfSUN", "GL_SUN_global_alpha\0", offsetof(struct opengl_funcs, p_glGlobalAlphaFactorfSUN) }, - { "glGlobalAlphaFactoriSUN", "GL_SUN_global_alpha\0", offsetof(struct opengl_funcs, p_glGlobalAlphaFactoriSUN) }, - { "glGlobalAlphaFactorsSUN", "GL_SUN_global_alpha\0", offsetof(struct opengl_funcs, p_glGlobalAlphaFactorsSUN) }, - { "glGlobalAlphaFactorubSUN", "GL_SUN_global_alpha\0", offsetof(struct opengl_funcs, p_glGlobalAlphaFactorubSUN) }, - { "glGlobalAlphaFactoruiSUN", "GL_SUN_global_alpha\0", offsetof(struct opengl_funcs, p_glGlobalAlphaFactoruiSUN) }, - { "glGlobalAlphaFactorusSUN", "GL_SUN_global_alpha\0", offsetof(struct opengl_funcs, p_glGlobalAlphaFactorusSUN) }, - { "glHintPGI", "GL_PGI_misc_hints\0", offsetof(struct opengl_funcs, p_glHintPGI) }, - { "glHistogram", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glHistogram) }, - { "glHistogramEXT", "GL_EXT_histogram\0", offsetof(struct opengl_funcs, p_glHistogramEXT) }, - { "glIglooInterfaceSGIX", "GL_SGIX_igloo_interface\0", offsetof(struct opengl_funcs, p_glIglooInterfaceSGIX) }, - { "glImageTransformParameterfHP", "GL_HP_image_transform\0", offsetof(struct opengl_funcs, p_glImageTransformParameterfHP) }, - { "glImageTransformParameterfvHP", "GL_HP_image_transform\0", offsetof(struct opengl_funcs, p_glImageTransformParameterfvHP) }, - { "glImageTransformParameteriHP", "GL_HP_image_transform\0", offsetof(struct opengl_funcs, p_glImageTransformParameteriHP) }, - { "glImageTransformParameterivHP", "GL_HP_image_transform\0", offsetof(struct opengl_funcs, p_glImageTransformParameterivHP) }, - { "glImportMemoryWin32HandleEXT", "GL_EXT_memory_object_win32\0", offsetof(struct opengl_funcs, p_glImportMemoryWin32HandleEXT) }, - { "glImportMemoryWin32NameEXT", "GL_EXT_memory_object_win32\0", offsetof(struct opengl_funcs, p_glImportMemoryWin32NameEXT) }, - { "glImportSemaphoreWin32HandleEXT", "GL_EXT_semaphore_win32\0", offsetof(struct opengl_funcs, p_glImportSemaphoreWin32HandleEXT) }, - { "glImportSemaphoreWin32NameEXT", "GL_EXT_semaphore_win32\0", offsetof(struct opengl_funcs, p_glImportSemaphoreWin32NameEXT) }, - { "glImportSyncEXT", "GL_EXT_x11_sync_object\0", offsetof(struct opengl_funcs, p_glImportSyncEXT) }, - { "glIndexFormatNV", "GL_NV_vertex_buffer_unified_memory\0", offsetof(struct opengl_funcs, p_glIndexFormatNV) }, - { "glIndexFuncEXT", "GL_EXT_index_func\0", offsetof(struct opengl_funcs, p_glIndexFuncEXT) }, - { "glIndexMaterialEXT", "GL_EXT_index_material\0", offsetof(struct opengl_funcs, p_glIndexMaterialEXT) }, - { "glIndexPointerEXT", "GL_EXT_vertex_array\0", offsetof(struct opengl_funcs, p_glIndexPointerEXT) }, - { "glIndexPointerListIBM", "GL_IBM_vertex_array_lists\0", offsetof(struct opengl_funcs, p_glIndexPointerListIBM) }, - { "glIndexxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glIndexxOES) }, - { "glIndexxvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glIndexxvOES) }, - { "glInsertComponentEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glInsertComponentEXT) }, - { "glInsertEventMarkerEXT", "GL_EXT_debug_marker\0", offsetof(struct opengl_funcs, p_glInsertEventMarkerEXT) }, - { "glInstrumentsBufferSGIX", "GL_SGIX_instruments\0", offsetof(struct opengl_funcs, p_glInstrumentsBufferSGIX) }, - { "glInterpolatePathsNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glInterpolatePathsNV) }, - { "glInvalidateBufferData", "GL_ARB_invalidate_subdata\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glInvalidateBufferData) }, - { "glInvalidateBufferSubData", "GL_ARB_invalidate_subdata\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glInvalidateBufferSubData) }, - { "glInvalidateFramebuffer", "GL_ARB_invalidate_subdata\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glInvalidateFramebuffer) }, - { "glInvalidateNamedFramebufferData", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glInvalidateNamedFramebufferData) }, - { "glInvalidateNamedFramebufferSubData", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glInvalidateNamedFramebufferSubData) }, - { "glInvalidateSubFramebuffer", "GL_ARB_invalidate_subdata\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glInvalidateSubFramebuffer) }, - { "glInvalidateTexImage", "GL_ARB_invalidate_subdata\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glInvalidateTexImage) }, - { "glInvalidateTexSubImage", "GL_ARB_invalidate_subdata\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glInvalidateTexSubImage) }, - { "glIsAsyncMarkerSGIX", "GL_SGIX_async\0", offsetof(struct opengl_funcs, p_glIsAsyncMarkerSGIX) }, - { "glIsBuffer", "GL_VERSION_1_5\0", offsetof(struct opengl_funcs, p_glIsBuffer) }, - { "glIsBufferARB", "GL_ARB_vertex_buffer_object\0", offsetof(struct opengl_funcs, p_glIsBufferARB) }, - { "glIsBufferResidentNV", "GL_NV_shader_buffer_load\0", offsetof(struct opengl_funcs, p_glIsBufferResidentNV) }, - { "glIsCommandListNV", "GL_NV_command_list\0", offsetof(struct opengl_funcs, p_glIsCommandListNV) }, - { "glIsEnabledIndexedEXT", "GL_EXT_direct_state_access\0GL_EXT_draw_buffers2\0", offsetof(struct opengl_funcs, p_glIsEnabledIndexedEXT) }, - { "glIsEnabledi", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glIsEnabledi) }, - { "glIsFenceAPPLE", "GL_APPLE_fence\0", offsetof(struct opengl_funcs, p_glIsFenceAPPLE) }, - { "glIsFenceNV", "GL_NV_fence\0", offsetof(struct opengl_funcs, p_glIsFenceNV) }, - { "glIsFramebuffer", "GL_ARB_framebuffer_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glIsFramebuffer) }, - { "glIsFramebufferEXT", "GL_EXT_framebuffer_object\0", offsetof(struct opengl_funcs, p_glIsFramebufferEXT) }, - { "glIsImageHandleResidentARB", "GL_ARB_bindless_texture\0", offsetof(struct opengl_funcs, p_glIsImageHandleResidentARB) }, - { "glIsImageHandleResidentNV", "GL_NV_bindless_texture\0", offsetof(struct opengl_funcs, p_glIsImageHandleResidentNV) }, - { "glIsMemoryObjectEXT", "GL_EXT_memory_object\0", offsetof(struct opengl_funcs, p_glIsMemoryObjectEXT) }, - { "glIsNameAMD", "GL_AMD_name_gen_delete\0", offsetof(struct opengl_funcs, p_glIsNameAMD) }, - { "glIsNamedBufferResidentNV", "GL_NV_shader_buffer_load\0", offsetof(struct opengl_funcs, p_glIsNamedBufferResidentNV) }, - { "glIsNamedStringARB", "GL_ARB_shading_language_include\0", offsetof(struct opengl_funcs, p_glIsNamedStringARB) }, - { "glIsObjectBufferATI", "GL_ATI_vertex_array_object\0", offsetof(struct opengl_funcs, p_glIsObjectBufferATI) }, - { "glIsOcclusionQueryNV", "GL_NV_occlusion_query\0", offsetof(struct opengl_funcs, p_glIsOcclusionQueryNV) }, - { "glIsPathNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glIsPathNV) }, - { "glIsPointInFillPathNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glIsPointInFillPathNV) }, - { "glIsPointInStrokePathNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glIsPointInStrokePathNV) }, - { "glIsProgram", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glIsProgram) }, - { "glIsProgramARB", "GL_ARB_fragment_program\0GL_ARB_vertex_program\0", offsetof(struct opengl_funcs, p_glIsProgramARB) }, - { "glIsProgramNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glIsProgramNV) }, - { "glIsProgramPipeline", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glIsProgramPipeline) }, - { "glIsQuery", "GL_VERSION_1_5\0", offsetof(struct opengl_funcs, p_glIsQuery) }, - { "glIsQueryARB", "GL_ARB_occlusion_query\0", offsetof(struct opengl_funcs, p_glIsQueryARB) }, - { "glIsRenderbuffer", "GL_ARB_framebuffer_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glIsRenderbuffer) }, - { "glIsRenderbufferEXT", "GL_EXT_framebuffer_object\0", offsetof(struct opengl_funcs, p_glIsRenderbufferEXT) }, - { "glIsSampler", "GL_ARB_sampler_objects\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glIsSampler) }, - { "glIsSemaphoreEXT", "GL_EXT_semaphore\0", offsetof(struct opengl_funcs, p_glIsSemaphoreEXT) }, - { "glIsShader", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glIsShader) }, - { "glIsStateNV", "GL_NV_command_list\0", offsetof(struct opengl_funcs, p_glIsStateNV) }, - { "glIsSync", "GL_ARB_sync\0GL_VERSION_3_2\0", offsetof(struct opengl_funcs, p_glIsSync) }, - { "glIsTextureEXT", "GL_EXT_texture_object\0", offsetof(struct opengl_funcs, p_glIsTextureEXT) }, - { "glIsTextureHandleResidentARB", "GL_ARB_bindless_texture\0", offsetof(struct opengl_funcs, p_glIsTextureHandleResidentARB) }, - { "glIsTextureHandleResidentNV", "GL_NV_bindless_texture\0", offsetof(struct opengl_funcs, p_glIsTextureHandleResidentNV) }, - { "glIsTransformFeedback", "GL_ARB_transform_feedback2\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glIsTransformFeedback) }, - { "glIsTransformFeedbackNV", "GL_NV_transform_feedback2\0", offsetof(struct opengl_funcs, p_glIsTransformFeedbackNV) }, - { "glIsVariantEnabledEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glIsVariantEnabledEXT) }, - { "glIsVertexArray", "GL_ARB_vertex_array_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glIsVertexArray) }, - { "glIsVertexArrayAPPLE", "GL_APPLE_vertex_array_object\0", offsetof(struct opengl_funcs, p_glIsVertexArrayAPPLE) }, - { "glIsVertexAttribEnabledAPPLE", "GL_APPLE_vertex_program_evaluators\0", offsetof(struct opengl_funcs, p_glIsVertexAttribEnabledAPPLE) }, - { "glLGPUCopyImageSubDataNVX", "GL_NVX_linked_gpu_multicast\0", offsetof(struct opengl_funcs, p_glLGPUCopyImageSubDataNVX) }, - { "glLGPUInterlockNVX", "GL_NVX_linked_gpu_multicast\0", offsetof(struct opengl_funcs, p_glLGPUInterlockNVX) }, - { "glLGPUNamedBufferSubDataNVX", "GL_NVX_linked_gpu_multicast\0", offsetof(struct opengl_funcs, p_glLGPUNamedBufferSubDataNVX) }, - { "glLabelObjectEXT", "GL_EXT_debug_label\0", offsetof(struct opengl_funcs, p_glLabelObjectEXT) }, - { "glLightEnviSGIX", "GL_SGIX_fragment_lighting\0", offsetof(struct opengl_funcs, p_glLightEnviSGIX) }, - { "glLightModelx", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glLightModelx) }, - { "glLightModelxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glLightModelxOES) }, - { "glLightModelxv", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glLightModelxv) }, - { "glLightModelxvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glLightModelxvOES) }, - { "glLightx", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glLightx) }, - { "glLightxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glLightxOES) }, - { "glLightxv", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glLightxv) }, - { "glLightxvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glLightxvOES) }, - { "glLineWidthx", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glLineWidthx) }, - { "glLineWidthxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glLineWidthxOES) }, - { "glLinkProgram", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glLinkProgram) }, - { "glLinkProgramARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glLinkProgramARB) }, - { "glListDrawCommandsStatesClientNV", "GL_NV_command_list\0", offsetof(struct opengl_funcs, p_glListDrawCommandsStatesClientNV) }, - { "glListParameterfSGIX", "GL_SGIX_list_priority\0", offsetof(struct opengl_funcs, p_glListParameterfSGIX) }, - { "glListParameterfvSGIX", "GL_SGIX_list_priority\0", offsetof(struct opengl_funcs, p_glListParameterfvSGIX) }, - { "glListParameteriSGIX", "GL_SGIX_list_priority\0", offsetof(struct opengl_funcs, p_glListParameteriSGIX) }, - { "glListParameterivSGIX", "GL_SGIX_list_priority\0", offsetof(struct opengl_funcs, p_glListParameterivSGIX) }, - { "glLoadIdentityDeformationMapSGIX", "GL_SGIX_polynomial_ffd\0", offsetof(struct opengl_funcs, p_glLoadIdentityDeformationMapSGIX) }, - { "glLoadMatrixx", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glLoadMatrixx) }, - { "glLoadMatrixxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glLoadMatrixxOES) }, - { "glLoadProgramNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glLoadProgramNV) }, - { "glLoadTransposeMatrixd", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glLoadTransposeMatrixd) }, - { "glLoadTransposeMatrixdARB", "GL_ARB_transpose_matrix\0", offsetof(struct opengl_funcs, p_glLoadTransposeMatrixdARB) }, - { "glLoadTransposeMatrixf", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glLoadTransposeMatrixf) }, - { "glLoadTransposeMatrixfARB", "GL_ARB_transpose_matrix\0", offsetof(struct opengl_funcs, p_glLoadTransposeMatrixfARB) }, - { "glLoadTransposeMatrixxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glLoadTransposeMatrixxOES) }, - { "glLockArraysEXT", "GL_EXT_compiled_vertex_array\0", offsetof(struct opengl_funcs, p_glLockArraysEXT) }, - { "glMTexCoord2fSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMTexCoord2fSGIS) }, - { "glMTexCoord2fvSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMTexCoord2fvSGIS) }, - { "glMakeBufferNonResidentNV", "GL_NV_shader_buffer_load\0", offsetof(struct opengl_funcs, p_glMakeBufferNonResidentNV) }, - { "glMakeBufferResidentNV", "GL_NV_shader_buffer_load\0", offsetof(struct opengl_funcs, p_glMakeBufferResidentNV) }, - { "glMakeImageHandleNonResidentARB", "GL_ARB_bindless_texture\0", offsetof(struct opengl_funcs, p_glMakeImageHandleNonResidentARB) }, - { "glMakeImageHandleNonResidentNV", "GL_NV_bindless_texture\0", offsetof(struct opengl_funcs, p_glMakeImageHandleNonResidentNV) }, - { "glMakeImageHandleResidentARB", "GL_ARB_bindless_texture\0", offsetof(struct opengl_funcs, p_glMakeImageHandleResidentARB) }, - { "glMakeImageHandleResidentNV", "GL_NV_bindless_texture\0", offsetof(struct opengl_funcs, p_glMakeImageHandleResidentNV) }, - { "glMakeNamedBufferNonResidentNV", "GL_NV_shader_buffer_load\0", offsetof(struct opengl_funcs, p_glMakeNamedBufferNonResidentNV) }, - { "glMakeNamedBufferResidentNV", "GL_NV_shader_buffer_load\0", offsetof(struct opengl_funcs, p_glMakeNamedBufferResidentNV) }, - { "glMakeTextureHandleNonResidentARB", "GL_ARB_bindless_texture\0", offsetof(struct opengl_funcs, p_glMakeTextureHandleNonResidentARB) }, - { "glMakeTextureHandleNonResidentNV", "GL_NV_bindless_texture\0", offsetof(struct opengl_funcs, p_glMakeTextureHandleNonResidentNV) }, - { "glMakeTextureHandleResidentARB", "GL_ARB_bindless_texture\0", offsetof(struct opengl_funcs, p_glMakeTextureHandleResidentARB) }, - { "glMakeTextureHandleResidentNV", "GL_NV_bindless_texture\0", offsetof(struct opengl_funcs, p_glMakeTextureHandleResidentNV) }, - { "glMap1xOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glMap1xOES) }, - { "glMap2xOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glMap2xOES) }, - { "glMapBuffer", "GL_VERSION_1_5\0", offsetof(struct opengl_funcs, p_glMapBuffer) }, - { "glMapBufferARB", "GL_ARB_vertex_buffer_object\0", offsetof(struct opengl_funcs, p_glMapBufferARB) }, - { "glMapBufferRange", "GL_ARB_map_buffer_range\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glMapBufferRange) }, - { "glMapControlPointsNV", "GL_NV_evaluators\0", offsetof(struct opengl_funcs, p_glMapControlPointsNV) }, - { "glMapGrid1xOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glMapGrid1xOES) }, - { "glMapGrid2xOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glMapGrid2xOES) }, - { "glMapNamedBuffer", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glMapNamedBuffer) }, - { "glMapNamedBufferEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMapNamedBufferEXT) }, - { "glMapNamedBufferRange", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glMapNamedBufferRange) }, - { "glMapNamedBufferRangeEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMapNamedBufferRangeEXT) }, - { "glMapObjectBufferATI", "GL_ATI_map_object_buffer\0", offsetof(struct opengl_funcs, p_glMapObjectBufferATI) }, - { "glMapParameterfvNV", "GL_NV_evaluators\0", offsetof(struct opengl_funcs, p_glMapParameterfvNV) }, - { "glMapParameterivNV", "GL_NV_evaluators\0", offsetof(struct opengl_funcs, p_glMapParameterivNV) }, - { "glMapTexture2DINTEL", "GL_INTEL_map_texture\0", offsetof(struct opengl_funcs, p_glMapTexture2DINTEL) }, - { "glMapVertexAttrib1dAPPLE", "GL_APPLE_vertex_program_evaluators\0", offsetof(struct opengl_funcs, p_glMapVertexAttrib1dAPPLE) }, - { "glMapVertexAttrib1fAPPLE", "GL_APPLE_vertex_program_evaluators\0", offsetof(struct opengl_funcs, p_glMapVertexAttrib1fAPPLE) }, - { "glMapVertexAttrib2dAPPLE", "GL_APPLE_vertex_program_evaluators\0", offsetof(struct opengl_funcs, p_glMapVertexAttrib2dAPPLE) }, - { "glMapVertexAttrib2fAPPLE", "GL_APPLE_vertex_program_evaluators\0", offsetof(struct opengl_funcs, p_glMapVertexAttrib2fAPPLE) }, - { "glMaterialx", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glMaterialx) }, - { "glMaterialxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glMaterialxOES) }, - { "glMaterialxv", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glMaterialxv) }, - { "glMaterialxvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glMaterialxvOES) }, - { "glMatrixFrustumEXT", "GL_EXT_direct_state_access\0GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glMatrixFrustumEXT) }, - { "glMatrixIndexPointerARB", "GL_ARB_matrix_palette\0", offsetof(struct opengl_funcs, p_glMatrixIndexPointerARB) }, - { "glMatrixIndexubvARB", "GL_ARB_matrix_palette\0", offsetof(struct opengl_funcs, p_glMatrixIndexubvARB) }, - { "glMatrixIndexuivARB", "GL_ARB_matrix_palette\0", offsetof(struct opengl_funcs, p_glMatrixIndexuivARB) }, - { "glMatrixIndexusvARB", "GL_ARB_matrix_palette\0", offsetof(struct opengl_funcs, p_glMatrixIndexusvARB) }, - { "glMatrixLoad3x2fNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glMatrixLoad3x2fNV) }, - { "glMatrixLoad3x3fNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glMatrixLoad3x3fNV) }, - { "glMatrixLoadIdentityEXT", "GL_EXT_direct_state_access\0GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glMatrixLoadIdentityEXT) }, - { "glMatrixLoadTranspose3x3fNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glMatrixLoadTranspose3x3fNV) }, - { "glMatrixLoadTransposedEXT", "GL_EXT_direct_state_access\0GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glMatrixLoadTransposedEXT) }, - { "glMatrixLoadTransposefEXT", "GL_EXT_direct_state_access\0GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glMatrixLoadTransposefEXT) }, - { "glMatrixLoaddEXT", "GL_EXT_direct_state_access\0GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glMatrixLoaddEXT) }, - { "glMatrixLoadfEXT", "GL_EXT_direct_state_access\0GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glMatrixLoadfEXT) }, - { "glMatrixMult3x2fNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glMatrixMult3x2fNV) }, - { "glMatrixMult3x3fNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glMatrixMult3x3fNV) }, - { "glMatrixMultTranspose3x3fNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glMatrixMultTranspose3x3fNV) }, - { "glMatrixMultTransposedEXT", "GL_EXT_direct_state_access\0GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glMatrixMultTransposedEXT) }, - { "glMatrixMultTransposefEXT", "GL_EXT_direct_state_access\0GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glMatrixMultTransposefEXT) }, - { "glMatrixMultdEXT", "GL_EXT_direct_state_access\0GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glMatrixMultdEXT) }, - { "glMatrixMultfEXT", "GL_EXT_direct_state_access\0GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glMatrixMultfEXT) }, - { "glMatrixOrthoEXT", "GL_EXT_direct_state_access\0GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glMatrixOrthoEXT) }, - { "glMatrixPopEXT", "GL_EXT_direct_state_access\0GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glMatrixPopEXT) }, - { "glMatrixPushEXT", "GL_EXT_direct_state_access\0GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glMatrixPushEXT) }, - { "glMatrixRotatedEXT", "GL_EXT_direct_state_access\0GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glMatrixRotatedEXT) }, - { "glMatrixRotatefEXT", "GL_EXT_direct_state_access\0GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glMatrixRotatefEXT) }, - { "glMatrixScaledEXT", "GL_EXT_direct_state_access\0GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glMatrixScaledEXT) }, - { "glMatrixScalefEXT", "GL_EXT_direct_state_access\0GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glMatrixScalefEXT) }, - { "glMatrixTranslatedEXT", "GL_EXT_direct_state_access\0GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glMatrixTranslatedEXT) }, - { "glMatrixTranslatefEXT", "GL_EXT_direct_state_access\0GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glMatrixTranslatefEXT) }, - { "glMaxShaderCompilerThreadsARB", "GL_ARB_parallel_shader_compile\0", offsetof(struct opengl_funcs, p_glMaxShaderCompilerThreadsARB) }, - { "glMaxShaderCompilerThreadsKHR", "GL_KHR_parallel_shader_compile\0", offsetof(struct opengl_funcs, p_glMaxShaderCompilerThreadsKHR) }, - { "glMemoryBarrier", "GL_ARB_shader_image_load_store\0GL_VERSION_4_2\0", offsetof(struct opengl_funcs, p_glMemoryBarrier) }, - { "glMemoryBarrierByRegion", "GL_ARB_ES3_1_compatibility\0GL_NV_ES3_1_compatibility\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glMemoryBarrierByRegion) }, - { "glMemoryBarrierEXT", "GL_EXT_shader_image_load_store\0", offsetof(struct opengl_funcs, p_glMemoryBarrierEXT) }, - { "glMemoryObjectParameterivEXT", "GL_EXT_memory_object\0", offsetof(struct opengl_funcs, p_glMemoryObjectParameterivEXT) }, - { "glMinSampleShading", "GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glMinSampleShading) }, - { "glMinSampleShadingARB", "GL_ARB_sample_shading\0", offsetof(struct opengl_funcs, p_glMinSampleShadingARB) }, - { "glMinmax", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glMinmax) }, - { "glMinmaxEXT", "GL_EXT_histogram\0", offsetof(struct opengl_funcs, p_glMinmaxEXT) }, - { "glMultMatrixx", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glMultMatrixx) }, - { "glMultMatrixxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glMultMatrixxOES) }, - { "glMultTransposeMatrixd", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultTransposeMatrixd) }, - { "glMultTransposeMatrixdARB", "GL_ARB_transpose_matrix\0", offsetof(struct opengl_funcs, p_glMultTransposeMatrixdARB) }, - { "glMultTransposeMatrixf", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultTransposeMatrixf) }, - { "glMultTransposeMatrixfARB", "GL_ARB_transpose_matrix\0", offsetof(struct opengl_funcs, p_glMultTransposeMatrixfARB) }, - { "glMultTransposeMatrixxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glMultTransposeMatrixxOES) }, - { "glMultiDrawArrays", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glMultiDrawArrays) }, - { "glMultiDrawArraysEXT", "GL_EXT_multi_draw_arrays\0GL_SUN_multi_draw_arrays\0", offsetof(struct opengl_funcs, p_glMultiDrawArraysEXT) }, - { "glMultiDrawArraysIndirect", "GL_ARB_multi_draw_indirect\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glMultiDrawArraysIndirect) }, - { "glMultiDrawArraysIndirectAMD", "GL_AMD_multi_draw_indirect\0", offsetof(struct opengl_funcs, p_glMultiDrawArraysIndirectAMD) }, - { "glMultiDrawArraysIndirectBindlessCountNV", "GL_NV_bindless_multi_draw_indirect_count\0", offsetof(struct opengl_funcs, p_glMultiDrawArraysIndirectBindlessCountNV) }, - { "glMultiDrawArraysIndirectBindlessNV", "GL_NV_bindless_multi_draw_indirect\0", offsetof(struct opengl_funcs, p_glMultiDrawArraysIndirectBindlessNV) }, - { "glMultiDrawArraysIndirectCount", "GL_VERSION_4_6\0", offsetof(struct opengl_funcs, p_glMultiDrawArraysIndirectCount) }, - { "glMultiDrawArraysIndirectCountARB", "GL_ARB_indirect_parameters\0", offsetof(struct opengl_funcs, p_glMultiDrawArraysIndirectCountARB) }, - { "glMultiDrawElementArrayAPPLE", "GL_APPLE_element_array\0", offsetof(struct opengl_funcs, p_glMultiDrawElementArrayAPPLE) }, - { "glMultiDrawElements", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glMultiDrawElements) }, - { "glMultiDrawElementsBaseVertex", "GL_ARB_draw_elements_base_vertex\0GL_VERSION_3_2\0", offsetof(struct opengl_funcs, p_glMultiDrawElementsBaseVertex) }, - { "glMultiDrawElementsEXT", "GL_EXT_multi_draw_arrays\0GL_SUN_multi_draw_arrays\0", offsetof(struct opengl_funcs, p_glMultiDrawElementsEXT) }, - { "glMultiDrawElementsIndirect", "GL_ARB_multi_draw_indirect\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glMultiDrawElementsIndirect) }, - { "glMultiDrawElementsIndirectAMD", "GL_AMD_multi_draw_indirect\0", offsetof(struct opengl_funcs, p_glMultiDrawElementsIndirectAMD) }, - { "glMultiDrawElementsIndirectBindlessCountNV", "GL_NV_bindless_multi_draw_indirect_count\0", offsetof(struct opengl_funcs, p_glMultiDrawElementsIndirectBindlessCountNV) }, - { "glMultiDrawElementsIndirectBindlessNV", "GL_NV_bindless_multi_draw_indirect\0", offsetof(struct opengl_funcs, p_glMultiDrawElementsIndirectBindlessNV) }, - { "glMultiDrawElementsIndirectCount", "GL_VERSION_4_6\0", offsetof(struct opengl_funcs, p_glMultiDrawElementsIndirectCount) }, - { "glMultiDrawElementsIndirectCountARB", "GL_ARB_indirect_parameters\0", offsetof(struct opengl_funcs, p_glMultiDrawElementsIndirectCountARB) }, - { "glMultiDrawMeshTasksIndirectCountEXT", "GL_EXT_mesh_shader\0", offsetof(struct opengl_funcs, p_glMultiDrawMeshTasksIndirectCountEXT) }, - { "glMultiDrawMeshTasksIndirectCountNV", "GL_NV_mesh_shader\0", offsetof(struct opengl_funcs, p_glMultiDrawMeshTasksIndirectCountNV) }, - { "glMultiDrawMeshTasksIndirectEXT", "GL_EXT_mesh_shader\0", offsetof(struct opengl_funcs, p_glMultiDrawMeshTasksIndirectEXT) }, - { "glMultiDrawMeshTasksIndirectNV", "GL_NV_mesh_shader\0", offsetof(struct opengl_funcs, p_glMultiDrawMeshTasksIndirectNV) }, - { "glMultiDrawRangeElementArrayAPPLE", "GL_APPLE_element_array\0", offsetof(struct opengl_funcs, p_glMultiDrawRangeElementArrayAPPLE) }, - { "glMultiModeDrawArraysIBM", "GL_IBM_multimode_draw_arrays\0", offsetof(struct opengl_funcs, p_glMultiModeDrawArraysIBM) }, - { "glMultiModeDrawElementsIBM", "GL_IBM_multimode_draw_arrays\0", offsetof(struct opengl_funcs, p_glMultiModeDrawElementsIBM) }, - { "glMultiTexBufferEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMultiTexBufferEXT) }, - { "glMultiTexCoord1bOES", "GL_OES_byte_coordinates\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1bOES) }, - { "glMultiTexCoord1bvOES", "GL_OES_byte_coordinates\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1bvOES) }, - { "glMultiTexCoord1d", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1d) }, - { "glMultiTexCoord1dARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1dARB) }, - { "glMultiTexCoord1dSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1dSGIS) }, - { "glMultiTexCoord1dv", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1dv) }, - { "glMultiTexCoord1dvARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1dvARB) }, - { "glMultiTexCoord1dvSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1dvSGIS) }, - { "glMultiTexCoord1f", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1f) }, - { "glMultiTexCoord1fARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1fARB) }, - { "glMultiTexCoord1fSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1fSGIS) }, - { "glMultiTexCoord1fv", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1fv) }, - { "glMultiTexCoord1fvARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1fvARB) }, - { "glMultiTexCoord1fvSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1fvSGIS) }, - { "glMultiTexCoord1hNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1hNV) }, - { "glMultiTexCoord1hvNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1hvNV) }, - { "glMultiTexCoord1i", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1i) }, - { "glMultiTexCoord1iARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1iARB) }, - { "glMultiTexCoord1iSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1iSGIS) }, - { "glMultiTexCoord1iv", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1iv) }, - { "glMultiTexCoord1ivARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1ivARB) }, - { "glMultiTexCoord1ivSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1ivSGIS) }, - { "glMultiTexCoord1s", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1s) }, - { "glMultiTexCoord1sARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1sARB) }, - { "glMultiTexCoord1sSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1sSGIS) }, - { "glMultiTexCoord1sv", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1sv) }, - { "glMultiTexCoord1svARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1svARB) }, - { "glMultiTexCoord1svSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1svSGIS) }, - { "glMultiTexCoord1xOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1xOES) }, - { "glMultiTexCoord1xvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glMultiTexCoord1xvOES) }, - { "glMultiTexCoord2bOES", "GL_OES_byte_coordinates\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2bOES) }, - { "glMultiTexCoord2bvOES", "GL_OES_byte_coordinates\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2bvOES) }, - { "glMultiTexCoord2d", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2d) }, - { "glMultiTexCoord2dARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2dARB) }, - { "glMultiTexCoord2dSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2dSGIS) }, - { "glMultiTexCoord2dv", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2dv) }, - { "glMultiTexCoord2dvARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2dvARB) }, - { "glMultiTexCoord2dvSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2dvSGIS) }, - { "glMultiTexCoord2f", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2f) }, - { "glMultiTexCoord2fARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2fARB) }, - { "glMultiTexCoord2fSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2fSGIS) }, - { "glMultiTexCoord2fv", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2fv) }, - { "glMultiTexCoord2fvARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2fvARB) }, - { "glMultiTexCoord2fvSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2fvSGIS) }, - { "glMultiTexCoord2hNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2hNV) }, - { "glMultiTexCoord2hvNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2hvNV) }, - { "glMultiTexCoord2i", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2i) }, - { "glMultiTexCoord2iARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2iARB) }, - { "glMultiTexCoord2iSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2iSGIS) }, - { "glMultiTexCoord2iv", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2iv) }, - { "glMultiTexCoord2ivARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2ivARB) }, - { "glMultiTexCoord2ivSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2ivSGIS) }, - { "glMultiTexCoord2s", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2s) }, - { "glMultiTexCoord2sARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2sARB) }, - { "glMultiTexCoord2sSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2sSGIS) }, - { "glMultiTexCoord2sv", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2sv) }, - { "glMultiTexCoord2svARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2svARB) }, - { "glMultiTexCoord2svSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2svSGIS) }, - { "glMultiTexCoord2xOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2xOES) }, - { "glMultiTexCoord2xvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glMultiTexCoord2xvOES) }, - { "glMultiTexCoord3bOES", "GL_OES_byte_coordinates\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3bOES) }, - { "glMultiTexCoord3bvOES", "GL_OES_byte_coordinates\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3bvOES) }, - { "glMultiTexCoord3d", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3d) }, - { "glMultiTexCoord3dARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3dARB) }, - { "glMultiTexCoord3dSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3dSGIS) }, - { "glMultiTexCoord3dv", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3dv) }, - { "glMultiTexCoord3dvARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3dvARB) }, - { "glMultiTexCoord3dvSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3dvSGIS) }, - { "glMultiTexCoord3f", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3f) }, - { "glMultiTexCoord3fARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3fARB) }, - { "glMultiTexCoord3fSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3fSGIS) }, - { "glMultiTexCoord3fv", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3fv) }, - { "glMultiTexCoord3fvARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3fvARB) }, - { "glMultiTexCoord3fvSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3fvSGIS) }, - { "glMultiTexCoord3hNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3hNV) }, - { "glMultiTexCoord3hvNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3hvNV) }, - { "glMultiTexCoord3i", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3i) }, - { "glMultiTexCoord3iARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3iARB) }, - { "glMultiTexCoord3iSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3iSGIS) }, - { "glMultiTexCoord3iv", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3iv) }, - { "glMultiTexCoord3ivARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3ivARB) }, - { "glMultiTexCoord3ivSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3ivSGIS) }, - { "glMultiTexCoord3s", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3s) }, - { "glMultiTexCoord3sARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3sARB) }, - { "glMultiTexCoord3sSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3sSGIS) }, - { "glMultiTexCoord3sv", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3sv) }, - { "glMultiTexCoord3svARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3svARB) }, - { "glMultiTexCoord3svSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3svSGIS) }, - { "glMultiTexCoord3xOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3xOES) }, - { "glMultiTexCoord3xvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glMultiTexCoord3xvOES) }, - { "glMultiTexCoord4bOES", "GL_OES_byte_coordinates\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4bOES) }, - { "glMultiTexCoord4bvOES", "GL_OES_byte_coordinates\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4bvOES) }, - { "glMultiTexCoord4d", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4d) }, - { "glMultiTexCoord4dARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4dARB) }, - { "glMultiTexCoord4dSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4dSGIS) }, - { "glMultiTexCoord4dv", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4dv) }, - { "glMultiTexCoord4dvARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4dvARB) }, - { "glMultiTexCoord4dvSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4dvSGIS) }, - { "glMultiTexCoord4f", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4f) }, - { "glMultiTexCoord4fARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4fARB) }, - { "glMultiTexCoord4fSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4fSGIS) }, - { "glMultiTexCoord4fv", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4fv) }, - { "glMultiTexCoord4fvARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4fvARB) }, - { "glMultiTexCoord4fvSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4fvSGIS) }, - { "glMultiTexCoord4hNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4hNV) }, - { "glMultiTexCoord4hvNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4hvNV) }, - { "glMultiTexCoord4i", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4i) }, - { "glMultiTexCoord4iARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4iARB) }, - { "glMultiTexCoord4iSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4iSGIS) }, - { "glMultiTexCoord4iv", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4iv) }, - { "glMultiTexCoord4ivARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4ivARB) }, - { "glMultiTexCoord4ivSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4ivSGIS) }, - { "glMultiTexCoord4s", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4s) }, - { "glMultiTexCoord4sARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4sARB) }, - { "glMultiTexCoord4sSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4sSGIS) }, - { "glMultiTexCoord4sv", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4sv) }, - { "glMultiTexCoord4svARB", "GL_ARB_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4svARB) }, - { "glMultiTexCoord4svSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4svSGIS) }, - { "glMultiTexCoord4x", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4x) }, - { "glMultiTexCoord4xOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4xOES) }, - { "glMultiTexCoord4xvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glMultiTexCoord4xvOES) }, - { "glMultiTexCoordP1ui", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoordP1ui) }, - { "glMultiTexCoordP1uiv", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoordP1uiv) }, - { "glMultiTexCoordP2ui", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoordP2ui) }, - { "glMultiTexCoordP2uiv", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoordP2uiv) }, - { "glMultiTexCoordP3ui", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoordP3ui) }, - { "glMultiTexCoordP3uiv", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoordP3uiv) }, - { "glMultiTexCoordP4ui", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoordP4ui) }, - { "glMultiTexCoordP4uiv", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glMultiTexCoordP4uiv) }, - { "glMultiTexCoordPointerEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMultiTexCoordPointerEXT) }, - { "glMultiTexCoordPointerSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glMultiTexCoordPointerSGIS) }, - { "glMultiTexEnvfEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMultiTexEnvfEXT) }, - { "glMultiTexEnvfvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMultiTexEnvfvEXT) }, - { "glMultiTexEnviEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMultiTexEnviEXT) }, - { "glMultiTexEnvivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMultiTexEnvivEXT) }, - { "glMultiTexGendEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMultiTexGendEXT) }, - { "glMultiTexGendvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMultiTexGendvEXT) }, - { "glMultiTexGenfEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMultiTexGenfEXT) }, - { "glMultiTexGenfvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMultiTexGenfvEXT) }, - { "glMultiTexGeniEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMultiTexGeniEXT) }, - { "glMultiTexGenivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMultiTexGenivEXT) }, - { "glMultiTexImage1DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMultiTexImage1DEXT) }, - { "glMultiTexImage2DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMultiTexImage2DEXT) }, - { "glMultiTexImage3DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMultiTexImage3DEXT) }, - { "glMultiTexParameterIivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMultiTexParameterIivEXT) }, - { "glMultiTexParameterIuivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMultiTexParameterIuivEXT) }, - { "glMultiTexParameterfEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMultiTexParameterfEXT) }, - { "glMultiTexParameterfvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMultiTexParameterfvEXT) }, - { "glMultiTexParameteriEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMultiTexParameteriEXT) }, - { "glMultiTexParameterivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMultiTexParameterivEXT) }, - { "glMultiTexRenderbufferEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMultiTexRenderbufferEXT) }, - { "glMultiTexSubImage1DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMultiTexSubImage1DEXT) }, - { "glMultiTexSubImage2DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMultiTexSubImage2DEXT) }, - { "glMultiTexSubImage3DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glMultiTexSubImage3DEXT) }, - { "glMulticastBarrierNV", "GL_NV_gpu_multicast\0", offsetof(struct opengl_funcs, p_glMulticastBarrierNV) }, - { "glMulticastBlitFramebufferNV", "GL_NV_gpu_multicast\0", offsetof(struct opengl_funcs, p_glMulticastBlitFramebufferNV) }, - { "glMulticastBufferSubDataNV", "GL_NV_gpu_multicast\0", offsetof(struct opengl_funcs, p_glMulticastBufferSubDataNV) }, - { "glMulticastCopyBufferSubDataNV", "GL_NV_gpu_multicast\0", offsetof(struct opengl_funcs, p_glMulticastCopyBufferSubDataNV) }, - { "glMulticastCopyImageSubDataNV", "GL_NV_gpu_multicast\0", offsetof(struct opengl_funcs, p_glMulticastCopyImageSubDataNV) }, - { "glMulticastFramebufferSampleLocationsfvNV", "GL_NV_gpu_multicast\0", offsetof(struct opengl_funcs, p_glMulticastFramebufferSampleLocationsfvNV) }, - { "glMulticastGetQueryObjecti64vNV", "GL_NV_gpu_multicast\0", offsetof(struct opengl_funcs, p_glMulticastGetQueryObjecti64vNV) }, - { "glMulticastGetQueryObjectivNV", "GL_NV_gpu_multicast\0", offsetof(struct opengl_funcs, p_glMulticastGetQueryObjectivNV) }, - { "glMulticastGetQueryObjectui64vNV", "GL_NV_gpu_multicast\0", offsetof(struct opengl_funcs, p_glMulticastGetQueryObjectui64vNV) }, - { "glMulticastGetQueryObjectuivNV", "GL_NV_gpu_multicast\0", offsetof(struct opengl_funcs, p_glMulticastGetQueryObjectuivNV) }, - { "glMulticastScissorArrayvNVX", "GL_NVX_gpu_multicast2\0", offsetof(struct opengl_funcs, p_glMulticastScissorArrayvNVX) }, - { "glMulticastViewportArrayvNVX", "GL_NVX_gpu_multicast2\0", offsetof(struct opengl_funcs, p_glMulticastViewportArrayvNVX) }, - { "glMulticastViewportPositionWScaleNVX", "GL_NVX_gpu_multicast2\0", offsetof(struct opengl_funcs, p_glMulticastViewportPositionWScaleNVX) }, - { "glMulticastWaitSyncNV", "GL_NV_gpu_multicast\0", offsetof(struct opengl_funcs, p_glMulticastWaitSyncNV) }, - { "glNamedBufferAttachMemoryNV", "GL_NV_memory_attachment\0", offsetof(struct opengl_funcs, p_glNamedBufferAttachMemoryNV) }, - { "glNamedBufferData", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glNamedBufferData) }, - { "glNamedBufferDataEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedBufferDataEXT) }, - { "glNamedBufferPageCommitmentARB", "GL_ARB_sparse_buffer\0", offsetof(struct opengl_funcs, p_glNamedBufferPageCommitmentARB) }, - { "glNamedBufferPageCommitmentEXT", "GL_ARB_sparse_buffer\0", offsetof(struct opengl_funcs, p_glNamedBufferPageCommitmentEXT) }, - { "glNamedBufferPageCommitmentMemNV", "GL_NV_memory_object_sparse\0", offsetof(struct opengl_funcs, p_glNamedBufferPageCommitmentMemNV) }, - { "glNamedBufferStorage", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glNamedBufferStorage) }, - { "glNamedBufferStorageEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedBufferStorageEXT) }, - { "glNamedBufferStorageExternalEXT", "GL_EXT_external_buffer\0", offsetof(struct opengl_funcs, p_glNamedBufferStorageExternalEXT) }, - { "glNamedBufferStorageMemEXT", "GL_EXT_memory_object\0", offsetof(struct opengl_funcs, p_glNamedBufferStorageMemEXT) }, - { "glNamedBufferSubData", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glNamedBufferSubData) }, - { "glNamedBufferSubDataEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedBufferSubDataEXT) }, - { "glNamedCopyBufferSubDataEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedCopyBufferSubDataEXT) }, - { "glNamedFramebufferDrawBuffer", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glNamedFramebufferDrawBuffer) }, - { "glNamedFramebufferDrawBuffers", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glNamedFramebufferDrawBuffers) }, - { "glNamedFramebufferParameteri", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glNamedFramebufferParameteri) }, - { "glNamedFramebufferParameteriEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedFramebufferParameteriEXT) }, - { "glNamedFramebufferReadBuffer", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glNamedFramebufferReadBuffer) }, - { "glNamedFramebufferRenderbuffer", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glNamedFramebufferRenderbuffer) }, - { "glNamedFramebufferRenderbufferEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedFramebufferRenderbufferEXT) }, - { "glNamedFramebufferSampleLocationsfvARB", "GL_ARB_sample_locations\0", offsetof(struct opengl_funcs, p_glNamedFramebufferSampleLocationsfvARB) }, - { "glNamedFramebufferSampleLocationsfvNV", "GL_NV_sample_locations\0", offsetof(struct opengl_funcs, p_glNamedFramebufferSampleLocationsfvNV) }, - { "glNamedFramebufferSamplePositionsfvAMD", "GL_AMD_framebuffer_sample_positions\0", offsetof(struct opengl_funcs, p_glNamedFramebufferSamplePositionsfvAMD) }, - { "glNamedFramebufferTexture", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glNamedFramebufferTexture) }, - { "glNamedFramebufferTexture1DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedFramebufferTexture1DEXT) }, - { "glNamedFramebufferTexture2DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedFramebufferTexture2DEXT) }, - { "glNamedFramebufferTexture3DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedFramebufferTexture3DEXT) }, - { "glNamedFramebufferTextureEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedFramebufferTextureEXT) }, - { "glNamedFramebufferTextureFaceEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedFramebufferTextureFaceEXT) }, - { "glNamedFramebufferTextureLayer", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glNamedFramebufferTextureLayer) }, - { "glNamedFramebufferTextureLayerEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedFramebufferTextureLayerEXT) }, - { "glNamedFramebufferTextureMultiviewOVR", "GL_OVR_multiview\0", offsetof(struct opengl_funcs, p_glNamedFramebufferTextureMultiviewOVR) }, - { "glNamedProgramLocalParameter4dEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedProgramLocalParameter4dEXT) }, - { "glNamedProgramLocalParameter4dvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedProgramLocalParameter4dvEXT) }, - { "glNamedProgramLocalParameter4fEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedProgramLocalParameter4fEXT) }, - { "glNamedProgramLocalParameter4fvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedProgramLocalParameter4fvEXT) }, - { "glNamedProgramLocalParameterI4iEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedProgramLocalParameterI4iEXT) }, - { "glNamedProgramLocalParameterI4ivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedProgramLocalParameterI4ivEXT) }, - { "glNamedProgramLocalParameterI4uiEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedProgramLocalParameterI4uiEXT) }, - { "glNamedProgramLocalParameterI4uivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedProgramLocalParameterI4uivEXT) }, - { "glNamedProgramLocalParameters4fvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedProgramLocalParameters4fvEXT) }, - { "glNamedProgramLocalParametersI4ivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedProgramLocalParametersI4ivEXT) }, - { "glNamedProgramLocalParametersI4uivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedProgramLocalParametersI4uivEXT) }, - { "glNamedProgramStringEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedProgramStringEXT) }, - { "glNamedRenderbufferStorage", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glNamedRenderbufferStorage) }, - { "glNamedRenderbufferStorageEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedRenderbufferStorageEXT) }, - { "glNamedRenderbufferStorageMultisample", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glNamedRenderbufferStorageMultisample) }, - { "glNamedRenderbufferStorageMultisampleAdvancedAMD", "GL_AMD_framebuffer_multisample_advanced\0", offsetof(struct opengl_funcs, p_glNamedRenderbufferStorageMultisampleAdvancedAMD) }, - { "glNamedRenderbufferStorageMultisampleCoverageEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedRenderbufferStorageMultisampleCoverageEXT) }, - { "glNamedRenderbufferStorageMultisampleEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glNamedRenderbufferStorageMultisampleEXT) }, - { "glNamedStringARB", "GL_ARB_shading_language_include\0", offsetof(struct opengl_funcs, p_glNamedStringARB) }, - { "glNewBufferRegion", "GL_KTX_buffer_region\0", offsetof(struct opengl_funcs, p_glNewBufferRegion) }, - { "glNewObjectBufferATI", "GL_ATI_vertex_array_object\0", offsetof(struct opengl_funcs, p_glNewObjectBufferATI) }, - { "glNormal3fVertex3fSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glNormal3fVertex3fSUN) }, - { "glNormal3fVertex3fvSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glNormal3fVertex3fvSUN) }, - { "glNormal3hNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glNormal3hNV) }, - { "glNormal3hvNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glNormal3hvNV) }, - { "glNormal3x", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glNormal3x) }, - { "glNormal3xOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glNormal3xOES) }, - { "glNormal3xvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glNormal3xvOES) }, - { "glNormalFormatNV", "GL_NV_vertex_buffer_unified_memory\0", offsetof(struct opengl_funcs, p_glNormalFormatNV) }, - { "glNormalP3ui", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glNormalP3ui) }, - { "glNormalP3uiv", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glNormalP3uiv) }, - { "glNormalPointerEXT", "GL_EXT_vertex_array\0", offsetof(struct opengl_funcs, p_glNormalPointerEXT) }, - { "glNormalPointerListIBM", "GL_IBM_vertex_array_lists\0", offsetof(struct opengl_funcs, p_glNormalPointerListIBM) }, - { "glNormalPointervINTEL", "GL_INTEL_parallel_arrays\0", offsetof(struct opengl_funcs, p_glNormalPointervINTEL) }, - { "glNormalStream3bATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glNormalStream3bATI) }, - { "glNormalStream3bvATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glNormalStream3bvATI) }, - { "glNormalStream3dATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glNormalStream3dATI) }, - { "glNormalStream3dvATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glNormalStream3dvATI) }, - { "glNormalStream3fATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glNormalStream3fATI) }, - { "glNormalStream3fvATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glNormalStream3fvATI) }, - { "glNormalStream3iATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glNormalStream3iATI) }, - { "glNormalStream3ivATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glNormalStream3ivATI) }, - { "glNormalStream3sATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glNormalStream3sATI) }, - { "glNormalStream3svATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glNormalStream3svATI) }, - { "glObjectLabel", "GL_KHR_debug\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glObjectLabel) }, - { "glObjectPtrLabel", "GL_KHR_debug\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glObjectPtrLabel) }, - { "glObjectPurgeableAPPLE", "GL_APPLE_object_purgeable\0", offsetof(struct opengl_funcs, p_glObjectPurgeableAPPLE) }, - { "glObjectUnpurgeableAPPLE", "GL_APPLE_object_purgeable\0", offsetof(struct opengl_funcs, p_glObjectUnpurgeableAPPLE) }, - { "glOrthof", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glOrthof) }, - { "glOrthofOES", "GL_OES_single_precision\0", offsetof(struct opengl_funcs, p_glOrthofOES) }, - { "glOrthox", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glOrthox) }, - { "glOrthoxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glOrthoxOES) }, - { "glPNTrianglesfATI", "GL_ATI_pn_triangles\0", offsetof(struct opengl_funcs, p_glPNTrianglesfATI) }, - { "glPNTrianglesiATI", "GL_ATI_pn_triangles\0", offsetof(struct opengl_funcs, p_glPNTrianglesiATI) }, - { "glPassTexCoordATI", "GL_ATI_fragment_shader\0", offsetof(struct opengl_funcs, p_glPassTexCoordATI) }, - { "glPassThroughxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glPassThroughxOES) }, - { "glPatchParameterfv", "GL_ARB_tessellation_shader\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glPatchParameterfv) }, - { "glPatchParameteri", "GL_ARB_tessellation_shader\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glPatchParameteri) }, - { "glPathColorGenNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glPathColorGenNV) }, - { "glPathCommandsNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glPathCommandsNV) }, - { "glPathCoordsNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glPathCoordsNV) }, - { "glPathCoverDepthFuncNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glPathCoverDepthFuncNV) }, - { "glPathDashArrayNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glPathDashArrayNV) }, - { "glPathFogGenNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glPathFogGenNV) }, - { "glPathGlyphIndexArrayNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glPathGlyphIndexArrayNV) }, - { "glPathGlyphIndexRangeNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glPathGlyphIndexRangeNV) }, - { "glPathGlyphRangeNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glPathGlyphRangeNV) }, - { "glPathGlyphsNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glPathGlyphsNV) }, - { "glPathMemoryGlyphIndexArrayNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glPathMemoryGlyphIndexArrayNV) }, - { "glPathParameterfNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glPathParameterfNV) }, - { "glPathParameterfvNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glPathParameterfvNV) }, - { "glPathParameteriNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glPathParameteriNV) }, - { "glPathParameterivNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glPathParameterivNV) }, - { "glPathStencilDepthOffsetNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glPathStencilDepthOffsetNV) }, - { "glPathStencilFuncNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glPathStencilFuncNV) }, - { "glPathStringNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glPathStringNV) }, - { "glPathSubCommandsNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glPathSubCommandsNV) }, - { "glPathSubCoordsNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glPathSubCoordsNV) }, - { "glPathTexGenNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glPathTexGenNV) }, - { "glPauseTransformFeedback", "GL_ARB_transform_feedback2\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glPauseTransformFeedback) }, - { "glPauseTransformFeedbackNV", "GL_NV_transform_feedback2\0", offsetof(struct opengl_funcs, p_glPauseTransformFeedbackNV) }, - { "glPixelDataRangeNV", "GL_NV_pixel_data_range\0", offsetof(struct opengl_funcs, p_glPixelDataRangeNV) }, - { "glPixelMapx", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glPixelMapx) }, - { "glPixelStorex", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glPixelStorex) }, - { "glPixelTexGenParameterfSGIS", "GL_SGIS_pixel_texture\0", offsetof(struct opengl_funcs, p_glPixelTexGenParameterfSGIS) }, - { "glPixelTexGenParameterfvSGIS", "GL_SGIS_pixel_texture\0", offsetof(struct opengl_funcs, p_glPixelTexGenParameterfvSGIS) }, - { "glPixelTexGenParameteriSGIS", "GL_SGIS_pixel_texture\0", offsetof(struct opengl_funcs, p_glPixelTexGenParameteriSGIS) }, - { "glPixelTexGenParameterivSGIS", "GL_SGIS_pixel_texture\0", offsetof(struct opengl_funcs, p_glPixelTexGenParameterivSGIS) }, - { "glPixelTexGenSGIX", "GL_SGIX_pixel_texture\0", offsetof(struct opengl_funcs, p_glPixelTexGenSGIX) }, - { "glPixelTransferxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glPixelTransferxOES) }, - { "glPixelTransformParameterfEXT", "GL_EXT_pixel_transform\0", offsetof(struct opengl_funcs, p_glPixelTransformParameterfEXT) }, - { "glPixelTransformParameterfvEXT", "GL_EXT_pixel_transform\0", offsetof(struct opengl_funcs, p_glPixelTransformParameterfvEXT) }, - { "glPixelTransformParameteriEXT", "GL_EXT_pixel_transform\0", offsetof(struct opengl_funcs, p_glPixelTransformParameteriEXT) }, - { "glPixelTransformParameterivEXT", "GL_EXT_pixel_transform\0", offsetof(struct opengl_funcs, p_glPixelTransformParameterivEXT) }, - { "glPixelZoomxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glPixelZoomxOES) }, - { "glPointAlongPathNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glPointAlongPathNV) }, - { "glPointParameterf", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glPointParameterf) }, - { "glPointParameterfARB", "GL_ARB_point_parameters\0", offsetof(struct opengl_funcs, p_glPointParameterfARB) }, - { "glPointParameterfEXT", "GL_EXT_point_parameters\0", offsetof(struct opengl_funcs, p_glPointParameterfEXT) }, - { "glPointParameterfSGIS", "GL_SGIS_point_parameters\0", offsetof(struct opengl_funcs, p_glPointParameterfSGIS) }, - { "glPointParameterfv", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glPointParameterfv) }, - { "glPointParameterfvARB", "GL_ARB_point_parameters\0", offsetof(struct opengl_funcs, p_glPointParameterfvARB) }, - { "glPointParameterfvEXT", "GL_EXT_point_parameters\0", offsetof(struct opengl_funcs, p_glPointParameterfvEXT) }, - { "glPointParameterfvSGIS", "GL_SGIS_point_parameters\0", offsetof(struct opengl_funcs, p_glPointParameterfvSGIS) }, - { "glPointParameteri", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glPointParameteri) }, - { "glPointParameteriNV", "GL_NV_point_sprite\0", offsetof(struct opengl_funcs, p_glPointParameteriNV) }, - { "glPointParameteriv", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glPointParameteriv) }, - { "glPointParameterivNV", "GL_NV_point_sprite\0", offsetof(struct opengl_funcs, p_glPointParameterivNV) }, - { "glPointParameterx", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glPointParameterx) }, - { "glPointParameterxv", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glPointParameterxv) }, - { "glPointParameterxvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glPointParameterxvOES) }, - { "glPointSizex", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glPointSizex) }, - { "glPointSizexOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glPointSizexOES) }, - { "glPollAsyncSGIX", "GL_SGIX_async\0", offsetof(struct opengl_funcs, p_glPollAsyncSGIX) }, - { "glPollInstrumentsSGIX", "GL_SGIX_instruments\0", offsetof(struct opengl_funcs, p_glPollInstrumentsSGIX) }, - { "glPolygonOffsetClamp", "GL_ARB_polygon_offset_clamp\0GL_VERSION_4_6\0", offsetof(struct opengl_funcs, p_glPolygonOffsetClamp) }, - { "glPolygonOffsetClampEXT", "GL_EXT_polygon_offset_clamp\0", offsetof(struct opengl_funcs, p_glPolygonOffsetClampEXT) }, - { "glPolygonOffsetEXT", "GL_EXT_polygon_offset\0", offsetof(struct opengl_funcs, p_glPolygonOffsetEXT) }, - { "glPolygonOffsetx", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glPolygonOffsetx) }, - { "glPolygonOffsetxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glPolygonOffsetxOES) }, - { "glPopDebugGroup", "GL_KHR_debug\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glPopDebugGroup) }, - { "glPopGroupMarkerEXT", "GL_EXT_debug_marker\0", offsetof(struct opengl_funcs, p_glPopGroupMarkerEXT) }, - { "glPresentFrameDualFillNV", "GL_NV_present_video\0", offsetof(struct opengl_funcs, p_glPresentFrameDualFillNV) }, - { "glPresentFrameKeyedNV", "GL_NV_present_video\0", offsetof(struct opengl_funcs, p_glPresentFrameKeyedNV) }, - { "glPrimitiveBoundingBox", "GL_ARB_ES3_2_compatibility\0", offsetof(struct opengl_funcs, p_glPrimitiveBoundingBox) }, - { "glPrimitiveBoundingBoxARB", "GL_ARB_ES3_2_compatibility\0", offsetof(struct opengl_funcs, p_glPrimitiveBoundingBoxARB) }, - { "glPrimitiveRestartIndex", "GL_VERSION_3_1\0", offsetof(struct opengl_funcs, p_glPrimitiveRestartIndex) }, - { "glPrimitiveRestartIndexNV", "GL_NV_primitive_restart\0", offsetof(struct opengl_funcs, p_glPrimitiveRestartIndexNV) }, - { "glPrimitiveRestartNV", "GL_NV_primitive_restart\0", offsetof(struct opengl_funcs, p_glPrimitiveRestartNV) }, - { "glPrioritizeTexturesEXT", "GL_EXT_texture_object\0", offsetof(struct opengl_funcs, p_glPrioritizeTexturesEXT) }, - { "glPrioritizeTexturesxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glPrioritizeTexturesxOES) }, - { "glProgramBinary", "GL_ARB_get_program_binary\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramBinary) }, - { "glProgramBufferParametersIivNV", "GL_NV_parameter_buffer_object\0", offsetof(struct opengl_funcs, p_glProgramBufferParametersIivNV) }, - { "glProgramBufferParametersIuivNV", "GL_NV_parameter_buffer_object\0", offsetof(struct opengl_funcs, p_glProgramBufferParametersIuivNV) }, - { "glProgramBufferParametersfvNV", "GL_NV_parameter_buffer_object\0", offsetof(struct opengl_funcs, p_glProgramBufferParametersfvNV) }, - { "glProgramEnvParameter4dARB", "GL_ARB_fragment_program\0GL_ARB_vertex_program\0", offsetof(struct opengl_funcs, p_glProgramEnvParameter4dARB) }, - { "glProgramEnvParameter4dvARB", "GL_ARB_fragment_program\0GL_ARB_vertex_program\0", offsetof(struct opengl_funcs, p_glProgramEnvParameter4dvARB) }, - { "glProgramEnvParameter4fARB", "GL_ARB_fragment_program\0GL_ARB_vertex_program\0", offsetof(struct opengl_funcs, p_glProgramEnvParameter4fARB) }, - { "glProgramEnvParameter4fvARB", "GL_ARB_fragment_program\0GL_ARB_vertex_program\0", offsetof(struct opengl_funcs, p_glProgramEnvParameter4fvARB) }, - { "glProgramEnvParameterI4iNV", "GL_NV_gpu_program4\0", offsetof(struct opengl_funcs, p_glProgramEnvParameterI4iNV) }, - { "glProgramEnvParameterI4ivNV", "GL_NV_gpu_program4\0", offsetof(struct opengl_funcs, p_glProgramEnvParameterI4ivNV) }, - { "glProgramEnvParameterI4uiNV", "GL_NV_gpu_program4\0", offsetof(struct opengl_funcs, p_glProgramEnvParameterI4uiNV) }, - { "glProgramEnvParameterI4uivNV", "GL_NV_gpu_program4\0", offsetof(struct opengl_funcs, p_glProgramEnvParameterI4uivNV) }, - { "glProgramEnvParameters4fvEXT", "GL_EXT_gpu_program_parameters\0", offsetof(struct opengl_funcs, p_glProgramEnvParameters4fvEXT) }, - { "glProgramEnvParametersI4ivNV", "GL_NV_gpu_program4\0", offsetof(struct opengl_funcs, p_glProgramEnvParametersI4ivNV) }, - { "glProgramEnvParametersI4uivNV", "GL_NV_gpu_program4\0", offsetof(struct opengl_funcs, p_glProgramEnvParametersI4uivNV) }, - { "glProgramLocalParameter4dARB", "GL_ARB_fragment_program\0GL_ARB_vertex_program\0", offsetof(struct opengl_funcs, p_glProgramLocalParameter4dARB) }, - { "glProgramLocalParameter4dvARB", "GL_ARB_fragment_program\0GL_ARB_vertex_program\0", offsetof(struct opengl_funcs, p_glProgramLocalParameter4dvARB) }, - { "glProgramLocalParameter4fARB", "GL_ARB_fragment_program\0GL_ARB_vertex_program\0", offsetof(struct opengl_funcs, p_glProgramLocalParameter4fARB) }, - { "glProgramLocalParameter4fvARB", "GL_ARB_fragment_program\0GL_ARB_vertex_program\0", offsetof(struct opengl_funcs, p_glProgramLocalParameter4fvARB) }, - { "glProgramLocalParameterI4iNV", "GL_NV_gpu_program4\0", offsetof(struct opengl_funcs, p_glProgramLocalParameterI4iNV) }, - { "glProgramLocalParameterI4ivNV", "GL_NV_gpu_program4\0", offsetof(struct opengl_funcs, p_glProgramLocalParameterI4ivNV) }, - { "glProgramLocalParameterI4uiNV", "GL_NV_gpu_program4\0", offsetof(struct opengl_funcs, p_glProgramLocalParameterI4uiNV) }, - { "glProgramLocalParameterI4uivNV", "GL_NV_gpu_program4\0", offsetof(struct opengl_funcs, p_glProgramLocalParameterI4uivNV) }, - { "glProgramLocalParameters4fvEXT", "GL_EXT_gpu_program_parameters\0", offsetof(struct opengl_funcs, p_glProgramLocalParameters4fvEXT) }, - { "glProgramLocalParametersI4ivNV", "GL_NV_gpu_program4\0", offsetof(struct opengl_funcs, p_glProgramLocalParametersI4ivNV) }, - { "glProgramLocalParametersI4uivNV", "GL_NV_gpu_program4\0", offsetof(struct opengl_funcs, p_glProgramLocalParametersI4uivNV) }, - { "glProgramNamedParameter4dNV", "GL_NV_fragment_program\0", offsetof(struct opengl_funcs, p_glProgramNamedParameter4dNV) }, - { "glProgramNamedParameter4dvNV", "GL_NV_fragment_program\0", offsetof(struct opengl_funcs, p_glProgramNamedParameter4dvNV) }, - { "glProgramNamedParameter4fNV", "GL_NV_fragment_program\0", offsetof(struct opengl_funcs, p_glProgramNamedParameter4fNV) }, - { "glProgramNamedParameter4fvNV", "GL_NV_fragment_program\0", offsetof(struct opengl_funcs, p_glProgramNamedParameter4fvNV) }, - { "glProgramParameter4dNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glProgramParameter4dNV) }, - { "glProgramParameter4dvNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glProgramParameter4dvNV) }, - { "glProgramParameter4fNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glProgramParameter4fNV) }, - { "glProgramParameter4fvNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glProgramParameter4fvNV) }, - { "glProgramParameteri", "GL_ARB_get_program_binary\0GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramParameteri) }, - { "glProgramParameteriARB", "GL_ARB_geometry_shader4\0", offsetof(struct opengl_funcs, p_glProgramParameteriARB) }, - { "glProgramParameteriEXT", "GL_EXT_geometry_shader4\0", offsetof(struct opengl_funcs, p_glProgramParameteriEXT) }, - { "glProgramParameters4dvNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glProgramParameters4dvNV) }, - { "glProgramParameters4fvNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glProgramParameters4fvNV) }, - { "glProgramPathFragmentInputGenNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glProgramPathFragmentInputGenNV) }, - { "glProgramStringARB", "GL_ARB_fragment_program\0GL_ARB_vertex_program\0", offsetof(struct opengl_funcs, p_glProgramStringARB) }, - { "glProgramSubroutineParametersuivNV", "GL_NV_gpu_program5\0GL_NV_gpu_program_fp64\0", offsetof(struct opengl_funcs, p_glProgramSubroutineParametersuivNV) }, - { "glProgramUniform1d", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform1d) }, - { "glProgramUniform1dEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform1dEXT) }, - { "glProgramUniform1dv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform1dv) }, - { "glProgramUniform1dvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform1dvEXT) }, - { "glProgramUniform1f", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform1f) }, - { "glProgramUniform1fEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform1fEXT) }, - { "glProgramUniform1fv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform1fv) }, - { "glProgramUniform1fvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform1fvEXT) }, - { "glProgramUniform1i", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform1i) }, - { "glProgramUniform1i64ARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glProgramUniform1i64ARB) }, - { "glProgramUniform1i64NV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glProgramUniform1i64NV) }, - { "glProgramUniform1i64vARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glProgramUniform1i64vARB) }, - { "glProgramUniform1i64vNV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glProgramUniform1i64vNV) }, - { "glProgramUniform1iEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform1iEXT) }, - { "glProgramUniform1iv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform1iv) }, - { "glProgramUniform1ivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform1ivEXT) }, - { "glProgramUniform1ui", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform1ui) }, - { "glProgramUniform1ui64ARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glProgramUniform1ui64ARB) }, - { "glProgramUniform1ui64NV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glProgramUniform1ui64NV) }, - { "glProgramUniform1ui64vARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glProgramUniform1ui64vARB) }, - { "glProgramUniform1ui64vNV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glProgramUniform1ui64vNV) }, - { "glProgramUniform1uiEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform1uiEXT) }, - { "glProgramUniform1uiv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform1uiv) }, - { "glProgramUniform1uivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform1uivEXT) }, - { "glProgramUniform2d", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform2d) }, - { "glProgramUniform2dEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform2dEXT) }, - { "glProgramUniform2dv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform2dv) }, - { "glProgramUniform2dvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform2dvEXT) }, - { "glProgramUniform2f", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform2f) }, - { "glProgramUniform2fEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform2fEXT) }, - { "glProgramUniform2fv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform2fv) }, - { "glProgramUniform2fvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform2fvEXT) }, - { "glProgramUniform2i", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform2i) }, - { "glProgramUniform2i64ARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glProgramUniform2i64ARB) }, - { "glProgramUniform2i64NV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glProgramUniform2i64NV) }, - { "glProgramUniform2i64vARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glProgramUniform2i64vARB) }, - { "glProgramUniform2i64vNV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glProgramUniform2i64vNV) }, - { "glProgramUniform2iEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform2iEXT) }, - { "glProgramUniform2iv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform2iv) }, - { "glProgramUniform2ivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform2ivEXT) }, - { "glProgramUniform2ui", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform2ui) }, - { "glProgramUniform2ui64ARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glProgramUniform2ui64ARB) }, - { "glProgramUniform2ui64NV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glProgramUniform2ui64NV) }, - { "glProgramUniform2ui64vARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glProgramUniform2ui64vARB) }, - { "glProgramUniform2ui64vNV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glProgramUniform2ui64vNV) }, - { "glProgramUniform2uiEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform2uiEXT) }, - { "glProgramUniform2uiv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform2uiv) }, - { "glProgramUniform2uivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform2uivEXT) }, - { "glProgramUniform3d", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform3d) }, - { "glProgramUniform3dEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform3dEXT) }, - { "glProgramUniform3dv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform3dv) }, - { "glProgramUniform3dvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform3dvEXT) }, - { "glProgramUniform3f", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform3f) }, - { "glProgramUniform3fEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform3fEXT) }, - { "glProgramUniform3fv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform3fv) }, - { "glProgramUniform3fvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform3fvEXT) }, - { "glProgramUniform3i", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform3i) }, - { "glProgramUniform3i64ARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glProgramUniform3i64ARB) }, - { "glProgramUniform3i64NV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glProgramUniform3i64NV) }, - { "glProgramUniform3i64vARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glProgramUniform3i64vARB) }, - { "glProgramUniform3i64vNV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glProgramUniform3i64vNV) }, - { "glProgramUniform3iEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform3iEXT) }, - { "glProgramUniform3iv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform3iv) }, - { "glProgramUniform3ivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform3ivEXT) }, - { "glProgramUniform3ui", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform3ui) }, - { "glProgramUniform3ui64ARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glProgramUniform3ui64ARB) }, - { "glProgramUniform3ui64NV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glProgramUniform3ui64NV) }, - { "glProgramUniform3ui64vARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glProgramUniform3ui64vARB) }, - { "glProgramUniform3ui64vNV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glProgramUniform3ui64vNV) }, - { "glProgramUniform3uiEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform3uiEXT) }, - { "glProgramUniform3uiv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform3uiv) }, - { "glProgramUniform3uivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform3uivEXT) }, - { "glProgramUniform4d", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform4d) }, - { "glProgramUniform4dEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform4dEXT) }, - { "glProgramUniform4dv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform4dv) }, - { "glProgramUniform4dvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform4dvEXT) }, - { "glProgramUniform4f", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform4f) }, - { "glProgramUniform4fEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform4fEXT) }, - { "glProgramUniform4fv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform4fv) }, - { "glProgramUniform4fvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform4fvEXT) }, - { "glProgramUniform4i", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform4i) }, - { "glProgramUniform4i64ARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glProgramUniform4i64ARB) }, - { "glProgramUniform4i64NV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glProgramUniform4i64NV) }, - { "glProgramUniform4i64vARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glProgramUniform4i64vARB) }, - { "glProgramUniform4i64vNV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glProgramUniform4i64vNV) }, - { "glProgramUniform4iEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform4iEXT) }, - { "glProgramUniform4iv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform4iv) }, - { "glProgramUniform4ivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform4ivEXT) }, - { "glProgramUniform4ui", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform4ui) }, - { "glProgramUniform4ui64ARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glProgramUniform4ui64ARB) }, - { "glProgramUniform4ui64NV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glProgramUniform4ui64NV) }, - { "glProgramUniform4ui64vARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glProgramUniform4ui64vARB) }, - { "glProgramUniform4ui64vNV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glProgramUniform4ui64vNV) }, - { "glProgramUniform4uiEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform4uiEXT) }, - { "glProgramUniform4uiv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniform4uiv) }, - { "glProgramUniform4uivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniform4uivEXT) }, - { "glProgramUniformHandleui64ARB", "GL_ARB_bindless_texture\0", offsetof(struct opengl_funcs, p_glProgramUniformHandleui64ARB) }, - { "glProgramUniformHandleui64NV", "GL_NV_bindless_texture\0", offsetof(struct opengl_funcs, p_glProgramUniformHandleui64NV) }, - { "glProgramUniformHandleui64vARB", "GL_ARB_bindless_texture\0", offsetof(struct opengl_funcs, p_glProgramUniformHandleui64vARB) }, - { "glProgramUniformHandleui64vNV", "GL_NV_bindless_texture\0", offsetof(struct opengl_funcs, p_glProgramUniformHandleui64vNV) }, - { "glProgramUniformMatrix2dv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix2dv) }, - { "glProgramUniformMatrix2dvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix2dvEXT) }, - { "glProgramUniformMatrix2fv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix2fv) }, - { "glProgramUniformMatrix2fvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix2fvEXT) }, - { "glProgramUniformMatrix2x3dv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix2x3dv) }, - { "glProgramUniformMatrix2x3dvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix2x3dvEXT) }, - { "glProgramUniformMatrix2x3fv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix2x3fv) }, - { "glProgramUniformMatrix2x3fvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix2x3fvEXT) }, - { "glProgramUniformMatrix2x4dv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix2x4dv) }, - { "glProgramUniformMatrix2x4dvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix2x4dvEXT) }, - { "glProgramUniformMatrix2x4fv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix2x4fv) }, - { "glProgramUniformMatrix2x4fvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix2x4fvEXT) }, - { "glProgramUniformMatrix3dv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix3dv) }, - { "glProgramUniformMatrix3dvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix3dvEXT) }, - { "glProgramUniformMatrix3fv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix3fv) }, - { "glProgramUniformMatrix3fvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix3fvEXT) }, - { "glProgramUniformMatrix3x2dv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix3x2dv) }, - { "glProgramUniformMatrix3x2dvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix3x2dvEXT) }, - { "glProgramUniformMatrix3x2fv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix3x2fv) }, - { "glProgramUniformMatrix3x2fvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix3x2fvEXT) }, - { "glProgramUniformMatrix3x4dv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix3x4dv) }, - { "glProgramUniformMatrix3x4dvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix3x4dvEXT) }, - { "glProgramUniformMatrix3x4fv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix3x4fv) }, - { "glProgramUniformMatrix3x4fvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix3x4fvEXT) }, - { "glProgramUniformMatrix4dv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix4dv) }, - { "glProgramUniformMatrix4dvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix4dvEXT) }, - { "glProgramUniformMatrix4fv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix4fv) }, - { "glProgramUniformMatrix4fvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix4fvEXT) }, - { "glProgramUniformMatrix4x2dv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix4x2dv) }, - { "glProgramUniformMatrix4x2dvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix4x2dvEXT) }, - { "glProgramUniformMatrix4x2fv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix4x2fv) }, - { "glProgramUniformMatrix4x2fvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix4x2fvEXT) }, - { "glProgramUniformMatrix4x3dv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix4x3dv) }, - { "glProgramUniformMatrix4x3dvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix4x3dvEXT) }, - { "glProgramUniformMatrix4x3fv", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix4x3fv) }, - { "glProgramUniformMatrix4x3fvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glProgramUniformMatrix4x3fvEXT) }, - { "glProgramUniformui64NV", "GL_NV_shader_buffer_load\0", offsetof(struct opengl_funcs, p_glProgramUniformui64NV) }, - { "glProgramUniformui64vNV", "GL_NV_shader_buffer_load\0", offsetof(struct opengl_funcs, p_glProgramUniformui64vNV) }, - { "glProgramVertexLimitNV", "GL_NV_geometry_program4\0", offsetof(struct opengl_funcs, p_glProgramVertexLimitNV) }, - { "glProvokingVertex", "GL_ARB_provoking_vertex\0GL_VERSION_3_2\0", offsetof(struct opengl_funcs, p_glProvokingVertex) }, - { "glProvokingVertexEXT", "GL_EXT_provoking_vertex\0", offsetof(struct opengl_funcs, p_glProvokingVertexEXT) }, - { "glPushClientAttribDefaultEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glPushClientAttribDefaultEXT) }, - { "glPushDebugGroup", "GL_KHR_debug\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glPushDebugGroup) }, - { "glPushGroupMarkerEXT", "GL_EXT_debug_marker\0", offsetof(struct opengl_funcs, p_glPushGroupMarkerEXT) }, - { "glQueryCounter", "GL_ARB_timer_query\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glQueryCounter) }, - { "glQueryMatrixxOES", "GL_OES_query_matrix\0", offsetof(struct opengl_funcs, p_glQueryMatrixxOES) }, - { "glQueryObjectParameteruiAMD", "GL_AMD_occlusion_query_event\0", offsetof(struct opengl_funcs, p_glQueryObjectParameteruiAMD) }, - { "glQueryResourceNV", "GL_NV_query_resource\0", offsetof(struct opengl_funcs, p_glQueryResourceNV) }, - { "glQueryResourceTagNV", "GL_NV_query_resource_tag\0", offsetof(struct opengl_funcs, p_glQueryResourceTagNV) }, - { "glRasterPos2xOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glRasterPos2xOES) }, - { "glRasterPos2xvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glRasterPos2xvOES) }, - { "glRasterPos3xOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glRasterPos3xOES) }, - { "glRasterPos3xvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glRasterPos3xvOES) }, - { "glRasterPos4xOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glRasterPos4xOES) }, - { "glRasterPos4xvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glRasterPos4xvOES) }, - { "glRasterSamplesEXT", "GL_EXT_raster_multisample\0GL_NV_framebuffer_mixed_samples\0", offsetof(struct opengl_funcs, p_glRasterSamplesEXT) }, - { "glReadBufferRegion", "GL_KTX_buffer_region\0", offsetof(struct opengl_funcs, p_glReadBufferRegion) }, - { "glReadInstrumentsSGIX", "GL_SGIX_instruments\0", offsetof(struct opengl_funcs, p_glReadInstrumentsSGIX) }, - { "glReadnPixels", "GL_KHR_robustness\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glReadnPixels) }, - { "glReadnPixelsARB", "GL_ARB_robustness\0", offsetof(struct opengl_funcs, p_glReadnPixelsARB) }, - { "glRectxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glRectxOES) }, - { "glRectxvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glRectxvOES) }, - { "glReferencePlaneSGIX", "GL_SGIX_reference_plane\0", offsetof(struct opengl_funcs, p_glReferencePlaneSGIX) }, - { "glReleaseKeyedMutexWin32EXT", "GL_EXT_win32_keyed_mutex\0", offsetof(struct opengl_funcs, p_glReleaseKeyedMutexWin32EXT) }, - { "glReleaseShaderCompiler", "GL_ARB_ES2_compatibility\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glReleaseShaderCompiler) }, - { "glRenderGpuMaskNV", "GL_NV_gpu_multicast\0", offsetof(struct opengl_funcs, p_glRenderGpuMaskNV) }, - { "glRenderbufferStorage", "GL_ARB_framebuffer_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glRenderbufferStorage) }, - { "glRenderbufferStorageEXT", "GL_EXT_framebuffer_object\0", offsetof(struct opengl_funcs, p_glRenderbufferStorageEXT) }, - { "glRenderbufferStorageMultisample", "GL_ARB_framebuffer_object\0GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glRenderbufferStorageMultisample) }, - { "glRenderbufferStorageMultisampleAdvancedAMD", "GL_AMD_framebuffer_multisample_advanced\0", offsetof(struct opengl_funcs, p_glRenderbufferStorageMultisampleAdvancedAMD) }, - { "glRenderbufferStorageMultisampleCoverageNV", "GL_NV_framebuffer_multisample_coverage\0", offsetof(struct opengl_funcs, p_glRenderbufferStorageMultisampleCoverageNV) }, - { "glRenderbufferStorageMultisampleEXT", "GL_EXT_framebuffer_multisample\0", offsetof(struct opengl_funcs, p_glRenderbufferStorageMultisampleEXT) }, - { "glReplacementCodePointerSUN", "GL_SUN_triangle_list\0", offsetof(struct opengl_funcs, p_glReplacementCodePointerSUN) }, - { "glReplacementCodeubSUN", "GL_SUN_triangle_list\0", offsetof(struct opengl_funcs, p_glReplacementCodeubSUN) }, - { "glReplacementCodeubvSUN", "GL_SUN_triangle_list\0", offsetof(struct opengl_funcs, p_glReplacementCodeubvSUN) }, - { "glReplacementCodeuiColor3fVertex3fSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glReplacementCodeuiColor3fVertex3fSUN) }, - { "glReplacementCodeuiColor3fVertex3fvSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glReplacementCodeuiColor3fVertex3fvSUN) }, - { "glReplacementCodeuiColor4fNormal3fVertex3fSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glReplacementCodeuiColor4fNormal3fVertex3fSUN) }, - { "glReplacementCodeuiColor4fNormal3fVertex3fvSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glReplacementCodeuiColor4fNormal3fVertex3fvSUN) }, - { "glReplacementCodeuiColor4ubVertex3fSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glReplacementCodeuiColor4ubVertex3fSUN) }, - { "glReplacementCodeuiColor4ubVertex3fvSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glReplacementCodeuiColor4ubVertex3fvSUN) }, - { "glReplacementCodeuiNormal3fVertex3fSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glReplacementCodeuiNormal3fVertex3fSUN) }, - { "glReplacementCodeuiNormal3fVertex3fvSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glReplacementCodeuiNormal3fVertex3fvSUN) }, - { "glReplacementCodeuiSUN", "GL_SUN_triangle_list\0", offsetof(struct opengl_funcs, p_glReplacementCodeuiSUN) }, - { "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN) }, - { "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN) }, - { "glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN) }, - { "glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN) }, - { "glReplacementCodeuiTexCoord2fVertex3fSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glReplacementCodeuiTexCoord2fVertex3fSUN) }, - { "glReplacementCodeuiTexCoord2fVertex3fvSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glReplacementCodeuiTexCoord2fVertex3fvSUN) }, - { "glReplacementCodeuiVertex3fSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glReplacementCodeuiVertex3fSUN) }, - { "glReplacementCodeuiVertex3fvSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glReplacementCodeuiVertex3fvSUN) }, - { "glReplacementCodeuivSUN", "GL_SUN_triangle_list\0", offsetof(struct opengl_funcs, p_glReplacementCodeuivSUN) }, - { "glReplacementCodeusSUN", "GL_SUN_triangle_list\0", offsetof(struct opengl_funcs, p_glReplacementCodeusSUN) }, - { "glReplacementCodeusvSUN", "GL_SUN_triangle_list\0", offsetof(struct opengl_funcs, p_glReplacementCodeusvSUN) }, - { "glRequestResidentProgramsNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glRequestResidentProgramsNV) }, - { "glResetHistogram", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glResetHistogram) }, - { "glResetHistogramEXT", "GL_EXT_histogram\0", offsetof(struct opengl_funcs, p_glResetHistogramEXT) }, - { "glResetMemoryObjectParameterNV", "GL_NV_memory_attachment\0", offsetof(struct opengl_funcs, p_glResetMemoryObjectParameterNV) }, - { "glResetMinmax", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glResetMinmax) }, - { "glResetMinmaxEXT", "GL_EXT_histogram\0", offsetof(struct opengl_funcs, p_glResetMinmaxEXT) }, - { "glResizeBuffersMESA", "GL_MESA_resize_buffers\0", offsetof(struct opengl_funcs, p_glResizeBuffersMESA) }, - { "glResolveDepthValuesNV", "GL_NV_sample_locations\0", offsetof(struct opengl_funcs, p_glResolveDepthValuesNV) }, - { "glResumeTransformFeedback", "GL_ARB_transform_feedback2\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glResumeTransformFeedback) }, - { "glResumeTransformFeedbackNV", "GL_NV_transform_feedback2\0", offsetof(struct opengl_funcs, p_glResumeTransformFeedbackNV) }, - { "glRotatex", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glRotatex) }, - { "glRotatexOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glRotatexOES) }, - { "glSampleCoverage", "GL_VERSION_1_3\0", offsetof(struct opengl_funcs, p_glSampleCoverage) }, - { "glSampleCoverageARB", "GL_ARB_multisample\0", offsetof(struct opengl_funcs, p_glSampleCoverageARB) }, - { "glSampleCoveragex", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glSampleCoveragex) }, - { "glSampleMapATI", "GL_ATI_fragment_shader\0", offsetof(struct opengl_funcs, p_glSampleMapATI) }, - { "glSampleMaskEXT", "GL_EXT_multisample\0", offsetof(struct opengl_funcs, p_glSampleMaskEXT) }, - { "glSampleMaskIndexedNV", "GL_NV_explicit_multisample\0", offsetof(struct opengl_funcs, p_glSampleMaskIndexedNV) }, - { "glSampleMaskSGIS", "GL_SGIS_multisample\0", offsetof(struct opengl_funcs, p_glSampleMaskSGIS) }, - { "glSampleMaski", "GL_ARB_texture_multisample\0GL_VERSION_3_2\0", offsetof(struct opengl_funcs, p_glSampleMaski) }, - { "glSamplePatternEXT", "GL_EXT_multisample\0", offsetof(struct opengl_funcs, p_glSamplePatternEXT) }, - { "glSamplePatternSGIS", "GL_SGIS_multisample\0", offsetof(struct opengl_funcs, p_glSamplePatternSGIS) }, - { "glSamplerParameterIiv", "GL_ARB_sampler_objects\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glSamplerParameterIiv) }, - { "glSamplerParameterIuiv", "GL_ARB_sampler_objects\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glSamplerParameterIuiv) }, - { "glSamplerParameterf", "GL_ARB_sampler_objects\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glSamplerParameterf) }, - { "glSamplerParameterfv", "GL_ARB_sampler_objects\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glSamplerParameterfv) }, - { "glSamplerParameteri", "GL_ARB_sampler_objects\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glSamplerParameteri) }, - { "glSamplerParameteriv", "GL_ARB_sampler_objects\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glSamplerParameteriv) }, - { "glScalex", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glScalex) }, - { "glScalexOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glScalexOES) }, - { "glScissorArrayv", "GL_ARB_viewport_array\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glScissorArrayv) }, - { "glScissorExclusiveArrayvNV", "GL_NV_scissor_exclusive\0", offsetof(struct opengl_funcs, p_glScissorExclusiveArrayvNV) }, - { "glScissorExclusiveNV", "GL_NV_scissor_exclusive\0", offsetof(struct opengl_funcs, p_glScissorExclusiveNV) }, - { "glScissorIndexed", "GL_ARB_viewport_array\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glScissorIndexed) }, - { "glScissorIndexedv", "GL_ARB_viewport_array\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glScissorIndexedv) }, - { "glSecondaryColor3b", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glSecondaryColor3b) }, - { "glSecondaryColor3bEXT", "GL_EXT_secondary_color\0", offsetof(struct opengl_funcs, p_glSecondaryColor3bEXT) }, - { "glSecondaryColor3bv", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glSecondaryColor3bv) }, - { "glSecondaryColor3bvEXT", "GL_EXT_secondary_color\0", offsetof(struct opengl_funcs, p_glSecondaryColor3bvEXT) }, - { "glSecondaryColor3d", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glSecondaryColor3d) }, - { "glSecondaryColor3dEXT", "GL_EXT_secondary_color\0", offsetof(struct opengl_funcs, p_glSecondaryColor3dEXT) }, - { "glSecondaryColor3dv", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glSecondaryColor3dv) }, - { "glSecondaryColor3dvEXT", "GL_EXT_secondary_color\0", offsetof(struct opengl_funcs, p_glSecondaryColor3dvEXT) }, - { "glSecondaryColor3f", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glSecondaryColor3f) }, - { "glSecondaryColor3fEXT", "GL_EXT_secondary_color\0", offsetof(struct opengl_funcs, p_glSecondaryColor3fEXT) }, - { "glSecondaryColor3fv", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glSecondaryColor3fv) }, - { "glSecondaryColor3fvEXT", "GL_EXT_secondary_color\0", offsetof(struct opengl_funcs, p_glSecondaryColor3fvEXT) }, - { "glSecondaryColor3hNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glSecondaryColor3hNV) }, - { "glSecondaryColor3hvNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glSecondaryColor3hvNV) }, - { "glSecondaryColor3i", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glSecondaryColor3i) }, - { "glSecondaryColor3iEXT", "GL_EXT_secondary_color\0", offsetof(struct opengl_funcs, p_glSecondaryColor3iEXT) }, - { "glSecondaryColor3iv", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glSecondaryColor3iv) }, - { "glSecondaryColor3ivEXT", "GL_EXT_secondary_color\0", offsetof(struct opengl_funcs, p_glSecondaryColor3ivEXT) }, - { "glSecondaryColor3s", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glSecondaryColor3s) }, - { "glSecondaryColor3sEXT", "GL_EXT_secondary_color\0", offsetof(struct opengl_funcs, p_glSecondaryColor3sEXT) }, - { "glSecondaryColor3sv", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glSecondaryColor3sv) }, - { "glSecondaryColor3svEXT", "GL_EXT_secondary_color\0", offsetof(struct opengl_funcs, p_glSecondaryColor3svEXT) }, - { "glSecondaryColor3ub", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glSecondaryColor3ub) }, - { "glSecondaryColor3ubEXT", "GL_EXT_secondary_color\0", offsetof(struct opengl_funcs, p_glSecondaryColor3ubEXT) }, - { "glSecondaryColor3ubv", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glSecondaryColor3ubv) }, - { "glSecondaryColor3ubvEXT", "GL_EXT_secondary_color\0", offsetof(struct opengl_funcs, p_glSecondaryColor3ubvEXT) }, - { "glSecondaryColor3ui", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glSecondaryColor3ui) }, - { "glSecondaryColor3uiEXT", "GL_EXT_secondary_color\0", offsetof(struct opengl_funcs, p_glSecondaryColor3uiEXT) }, - { "glSecondaryColor3uiv", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glSecondaryColor3uiv) }, - { "glSecondaryColor3uivEXT", "GL_EXT_secondary_color\0", offsetof(struct opengl_funcs, p_glSecondaryColor3uivEXT) }, - { "glSecondaryColor3us", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glSecondaryColor3us) }, - { "glSecondaryColor3usEXT", "GL_EXT_secondary_color\0", offsetof(struct opengl_funcs, p_glSecondaryColor3usEXT) }, - { "glSecondaryColor3usv", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glSecondaryColor3usv) }, - { "glSecondaryColor3usvEXT", "GL_EXT_secondary_color\0", offsetof(struct opengl_funcs, p_glSecondaryColor3usvEXT) }, - { "glSecondaryColorFormatNV", "GL_NV_vertex_buffer_unified_memory\0", offsetof(struct opengl_funcs, p_glSecondaryColorFormatNV) }, - { "glSecondaryColorP3ui", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glSecondaryColorP3ui) }, - { "glSecondaryColorP3uiv", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glSecondaryColorP3uiv) }, - { "glSecondaryColorPointer", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glSecondaryColorPointer) }, - { "glSecondaryColorPointerEXT", "GL_EXT_secondary_color\0", offsetof(struct opengl_funcs, p_glSecondaryColorPointerEXT) }, - { "glSecondaryColorPointerListIBM", "GL_IBM_vertex_array_lists\0", offsetof(struct opengl_funcs, p_glSecondaryColorPointerListIBM) }, - { "glSelectPerfMonitorCountersAMD", "GL_AMD_performance_monitor\0", offsetof(struct opengl_funcs, p_glSelectPerfMonitorCountersAMD) }, - { "glSelectTextureCoordSetSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glSelectTextureCoordSetSGIS) }, - { "glSelectTextureSGIS", "GL_SGIS_multitexture\0", offsetof(struct opengl_funcs, p_glSelectTextureSGIS) }, - { "glSemaphoreParameterivNV", "GL_NV_timeline_semaphore\0", offsetof(struct opengl_funcs, p_glSemaphoreParameterivNV) }, - { "glSemaphoreParameterui64vEXT", "GL_EXT_semaphore\0", offsetof(struct opengl_funcs, p_glSemaphoreParameterui64vEXT) }, - { "glSeparableFilter2D", "GL_ARB_imaging\0", offsetof(struct opengl_funcs, p_glSeparableFilter2D) }, - { "glSeparableFilter2DEXT", "GL_EXT_convolution\0", offsetof(struct opengl_funcs, p_glSeparableFilter2DEXT) }, - { "glSetFenceAPPLE", "GL_APPLE_fence\0", offsetof(struct opengl_funcs, p_glSetFenceAPPLE) }, - { "glSetFenceNV", "GL_NV_fence\0", offsetof(struct opengl_funcs, p_glSetFenceNV) }, - { "glSetFragmentShaderConstantATI", "GL_ATI_fragment_shader\0", offsetof(struct opengl_funcs, p_glSetFragmentShaderConstantATI) }, - { "glSetInvariantEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glSetInvariantEXT) }, - { "glSetLocalConstantEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glSetLocalConstantEXT) }, - { "glSetMultisamplefvAMD", "GL_AMD_sample_positions\0", offsetof(struct opengl_funcs, p_glSetMultisamplefvAMD) }, - { "glShaderBinary", "GL_ARB_ES2_compatibility\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glShaderBinary) }, - { "glShaderOp1EXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glShaderOp1EXT) }, - { "glShaderOp2EXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glShaderOp2EXT) }, - { "glShaderOp3EXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glShaderOp3EXT) }, - { "glShaderSource", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glShaderSource) }, - { "glShaderSourceARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glShaderSourceARB) }, - { "glShaderStorageBlockBinding", "GL_ARB_shader_storage_buffer_object\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glShaderStorageBlockBinding) }, - { "glShadingRateCombinerOpsEXT", "GL_EXT_fragment_shading_rate\0GL_EXT_fragment_shading_rate_attachment\0GL_EXT_fragment_shading_rate_primitive\0", offsetof(struct opengl_funcs, p_glShadingRateCombinerOpsEXT) }, - { "glShadingRateEXT", "GL_EXT_fragment_shading_rate\0GL_EXT_fragment_shading_rate_attachment\0GL_EXT_fragment_shading_rate_primitive\0", offsetof(struct opengl_funcs, p_glShadingRateEXT) }, - { "glShadingRateImageBarrierNV", "GL_NV_shading_rate_image\0", offsetof(struct opengl_funcs, p_glShadingRateImageBarrierNV) }, - { "glShadingRateImagePaletteNV", "GL_NV_shading_rate_image\0", offsetof(struct opengl_funcs, p_glShadingRateImagePaletteNV) }, - { "glShadingRateSampleOrderCustomNV", "GL_NV_shading_rate_image\0", offsetof(struct opengl_funcs, p_glShadingRateSampleOrderCustomNV) }, - { "glShadingRateSampleOrderNV", "GL_NV_shading_rate_image\0", offsetof(struct opengl_funcs, p_glShadingRateSampleOrderNV) }, - { "glSharpenTexFuncSGIS", "GL_SGIS_sharpen_texture\0", offsetof(struct opengl_funcs, p_glSharpenTexFuncSGIS) }, - { "glSignalSemaphoreEXT", "GL_EXT_semaphore\0", offsetof(struct opengl_funcs, p_glSignalSemaphoreEXT) }, - { "glSignalSemaphoreui64NVX", "GL_NVX_progress_fence\0", offsetof(struct opengl_funcs, p_glSignalSemaphoreui64NVX) }, - { "glSignalVkFenceNV", "GL_NV_draw_vulkan_image\0", offsetof(struct opengl_funcs, p_glSignalVkFenceNV) }, - { "glSignalVkSemaphoreNV", "GL_NV_draw_vulkan_image\0", offsetof(struct opengl_funcs, p_glSignalVkSemaphoreNV) }, - { "glSpecializeShader", "GL_VERSION_4_6\0", offsetof(struct opengl_funcs, p_glSpecializeShader) }, - { "glSpecializeShaderARB", "GL_ARB_gl_spirv\0", offsetof(struct opengl_funcs, p_glSpecializeShaderARB) }, - { "glSpriteParameterfSGIX", "GL_SGIX_sprite\0", offsetof(struct opengl_funcs, p_glSpriteParameterfSGIX) }, - { "glSpriteParameterfvSGIX", "GL_SGIX_sprite\0", offsetof(struct opengl_funcs, p_glSpriteParameterfvSGIX) }, - { "glSpriteParameteriSGIX", "GL_SGIX_sprite\0", offsetof(struct opengl_funcs, p_glSpriteParameteriSGIX) }, - { "glSpriteParameterivSGIX", "GL_SGIX_sprite\0", offsetof(struct opengl_funcs, p_glSpriteParameterivSGIX) }, - { "glStartInstrumentsSGIX", "GL_SGIX_instruments\0", offsetof(struct opengl_funcs, p_glStartInstrumentsSGIX) }, - { "glStateCaptureNV", "GL_NV_command_list\0", offsetof(struct opengl_funcs, p_glStateCaptureNV) }, - { "glStencilClearTagEXT", "GL_EXT_stencil_clear_tag\0", offsetof(struct opengl_funcs, p_glStencilClearTagEXT) }, - { "glStencilFillPathInstancedNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glStencilFillPathInstancedNV) }, - { "glStencilFillPathNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glStencilFillPathNV) }, - { "glStencilFuncSeparate", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glStencilFuncSeparate) }, - { "glStencilFuncSeparateATI", "GL_ATI_separate_stencil\0", offsetof(struct opengl_funcs, p_glStencilFuncSeparateATI) }, - { "glStencilMaskSeparate", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glStencilMaskSeparate) }, - { "glStencilOpSeparate", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glStencilOpSeparate) }, - { "glStencilOpSeparateATI", "GL_ATI_separate_stencil\0", offsetof(struct opengl_funcs, p_glStencilOpSeparateATI) }, - { "glStencilOpValueAMD", "GL_AMD_stencil_operation_extended\0", offsetof(struct opengl_funcs, p_glStencilOpValueAMD) }, - { "glStencilStrokePathInstancedNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glStencilStrokePathInstancedNV) }, - { "glStencilStrokePathNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glStencilStrokePathNV) }, - { "glStencilThenCoverFillPathInstancedNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glStencilThenCoverFillPathInstancedNV) }, - { "glStencilThenCoverFillPathNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glStencilThenCoverFillPathNV) }, - { "glStencilThenCoverStrokePathInstancedNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glStencilThenCoverStrokePathInstancedNV) }, - { "glStencilThenCoverStrokePathNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glStencilThenCoverStrokePathNV) }, - { "glStopInstrumentsSGIX", "GL_SGIX_instruments\0", offsetof(struct opengl_funcs, p_glStopInstrumentsSGIX) }, - { "glStringMarkerGREMEDY", "GL_GREMEDY_string_marker\0", offsetof(struct opengl_funcs, p_glStringMarkerGREMEDY) }, - { "glSubpixelPrecisionBiasNV", "GL_NV_conservative_raster\0", offsetof(struct opengl_funcs, p_glSubpixelPrecisionBiasNV) }, - { "glSwizzleEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glSwizzleEXT) }, - { "glSyncTextureINTEL", "GL_INTEL_map_texture\0", offsetof(struct opengl_funcs, p_glSyncTextureINTEL) }, - { "glTagSampleBufferSGIX", "GL_SGIX_tag_sample_buffer\0", offsetof(struct opengl_funcs, p_glTagSampleBufferSGIX) }, - { "glTangent3bEXT", "GL_EXT_coordinate_frame\0", offsetof(struct opengl_funcs, p_glTangent3bEXT) }, - { "glTangent3bvEXT", "GL_EXT_coordinate_frame\0", offsetof(struct opengl_funcs, p_glTangent3bvEXT) }, - { "glTangent3dEXT", "GL_EXT_coordinate_frame\0", offsetof(struct opengl_funcs, p_glTangent3dEXT) }, - { "glTangent3dvEXT", "GL_EXT_coordinate_frame\0", offsetof(struct opengl_funcs, p_glTangent3dvEXT) }, - { "glTangent3fEXT", "GL_EXT_coordinate_frame\0", offsetof(struct opengl_funcs, p_glTangent3fEXT) }, - { "glTangent3fvEXT", "GL_EXT_coordinate_frame\0", offsetof(struct opengl_funcs, p_glTangent3fvEXT) }, - { "glTangent3iEXT", "GL_EXT_coordinate_frame\0", offsetof(struct opengl_funcs, p_glTangent3iEXT) }, - { "glTangent3ivEXT", "GL_EXT_coordinate_frame\0", offsetof(struct opengl_funcs, p_glTangent3ivEXT) }, - { "glTangent3sEXT", "GL_EXT_coordinate_frame\0", offsetof(struct opengl_funcs, p_glTangent3sEXT) }, - { "glTangent3svEXT", "GL_EXT_coordinate_frame\0", offsetof(struct opengl_funcs, p_glTangent3svEXT) }, - { "glTangentPointerEXT", "GL_EXT_coordinate_frame\0", offsetof(struct opengl_funcs, p_glTangentPointerEXT) }, - { "glTbufferMask3DFX", "GL_3DFX_tbuffer\0", offsetof(struct opengl_funcs, p_glTbufferMask3DFX) }, - { "glTessellationFactorAMD", "GL_AMD_vertex_shader_tessellator\0", offsetof(struct opengl_funcs, p_glTessellationFactorAMD) }, - { "glTessellationModeAMD", "GL_AMD_vertex_shader_tessellator\0", offsetof(struct opengl_funcs, p_glTessellationModeAMD) }, - { "glTestFenceAPPLE", "GL_APPLE_fence\0", offsetof(struct opengl_funcs, p_glTestFenceAPPLE) }, - { "glTestFenceNV", "GL_NV_fence\0", offsetof(struct opengl_funcs, p_glTestFenceNV) }, - { "glTestObjectAPPLE", "GL_APPLE_fence\0", offsetof(struct opengl_funcs, p_glTestObjectAPPLE) }, - { "glTexAttachMemoryNV", "GL_NV_memory_attachment\0", offsetof(struct opengl_funcs, p_glTexAttachMemoryNV) }, - { "glTexBuffer", "GL_VERSION_3_1\0", offsetof(struct opengl_funcs, p_glTexBuffer) }, - { "glTexBufferARB", "GL_ARB_texture_buffer_object\0", offsetof(struct opengl_funcs, p_glTexBufferARB) }, - { "glTexBufferEXT", "GL_EXT_texture_buffer_object\0", offsetof(struct opengl_funcs, p_glTexBufferEXT) }, - { "glTexBufferRange", "GL_ARB_texture_buffer_range\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glTexBufferRange) }, - { "glTexBumpParameterfvATI", "GL_ATI_envmap_bumpmap\0", offsetof(struct opengl_funcs, p_glTexBumpParameterfvATI) }, - { "glTexBumpParameterivATI", "GL_ATI_envmap_bumpmap\0", offsetof(struct opengl_funcs, p_glTexBumpParameterivATI) }, - { "glTexCoord1bOES", "GL_OES_byte_coordinates\0", offsetof(struct opengl_funcs, p_glTexCoord1bOES) }, - { "glTexCoord1bvOES", "GL_OES_byte_coordinates\0", offsetof(struct opengl_funcs, p_glTexCoord1bvOES) }, - { "glTexCoord1hNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glTexCoord1hNV) }, - { "glTexCoord1hvNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glTexCoord1hvNV) }, - { "glTexCoord1xOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glTexCoord1xOES) }, - { "glTexCoord1xvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glTexCoord1xvOES) }, - { "glTexCoord2bOES", "GL_OES_byte_coordinates\0", offsetof(struct opengl_funcs, p_glTexCoord2bOES) }, - { "glTexCoord2bvOES", "GL_OES_byte_coordinates\0", offsetof(struct opengl_funcs, p_glTexCoord2bvOES) }, - { "glTexCoord2fColor3fVertex3fSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glTexCoord2fColor3fVertex3fSUN) }, - { "glTexCoord2fColor3fVertex3fvSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glTexCoord2fColor3fVertex3fvSUN) }, - { "glTexCoord2fColor4fNormal3fVertex3fSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glTexCoord2fColor4fNormal3fVertex3fSUN) }, - { "glTexCoord2fColor4fNormal3fVertex3fvSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glTexCoord2fColor4fNormal3fVertex3fvSUN) }, - { "glTexCoord2fColor4ubVertex3fSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glTexCoord2fColor4ubVertex3fSUN) }, - { "glTexCoord2fColor4ubVertex3fvSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glTexCoord2fColor4ubVertex3fvSUN) }, - { "glTexCoord2fNormal3fVertex3fSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glTexCoord2fNormal3fVertex3fSUN) }, - { "glTexCoord2fNormal3fVertex3fvSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glTexCoord2fNormal3fVertex3fvSUN) }, - { "glTexCoord2fVertex3fSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glTexCoord2fVertex3fSUN) }, - { "glTexCoord2fVertex3fvSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glTexCoord2fVertex3fvSUN) }, - { "glTexCoord2hNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glTexCoord2hNV) }, - { "glTexCoord2hvNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glTexCoord2hvNV) }, - { "glTexCoord2xOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glTexCoord2xOES) }, - { "glTexCoord2xvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glTexCoord2xvOES) }, - { "glTexCoord3bOES", "GL_OES_byte_coordinates\0", offsetof(struct opengl_funcs, p_glTexCoord3bOES) }, - { "glTexCoord3bvOES", "GL_OES_byte_coordinates\0", offsetof(struct opengl_funcs, p_glTexCoord3bvOES) }, - { "glTexCoord3hNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glTexCoord3hNV) }, - { "glTexCoord3hvNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glTexCoord3hvNV) }, - { "glTexCoord3xOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glTexCoord3xOES) }, - { "glTexCoord3xvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glTexCoord3xvOES) }, - { "glTexCoord4bOES", "GL_OES_byte_coordinates\0", offsetof(struct opengl_funcs, p_glTexCoord4bOES) }, - { "glTexCoord4bvOES", "GL_OES_byte_coordinates\0", offsetof(struct opengl_funcs, p_glTexCoord4bvOES) }, - { "glTexCoord4fColor4fNormal3fVertex4fSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glTexCoord4fColor4fNormal3fVertex4fSUN) }, - { "glTexCoord4fColor4fNormal3fVertex4fvSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glTexCoord4fColor4fNormal3fVertex4fvSUN) }, - { "glTexCoord4fVertex4fSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glTexCoord4fVertex4fSUN) }, - { "glTexCoord4fVertex4fvSUN", "GL_SUN_vertex\0", offsetof(struct opengl_funcs, p_glTexCoord4fVertex4fvSUN) }, - { "glTexCoord4hNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glTexCoord4hNV) }, - { "glTexCoord4hvNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glTexCoord4hvNV) }, - { "glTexCoord4xOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glTexCoord4xOES) }, - { "glTexCoord4xvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glTexCoord4xvOES) }, - { "glTexCoordFormatNV", "GL_NV_vertex_buffer_unified_memory\0", offsetof(struct opengl_funcs, p_glTexCoordFormatNV) }, - { "glTexCoordP1ui", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glTexCoordP1ui) }, - { "glTexCoordP1uiv", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glTexCoordP1uiv) }, - { "glTexCoordP2ui", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glTexCoordP2ui) }, - { "glTexCoordP2uiv", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glTexCoordP2uiv) }, - { "glTexCoordP3ui", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glTexCoordP3ui) }, - { "glTexCoordP3uiv", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glTexCoordP3uiv) }, - { "glTexCoordP4ui", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glTexCoordP4ui) }, - { "glTexCoordP4uiv", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glTexCoordP4uiv) }, - { "glTexCoordPointerEXT", "GL_EXT_vertex_array\0", offsetof(struct opengl_funcs, p_glTexCoordPointerEXT) }, - { "glTexCoordPointerListIBM", "GL_IBM_vertex_array_lists\0", offsetof(struct opengl_funcs, p_glTexCoordPointerListIBM) }, - { "glTexCoordPointervINTEL", "GL_INTEL_parallel_arrays\0", offsetof(struct opengl_funcs, p_glTexCoordPointervINTEL) }, - { "glTexEnvx", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glTexEnvx) }, - { "glTexEnvxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glTexEnvxOES) }, - { "glTexEnvxv", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glTexEnvxv) }, - { "glTexEnvxvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glTexEnvxvOES) }, - { "glTexFilterFuncSGIS", "GL_SGIS_texture_filter4\0", offsetof(struct opengl_funcs, p_glTexFilterFuncSGIS) }, - { "glTexGenxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glTexGenxOES) }, - { "glTexGenxvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glTexGenxvOES) }, - { "glTexImage2DMultisample", "GL_ARB_texture_multisample\0GL_VERSION_3_2\0", offsetof(struct opengl_funcs, p_glTexImage2DMultisample) }, - { "glTexImage2DMultisampleCoverageNV", "GL_NV_texture_multisample\0", offsetof(struct opengl_funcs, p_glTexImage2DMultisampleCoverageNV) }, - { "glTexImage3D", "GL_VERSION_1_2\0", offsetof(struct opengl_funcs, p_glTexImage3D) }, - { "glTexImage3DEXT", "GL_EXT_texture3D\0", offsetof(struct opengl_funcs, p_glTexImage3DEXT) }, - { "glTexImage3DMultisample", "GL_ARB_texture_multisample\0GL_VERSION_3_2\0", offsetof(struct opengl_funcs, p_glTexImage3DMultisample) }, - { "glTexImage3DMultisampleCoverageNV", "GL_NV_texture_multisample\0", offsetof(struct opengl_funcs, p_glTexImage3DMultisampleCoverageNV) }, - { "glTexImage4DSGIS", "GL_SGIS_texture4D\0", offsetof(struct opengl_funcs, p_glTexImage4DSGIS) }, - { "glTexPageCommitmentARB", "GL_ARB_sparse_texture\0", offsetof(struct opengl_funcs, p_glTexPageCommitmentARB) }, - { "glTexPageCommitmentMemNV", "GL_NV_memory_object_sparse\0", offsetof(struct opengl_funcs, p_glTexPageCommitmentMemNV) }, - { "glTexParameterIiv", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glTexParameterIiv) }, - { "glTexParameterIivEXT", "GL_EXT_texture_integer\0", offsetof(struct opengl_funcs, p_glTexParameterIivEXT) }, - { "glTexParameterIuiv", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glTexParameterIuiv) }, - { "glTexParameterIuivEXT", "GL_EXT_texture_integer\0", offsetof(struct opengl_funcs, p_glTexParameterIuivEXT) }, - { "glTexParameterx", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glTexParameterx) }, - { "glTexParameterxOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glTexParameterxOES) }, - { "glTexParameterxv", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glTexParameterxv) }, - { "glTexParameterxvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glTexParameterxvOES) }, - { "glTexRenderbufferNV", "GL_NV_explicit_multisample\0", offsetof(struct opengl_funcs, p_glTexRenderbufferNV) }, - { "glTexStorage1D", "GL_ARB_texture_storage\0GL_VERSION_4_2\0", offsetof(struct opengl_funcs, p_glTexStorage1D) }, - { "glTexStorage1DEXT", "GL_EXT_texture_storage\0", offsetof(struct opengl_funcs, p_glTexStorage1DEXT) }, - { "glTexStorage2D", "GL_ARB_texture_storage\0GL_VERSION_4_2\0", offsetof(struct opengl_funcs, p_glTexStorage2D) }, - { "glTexStorage2DEXT", "GL_EXT_texture_storage\0", offsetof(struct opengl_funcs, p_glTexStorage2DEXT) }, - { "glTexStorage2DMultisample", "GL_ARB_texture_storage_multisample\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glTexStorage2DMultisample) }, - { "glTexStorage3D", "GL_ARB_texture_storage\0GL_VERSION_4_2\0", offsetof(struct opengl_funcs, p_glTexStorage3D) }, - { "glTexStorage3DEXT", "GL_EXT_texture_storage\0", offsetof(struct opengl_funcs, p_glTexStorage3DEXT) }, - { "glTexStorage3DMultisample", "GL_ARB_texture_storage_multisample\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glTexStorage3DMultisample) }, - { "glTexStorageMem1DEXT", "GL_EXT_memory_object\0", offsetof(struct opengl_funcs, p_glTexStorageMem1DEXT) }, - { "glTexStorageMem2DEXT", "GL_EXT_memory_object\0", offsetof(struct opengl_funcs, p_glTexStorageMem2DEXT) }, - { "glTexStorageMem2DMultisampleEXT", "GL_EXT_memory_object\0", offsetof(struct opengl_funcs, p_glTexStorageMem2DMultisampleEXT) }, - { "glTexStorageMem3DEXT", "GL_EXT_memory_object\0", offsetof(struct opengl_funcs, p_glTexStorageMem3DEXT) }, - { "glTexStorageMem3DMultisampleEXT", "GL_EXT_memory_object\0", offsetof(struct opengl_funcs, p_glTexStorageMem3DMultisampleEXT) }, - { "glTexStorageSparseAMD", "GL_AMD_sparse_texture\0", offsetof(struct opengl_funcs, p_glTexStorageSparseAMD) }, - { "glTexSubImage1DEXT", "GL_EXT_subtexture\0", offsetof(struct opengl_funcs, p_glTexSubImage1DEXT) }, - { "glTexSubImage2DEXT", "GL_EXT_subtexture\0", offsetof(struct opengl_funcs, p_glTexSubImage2DEXT) }, - { "glTexSubImage3D", "GL_VERSION_1_2\0", offsetof(struct opengl_funcs, p_glTexSubImage3D) }, - { "glTexSubImage3DEXT", "GL_EXT_texture3D\0", offsetof(struct opengl_funcs, p_glTexSubImage3DEXT) }, - { "glTexSubImage4DSGIS", "GL_SGIS_texture4D\0", offsetof(struct opengl_funcs, p_glTexSubImage4DSGIS) }, - { "glTextureAttachMemoryNV", "GL_NV_memory_attachment\0", offsetof(struct opengl_funcs, p_glTextureAttachMemoryNV) }, - { "glTextureBarrier", "GL_ARB_texture_barrier\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glTextureBarrier) }, - { "glTextureBarrierNV", "GL_NV_texture_barrier\0", offsetof(struct opengl_funcs, p_glTextureBarrierNV) }, - { "glTextureBuffer", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glTextureBuffer) }, - { "glTextureBufferEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glTextureBufferEXT) }, - { "glTextureBufferRange", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glTextureBufferRange) }, - { "glTextureBufferRangeEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glTextureBufferRangeEXT) }, - { "glTextureColorMaskSGIS", "GL_SGIS_texture_color_mask\0", offsetof(struct opengl_funcs, p_glTextureColorMaskSGIS) }, - { "glTextureImage1DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glTextureImage1DEXT) }, - { "glTextureImage2DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glTextureImage2DEXT) }, - { "glTextureImage2DMultisampleCoverageNV", "GL_NV_texture_multisample\0", offsetof(struct opengl_funcs, p_glTextureImage2DMultisampleCoverageNV) }, - { "glTextureImage2DMultisampleNV", "GL_NV_texture_multisample\0", offsetof(struct opengl_funcs, p_glTextureImage2DMultisampleNV) }, - { "glTextureImage3DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glTextureImage3DEXT) }, - { "glTextureImage3DMultisampleCoverageNV", "GL_NV_texture_multisample\0", offsetof(struct opengl_funcs, p_glTextureImage3DMultisampleCoverageNV) }, - { "glTextureImage3DMultisampleNV", "GL_NV_texture_multisample\0", offsetof(struct opengl_funcs, p_glTextureImage3DMultisampleNV) }, - { "glTextureLightEXT", "GL_EXT_light_texture\0", offsetof(struct opengl_funcs, p_glTextureLightEXT) }, - { "glTextureMaterialEXT", "GL_EXT_light_texture\0", offsetof(struct opengl_funcs, p_glTextureMaterialEXT) }, - { "glTextureNormalEXT", "GL_EXT_texture_perturb_normal\0", offsetof(struct opengl_funcs, p_glTextureNormalEXT) }, - { "glTexturePageCommitmentEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glTexturePageCommitmentEXT) }, - { "glTexturePageCommitmentMemNV", "GL_NV_memory_object_sparse\0", offsetof(struct opengl_funcs, p_glTexturePageCommitmentMemNV) }, - { "glTextureParameterIiv", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glTextureParameterIiv) }, - { "glTextureParameterIivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glTextureParameterIivEXT) }, - { "glTextureParameterIuiv", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glTextureParameterIuiv) }, - { "glTextureParameterIuivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glTextureParameterIuivEXT) }, - { "glTextureParameterf", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glTextureParameterf) }, - { "glTextureParameterfEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glTextureParameterfEXT) }, - { "glTextureParameterfv", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glTextureParameterfv) }, - { "glTextureParameterfvEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glTextureParameterfvEXT) }, - { "glTextureParameteri", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glTextureParameteri) }, - { "glTextureParameteriEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glTextureParameteriEXT) }, - { "glTextureParameteriv", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glTextureParameteriv) }, - { "glTextureParameterivEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glTextureParameterivEXT) }, - { "glTextureRangeAPPLE", "GL_APPLE_texture_range\0", offsetof(struct opengl_funcs, p_glTextureRangeAPPLE) }, - { "glTextureRenderbufferEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glTextureRenderbufferEXT) }, - { "glTextureStorage1D", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glTextureStorage1D) }, - { "glTextureStorage1DEXT", "GL_EXT_direct_state_access\0GL_EXT_texture_storage\0", offsetof(struct opengl_funcs, p_glTextureStorage1DEXT) }, - { "glTextureStorage2D", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glTextureStorage2D) }, - { "glTextureStorage2DEXT", "GL_EXT_direct_state_access\0GL_EXT_texture_storage\0", offsetof(struct opengl_funcs, p_glTextureStorage2DEXT) }, - { "glTextureStorage2DMultisample", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glTextureStorage2DMultisample) }, - { "glTextureStorage2DMultisampleEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glTextureStorage2DMultisampleEXT) }, - { "glTextureStorage3D", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glTextureStorage3D) }, - { "glTextureStorage3DEXT", "GL_EXT_direct_state_access\0GL_EXT_texture_storage\0", offsetof(struct opengl_funcs, p_glTextureStorage3DEXT) }, - { "glTextureStorage3DMultisample", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glTextureStorage3DMultisample) }, - { "glTextureStorage3DMultisampleEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glTextureStorage3DMultisampleEXT) }, - { "glTextureStorageMem1DEXT", "GL_EXT_memory_object\0", offsetof(struct opengl_funcs, p_glTextureStorageMem1DEXT) }, - { "glTextureStorageMem2DEXT", "GL_EXT_memory_object\0", offsetof(struct opengl_funcs, p_glTextureStorageMem2DEXT) }, - { "glTextureStorageMem2DMultisampleEXT", "GL_EXT_memory_object\0", offsetof(struct opengl_funcs, p_glTextureStorageMem2DMultisampleEXT) }, - { "glTextureStorageMem3DEXT", "GL_EXT_memory_object\0", offsetof(struct opengl_funcs, p_glTextureStorageMem3DEXT) }, - { "glTextureStorageMem3DMultisampleEXT", "GL_EXT_memory_object\0", offsetof(struct opengl_funcs, p_glTextureStorageMem3DMultisampleEXT) }, - { "glTextureStorageSparseAMD", "GL_AMD_sparse_texture\0", offsetof(struct opengl_funcs, p_glTextureStorageSparseAMD) }, - { "glTextureSubImage1D", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glTextureSubImage1D) }, - { "glTextureSubImage1DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glTextureSubImage1DEXT) }, - { "glTextureSubImage2D", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glTextureSubImage2D) }, - { "glTextureSubImage2DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glTextureSubImage2DEXT) }, - { "glTextureSubImage3D", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glTextureSubImage3D) }, - { "glTextureSubImage3DEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glTextureSubImage3DEXT) }, - { "glTextureView", "GL_ARB_texture_view\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glTextureView) }, - { "glTrackMatrixNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glTrackMatrixNV) }, - { "glTransformFeedbackAttribsNV", "GL_NV_transform_feedback\0", offsetof(struct opengl_funcs, p_glTransformFeedbackAttribsNV) }, - { "glTransformFeedbackBufferBase", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glTransformFeedbackBufferBase) }, - { "glTransformFeedbackBufferRange", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glTransformFeedbackBufferRange) }, - { "glTransformFeedbackStreamAttribsNV", "GL_NV_transform_feedback\0", offsetof(struct opengl_funcs, p_glTransformFeedbackStreamAttribsNV) }, - { "glTransformFeedbackVaryings", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glTransformFeedbackVaryings) }, - { "glTransformFeedbackVaryingsEXT", "GL_EXT_transform_feedback\0", offsetof(struct opengl_funcs, p_glTransformFeedbackVaryingsEXT) }, - { "glTransformFeedbackVaryingsNV", "GL_NV_transform_feedback\0", offsetof(struct opengl_funcs, p_glTransformFeedbackVaryingsNV) }, - { "glTransformPathNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glTransformPathNV) }, - { "glTranslatex", "GL_NV_ES1_1_compatibility\0", offsetof(struct opengl_funcs, p_glTranslatex) }, - { "glTranslatexOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glTranslatexOES) }, - { "glUniform1d", "GL_ARB_gpu_shader_fp64\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glUniform1d) }, - { "glUniform1dv", "GL_ARB_gpu_shader_fp64\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glUniform1dv) }, - { "glUniform1f", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glUniform1f) }, - { "glUniform1fARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glUniform1fARB) }, - { "glUniform1fv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glUniform1fv) }, - { "glUniform1fvARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glUniform1fvARB) }, - { "glUniform1i", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glUniform1i) }, - { "glUniform1i64ARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glUniform1i64ARB) }, - { "glUniform1i64NV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glUniform1i64NV) }, - { "glUniform1i64vARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glUniform1i64vARB) }, - { "glUniform1i64vNV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glUniform1i64vNV) }, - { "glUniform1iARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glUniform1iARB) }, - { "glUniform1iv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glUniform1iv) }, - { "glUniform1ivARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glUniform1ivARB) }, - { "glUniform1ui", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glUniform1ui) }, - { "glUniform1ui64ARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glUniform1ui64ARB) }, - { "glUniform1ui64NV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glUniform1ui64NV) }, - { "glUniform1ui64vARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glUniform1ui64vARB) }, - { "glUniform1ui64vNV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glUniform1ui64vNV) }, - { "glUniform1uiEXT", "GL_EXT_gpu_shader4\0", offsetof(struct opengl_funcs, p_glUniform1uiEXT) }, - { "glUniform1uiv", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glUniform1uiv) }, - { "glUniform1uivEXT", "GL_EXT_gpu_shader4\0", offsetof(struct opengl_funcs, p_glUniform1uivEXT) }, - { "glUniform2d", "GL_ARB_gpu_shader_fp64\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glUniform2d) }, - { "glUniform2dv", "GL_ARB_gpu_shader_fp64\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glUniform2dv) }, - { "glUniform2f", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glUniform2f) }, - { "glUniform2fARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glUniform2fARB) }, - { "glUniform2fv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glUniform2fv) }, - { "glUniform2fvARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glUniform2fvARB) }, - { "glUniform2i", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glUniform2i) }, - { "glUniform2i64ARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glUniform2i64ARB) }, - { "glUniform2i64NV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glUniform2i64NV) }, - { "glUniform2i64vARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glUniform2i64vARB) }, - { "glUniform2i64vNV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glUniform2i64vNV) }, - { "glUniform2iARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glUniform2iARB) }, - { "glUniform2iv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glUniform2iv) }, - { "glUniform2ivARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glUniform2ivARB) }, - { "glUniform2ui", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glUniform2ui) }, - { "glUniform2ui64ARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glUniform2ui64ARB) }, - { "glUniform2ui64NV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glUniform2ui64NV) }, - { "glUniform2ui64vARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glUniform2ui64vARB) }, - { "glUniform2ui64vNV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glUniform2ui64vNV) }, - { "glUniform2uiEXT", "GL_EXT_gpu_shader4\0", offsetof(struct opengl_funcs, p_glUniform2uiEXT) }, - { "glUniform2uiv", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glUniform2uiv) }, - { "glUniform2uivEXT", "GL_EXT_gpu_shader4\0", offsetof(struct opengl_funcs, p_glUniform2uivEXT) }, - { "glUniform3d", "GL_ARB_gpu_shader_fp64\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glUniform3d) }, - { "glUniform3dv", "GL_ARB_gpu_shader_fp64\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glUniform3dv) }, - { "glUniform3f", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glUniform3f) }, - { "glUniform3fARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glUniform3fARB) }, - { "glUniform3fv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glUniform3fv) }, - { "glUniform3fvARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glUniform3fvARB) }, - { "glUniform3i", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glUniform3i) }, - { "glUniform3i64ARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glUniform3i64ARB) }, - { "glUniform3i64NV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glUniform3i64NV) }, - { "glUniform3i64vARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glUniform3i64vARB) }, - { "glUniform3i64vNV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glUniform3i64vNV) }, - { "glUniform3iARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glUniform3iARB) }, - { "glUniform3iv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glUniform3iv) }, - { "glUniform3ivARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glUniform3ivARB) }, - { "glUniform3ui", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glUniform3ui) }, - { "glUniform3ui64ARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glUniform3ui64ARB) }, - { "glUniform3ui64NV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glUniform3ui64NV) }, - { "glUniform3ui64vARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glUniform3ui64vARB) }, - { "glUniform3ui64vNV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glUniform3ui64vNV) }, - { "glUniform3uiEXT", "GL_EXT_gpu_shader4\0", offsetof(struct opengl_funcs, p_glUniform3uiEXT) }, - { "glUniform3uiv", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glUniform3uiv) }, - { "glUniform3uivEXT", "GL_EXT_gpu_shader4\0", offsetof(struct opengl_funcs, p_glUniform3uivEXT) }, - { "glUniform4d", "GL_ARB_gpu_shader_fp64\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glUniform4d) }, - { "glUniform4dv", "GL_ARB_gpu_shader_fp64\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glUniform4dv) }, - { "glUniform4f", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glUniform4f) }, - { "glUniform4fARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glUniform4fARB) }, - { "glUniform4fv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glUniform4fv) }, - { "glUniform4fvARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glUniform4fvARB) }, - { "glUniform4i", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glUniform4i) }, - { "glUniform4i64ARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glUniform4i64ARB) }, - { "glUniform4i64NV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glUniform4i64NV) }, - { "glUniform4i64vARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glUniform4i64vARB) }, - { "glUniform4i64vNV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glUniform4i64vNV) }, - { "glUniform4iARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glUniform4iARB) }, - { "glUniform4iv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glUniform4iv) }, - { "glUniform4ivARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glUniform4ivARB) }, - { "glUniform4ui", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glUniform4ui) }, - { "glUniform4ui64ARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glUniform4ui64ARB) }, - { "glUniform4ui64NV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glUniform4ui64NV) }, - { "glUniform4ui64vARB", "GL_ARB_gpu_shader_int64\0", offsetof(struct opengl_funcs, p_glUniform4ui64vARB) }, - { "glUniform4ui64vNV", "GL_AMD_gpu_shader_int64\0GL_NV_gpu_shader5\0", offsetof(struct opengl_funcs, p_glUniform4ui64vNV) }, - { "glUniform4uiEXT", "GL_EXT_gpu_shader4\0", offsetof(struct opengl_funcs, p_glUniform4uiEXT) }, - { "glUniform4uiv", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glUniform4uiv) }, - { "glUniform4uivEXT", "GL_EXT_gpu_shader4\0", offsetof(struct opengl_funcs, p_glUniform4uivEXT) }, - { "glUniformBlockBinding", "GL_ARB_uniform_buffer_object\0GL_VERSION_3_1\0", offsetof(struct opengl_funcs, p_glUniformBlockBinding) }, - { "glUniformBufferEXT", "GL_EXT_bindable_uniform\0", offsetof(struct opengl_funcs, p_glUniformBufferEXT) }, - { "glUniformHandleui64ARB", "GL_ARB_bindless_texture\0", offsetof(struct opengl_funcs, p_glUniformHandleui64ARB) }, - { "glUniformHandleui64NV", "GL_NV_bindless_texture\0", offsetof(struct opengl_funcs, p_glUniformHandleui64NV) }, - { "glUniformHandleui64vARB", "GL_ARB_bindless_texture\0", offsetof(struct opengl_funcs, p_glUniformHandleui64vARB) }, - { "glUniformHandleui64vNV", "GL_NV_bindless_texture\0", offsetof(struct opengl_funcs, p_glUniformHandleui64vNV) }, - { "glUniformMatrix2dv", "GL_ARB_gpu_shader_fp64\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glUniformMatrix2dv) }, - { "glUniformMatrix2fv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glUniformMatrix2fv) }, - { "glUniformMatrix2fvARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glUniformMatrix2fvARB) }, - { "glUniformMatrix2x3dv", "GL_ARB_gpu_shader_fp64\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glUniformMatrix2x3dv) }, - { "glUniformMatrix2x3fv", "GL_VERSION_2_1\0", offsetof(struct opengl_funcs, p_glUniformMatrix2x3fv) }, - { "glUniformMatrix2x4dv", "GL_ARB_gpu_shader_fp64\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glUniformMatrix2x4dv) }, - { "glUniformMatrix2x4fv", "GL_VERSION_2_1\0", offsetof(struct opengl_funcs, p_glUniformMatrix2x4fv) }, - { "glUniformMatrix3dv", "GL_ARB_gpu_shader_fp64\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glUniformMatrix3dv) }, - { "glUniformMatrix3fv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glUniformMatrix3fv) }, - { "glUniformMatrix3fvARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glUniformMatrix3fvARB) }, - { "glUniformMatrix3x2dv", "GL_ARB_gpu_shader_fp64\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glUniformMatrix3x2dv) }, - { "glUniformMatrix3x2fv", "GL_VERSION_2_1\0", offsetof(struct opengl_funcs, p_glUniformMatrix3x2fv) }, - { "glUniformMatrix3x4dv", "GL_ARB_gpu_shader_fp64\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glUniformMatrix3x4dv) }, - { "glUniformMatrix3x4fv", "GL_VERSION_2_1\0", offsetof(struct opengl_funcs, p_glUniformMatrix3x4fv) }, - { "glUniformMatrix4dv", "GL_ARB_gpu_shader_fp64\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glUniformMatrix4dv) }, - { "glUniformMatrix4fv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glUniformMatrix4fv) }, - { "glUniformMatrix4fvARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glUniformMatrix4fvARB) }, - { "glUniformMatrix4x2dv", "GL_ARB_gpu_shader_fp64\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glUniformMatrix4x2dv) }, - { "glUniformMatrix4x2fv", "GL_VERSION_2_1\0", offsetof(struct opengl_funcs, p_glUniformMatrix4x2fv) }, - { "glUniformMatrix4x3dv", "GL_ARB_gpu_shader_fp64\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glUniformMatrix4x3dv) }, - { "glUniformMatrix4x3fv", "GL_VERSION_2_1\0", offsetof(struct opengl_funcs, p_glUniformMatrix4x3fv) }, - { "glUniformSubroutinesuiv", "GL_ARB_shader_subroutine\0GL_VERSION_4_0\0", offsetof(struct opengl_funcs, p_glUniformSubroutinesuiv) }, - { "glUniformui64NV", "GL_NV_shader_buffer_load\0", offsetof(struct opengl_funcs, p_glUniformui64NV) }, - { "glUniformui64vNV", "GL_NV_shader_buffer_load\0", offsetof(struct opengl_funcs, p_glUniformui64vNV) }, - { "glUnlockArraysEXT", "GL_EXT_compiled_vertex_array\0", offsetof(struct opengl_funcs, p_glUnlockArraysEXT) }, - { "glUnmapBuffer", "GL_VERSION_1_5\0", offsetof(struct opengl_funcs, p_glUnmapBuffer) }, - { "glUnmapBufferARB", "GL_ARB_vertex_buffer_object\0", offsetof(struct opengl_funcs, p_glUnmapBufferARB) }, - { "glUnmapNamedBuffer", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glUnmapNamedBuffer) }, - { "glUnmapNamedBufferEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glUnmapNamedBufferEXT) }, - { "glUnmapObjectBufferATI", "GL_ATI_map_object_buffer\0", offsetof(struct opengl_funcs, p_glUnmapObjectBufferATI) }, - { "glUnmapTexture2DINTEL", "GL_INTEL_map_texture\0", offsetof(struct opengl_funcs, p_glUnmapTexture2DINTEL) }, - { "glUpdateObjectBufferATI", "GL_ATI_vertex_array_object\0", offsetof(struct opengl_funcs, p_glUpdateObjectBufferATI) }, - { "glUploadGpuMaskNVX", "GL_NVX_gpu_multicast2\0", offsetof(struct opengl_funcs, p_glUploadGpuMaskNVX) }, - { "glUseProgram", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glUseProgram) }, - { "glUseProgramObjectARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glUseProgramObjectARB) }, - { "glUseProgramStages", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glUseProgramStages) }, - { "glUseShaderProgramEXT", "GL_EXT_separate_shader_objects\0", offsetof(struct opengl_funcs, p_glUseShaderProgramEXT) }, - { "glVDPAUFiniNV", "GL_NV_vdpau_interop\0", offsetof(struct opengl_funcs, p_glVDPAUFiniNV) }, - { "glVDPAUGetSurfaceivNV", "GL_NV_vdpau_interop\0", offsetof(struct opengl_funcs, p_glVDPAUGetSurfaceivNV) }, - { "glVDPAUInitNV", "GL_NV_vdpau_interop\0", offsetof(struct opengl_funcs, p_glVDPAUInitNV) }, - { "glVDPAUIsSurfaceNV", "GL_NV_vdpau_interop\0", offsetof(struct opengl_funcs, p_glVDPAUIsSurfaceNV) }, - { "glVDPAUMapSurfacesNV", "GL_NV_vdpau_interop\0", offsetof(struct opengl_funcs, p_glVDPAUMapSurfacesNV) }, - { "glVDPAURegisterOutputSurfaceNV", "GL_NV_vdpau_interop\0", offsetof(struct opengl_funcs, p_glVDPAURegisterOutputSurfaceNV) }, - { "glVDPAURegisterVideoSurfaceNV", "GL_NV_vdpau_interop\0", offsetof(struct opengl_funcs, p_glVDPAURegisterVideoSurfaceNV) }, - { "glVDPAURegisterVideoSurfaceWithPictureStructureNV", "GL_NV_vdpau_interop2\0", offsetof(struct opengl_funcs, p_glVDPAURegisterVideoSurfaceWithPictureStructureNV) }, - { "glVDPAUSurfaceAccessNV", "GL_NV_vdpau_interop\0", offsetof(struct opengl_funcs, p_glVDPAUSurfaceAccessNV) }, - { "glVDPAUUnmapSurfacesNV", "GL_NV_vdpau_interop\0", offsetof(struct opengl_funcs, p_glVDPAUUnmapSurfacesNV) }, - { "glVDPAUUnregisterSurfaceNV", "GL_NV_vdpau_interop\0", offsetof(struct opengl_funcs, p_glVDPAUUnregisterSurfaceNV) }, - { "glValidateProgram", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glValidateProgram) }, - { "glValidateProgramARB", "GL_ARB_shader_objects\0", offsetof(struct opengl_funcs, p_glValidateProgramARB) }, - { "glValidateProgramPipeline", "GL_ARB_separate_shader_objects\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glValidateProgramPipeline) }, - { "glVariantArrayObjectATI", "GL_ATI_vertex_array_object\0", offsetof(struct opengl_funcs, p_glVariantArrayObjectATI) }, - { "glVariantPointerEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glVariantPointerEXT) }, - { "glVariantbvEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glVariantbvEXT) }, - { "glVariantdvEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glVariantdvEXT) }, - { "glVariantfvEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glVariantfvEXT) }, - { "glVariantivEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glVariantivEXT) }, - { "glVariantsvEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glVariantsvEXT) }, - { "glVariantubvEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glVariantubvEXT) }, - { "glVariantuivEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glVariantuivEXT) }, - { "glVariantusvEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glVariantusvEXT) }, - { "glVertex2bOES", "GL_OES_byte_coordinates\0", offsetof(struct opengl_funcs, p_glVertex2bOES) }, - { "glVertex2bvOES", "GL_OES_byte_coordinates\0", offsetof(struct opengl_funcs, p_glVertex2bvOES) }, - { "glVertex2hNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glVertex2hNV) }, - { "glVertex2hvNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glVertex2hvNV) }, - { "glVertex2xOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glVertex2xOES) }, - { "glVertex2xvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glVertex2xvOES) }, - { "glVertex3bOES", "GL_OES_byte_coordinates\0", offsetof(struct opengl_funcs, p_glVertex3bOES) }, - { "glVertex3bvOES", "GL_OES_byte_coordinates\0", offsetof(struct opengl_funcs, p_glVertex3bvOES) }, - { "glVertex3hNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glVertex3hNV) }, - { "glVertex3hvNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glVertex3hvNV) }, - { "glVertex3xOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glVertex3xOES) }, - { "glVertex3xvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glVertex3xvOES) }, - { "glVertex4bOES", "GL_OES_byte_coordinates\0", offsetof(struct opengl_funcs, p_glVertex4bOES) }, - { "glVertex4bvOES", "GL_OES_byte_coordinates\0", offsetof(struct opengl_funcs, p_glVertex4bvOES) }, - { "glVertex4hNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glVertex4hNV) }, - { "glVertex4hvNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glVertex4hvNV) }, - { "glVertex4xOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glVertex4xOES) }, - { "glVertex4xvOES", "GL_OES_fixed_point\0", offsetof(struct opengl_funcs, p_glVertex4xvOES) }, - { "glVertexArrayAttribBinding", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glVertexArrayAttribBinding) }, - { "glVertexArrayAttribFormat", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glVertexArrayAttribFormat) }, - { "glVertexArrayAttribIFormat", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glVertexArrayAttribIFormat) }, - { "glVertexArrayAttribLFormat", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glVertexArrayAttribLFormat) }, - { "glVertexArrayBindVertexBufferEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glVertexArrayBindVertexBufferEXT) }, - { "glVertexArrayBindingDivisor", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glVertexArrayBindingDivisor) }, - { "glVertexArrayColorOffsetEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glVertexArrayColorOffsetEXT) }, - { "glVertexArrayEdgeFlagOffsetEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glVertexArrayEdgeFlagOffsetEXT) }, - { "glVertexArrayElementBuffer", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glVertexArrayElementBuffer) }, - { "glVertexArrayFogCoordOffsetEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glVertexArrayFogCoordOffsetEXT) }, - { "glVertexArrayIndexOffsetEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glVertexArrayIndexOffsetEXT) }, - { "glVertexArrayMultiTexCoordOffsetEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glVertexArrayMultiTexCoordOffsetEXT) }, - { "glVertexArrayNormalOffsetEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glVertexArrayNormalOffsetEXT) }, - { "glVertexArrayParameteriAPPLE", "GL_APPLE_vertex_array_range\0", offsetof(struct opengl_funcs, p_glVertexArrayParameteriAPPLE) }, - { "glVertexArrayRangeAPPLE", "GL_APPLE_vertex_array_range\0", offsetof(struct opengl_funcs, p_glVertexArrayRangeAPPLE) }, - { "glVertexArrayRangeNV", "GL_NV_vertex_array_range\0", offsetof(struct opengl_funcs, p_glVertexArrayRangeNV) }, - { "glVertexArraySecondaryColorOffsetEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glVertexArraySecondaryColorOffsetEXT) }, - { "glVertexArrayTexCoordOffsetEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glVertexArrayTexCoordOffsetEXT) }, - { "glVertexArrayVertexAttribBindingEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glVertexArrayVertexAttribBindingEXT) }, - { "glVertexArrayVertexAttribDivisorEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glVertexArrayVertexAttribDivisorEXT) }, - { "glVertexArrayVertexAttribFormatEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glVertexArrayVertexAttribFormatEXT) }, - { "glVertexArrayVertexAttribIFormatEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glVertexArrayVertexAttribIFormatEXT) }, - { "glVertexArrayVertexAttribIOffsetEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glVertexArrayVertexAttribIOffsetEXT) }, - { "glVertexArrayVertexAttribLFormatEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glVertexArrayVertexAttribLFormatEXT) }, - { "glVertexArrayVertexAttribLOffsetEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glVertexArrayVertexAttribLOffsetEXT) }, - { "glVertexArrayVertexAttribOffsetEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glVertexArrayVertexAttribOffsetEXT) }, - { "glVertexArrayVertexBindingDivisorEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glVertexArrayVertexBindingDivisorEXT) }, - { "glVertexArrayVertexBuffer", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glVertexArrayVertexBuffer) }, - { "glVertexArrayVertexBuffers", "GL_ARB_direct_state_access\0GL_VERSION_4_5\0", offsetof(struct opengl_funcs, p_glVertexArrayVertexBuffers) }, - { "glVertexArrayVertexOffsetEXT", "GL_EXT_direct_state_access\0", offsetof(struct opengl_funcs, p_glVertexArrayVertexOffsetEXT) }, - { "glVertexAttrib1d", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib1d) }, - { "glVertexAttrib1dARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib1dARB) }, - { "glVertexAttrib1dNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttrib1dNV) }, - { "glVertexAttrib1dv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib1dv) }, - { "glVertexAttrib1dvARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib1dvARB) }, - { "glVertexAttrib1dvNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttrib1dvNV) }, - { "glVertexAttrib1f", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib1f) }, - { "glVertexAttrib1fARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib1fARB) }, - { "glVertexAttrib1fNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttrib1fNV) }, - { "glVertexAttrib1fv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib1fv) }, - { "glVertexAttrib1fvARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib1fvARB) }, - { "glVertexAttrib1fvNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttrib1fvNV) }, - { "glVertexAttrib1hNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glVertexAttrib1hNV) }, - { "glVertexAttrib1hvNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glVertexAttrib1hvNV) }, - { "glVertexAttrib1s", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib1s) }, - { "glVertexAttrib1sARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib1sARB) }, - { "glVertexAttrib1sNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttrib1sNV) }, - { "glVertexAttrib1sv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib1sv) }, - { "glVertexAttrib1svARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib1svARB) }, - { "glVertexAttrib1svNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttrib1svNV) }, - { "glVertexAttrib2d", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib2d) }, - { "glVertexAttrib2dARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib2dARB) }, - { "glVertexAttrib2dNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttrib2dNV) }, - { "glVertexAttrib2dv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib2dv) }, - { "glVertexAttrib2dvARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib2dvARB) }, - { "glVertexAttrib2dvNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttrib2dvNV) }, - { "glVertexAttrib2f", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib2f) }, - { "glVertexAttrib2fARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib2fARB) }, - { "glVertexAttrib2fNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttrib2fNV) }, - { "glVertexAttrib2fv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib2fv) }, - { "glVertexAttrib2fvARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib2fvARB) }, - { "glVertexAttrib2fvNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttrib2fvNV) }, - { "glVertexAttrib2hNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glVertexAttrib2hNV) }, - { "glVertexAttrib2hvNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glVertexAttrib2hvNV) }, - { "glVertexAttrib2s", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib2s) }, - { "glVertexAttrib2sARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib2sARB) }, - { "glVertexAttrib2sNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttrib2sNV) }, - { "glVertexAttrib2sv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib2sv) }, - { "glVertexAttrib2svARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib2svARB) }, - { "glVertexAttrib2svNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttrib2svNV) }, - { "glVertexAttrib3d", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib3d) }, - { "glVertexAttrib3dARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib3dARB) }, - { "glVertexAttrib3dNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttrib3dNV) }, - { "glVertexAttrib3dv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib3dv) }, - { "glVertexAttrib3dvARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib3dvARB) }, - { "glVertexAttrib3dvNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttrib3dvNV) }, - { "glVertexAttrib3f", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib3f) }, - { "glVertexAttrib3fARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib3fARB) }, - { "glVertexAttrib3fNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttrib3fNV) }, - { "glVertexAttrib3fv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib3fv) }, - { "glVertexAttrib3fvARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib3fvARB) }, - { "glVertexAttrib3fvNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttrib3fvNV) }, - { "glVertexAttrib3hNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glVertexAttrib3hNV) }, - { "glVertexAttrib3hvNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glVertexAttrib3hvNV) }, - { "glVertexAttrib3s", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib3s) }, - { "glVertexAttrib3sARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib3sARB) }, - { "glVertexAttrib3sNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttrib3sNV) }, - { "glVertexAttrib3sv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib3sv) }, - { "glVertexAttrib3svARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib3svARB) }, - { "glVertexAttrib3svNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttrib3svNV) }, - { "glVertexAttrib4Nbv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib4Nbv) }, - { "glVertexAttrib4NbvARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib4NbvARB) }, - { "glVertexAttrib4Niv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib4Niv) }, - { "glVertexAttrib4NivARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib4NivARB) }, - { "glVertexAttrib4Nsv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib4Nsv) }, - { "glVertexAttrib4NsvARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib4NsvARB) }, - { "glVertexAttrib4Nub", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib4Nub) }, - { "glVertexAttrib4NubARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib4NubARB) }, - { "glVertexAttrib4Nubv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib4Nubv) }, - { "glVertexAttrib4NubvARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib4NubvARB) }, - { "glVertexAttrib4Nuiv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib4Nuiv) }, - { "glVertexAttrib4NuivARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib4NuivARB) }, - { "glVertexAttrib4Nusv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib4Nusv) }, - { "glVertexAttrib4NusvARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib4NusvARB) }, - { "glVertexAttrib4bv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib4bv) }, - { "glVertexAttrib4bvARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib4bvARB) }, - { "glVertexAttrib4d", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib4d) }, - { "glVertexAttrib4dARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib4dARB) }, - { "glVertexAttrib4dNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttrib4dNV) }, - { "glVertexAttrib4dv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib4dv) }, - { "glVertexAttrib4dvARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib4dvARB) }, - { "glVertexAttrib4dvNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttrib4dvNV) }, - { "glVertexAttrib4f", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib4f) }, - { "glVertexAttrib4fARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib4fARB) }, - { "glVertexAttrib4fNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttrib4fNV) }, - { "glVertexAttrib4fv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib4fv) }, - { "glVertexAttrib4fvARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib4fvARB) }, - { "glVertexAttrib4fvNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttrib4fvNV) }, - { "glVertexAttrib4hNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glVertexAttrib4hNV) }, - { "glVertexAttrib4hvNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glVertexAttrib4hvNV) }, - { "glVertexAttrib4iv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib4iv) }, - { "glVertexAttrib4ivARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib4ivARB) }, - { "glVertexAttrib4s", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib4s) }, - { "glVertexAttrib4sARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib4sARB) }, - { "glVertexAttrib4sNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttrib4sNV) }, - { "glVertexAttrib4sv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib4sv) }, - { "glVertexAttrib4svARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib4svARB) }, - { "glVertexAttrib4svNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttrib4svNV) }, - { "glVertexAttrib4ubNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttrib4ubNV) }, - { "glVertexAttrib4ubv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib4ubv) }, - { "glVertexAttrib4ubvARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib4ubvARB) }, - { "glVertexAttrib4ubvNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttrib4ubvNV) }, - { "glVertexAttrib4uiv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib4uiv) }, - { "glVertexAttrib4uivARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib4uivARB) }, - { "glVertexAttrib4usv", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttrib4usv) }, - { "glVertexAttrib4usvARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttrib4usvARB) }, - { "glVertexAttribArrayObjectATI", "GL_ATI_vertex_attrib_array_object\0", offsetof(struct opengl_funcs, p_glVertexAttribArrayObjectATI) }, - { "glVertexAttribBinding", "GL_ARB_vertex_attrib_binding\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glVertexAttribBinding) }, - { "glVertexAttribDivisor", "GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glVertexAttribDivisor) }, - { "glVertexAttribDivisorARB", "GL_ARB_instanced_arrays\0", offsetof(struct opengl_funcs, p_glVertexAttribDivisorARB) }, - { "glVertexAttribFormat", "GL_ARB_vertex_attrib_binding\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glVertexAttribFormat) }, - { "glVertexAttribFormatNV", "GL_NV_vertex_buffer_unified_memory\0", offsetof(struct opengl_funcs, p_glVertexAttribFormatNV) }, - { "glVertexAttribI1i", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glVertexAttribI1i) }, - { "glVertexAttribI1iEXT", "GL_EXT_gpu_shader4\0GL_NV_vertex_program4\0", offsetof(struct opengl_funcs, p_glVertexAttribI1iEXT) }, - { "glVertexAttribI1iv", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glVertexAttribI1iv) }, - { "glVertexAttribI1ivEXT", "GL_EXT_gpu_shader4\0GL_NV_vertex_program4\0", offsetof(struct opengl_funcs, p_glVertexAttribI1ivEXT) }, - { "glVertexAttribI1ui", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glVertexAttribI1ui) }, - { "glVertexAttribI1uiEXT", "GL_EXT_gpu_shader4\0GL_NV_vertex_program4\0", offsetof(struct opengl_funcs, p_glVertexAttribI1uiEXT) }, - { "glVertexAttribI1uiv", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glVertexAttribI1uiv) }, - { "glVertexAttribI1uivEXT", "GL_EXT_gpu_shader4\0GL_NV_vertex_program4\0", offsetof(struct opengl_funcs, p_glVertexAttribI1uivEXT) }, - { "glVertexAttribI2i", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glVertexAttribI2i) }, - { "glVertexAttribI2iEXT", "GL_EXT_gpu_shader4\0GL_NV_vertex_program4\0", offsetof(struct opengl_funcs, p_glVertexAttribI2iEXT) }, - { "glVertexAttribI2iv", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glVertexAttribI2iv) }, - { "glVertexAttribI2ivEXT", "GL_EXT_gpu_shader4\0GL_NV_vertex_program4\0", offsetof(struct opengl_funcs, p_glVertexAttribI2ivEXT) }, - { "glVertexAttribI2ui", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glVertexAttribI2ui) }, - { "glVertexAttribI2uiEXT", "GL_EXT_gpu_shader4\0GL_NV_vertex_program4\0", offsetof(struct opengl_funcs, p_glVertexAttribI2uiEXT) }, - { "glVertexAttribI2uiv", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glVertexAttribI2uiv) }, - { "glVertexAttribI2uivEXT", "GL_EXT_gpu_shader4\0GL_NV_vertex_program4\0", offsetof(struct opengl_funcs, p_glVertexAttribI2uivEXT) }, - { "glVertexAttribI3i", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glVertexAttribI3i) }, - { "glVertexAttribI3iEXT", "GL_EXT_gpu_shader4\0GL_NV_vertex_program4\0", offsetof(struct opengl_funcs, p_glVertexAttribI3iEXT) }, - { "glVertexAttribI3iv", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glVertexAttribI3iv) }, - { "glVertexAttribI3ivEXT", "GL_EXT_gpu_shader4\0GL_NV_vertex_program4\0", offsetof(struct opengl_funcs, p_glVertexAttribI3ivEXT) }, - { "glVertexAttribI3ui", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glVertexAttribI3ui) }, - { "glVertexAttribI3uiEXT", "GL_EXT_gpu_shader4\0GL_NV_vertex_program4\0", offsetof(struct opengl_funcs, p_glVertexAttribI3uiEXT) }, - { "glVertexAttribI3uiv", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glVertexAttribI3uiv) }, - { "glVertexAttribI3uivEXT", "GL_EXT_gpu_shader4\0GL_NV_vertex_program4\0", offsetof(struct opengl_funcs, p_glVertexAttribI3uivEXT) }, - { "glVertexAttribI4bv", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glVertexAttribI4bv) }, - { "glVertexAttribI4bvEXT", "GL_EXT_gpu_shader4\0GL_NV_vertex_program4\0", offsetof(struct opengl_funcs, p_glVertexAttribI4bvEXT) }, - { "glVertexAttribI4i", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glVertexAttribI4i) }, - { "glVertexAttribI4iEXT", "GL_EXT_gpu_shader4\0GL_NV_vertex_program4\0", offsetof(struct opengl_funcs, p_glVertexAttribI4iEXT) }, - { "glVertexAttribI4iv", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glVertexAttribI4iv) }, - { "glVertexAttribI4ivEXT", "GL_EXT_gpu_shader4\0GL_NV_vertex_program4\0", offsetof(struct opengl_funcs, p_glVertexAttribI4ivEXT) }, - { "glVertexAttribI4sv", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glVertexAttribI4sv) }, - { "glVertexAttribI4svEXT", "GL_EXT_gpu_shader4\0GL_NV_vertex_program4\0", offsetof(struct opengl_funcs, p_glVertexAttribI4svEXT) }, - { "glVertexAttribI4ubv", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glVertexAttribI4ubv) }, - { "glVertexAttribI4ubvEXT", "GL_EXT_gpu_shader4\0GL_NV_vertex_program4\0", offsetof(struct opengl_funcs, p_glVertexAttribI4ubvEXT) }, - { "glVertexAttribI4ui", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glVertexAttribI4ui) }, - { "glVertexAttribI4uiEXT", "GL_EXT_gpu_shader4\0GL_NV_vertex_program4\0", offsetof(struct opengl_funcs, p_glVertexAttribI4uiEXT) }, - { "glVertexAttribI4uiv", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glVertexAttribI4uiv) }, - { "glVertexAttribI4uivEXT", "GL_EXT_gpu_shader4\0GL_NV_vertex_program4\0", offsetof(struct opengl_funcs, p_glVertexAttribI4uivEXT) }, - { "glVertexAttribI4usv", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glVertexAttribI4usv) }, - { "glVertexAttribI4usvEXT", "GL_EXT_gpu_shader4\0GL_NV_vertex_program4\0", offsetof(struct opengl_funcs, p_glVertexAttribI4usvEXT) }, - { "glVertexAttribIFormat", "GL_ARB_vertex_attrib_binding\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glVertexAttribIFormat) }, - { "glVertexAttribIFormatNV", "GL_NV_vertex_buffer_unified_memory\0", offsetof(struct opengl_funcs, p_glVertexAttribIFormatNV) }, - { "glVertexAttribIPointer", "GL_VERSION_3_0\0", offsetof(struct opengl_funcs, p_glVertexAttribIPointer) }, - { "glVertexAttribIPointerEXT", "GL_EXT_gpu_shader4\0GL_NV_vertex_program4\0", offsetof(struct opengl_funcs, p_glVertexAttribIPointerEXT) }, - { "glVertexAttribL1d", "GL_ARB_vertex_attrib_64bit\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glVertexAttribL1d) }, - { "glVertexAttribL1dEXT", "GL_EXT_vertex_attrib_64bit\0", offsetof(struct opengl_funcs, p_glVertexAttribL1dEXT) }, - { "glVertexAttribL1dv", "GL_ARB_vertex_attrib_64bit\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glVertexAttribL1dv) }, - { "glVertexAttribL1dvEXT", "GL_EXT_vertex_attrib_64bit\0", offsetof(struct opengl_funcs, p_glVertexAttribL1dvEXT) }, - { "glVertexAttribL1i64NV", "GL_NV_vertex_attrib_integer_64bit\0", offsetof(struct opengl_funcs, p_glVertexAttribL1i64NV) }, - { "glVertexAttribL1i64vNV", "GL_NV_vertex_attrib_integer_64bit\0", offsetof(struct opengl_funcs, p_glVertexAttribL1i64vNV) }, - { "glVertexAttribL1ui64ARB", "GL_ARB_bindless_texture\0", offsetof(struct opengl_funcs, p_glVertexAttribL1ui64ARB) }, - { "glVertexAttribL1ui64NV", "GL_NV_vertex_attrib_integer_64bit\0", offsetof(struct opengl_funcs, p_glVertexAttribL1ui64NV) }, - { "glVertexAttribL1ui64vARB", "GL_ARB_bindless_texture\0", offsetof(struct opengl_funcs, p_glVertexAttribL1ui64vARB) }, - { "glVertexAttribL1ui64vNV", "GL_NV_vertex_attrib_integer_64bit\0", offsetof(struct opengl_funcs, p_glVertexAttribL1ui64vNV) }, - { "glVertexAttribL2d", "GL_ARB_vertex_attrib_64bit\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glVertexAttribL2d) }, - { "glVertexAttribL2dEXT", "GL_EXT_vertex_attrib_64bit\0", offsetof(struct opengl_funcs, p_glVertexAttribL2dEXT) }, - { "glVertexAttribL2dv", "GL_ARB_vertex_attrib_64bit\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glVertexAttribL2dv) }, - { "glVertexAttribL2dvEXT", "GL_EXT_vertex_attrib_64bit\0", offsetof(struct opengl_funcs, p_glVertexAttribL2dvEXT) }, - { "glVertexAttribL2i64NV", "GL_NV_vertex_attrib_integer_64bit\0", offsetof(struct opengl_funcs, p_glVertexAttribL2i64NV) }, - { "glVertexAttribL2i64vNV", "GL_NV_vertex_attrib_integer_64bit\0", offsetof(struct opengl_funcs, p_glVertexAttribL2i64vNV) }, - { "glVertexAttribL2ui64NV", "GL_NV_vertex_attrib_integer_64bit\0", offsetof(struct opengl_funcs, p_glVertexAttribL2ui64NV) }, - { "glVertexAttribL2ui64vNV", "GL_NV_vertex_attrib_integer_64bit\0", offsetof(struct opengl_funcs, p_glVertexAttribL2ui64vNV) }, - { "glVertexAttribL3d", "GL_ARB_vertex_attrib_64bit\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glVertexAttribL3d) }, - { "glVertexAttribL3dEXT", "GL_EXT_vertex_attrib_64bit\0", offsetof(struct opengl_funcs, p_glVertexAttribL3dEXT) }, - { "glVertexAttribL3dv", "GL_ARB_vertex_attrib_64bit\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glVertexAttribL3dv) }, - { "glVertexAttribL3dvEXT", "GL_EXT_vertex_attrib_64bit\0", offsetof(struct opengl_funcs, p_glVertexAttribL3dvEXT) }, - { "glVertexAttribL3i64NV", "GL_NV_vertex_attrib_integer_64bit\0", offsetof(struct opengl_funcs, p_glVertexAttribL3i64NV) }, - { "glVertexAttribL3i64vNV", "GL_NV_vertex_attrib_integer_64bit\0", offsetof(struct opengl_funcs, p_glVertexAttribL3i64vNV) }, - { "glVertexAttribL3ui64NV", "GL_NV_vertex_attrib_integer_64bit\0", offsetof(struct opengl_funcs, p_glVertexAttribL3ui64NV) }, - { "glVertexAttribL3ui64vNV", "GL_NV_vertex_attrib_integer_64bit\0", offsetof(struct opengl_funcs, p_glVertexAttribL3ui64vNV) }, - { "glVertexAttribL4d", "GL_ARB_vertex_attrib_64bit\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glVertexAttribL4d) }, - { "glVertexAttribL4dEXT", "GL_EXT_vertex_attrib_64bit\0", offsetof(struct opengl_funcs, p_glVertexAttribL4dEXT) }, - { "glVertexAttribL4dv", "GL_ARB_vertex_attrib_64bit\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glVertexAttribL4dv) }, - { "glVertexAttribL4dvEXT", "GL_EXT_vertex_attrib_64bit\0", offsetof(struct opengl_funcs, p_glVertexAttribL4dvEXT) }, - { "glVertexAttribL4i64NV", "GL_NV_vertex_attrib_integer_64bit\0", offsetof(struct opengl_funcs, p_glVertexAttribL4i64NV) }, - { "glVertexAttribL4i64vNV", "GL_NV_vertex_attrib_integer_64bit\0", offsetof(struct opengl_funcs, p_glVertexAttribL4i64vNV) }, - { "glVertexAttribL4ui64NV", "GL_NV_vertex_attrib_integer_64bit\0", offsetof(struct opengl_funcs, p_glVertexAttribL4ui64NV) }, - { "glVertexAttribL4ui64vNV", "GL_NV_vertex_attrib_integer_64bit\0", offsetof(struct opengl_funcs, p_glVertexAttribL4ui64vNV) }, - { "glVertexAttribLFormat", "GL_ARB_vertex_attrib_binding\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glVertexAttribLFormat) }, - { "glVertexAttribLFormatNV", "GL_NV_vertex_attrib_integer_64bit\0", offsetof(struct opengl_funcs, p_glVertexAttribLFormatNV) }, - { "glVertexAttribLPointer", "GL_ARB_vertex_attrib_64bit\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glVertexAttribLPointer) }, - { "glVertexAttribLPointerEXT", "GL_EXT_vertex_attrib_64bit\0", offsetof(struct opengl_funcs, p_glVertexAttribLPointerEXT) }, - { "glVertexAttribP1ui", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glVertexAttribP1ui) }, - { "glVertexAttribP1uiv", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glVertexAttribP1uiv) }, - { "glVertexAttribP2ui", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glVertexAttribP2ui) }, - { "glVertexAttribP2uiv", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glVertexAttribP2uiv) }, - { "glVertexAttribP3ui", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glVertexAttribP3ui) }, - { "glVertexAttribP3uiv", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glVertexAttribP3uiv) }, - { "glVertexAttribP4ui", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glVertexAttribP4ui) }, - { "glVertexAttribP4uiv", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glVertexAttribP4uiv) }, - { "glVertexAttribParameteriAMD", "GL_AMD_interleaved_elements\0", offsetof(struct opengl_funcs, p_glVertexAttribParameteriAMD) }, - { "glVertexAttribPointer", "GL_VERSION_2_0\0", offsetof(struct opengl_funcs, p_glVertexAttribPointer) }, - { "glVertexAttribPointerARB", "GL_ARB_vertex_program\0GL_ARB_vertex_shader\0", offsetof(struct opengl_funcs, p_glVertexAttribPointerARB) }, - { "glVertexAttribPointerNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttribPointerNV) }, - { "glVertexAttribs1dvNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttribs1dvNV) }, - { "glVertexAttribs1fvNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttribs1fvNV) }, - { "glVertexAttribs1hvNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glVertexAttribs1hvNV) }, - { "glVertexAttribs1svNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttribs1svNV) }, - { "glVertexAttribs2dvNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttribs2dvNV) }, - { "glVertexAttribs2fvNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttribs2fvNV) }, - { "glVertexAttribs2hvNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glVertexAttribs2hvNV) }, - { "glVertexAttribs2svNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttribs2svNV) }, - { "glVertexAttribs3dvNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttribs3dvNV) }, - { "glVertexAttribs3fvNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttribs3fvNV) }, - { "glVertexAttribs3hvNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glVertexAttribs3hvNV) }, - { "glVertexAttribs3svNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttribs3svNV) }, - { "glVertexAttribs4dvNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttribs4dvNV) }, - { "glVertexAttribs4fvNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttribs4fvNV) }, - { "glVertexAttribs4hvNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glVertexAttribs4hvNV) }, - { "glVertexAttribs4svNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttribs4svNV) }, - { "glVertexAttribs4ubvNV", "GL_NV_vertex_program\0", offsetof(struct opengl_funcs, p_glVertexAttribs4ubvNV) }, - { "glVertexBindingDivisor", "GL_ARB_vertex_attrib_binding\0GL_VERSION_4_3\0", offsetof(struct opengl_funcs, p_glVertexBindingDivisor) }, - { "glVertexBlendARB", "GL_ARB_vertex_blend\0", offsetof(struct opengl_funcs, p_glVertexBlendARB) }, - { "glVertexBlendEnvfATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexBlendEnvfATI) }, - { "glVertexBlendEnviATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexBlendEnviATI) }, - { "glVertexFormatNV", "GL_NV_vertex_buffer_unified_memory\0", offsetof(struct opengl_funcs, p_glVertexFormatNV) }, - { "glVertexP2ui", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glVertexP2ui) }, - { "glVertexP2uiv", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glVertexP2uiv) }, - { "glVertexP3ui", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glVertexP3ui) }, - { "glVertexP3uiv", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glVertexP3uiv) }, - { "glVertexP4ui", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glVertexP4ui) }, - { "glVertexP4uiv", "GL_ARB_vertex_type_2_10_10_10_rev\0GL_VERSION_3_3\0", offsetof(struct opengl_funcs, p_glVertexP4uiv) }, - { "glVertexPointerEXT", "GL_EXT_vertex_array\0", offsetof(struct opengl_funcs, p_glVertexPointerEXT) }, - { "glVertexPointerListIBM", "GL_IBM_vertex_array_lists\0", offsetof(struct opengl_funcs, p_glVertexPointerListIBM) }, - { "glVertexPointervINTEL", "GL_INTEL_parallel_arrays\0", offsetof(struct opengl_funcs, p_glVertexPointervINTEL) }, - { "glVertexStream1dATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream1dATI) }, - { "glVertexStream1dvATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream1dvATI) }, - { "glVertexStream1fATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream1fATI) }, - { "glVertexStream1fvATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream1fvATI) }, - { "glVertexStream1iATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream1iATI) }, - { "glVertexStream1ivATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream1ivATI) }, - { "glVertexStream1sATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream1sATI) }, - { "glVertexStream1svATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream1svATI) }, - { "glVertexStream2dATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream2dATI) }, - { "glVertexStream2dvATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream2dvATI) }, - { "glVertexStream2fATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream2fATI) }, - { "glVertexStream2fvATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream2fvATI) }, - { "glVertexStream2iATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream2iATI) }, - { "glVertexStream2ivATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream2ivATI) }, - { "glVertexStream2sATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream2sATI) }, - { "glVertexStream2svATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream2svATI) }, - { "glVertexStream3dATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream3dATI) }, - { "glVertexStream3dvATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream3dvATI) }, - { "glVertexStream3fATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream3fATI) }, - { "glVertexStream3fvATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream3fvATI) }, - { "glVertexStream3iATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream3iATI) }, - { "glVertexStream3ivATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream3ivATI) }, - { "glVertexStream3sATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream3sATI) }, - { "glVertexStream3svATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream3svATI) }, - { "glVertexStream4dATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream4dATI) }, - { "glVertexStream4dvATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream4dvATI) }, - { "glVertexStream4fATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream4fATI) }, - { "glVertexStream4fvATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream4fvATI) }, - { "glVertexStream4iATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream4iATI) }, - { "glVertexStream4ivATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream4ivATI) }, - { "glVertexStream4sATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream4sATI) }, - { "glVertexStream4svATI", "GL_ATI_vertex_streams\0", offsetof(struct opengl_funcs, p_glVertexStream4svATI) }, - { "glVertexWeightPointerEXT", "GL_EXT_vertex_weighting\0", offsetof(struct opengl_funcs, p_glVertexWeightPointerEXT) }, - { "glVertexWeightfEXT", "GL_EXT_vertex_weighting\0", offsetof(struct opengl_funcs, p_glVertexWeightfEXT) }, - { "glVertexWeightfvEXT", "GL_EXT_vertex_weighting\0", offsetof(struct opengl_funcs, p_glVertexWeightfvEXT) }, - { "glVertexWeighthNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glVertexWeighthNV) }, - { "glVertexWeighthvNV", "GL_NV_half_float\0", offsetof(struct opengl_funcs, p_glVertexWeighthvNV) }, - { "glVideoCaptureNV", "GL_NV_video_capture\0", offsetof(struct opengl_funcs, p_glVideoCaptureNV) }, - { "glVideoCaptureStreamParameterdvNV", "GL_NV_video_capture\0", offsetof(struct opengl_funcs, p_glVideoCaptureStreamParameterdvNV) }, - { "glVideoCaptureStreamParameterfvNV", "GL_NV_video_capture\0", offsetof(struct opengl_funcs, p_glVideoCaptureStreamParameterfvNV) }, - { "glVideoCaptureStreamParameterivNV", "GL_NV_video_capture\0", offsetof(struct opengl_funcs, p_glVideoCaptureStreamParameterivNV) }, - { "glViewportArrayv", "GL_ARB_viewport_array\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glViewportArrayv) }, - { "glViewportIndexedf", "GL_ARB_viewport_array\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glViewportIndexedf) }, - { "glViewportIndexedfv", "GL_ARB_viewport_array\0GL_VERSION_4_1\0", offsetof(struct opengl_funcs, p_glViewportIndexedfv) }, - { "glViewportPositionWScaleNV", "GL_NV_clip_space_w_scaling\0", offsetof(struct opengl_funcs, p_glViewportPositionWScaleNV) }, - { "glViewportSwizzleNV", "GL_NV_viewport_swizzle\0", offsetof(struct opengl_funcs, p_glViewportSwizzleNV) }, - { "glWaitSemaphoreEXT", "GL_EXT_semaphore\0", offsetof(struct opengl_funcs, p_glWaitSemaphoreEXT) }, - { "glWaitSemaphoreui64NVX", "GL_NVX_progress_fence\0", offsetof(struct opengl_funcs, p_glWaitSemaphoreui64NVX) }, - { "glWaitSync", "GL_ARB_sync\0GL_VERSION_3_2\0", offsetof(struct opengl_funcs, p_glWaitSync) }, - { "glWaitVkSemaphoreNV", "GL_NV_draw_vulkan_image\0", offsetof(struct opengl_funcs, p_glWaitVkSemaphoreNV) }, - { "glWeightPathsNV", "GL_NV_path_rendering\0", offsetof(struct opengl_funcs, p_glWeightPathsNV) }, - { "glWeightPointerARB", "GL_ARB_vertex_blend\0", offsetof(struct opengl_funcs, p_glWeightPointerARB) }, - { "glWeightbvARB", "GL_ARB_vertex_blend\0", offsetof(struct opengl_funcs, p_glWeightbvARB) }, - { "glWeightdvARB", "GL_ARB_vertex_blend\0", offsetof(struct opengl_funcs, p_glWeightdvARB) }, - { "glWeightfvARB", "GL_ARB_vertex_blend\0", offsetof(struct opengl_funcs, p_glWeightfvARB) }, - { "glWeightivARB", "GL_ARB_vertex_blend\0", offsetof(struct opengl_funcs, p_glWeightivARB) }, - { "glWeightsvARB", "GL_ARB_vertex_blend\0", offsetof(struct opengl_funcs, p_glWeightsvARB) }, - { "glWeightubvARB", "GL_ARB_vertex_blend\0", offsetof(struct opengl_funcs, p_glWeightubvARB) }, - { "glWeightuivARB", "GL_ARB_vertex_blend\0", offsetof(struct opengl_funcs, p_glWeightuivARB) }, - { "glWeightusvARB", "GL_ARB_vertex_blend\0", offsetof(struct opengl_funcs, p_glWeightusvARB) }, - { "glWindowPos2d", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glWindowPos2d) }, - { "glWindowPos2dARB", "GL_ARB_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos2dARB) }, - { "glWindowPos2dMESA", "GL_MESA_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos2dMESA) }, - { "glWindowPos2dv", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glWindowPos2dv) }, - { "glWindowPos2dvARB", "GL_ARB_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos2dvARB) }, - { "glWindowPos2dvMESA", "GL_MESA_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos2dvMESA) }, - { "glWindowPos2f", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glWindowPos2f) }, - { "glWindowPos2fARB", "GL_ARB_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos2fARB) }, - { "glWindowPos2fMESA", "GL_MESA_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos2fMESA) }, - { "glWindowPos2fv", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glWindowPos2fv) }, - { "glWindowPos2fvARB", "GL_ARB_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos2fvARB) }, - { "glWindowPos2fvMESA", "GL_MESA_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos2fvMESA) }, - { "glWindowPos2i", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glWindowPos2i) }, - { "glWindowPos2iARB", "GL_ARB_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos2iARB) }, - { "glWindowPos2iMESA", "GL_MESA_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos2iMESA) }, - { "glWindowPos2iv", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glWindowPos2iv) }, - { "glWindowPos2ivARB", "GL_ARB_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos2ivARB) }, - { "glWindowPos2ivMESA", "GL_MESA_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos2ivMESA) }, - { "glWindowPos2s", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glWindowPos2s) }, - { "glWindowPos2sARB", "GL_ARB_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos2sARB) }, - { "glWindowPos2sMESA", "GL_MESA_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos2sMESA) }, - { "glWindowPos2sv", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glWindowPos2sv) }, - { "glWindowPos2svARB", "GL_ARB_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos2svARB) }, - { "glWindowPos2svMESA", "GL_MESA_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos2svMESA) }, - { "glWindowPos3d", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glWindowPos3d) }, - { "glWindowPos3dARB", "GL_ARB_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos3dARB) }, - { "glWindowPos3dMESA", "GL_MESA_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos3dMESA) }, - { "glWindowPos3dv", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glWindowPos3dv) }, - { "glWindowPos3dvARB", "GL_ARB_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos3dvARB) }, - { "glWindowPos3dvMESA", "GL_MESA_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos3dvMESA) }, - { "glWindowPos3f", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glWindowPos3f) }, - { "glWindowPos3fARB", "GL_ARB_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos3fARB) }, - { "glWindowPos3fMESA", "GL_MESA_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos3fMESA) }, - { "glWindowPos3fv", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glWindowPos3fv) }, - { "glWindowPos3fvARB", "GL_ARB_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos3fvARB) }, - { "glWindowPos3fvMESA", "GL_MESA_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos3fvMESA) }, - { "glWindowPos3i", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glWindowPos3i) }, - { "glWindowPos3iARB", "GL_ARB_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos3iARB) }, - { "glWindowPos3iMESA", "GL_MESA_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos3iMESA) }, - { "glWindowPos3iv", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glWindowPos3iv) }, - { "glWindowPos3ivARB", "GL_ARB_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos3ivARB) }, - { "glWindowPos3ivMESA", "GL_MESA_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos3ivMESA) }, - { "glWindowPos3s", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glWindowPos3s) }, - { "glWindowPos3sARB", "GL_ARB_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos3sARB) }, - { "glWindowPos3sMESA", "GL_MESA_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos3sMESA) }, - { "glWindowPos3sv", "GL_VERSION_1_4\0", offsetof(struct opengl_funcs, p_glWindowPos3sv) }, - { "glWindowPos3svARB", "GL_ARB_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos3svARB) }, - { "glWindowPos3svMESA", "GL_MESA_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos3svMESA) }, - { "glWindowPos4dMESA", "GL_MESA_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos4dMESA) }, - { "glWindowPos4dvMESA", "GL_MESA_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos4dvMESA) }, - { "glWindowPos4fMESA", "GL_MESA_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos4fMESA) }, - { "glWindowPos4fvMESA", "GL_MESA_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos4fvMESA) }, - { "glWindowPos4iMESA", "GL_MESA_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos4iMESA) }, - { "glWindowPos4ivMESA", "GL_MESA_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos4ivMESA) }, - { "glWindowPos4sMESA", "GL_MESA_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos4sMESA) }, - { "glWindowPos4svMESA", "GL_MESA_window_pos\0", offsetof(struct opengl_funcs, p_glWindowPos4svMESA) }, - { "glWindowRectanglesEXT", "GL_EXT_window_rectangles\0", offsetof(struct opengl_funcs, p_glWindowRectanglesEXT) }, - { "glWriteMaskEXT", "GL_EXT_vertex_shader\0", offsetof(struct opengl_funcs, p_glWriteMaskEXT) }, - { "wglAllocateMemoryNV", "WGL_NV_vertex_array_range\0", offsetof(struct opengl_funcs, p_wglAllocateMemoryNV) }, - { "wglBindTexImageARB", "WGL_ARB_render_texture\0", offsetof(struct opengl_funcs, p_wglBindTexImageARB) }, - { "wglChoosePixelFormatARB", "WGL_ARB_pixel_format\0", offsetof(struct opengl_funcs, p_wglChoosePixelFormatARB) }, - { "wglCreateContextAttribsARB", "WGL_ARB_create_context\0", offsetof(struct opengl_funcs, p_wglCreateContextAttribsARB) }, - { "wglCreatePbufferARB", "WGL_ARB_pbuffer\0", offsetof(struct opengl_funcs, p_wglCreatePbufferARB) }, - { "wglDestroyPbufferARB", "WGL_ARB_pbuffer\0", offsetof(struct opengl_funcs, p_wglDestroyPbufferARB) }, - { "wglFreeMemoryNV", "WGL_NV_vertex_array_range\0", offsetof(struct opengl_funcs, p_wglFreeMemoryNV) }, - { "wglGetCurrentReadDCARB", "WGL_ARB_make_current_read\0", offsetof(struct opengl_funcs, p_wglGetCurrentReadDCARB) }, - { "wglGetExtensionsStringARB", "WGL_ARB_extensions_string\0", offsetof(struct opengl_funcs, p_wglGetExtensionsStringARB) }, - { "wglGetExtensionsStringEXT", "WGL_EXT_extensions_string\0", offsetof(struct opengl_funcs, p_wglGetExtensionsStringEXT) }, - { "wglGetPbufferDCARB", "WGL_ARB_pbuffer\0", offsetof(struct opengl_funcs, p_wglGetPbufferDCARB) }, - { "wglGetPixelFormatAttribfvARB", "WGL_ARB_pixel_format\0", offsetof(struct opengl_funcs, p_wglGetPixelFormatAttribfvARB) }, - { "wglGetPixelFormatAttribivARB", "WGL_ARB_pixel_format\0", offsetof(struct opengl_funcs, p_wglGetPixelFormatAttribivARB) }, - { "wglGetSwapIntervalEXT", "WGL_EXT_swap_control\0", offsetof(struct opengl_funcs, p_wglGetSwapIntervalEXT) }, - { "wglMakeContextCurrentARB", "WGL_ARB_make_current_read\0", offsetof(struct opengl_funcs, p_wglMakeContextCurrentARB) }, - { "wglQueryCurrentRendererIntegerWINE", "WGL_WINE_query_renderer\0", offsetof(struct opengl_funcs, p_wglQueryCurrentRendererIntegerWINE) }, - { "wglQueryCurrentRendererStringWINE", "WGL_WINE_query_renderer\0", offsetof(struct opengl_funcs, p_wglQueryCurrentRendererStringWINE) }, - { "wglQueryPbufferARB", "WGL_ARB_pbuffer\0", offsetof(struct opengl_funcs, p_wglQueryPbufferARB) }, - { "wglQueryRendererIntegerWINE", "WGL_WINE_query_renderer\0", offsetof(struct opengl_funcs, p_wglQueryRendererIntegerWINE) }, - { "wglQueryRendererStringWINE", "WGL_WINE_query_renderer\0", offsetof(struct opengl_funcs, p_wglQueryRendererStringWINE) }, - { "wglReleasePbufferDCARB", "WGL_ARB_pbuffer\0", offsetof(struct opengl_funcs, p_wglReleasePbufferDCARB) }, - { "wglReleaseTexImageARB", "WGL_ARB_render_texture\0", offsetof(struct opengl_funcs, p_wglReleaseTexImageARB) }, - { "wglSetPbufferAttribARB", "WGL_ARB_render_texture\0", offsetof(struct opengl_funcs, p_wglSetPbufferAttribARB) }, - { "wglSetPixelFormatWINE", "WGL_WINE_pixel_format_passthrough\0", offsetof(struct opengl_funcs, p_wglSetPixelFormatWINE) }, - { "wglSwapIntervalEXT", "WGL_EXT_swap_control\0", offsetof(struct opengl_funcs, p_wglSwapIntervalEXT) }, -}; diff --git a/dlls/opengl32/unix_thunks.h b/dlls/opengl32/unix_thunks.h index a86626520f4..b2911b7e2a1 100644 --- a/dlls/opengl32/unix_thunks.h +++ b/dlls/opengl32/unix_thunks.h @@ -5,7 +5,6 @@ typedef ULONG PTR32; extern BOOL wrap_wglCopyContext( TEB *teb, HGLRC hglrcSrc, HGLRC hglrcDst, UINT mask ); extern HGLRC wrap_wglCreateContext( TEB *teb, HDC hDc, HGLRC handle ); extern BOOL wrap_wglDeleteContext( TEB *teb, HGLRC oldContext ); -extern PROC wrap_wglGetProcAddress( TEB *teb, LPCSTR lpszProc ); extern BOOL wrap_wglMakeCurrent( TEB *teb, HDC hDc, HGLRC newContext ); extern BOOL wrap_wglShareLists( TEB *teb, HGLRC hrcSrvShare, HGLRC hrcSrvSource ); extern BOOL wrap_wglSwapBuffers( TEB *teb, HDC hdc ); diff --git a/dlls/opengl32/unix_wgl.c b/dlls/opengl32/unix_wgl.c index 4bd84429cd3..3a331982ac4 100644 --- a/dlls/opengl32/unix_wgl.c +++ b/dlls/opengl32/unix_wgl.c @@ -128,11 +128,8 @@ struct context DWORD tid; /* thread that the context is current in */ UINT64 debug_callback; /* client pointer */ UINT64 debug_user; /* client pointer */ - GLubyte *extensions; /* extension string */ char *wow64_version; /* wow64 GL version override */ struct buffers *buffers; /* wow64 buffers map */ - const char **extension_array; /* array of supported extensions */ - size_t extension_count; /* size of supported extensions */ BOOL use_pinned_memory; /* use GL_AMD_pinned_memory to emulate persistent maps */ /* semi-stub state tracker for wglCopyContext */ @@ -450,25 +447,6 @@ static int *memdup_attribs( const int *attribs ) return copy; } -/* check if the extension is present in the list */ -static BOOL has_extension( const char *list, const char *ext, size_t len ) -{ - while (list) - { - while (*list == ' ') list++; - if (!strncmp( list, ext, len ) && (!list[len] || list[len] == ' ')) return TRUE; - list = strchr( list, ' ' ); - } - return FALSE; -} - -static const char *legacy_extensions[] = -{ - "WGL_EXT_extensions_string", - "WGL_EXT_swap_control", - NULL, -}; - static const char *parse_gl_version( const char *gl_version, int *major, int *minor ) { const char *ptr = gl_version; @@ -639,62 +617,6 @@ static char *query_opengl_option( const char *name ) return str; } -static int string_array_cmp( const void *p1, const void *p2 ) -{ - const char *const *s1 = p1; - const char *const *s2 = p2; - return strcmp( *s1, *s2 ); -} - -/* Check if a GL extension is supported */ -static BOOL is_extension_supported( struct context *ctx, const char *extension ) -{ - return bsearch( &extension, ctx->extension_array, ctx->extension_count, - sizeof(ctx->extension_array[0]), string_array_cmp ) != NULL; -} - -/* Check if any GL extension from the list is supported */ -static BOOL is_any_extension_supported( struct context *ctx, const char *extension ) -{ - struct opengl_client_context *client = opengl_client_context_from_client( ctx->base.client_context ); - size_t len; - - /* We use the GetProcAddress function from the display driver to retrieve function pointers - * for OpenGL and WGL extensions. In case of winex11.drv the OpenGL extension lookup is done - * using glXGetProcAddress. This function is quite unreliable in the sense that its specs don't - * require the function to return NULL when an extension isn't found. For this reason we check - * if the OpenGL extension required for the function we are looking up is supported. */ - - while ((len = strlen( extension ))) - { - TRACE( "Checking for extension '%s'\n", extension ); - - /* Check if the extension is part of the GL extension string to see if it is supported. */ - if (is_extension_supported( ctx, extension )) return TRUE; - - /* In general an OpenGL function starts as an ARB/EXT extension and at some stage - * it becomes part of the core OpenGL library and can be reached without the ARB/EXT - * suffix as well. In the extension table, these functions contain GL_VERSION_major_minor. - * Check if we are searching for a core GL function */ - if (!strncmp( extension, "GL_VERSION_", 11 )) - { - int major = extension[11] - '0'; /* Move past 'GL_VERSION_' */ - int minor = extension[13] - '0'; - - /* Compare the major/minor version numbers of the native OpenGL library and what is required by the function. - * The gl_version string is guaranteed to have at least a major/minor and sometimes it has a release number as well. */ - if (client->major_version > major || (client->major_version == major && client->minor_version >= minor)) return TRUE; - - WARN( "The function requires OpenGL version '%d.%d' while your drivers only provide '%d.%d'\n", - major, minor, client->major_version, client->minor_version ); - } - - extension += len + 1; - } - - return FALSE; -} - static void set_gl_error( TEB *teb, GLenum error ) { const struct opengl_funcs *funcs = teb->glTable; @@ -812,58 +734,11 @@ const GLubyte *wrap_glGetString( TEB *teb, GLenum name ) return ret; } -static int registry_entry_cmp( const void *a, const void *b ) +PROC wrap_wglGetProcAddress( TEB *teb, LPCSTR name, void *index ) { - const struct registry_entry *entry_a = a, *entry_b = b; - return strcmp( entry_a->name, entry_b->name ); -} - -PROC wrap_wglGetProcAddress( TEB *teb, LPCSTR name ) -{ - const struct registry_entry entry = {.name = name}, *found; - struct opengl_funcs *funcs = teb->glTable; - const void **func_ptr; - struct context *ctx; - - /* Without an active context opengl32 doesn't know to what - * driver it has to dispatch wglGetProcAddress. - */ - if (!(ctx = get_current_context( teb, NULL, NULL ))) - { - WARN( "No active WGL context found\n" ); - return (void *)-1; - } - - if (!(found = bsearch( &entry, extension_registry, extension_registry_size, sizeof(entry), registry_entry_cmp ))) - { - WARN( "Function %s unknown\n", name ); - return (void *)-1; - } - - func_ptr = (const void **)((char *)funcs + found->offset); - if (!*func_ptr) - { - void *driver_func = funcs->p_wglGetProcAddress( name ); - - if (!is_any_extension_supported( ctx, found->extension )) - { - WARN( "Extension %s required for %s not supported\n", found->extension, name ); - return (void *)-1; - } - - if (driver_func == NULL) - { - WARN( "Function %s not supported by driver\n", name ); - return (void *)-1; - } - - *func_ptr = driver_func; - } - - /* Return the index into the extension registry instead of a useless - * function pointer, PE side will returns its own function pointers. - */ - return (void *)(UINT_PTR)(found - extension_registry); + const void **funcs = teb->glTable; + if (!funcs[(UINT_PTR)index]) return (void *)-1; + return index; } BOOL wrap_wglCopyContext( TEB *teb, HGLRC client_src, HGLRC client_dst, UINT mask ) @@ -1126,11 +1001,7 @@ static void make_context_current( TEB *teb, const struct opengl_funcs *funcs, HD struct opengl_client_context *client = opengl_client_context_from_client( ctx->base.client_context ); DWORD tid = HandleToULong(teb->ClientId.UniqueThread); - size_t size = ARRAYSIZE(legacy_extensions) - 1, count = 0; - const char *version, *rest = "", **extensions, *ext; - int i, j; - - static const char *disabled, *enabled; + const char *version, *rest = "", *ext; ctx->tid = tid; teb->glReserved1[0] = draw_hdc; @@ -1170,73 +1041,8 @@ static void make_context_current( TEB *teb, const struct opengl_funcs *funcs, HD ALL_WGL_EXTS #undef USE_GL_EXT - if (funcs->p_glImportMemoryWin32HandleEXT) size++; - if (funcs->p_glImportSemaphoreWin32HandleEXT) size++; - - if (client->major_version >= 3) - { - GLint extensions_count; - funcs->p_glGetIntegerv( GL_NUM_EXTENSIONS, &extensions_count ); - size += extensions_count; - if (!(extensions = malloc( size * sizeof(*extensions) ))) return; - for (i = 0; i < extensions_count; i++) extensions[count++] = (const char *)funcs->p_glGetStringi( GL_EXTENSIONS, i ); - } - else - { - const char *str = (const char *)funcs->p_glGetString( GL_EXTENSIONS ); - size_t len = strlen( str ); - const char *p; - char *ext; - if (!str) str = ""; - if ((len = strlen( str )) && str[len - 1] == ' ') len--; - if (*str) size++; - for (p = str; p < str + len; p++) if (*p == ' ') size++; - if (!(extensions = malloc( size * sizeof(*extensions) + len + 1 ))) return; - ext = (char *)&extensions[size]; - memcpy( ext, str, len ); - ext[len] = 0; - if (*ext) extensions[count++] = ext; - while (*ext) - { - if (*ext == ' ') - { - *ext = 0; - extensions[count++] = ext + 1; - } - ext++; - } - } - - if (!disabled && !(disabled = query_opengl_option( "DisabledExtensions" ))) disabled = ""; - if (!enabled && !(enabled = query_opengl_option( "EnabledExtensions" ))) enabled = ""; - if (*enabled || *disabled) - { - for (i = 0, j = 0; i < count; i++) - { - size_t len = strlen( extensions[i] ); - if (!has_extension( disabled, extensions[i], len ) && (!*enabled || has_extension( enabled, extensions[i], len ))) - extensions[j++] = extensions[i]; - else - TRACE( "-- %s (disabled by config)\n", extensions[i] ); - } - count = j; - } - - if (funcs->p_glImportMemoryWin32HandleEXT) - { - client->extensions.has_GL_EXT_memory_object_win32 = 1; - extensions[count++] = "GL_EXT_memory_object_win32"; - } - if (funcs->p_glImportSemaphoreWin32HandleEXT) - { - client->extensions.has_GL_EXT_semaphore_win32 = 1; - extensions[count++] = "GL_EXT_semaphore_win32"; - } - - for (i = 0; legacy_extensions[i]; i++) extensions[count++] = legacy_extensions[i]; - qsort( extensions, count, sizeof(*extensions), string_array_cmp ); - ctx->extension_array = extensions; - ctx->extension_count = count; + if (funcs->p_glImportMemoryWin32HandleEXT) client->extensions.has_GL_EXT_memory_object_win32 = 1; + if (funcs->p_glImportSemaphoreWin32HandleEXT) client->extensions.has_GL_EXT_semaphore_win32 = 1; if (is_win64 && ctx->buffers && !initialize_vk_device( teb, ctx ) && !(ctx->use_pinned_memory = ctx->base.extensions.has_GL_AMD_pinned_memory)) @@ -1248,22 +1054,11 @@ static void make_context_current( TEB *teb, const struct opengl_funcs *funcs, HD client->minor_version = 3; asprintf( &ctx->wow64_version, "4.3%s", rest ); } - for (i = 0, j = 0; i < count; i++) - { - const char *ext = extensions[i]; - if (!strcmp( ext, "GL_ARB_buffer_storage" ) || !strcmp( ext, "GL_ARB_buffer_storage" )) - { - FIXME( "Disabling %s extension on wow64\n", ext ); - continue; - } - extensions[j++] = ext; - } if (client->extensions.has_GL_ARB_buffer_storage) { FIXME( "Disabling has_GL_ARB_buffer_storage extension on wow64\n" ); client->extensions.has_GL_ARB_buffer_storage = 0; } - ctx->extension_count = j; } dump_extensions( "Client", &client->extensions ); @@ -1320,8 +1115,6 @@ BOOL wrap_wglMakeCurrent( TEB *teb, HDC hdc, HGLRC client_context ) static void free_context( struct context *ctx ) { free( ctx->wow64_version ); - free( ctx->extension_array ); - free( ctx->extensions ); free( ctx->attribs ); free( ctx ); } diff --git a/dlls/opengl32/unixlib.h b/dlls/opengl32/unixlib.h index b370bf3d05e..ecb25857f75 100644 --- a/dlls/opengl32/unixlib.h +++ b/dlls/opengl32/unixlib.h @@ -14,7 +14,7 @@ #include "wingdi.h" #include "ntuser.h" -#include "wine/wgl.h" +#include "wine/opengl_driver.h" #include "wine/unixlib.h" struct process_attach_params diff --git a/dlls/opengl32/wgl.c b/dlls/opengl32/wgl.c index a959bc17e1c..17b07cbcb34 100644 --- a/dlls/opengl32/wgl.c +++ b/dlls/opengl32/wgl.c @@ -1352,17 +1352,13 @@ int WINAPI wglGetLayerPaletteEntries( HDC hdc, int plane, int start, int count, */ PROC WINAPI wglGetProcAddress( LPCSTR name ) { - struct wglGetProcAddress_params args = { .teb = NtCurrentTeb(), .lpszProc = name }; struct context *ctx; const void *proc; - NTSTATUS status; if (!name) return NULL; if (!(ctx = context_from_handle( NtCurrentTeb()->glCurrentRC ))) return NULL; - if ((status = UNIX_CALL( wglGetProcAddress, &args ))) - WARN( "wglGetProcAddress %s returned %#lx\n", debugstr_a(name), status ); - if (args.ret == (void *)-1) return NULL; + if (!(proc = get_proc_address( name, &ctx->base ))) return NULL; if (!strncmp( name, "wglGetExtensionsString", 22 )) { @@ -1371,7 +1367,6 @@ PROC WINAPI wglGetProcAddress( LPCSTR name ) LeaveCriticalSection( &wgl_cs ); } - proc = extension_procs[(UINT_PTR)args.ret]; TRACE( "returning %s -> %p\n", name, proc ); return proc; } -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10019
Jacek Caban (@jacek) commented about dlls/opengl32/make_opengl:
+print OUT " void *function;\n"; +print OUT " BOOL supported;\n"; +print OUT "};\n"; +print OUT "\n"; +print OUT "static int function_entry_cmp( const void *a, const void *b )\n"; +print OUT "{\n"; +print OUT " const struct function_entry *entry_a = a, *entry_b = b;\n"; +print OUT " return strcmp( entry_a->name, entry_b->name );\n"; +print OUT "};\n"; +print OUT "\n"; +print OUT "void *get_proc_address( const char *name, const struct opengl_client_context *ctx )\n"; +print OUT "{\n"; +print OUT " const int major = ctx->major_version, minor = ctx->minor_version;\n"; +print OUT " const struct opengl_extensions *extensions = &ctx->extensions;\n"; +print OUT " const struct function_entry *found, entry = { .name = name }, functions[] =\n"; +print OUT " {\n"; I think that the `functions[]` array really should be static. Initializing it like that on every call only to use a single entry seems ridiculous to me. That, combined with the extensive use of unnecessary `USE_GL_EXT` tricks, makes me question whether this is really the right representation of extensions.
One alternative would be to have an enum representing all known extensions. Converting from a string would then be just a `bsearch` away, and with that, things like `add_extension` would be as simple as `ctx->extensions[ext] = set`, `init_wgl_extensions` could use a proper loop, etc. The function registry could just have a list of extensions' enum values. -- https://gitlab.winehq.org/wine/wine/-/merge_requests/10019#note_128767
participants (3)
-
Jacek Caban (＠jacek) -
Rémi Bernon
-
Rémi Bernon (＠rbernon)